]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/msw/window.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
decouple wxTLW,Frame::ShowFullScreen in wxMSW
[wxWidgets.git] / src / msw / window.cpp
... / ...
CommitLineData
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// ---------------------------------------------------------------------------
123// global variables
124// ---------------------------------------------------------------------------
125
126// the last Windows message we got (MT-UNSAFE)
127extern MSG s_currentMsg;
128
129#if wxUSE_MENUS_NATIVE
130wxMenu *wxCurrentPopupMenu = NULL;
131#endif // wxUSE_MENUS_NATIVE
132
133extern const wxChar *wxCanvasClassName;
134
135// ---------------------------------------------------------------------------
136// private functions
137// ---------------------------------------------------------------------------
138
139// the window proc for all our windows
140LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
141 WPARAM wParam, LPARAM lParam);
142
143#ifdef __WXDEBUG__
144 const char *wxGetMessageName(int message);
145#endif //__WXDEBUG__
146
147void wxRemoveHandleAssociation(wxWindowMSW *win);
148void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
149wxWindow *wxFindWinFromHandle(WXHWND hWnd);
150
151// this magical function is used to translate VK_APPS key presses to right
152// mouse clicks
153static void TranslateKbdEventToMouse(wxWindowMSW *win,
154 int *x, int *y, WPARAM *flags);
155
156// get the text metrics for the current font
157static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win);
158
159// wrapper around BringWindowToTop() API
160static inline void wxBringWindowToTop(HWND hwnd)
161{
162#ifdef __WXMICROWIN__
163 // It seems that MicroWindows brings the _parent_ of the window to the top,
164 // which can be the wrong one.
165
166 // activate (set focus to) specified window
167 ::SetFocus(hwnd);
168
169 // raise top level parent to top of z order
170 ::SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
171#else // !__WXMICROWIN__
172 if ( !::BringWindowToTop(hwnd) )
173 {
174 wxLogLastError(_T("BringWindowToTop"));
175 }
176#endif // __WXMICROWIN__/!__WXMICROWIN__
177}
178
179// ---------------------------------------------------------------------------
180// event tables
181// ---------------------------------------------------------------------------
182
183// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
184// method
185#ifdef __WXUNIVERSAL__
186 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW, wxWindowBase)
187#else // __WXMSW__
188 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
189#endif // __WXUNIVERSAL__/__WXMSW__
190
191BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)
192 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
193 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
194 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
195 EVT_IDLE(wxWindowMSW::OnIdle)
196END_EVENT_TABLE()
197
198// ===========================================================================
199// implementation
200// ===========================================================================
201
202// ---------------------------------------------------------------------------
203// wxWindow utility functions
204// ---------------------------------------------------------------------------
205
206// Find an item given the MS Windows id
207wxWindow *wxWindowMSW::FindItem(long id) const
208{
209#if wxUSE_CONTROLS
210 wxControl *item = wxDynamicCastThis(wxControl);
211 if ( item )
212 {
213 // is it we or one of our "internal" children?
214 if ( item->GetId() == id
215#ifndef __WXUNIVERSAL__
216 || (item->GetSubcontrols().Index(id) != wxNOT_FOUND)
217#endif // __WXUNIVERSAL__
218 )
219 {
220 return item;
221 }
222 }
223#endif // wxUSE_CONTROLS
224
225 wxWindowList::Node *current = GetChildren().GetFirst();
226 while (current)
227 {
228 wxWindow *childWin = current->GetData();
229
230 wxWindow *wnd = childWin->FindItem(id);
231 if ( wnd )
232 return wnd;
233
234 current = current->GetNext();
235 }
236
237 return NULL;
238}
239
240// Find an item given the MS Windows handle
241wxWindow *wxWindowMSW::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
242{
243 wxWindowList::Node *current = GetChildren().GetFirst();
244 while (current)
245 {
246 wxWindow *parent = current->GetData();
247
248 // Do a recursive search.
249 wxWindow *wnd = parent->FindItemByHWND(hWnd);
250 if ( wnd )
251 return wnd;
252
253 if ( !controlOnly
254#if wxUSE_CONTROLS
255 || parent->IsKindOf(CLASSINFO(wxControl))
256#endif // wxUSE_CONTROLS
257 )
258 {
259 wxWindow *item = current->GetData();
260 if ( item->GetHWND() == hWnd )
261 return item;
262 else
263 {
264 if ( item->ContainsHWND(hWnd) )
265 return item;
266 }
267 }
268
269 current = current->GetNext();
270 }
271 return NULL;
272}
273
274// Default command handler
275bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
276{
277 return FALSE;
278}
279
280// ----------------------------------------------------------------------------
281// constructors and such
282// ----------------------------------------------------------------------------
283
284void wxWindowMSW::Init()
285{
286 // generic
287 InitBase();
288
289 // MSW specific
290 m_doubleClickAllowed = 0;
291
292 m_isBeingDeleted = FALSE;
293 m_oldWndProc = 0;
294 m_useCtl3D = FALSE;
295 m_mouseInWindow = FALSE;
296
297 // wxWnd
298 m_hMenu = 0;
299
300 m_hWnd = 0;
301
302 // pass WM_GETDLGCODE to DefWindowProc()
303 m_lDlgCode = 0;
304
305 m_xThumbSize = 0;
306 m_yThumbSize = 0;
307 m_backgroundTransparent = FALSE;
308
309 // as all windows are created with WS_VISIBLE style...
310 m_isShown = TRUE;
311
312#if wxUSE_MOUSEEVENT_HACK
313 m_lastMouseX =
314 m_lastMouseY = -1;
315 m_lastMouseEvent = -1;
316#endif // wxUSE_MOUSEEVENT_HACK
317}
318
319// Destructor
320wxWindowMSW::~wxWindowMSW()
321{
322 m_isBeingDeleted = TRUE;
323
324 MSWDetachWindowMenu();
325
326#ifndef __WXUNIVERSAL__
327 // VS: make sure there's no wxFrame with last focus set to us:
328 for ( wxWindow *win = GetParent(); win; win = win->GetParent() )
329 {
330 wxFrame *frame = wxDynamicCast(win, wxFrame);
331 if ( frame )
332 {
333 if ( frame->GetLastFocus() == this )
334 {
335 frame->SetLastFocus((wxWindow*)NULL);
336 }
337 break;
338 }
339 }
340#endif // __WXUNIVERSAL__
341
342 // VS: destroy children first and _then_ detach *this from its parent.
343 // If we'd do it the other way around, children wouldn't be able
344 // find their parent frame (see above).
345 DestroyChildren();
346
347 if ( m_parent )
348 m_parent->RemoveChild(this);
349
350 if ( m_hWnd )
351 {
352 // VZ: test temp removed to understand what really happens here
353 //if (::IsWindow(GetHwnd()))
354 {
355 if ( !::DestroyWindow(GetHwnd()) )
356 wxLogLastError(wxT("DestroyWindow"));
357 }
358
359 // remove hWnd <-> wxWindow association
360 wxRemoveHandleAssociation(this);
361 }
362}
363
364// real construction (Init() must have been called before!)
365bool wxWindowMSW::Create(wxWindow *parent,
366 wxWindowID id,
367 const wxPoint& pos,
368 const wxSize& size,
369 long style,
370 const wxString& name)
371{
372 wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") );
373
374#if wxUSE_STATBOX
375 // wxGTK doesn't allow to create controls with static box as the parent so
376 // this will result in a crash when the program is ported to wxGTK - warn
377 // about it
378 //
379 // the correct solution is to create the controls as siblings of the
380 // static box
381 wxASSERT_MSG( !wxDynamicCastThis(wxStaticBox),
382 _T("wxStaticBox can't be used as a window parent!") );
383#endif // wxUSE_STATBOX
384
385 if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
386 return FALSE;
387
388 parent->AddChild(this);
389
390 // all windows are created visible
391 DWORD msflags = WS_CHILD | WS_VISIBLE;
392
393#ifdef __WXUNIVERSAL__
394 // no 3d effects, we draw them ourselves
395 WXDWORD exStyle = 0;
396#else // !wxUniversal
397 if ( style & wxCLIP_CHILDREN )
398 msflags |= WS_CLIPCHILDREN;
399 if ( style & wxCLIP_SIBLINGS )
400 msflags |= WS_CLIPSIBLINGS;
401
402 bool want3D;
403 WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D);
404
405 // Even with extended styles, need to combine with WS_BORDER
406 // for them to look right.
407 if ( want3D ||
408 (m_windowStyle & (wxBORDER |
409 wxSIMPLE_BORDER |
410 wxRAISED_BORDER |
411 wxSUNKEN_BORDER |
412 wxDOUBLE_BORDER)) )
413 {
414 msflags |= WS_BORDER;
415 }
416
417 // calculate the value to return from WM_GETDLGCODE handler
418 if ( GetWindowStyleFlag() & wxWANTS_CHARS )
419 {
420 // want everything: i.e. all keys and WM_CHAR message
421 m_lDlgCode = DLGC_WANTARROWS | DLGC_WANTCHARS |
422 DLGC_WANTTAB | DLGC_WANTMESSAGE;
423 }
424#endif // wxUniversal/!wxUniversal
425
426 if ( style & wxPOPUP_WINDOW )
427 {
428 // a popup window floats on top of everything
429 exStyle |= WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
430
431 // it is also created hidden as other top level windows
432 msflags &= ~WS_VISIBLE;
433 m_isShown = FALSE;
434 }
435
436 return MSWCreate(wxCanvasClassName, NULL, pos, size, msflags, exStyle);
437}
438
439// ---------------------------------------------------------------------------
440// basic operations
441// ---------------------------------------------------------------------------
442
443void wxWindowMSW::SetFocus()
444{
445 HWND hWnd = GetHwnd();
446 wxCHECK_RET( hWnd, _T("can't set focus to invalid window") );
447
448#ifndef __WXMICROWIN__
449 ::SetLastError(0);
450#endif
451
452 if ( !::SetFocus(hWnd) )
453 {
454 // was there really an error?
455#ifndef __WXMICROWIN__
456 DWORD dwRes = ::GetLastError();
457#else
458
459 DWORD dwRes = 0;
460#endif
461 if ( dwRes )
462 {
463 wxLogApiError(_T("SetFocus"), dwRes);
464 }
465
466 // VZ: just why does this happen sometimes?? any idea?
467#if 0
468 HWND hwndFocus = ::GetFocus();
469 wxASSERT_MSG( hwndFocus == hWnd, _T("SetFocus() didn't work?") );
470#endif // 0
471 }
472}
473
474// Get the window with the focus
475wxWindow *wxWindowBase::FindFocus()
476{
477 HWND hWnd = ::GetFocus();
478 if ( hWnd )
479 {
480 return wxGetWindowFromHWND((WXHWND)hWnd);
481 }
482
483 return NULL;
484}
485
486bool wxWindowMSW::Enable(bool enable)
487{
488 if ( !wxWindowBase::Enable(enable) )
489 return FALSE;
490
491 HWND hWnd = GetHwnd();
492 if ( hWnd )
493 ::EnableWindow(hWnd, (BOOL)enable);
494
495 // VZ: no, this is a bad idea: imagine that you have a dialog with some
496 // disabled controls and disable it - you really wouldn't like the
497 // disabled controls be reenabled too when you reenable the dialog!
498#if 0
499 wxWindowList::Node *node = GetChildren().GetFirst();
500 while ( node )
501 {
502 wxWindow *child = node->GetData();
503 child->Enable(enable);
504
505 node = node->GetNext();
506 }
507#endif // 0
508
509 return TRUE;
510}
511
512bool wxWindowMSW::Show(bool show)
513{
514 if ( !wxWindowBase::Show(show) )
515 return FALSE;
516
517 HWND hWnd = GetHwnd();
518 int cshow = show ? SW_SHOW : SW_HIDE;
519 ::ShowWindow(hWnd, cshow);
520
521 if ( show )
522 {
523 wxBringWindowToTop(hWnd);
524 }
525
526 return TRUE;
527}
528
529// Raise the window to the top of the Z order
530void wxWindowMSW::Raise()
531{
532 wxBringWindowToTop(GetHwnd());
533}
534
535// Lower the window to the bottom of the Z order
536void wxWindowMSW::Lower()
537{
538 ::SetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0,
539 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
540}
541
542void wxWindowMSW::SetTitle( const wxString& title)
543{
544 SetWindowText(GetHwnd(), title.c_str());
545}
546
547wxString wxWindowMSW::GetTitle() const
548{
549 return wxGetWindowText(GetHWND());
550}
551
552void wxWindowMSW::CaptureMouse()
553{
554 HWND hWnd = GetHwnd();
555 if ( hWnd )
556 {
557 ::SetCapture(hWnd);
558 }
559}
560
561void wxWindowMSW::ReleaseMouse()
562{
563 if ( !::ReleaseCapture() )
564 {
565 wxLogLastError(_T("ReleaseCapture"));
566 }
567}
568
569/* static */ wxWindow *wxWindowBase::GetCapture()
570{
571 HWND hwnd = ::GetCapture();
572 return hwnd ? wxFindWinFromHandle((WXHWND)hwnd) : (wxWindow *)NULL;
573}
574
575bool wxWindowMSW::SetFont(const wxFont& font)
576{
577 if ( !wxWindowBase::SetFont(font) )
578 {
579 // nothing to do
580 return FALSE;
581 }
582
583 HWND hWnd = GetHwnd();
584 if ( hWnd != 0 )
585 {
586 WXHANDLE hFont = m_font.GetResourceHandle();
587
588 wxASSERT_MSG( hFont, wxT("should have valid font") );
589
590 ::SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
591 }
592
593 return TRUE;
594}
595bool wxWindowMSW::SetCursor(const wxCursor& cursor)
596{
597 if ( !wxWindowBase::SetCursor(cursor) )
598 {
599 // no change
600 return FALSE;
601 }
602
603 if ( m_cursor.Ok() )
604 {
605 HWND hWnd = GetHwnd();
606
607 // Change the cursor NOW if we're within the correct window
608 POINT point;
609 ::GetCursorPos(&point);
610
611 RECT rect = wxGetWindowRect(hWnd);
612
613 if ( ::PtInRect(&rect, point) && !wxIsBusy() )
614 ::SetCursor(GetHcursorOf(m_cursor));
615 }
616
617 return TRUE;
618}
619
620void wxWindowMSW::WarpPointer (int x, int y)
621{
622 ClientToScreen(&x, &y);
623
624 if ( !::SetCursorPos(x, y) )
625 {
626 wxLogLastError(_T("SetCursorPos"));
627 }
628}
629
630#if WXWIN_COMPATIBILITY
631void wxWindowMSW::MSWDeviceToLogical (float *x, float *y) const
632{
633}
634#endif // WXWIN_COMPATIBILITY
635
636// ---------------------------------------------------------------------------
637// scrolling stuff
638// ---------------------------------------------------------------------------
639
640#if WXWIN_COMPATIBILITY
641void wxWindowMSW::SetScrollRange(int orient, int range, bool refresh)
642{
643#if defined(__WIN95__)
644
645 int range1 = range;
646
647 // Try to adjust the range to cope with page size > 1
648 // - a Windows API quirk
649 int pageSize = GetScrollPage(orient);
650 if ( pageSize > 1 && range > 0)
651 {
652 range1 += (pageSize - 1);
653 }
654
655 SCROLLINFO info;
656 int dir;
657
658 if ( orient == wxHORIZONTAL ) {
659 dir = SB_HORZ;
660 } else {
661 dir = SB_VERT;
662 }
663
664 info.cbSize = sizeof(SCROLLINFO);
665 info.nPage = pageSize; // Have to set this, or scrollbar goes awry
666 info.nMin = 0;
667 info.nMax = range1;
668 info.nPos = 0;
669 info.fMask = SIF_RANGE | SIF_PAGE;
670
671 HWND hWnd = GetHwnd();
672 if ( hWnd )
673 ::SetScrollInfo(hWnd, dir, &info, refresh);
674#else
675 int wOrient;
676 if ( orient == wxHORIZONTAL )
677 wOrient = SB_HORZ;
678 else
679 wOrient = SB_VERT;
680
681 HWND hWnd = GetHwnd();
682 if ( hWnd )
683 ::SetScrollRange(hWnd, wOrient, 0, range, refresh);
684#endif
685}
686
687void wxWindowMSW::SetScrollPage(int orient, int page, bool refresh)
688{
689#if defined(__WIN95__)
690 SCROLLINFO info;
691 int dir;
692
693 if ( orient == wxHORIZONTAL ) {
694 dir = SB_HORZ;
695 m_xThumbSize = page;
696 } else {
697 dir = SB_VERT;
698 m_yThumbSize = page;
699 }
700
701 info.cbSize = sizeof(SCROLLINFO);
702 info.nPage = page;
703 info.nMin = 0;
704 info.fMask = SIF_PAGE;
705
706 HWND hWnd = GetHwnd();
707 if ( hWnd )
708 ::SetScrollInfo(hWnd, dir, &info, refresh);
709#else
710 if ( orient == wxHORIZONTAL )
711 m_xThumbSize = page;
712 else
713 m_yThumbSize = page;
714#endif
715}
716
717int wxWindowMSW::OldGetScrollRange(int orient) const
718{
719 int wOrient;
720 if ( orient == wxHORIZONTAL )
721 wOrient = SB_HORZ;
722 else
723 wOrient = SB_VERT;
724
725#if __WATCOMC__ && defined(__WINDOWS_386__)
726 short minPos, maxPos;
727#else
728 int minPos, maxPos;
729#endif
730 HWND hWnd = GetHwnd();
731 if ( hWnd )
732 {
733 ::GetScrollRange(hWnd, wOrient, &minPos, &maxPos);
734#if defined(__WIN95__)
735 // Try to adjust the range to cope with page size > 1
736 // - a Windows API quirk
737 int pageSize = GetScrollPage(orient);
738 if ( pageSize > 1 )
739 {
740 maxPos -= (pageSize - 1);
741 }
742#endif
743 return maxPos;
744 }
745 else
746 return 0;
747}
748
749int wxWindowMSW::GetScrollPage(int orient) const
750{
751 if ( orient == wxHORIZONTAL )
752 return m_xThumbSize;
753 else
754 return m_yThumbSize;
755}
756
757#endif // WXWIN_COMPATIBILITY
758
759inline int GetScrollPosition(HWND hWnd, int wOrient)
760{
761#ifdef __WXMICROWIN__
762 return ::GetScrollPosWX(hWnd, wOrient);
763#else
764 return ::GetScrollPos(hWnd, wOrient);
765#endif
766}
767
768int wxWindowMSW::GetScrollPos(int orient) const
769{
770 int wOrient;
771 if ( orient == wxHORIZONTAL )
772 wOrient = SB_HORZ;
773 else
774 wOrient = SB_VERT;
775
776 HWND hWnd = GetHwnd();
777 wxCHECK_MSG( hWnd, 0, _T("no HWND in GetScrollPos") );
778
779 return GetScrollPosition(hWnd, wOrient);
780}
781
782// This now returns the whole range, not just the number
783// of positions that we can scroll.
784int wxWindowMSW::GetScrollRange(int orient) const
785{
786 int wOrient;
787 if ( orient == wxHORIZONTAL )
788 wOrient = SB_HORZ;
789 else
790 wOrient = SB_VERT;
791
792#if __WATCOMC__ && defined(__WINDOWS_386__)
793 short minPos, maxPos;
794#else
795 int minPos, maxPos;
796#endif
797 HWND hWnd = GetHwnd();
798 if ( hWnd )
799 {
800 ::GetScrollRange(hWnd, wOrient, &minPos, &maxPos);
801#if defined(__WIN95__)
802 // Try to adjust the range to cope with page size > 1
803 // - a Windows API quirk
804 int pageSize = GetScrollThumb(orient);
805 if ( pageSize > 1 )
806 {
807 maxPos -= (pageSize - 1);
808 }
809 // October 10th: new range concept.
810 maxPos += pageSize;
811#endif
812
813 return maxPos;
814 }
815 else
816 return 0;
817}
818
819int wxWindowMSW::GetScrollThumb(int orient) const
820{
821 if ( orient == wxHORIZONTAL )
822 return m_xThumbSize;
823 else
824 return m_yThumbSize;
825}
826
827void wxWindowMSW::SetScrollPos(int orient, int pos, bool refresh)
828{
829#if defined(__WIN95__)
830 SCROLLINFO info;
831 int dir;
832
833 if ( orient == wxHORIZONTAL ) {
834 dir = SB_HORZ;
835 } else {
836 dir = SB_VERT;
837 }
838
839 info.cbSize = sizeof(SCROLLINFO);
840 info.nPage = 0;
841 info.nMin = 0;
842 info.nPos = pos;
843 info.fMask = SIF_POS;
844
845 HWND hWnd = GetHwnd();
846 if ( hWnd )
847 ::SetScrollInfo(hWnd, dir, &info, refresh);
848#else
849 int wOrient;
850 if ( orient == wxHORIZONTAL )
851 wOrient = SB_HORZ;
852 else
853 wOrient = SB_VERT;
854
855 HWND hWnd = GetHwnd();
856 if ( hWnd )
857 ::SetScrollPos(hWnd, wOrient, pos, refresh);
858#endif
859}
860
861// New function that will replace some of the above.
862void wxWindowMSW::SetScrollbar(int orient, int pos, int thumbVisible,
863 int range, bool refresh)
864{
865#if defined(__WIN95__)
866 int oldRange = range - thumbVisible;
867
868 int range1 = oldRange;
869
870 // Try to adjust the range to cope with page size > 1
871 // - a Windows API quirk
872 int pageSize = thumbVisible;
873 if ( pageSize > 1 && range > 0)
874 {
875 range1 += (pageSize - 1);
876 }
877
878 SCROLLINFO info;
879 int dir;
880
881 if ( orient == wxHORIZONTAL ) {
882 dir = SB_HORZ;
883 } else {
884 dir = SB_VERT;
885 }
886
887 info.cbSize = sizeof(SCROLLINFO);
888 info.nPage = pageSize; // Have to set this, or scrollbar goes awry
889 info.nMin = 0;
890 info.nMax = range1;
891 info.nPos = pos;
892 info.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
893
894 HWND hWnd = GetHwnd();
895 if ( hWnd )
896 ::SetScrollInfo(hWnd, dir, &info, refresh);
897#else
898 int wOrient;
899 if ( orient == wxHORIZONTAL )
900 wOrient = SB_HORZ;
901 else
902 wOrient = SB_VERT;
903
904 HWND hWnd = GetHwnd();
905 if ( hWnd )
906 {
907 ::SetScrollRange(hWnd, wOrient, 0, range, FALSE);
908 ::SetScrollPos(hWnd, wOrient, pos, refresh);
909 }
910#endif
911 if ( orient == wxHORIZONTAL ) {
912 m_xThumbSize = thumbVisible;
913 } else {
914 m_yThumbSize = thumbVisible;
915 }
916}
917
918void wxWindowMSW::ScrollWindow(int dx, int dy, const wxRect *prect)
919{
920 RECT rect;
921 if ( prect )
922 {
923 rect.left = prect->x;
924 rect.top = prect->y;
925 rect.right = prect->x + prect->width;
926 rect.bottom = prect->y + prect->height;
927 }
928
929 ::ScrollWindow(GetHwnd(), dx, dy, prect ? &rect : NULL, NULL);
930}
931
932static bool ScrollVertically(HWND hwnd, int kind, int count)
933{
934 int posStart = GetScrollPosition(hwnd, SB_VERT);
935
936 int pos = posStart;
937 for ( int n = 0; n < count; n++ )
938 {
939 ::SendMessage(hwnd, WM_VSCROLL, kind, 0);
940
941 int posNew = GetScrollPosition(hwnd, SB_VERT);
942 if ( posNew == pos )
943 {
944 // don't bother to continue, we're already at top/bottom
945 break;
946 }
947
948 pos = posNew;
949 }
950
951 return pos != posStart;
952}
953
954bool wxWindowMSW::ScrollLines(int lines)
955{
956 bool down = lines > 0;
957
958 return ScrollVertically(GetHwnd(),
959 down ? SB_LINEDOWN : SB_LINEUP,
960 down ? lines : -lines);
961}
962
963bool wxWindowMSW::ScrollPages(int pages)
964{
965 bool down = pages > 0;
966
967 return ScrollVertically(GetHwnd(),
968 down ? SB_PAGEDOWN : SB_PAGEUP,
969 down ? pages : -pages);
970}
971
972// ---------------------------------------------------------------------------
973// subclassing
974// ---------------------------------------------------------------------------
975
976void wxWindowMSW::SubclassWin(WXHWND hWnd)
977{
978 wxASSERT_MSG( !m_oldWndProc, wxT("subclassing window twice?") );
979
980 HWND hwnd = (HWND)hWnd;
981 wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in SubclassWin") );
982
983 wxAssociateWinWithHandle(hwnd, this);
984
985 m_oldWndProc = (WXFARPROC)::GetWindowLong(hwnd, GWL_WNDPROC);
986
987 // we don't need to subclass the window of our own class (in the Windows
988 // sense of the word)
989 if ( (WXFARPROC) m_oldWndProc != (WXFARPROC) wxWndProc )
990 {
991 ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) wxWndProc);
992 }
993 else
994 {
995 // don't bother restoring it neither
996 m_oldWndProc = NULL;
997 }
998}
999
1000void wxWindowMSW::UnsubclassWin()
1001{
1002 wxRemoveHandleAssociation(this);
1003
1004 // Restore old Window proc
1005 HWND hwnd = GetHwnd();
1006 if ( hwnd )
1007 {
1008 m_hWnd = 0;
1009
1010 wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in UnsubclassWin") );
1011
1012 if ( m_oldWndProc )
1013 {
1014 FARPROC wndProc = (FARPROC)::GetWindowLong(hwnd, GWL_WNDPROC);
1015 if ( wndProc != (FARPROC) m_oldWndProc )
1016 {
1017 ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) m_oldWndProc);
1018 }
1019
1020 m_oldWndProc = NULL;
1021 }
1022 }
1023}
1024
1025// Make a Windows extended style from the given wxWindows window style
1026WXDWORD wxWindowMSW::MakeExtendedStyle(long style, bool eliminateBorders)
1027{
1028 WXDWORD exStyle = 0;
1029 if ( style & wxTRANSPARENT_WINDOW )
1030 exStyle |= WS_EX_TRANSPARENT;
1031
1032 if ( !eliminateBorders )
1033 {
1034 if ( style & wxSUNKEN_BORDER )
1035 exStyle |= WS_EX_CLIENTEDGE;
1036 if ( style & wxDOUBLE_BORDER )
1037 exStyle |= WS_EX_DLGMODALFRAME;
1038#if defined(__WIN95__)
1039 if ( style & wxRAISED_BORDER )
1040 // It seems that WS_EX_WINDOWEDGE doesn't work, but WS_EX_DLGMODALFRAME does
1041 exStyle |= WS_EX_DLGMODALFRAME; /* WS_EX_WINDOWEDGE */;
1042 if ( style & wxSTATIC_BORDER )
1043 exStyle |= WS_EX_STATICEDGE;
1044#endif
1045 }
1046
1047 return exStyle;
1048}
1049
1050// Determines whether native 3D effects or CTL3D should be used,
1051// applying a default border style if required, and returning an extended
1052// style to pass to CreateWindowEx.
1053WXDWORD wxWindowMSW::Determine3DEffects(WXDWORD defaultBorderStyle,
1054 bool *want3D) const
1055{
1056 // If matches certain criteria, then assume no 3D effects
1057 // unless specifically requested (dealt with in MakeExtendedStyle)
1058 if ( !GetParent()
1059#if wxUSE_CONTROLS
1060 || !IsKindOf(CLASSINFO(wxControl))
1061#endif // wxUSE_CONTROLS
1062 || (m_windowStyle & wxNO_BORDER) )
1063 {
1064 *want3D = FALSE;
1065 return MakeExtendedStyle(m_windowStyle);
1066 }
1067
1068 // Determine whether we should be using 3D effects or not.
1069 bool nativeBorder = FALSE; // by default, we don't want a Win95 effect
1070
1071 // 1) App can specify global 3D effects
1072 *want3D = wxTheApp->GetAuto3D();
1073
1074 // 2) If the parent is being drawn with user colours, or simple border specified,
1075 // switch effects off. TODO: replace wxUSER_COLOURS with wxNO_3D
1076 if ( GetParent() && (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) || (m_windowStyle & wxSIMPLE_BORDER) )
1077 *want3D = FALSE;
1078
1079 // 3) Control can override this global setting by defining
1080 // a border style, e.g. wxSUNKEN_BORDER
1081 if ( m_windowStyle & wxSUNKEN_BORDER )
1082 *want3D = TRUE;
1083
1084 // 4) If it's a special border, CTL3D can't cope so we want a native border
1085 if ( (m_windowStyle & wxDOUBLE_BORDER) || (m_windowStyle & wxRAISED_BORDER) ||
1086 (m_windowStyle & wxSTATIC_BORDER) )
1087 {
1088 *want3D = TRUE;
1089 nativeBorder = TRUE;
1090 }
1091
1092 // 5) If this isn't a Win95 app, and we are using CTL3D, remove border
1093 // effects from extended style
1094#if wxUSE_CTL3D
1095 if ( *want3D )
1096 nativeBorder = FALSE;
1097#endif
1098
1099 DWORD exStyle = MakeExtendedStyle(m_windowStyle, !nativeBorder);
1100
1101 // If we want 3D, but haven't specified a border here,
1102 // apply the default border style specified.
1103 // TODO what about non-Win95 WIN32? Does it have borders?
1104#if defined(__WIN95__) && !wxUSE_CTL3D
1105 if ( defaultBorderStyle && (*want3D) && ! ((m_windowStyle & wxDOUBLE_BORDER) || (m_windowStyle & wxRAISED_BORDER ) ||
1106 (m_windowStyle & wxSTATIC_BORDER) || (m_windowStyle & wxSIMPLE_BORDER) ))
1107 exStyle |= defaultBorderStyle; // WS_EX_CLIENTEDGE;
1108#endif
1109
1110 return exStyle;
1111}
1112
1113#if WXWIN_COMPATIBILITY
1114// If nothing defined for this, try the parent.
1115// E.g. we may be a button loaded from a resource, with no callback function
1116// defined.
1117void wxWindowMSW::OnCommand(wxWindow& win, wxCommandEvent& event)
1118{
1119 if ( GetEventHandler()->ProcessEvent(event) )
1120 return;
1121 if ( m_parent )
1122 m_parent->GetEventHandler()->OnCommand(win, event);
1123}
1124#endif // WXWIN_COMPATIBILITY_2
1125
1126#if WXWIN_COMPATIBILITY
1127wxObject* wxWindowMSW::GetChild(int number) const
1128{
1129 // Return a pointer to the Nth object in the Panel
1130 wxNode *node = GetChildren().First();
1131 int n = number;
1132 while (node && n--)
1133 node = node->Next();
1134 if ( node )
1135 {
1136 wxObject *obj = (wxObject *)node->Data();
1137 return(obj);
1138 }
1139 else
1140 return NULL;
1141}
1142#endif // WXWIN_COMPATIBILITY
1143
1144// Setup background and foreground colours correctly
1145void wxWindowMSW::SetupColours()
1146{
1147 if ( GetParent() )
1148 SetBackgroundColour(GetParent()->GetBackgroundColour());
1149}
1150
1151bool wxWindowMSW::IsMouseInWindow() const
1152{
1153 // get the mouse position
1154 POINT pt;
1155 ::GetCursorPos(&pt);
1156
1157 // find the window which currently has the cursor and go up the window
1158 // chain until we find this window - or exhaust it
1159 HWND hwnd = ::WindowFromPoint(pt);
1160 while ( hwnd && (hwnd != GetHwnd()) )
1161 hwnd = ::GetParent(hwnd);
1162
1163 return hwnd != NULL;
1164}
1165
1166void wxWindowMSW::OnIdle(wxIdleEvent& WXUNUSED(event))
1167{
1168 // Check if we need to send a LEAVE event
1169 if ( m_mouseInWindow )
1170 {
1171 if ( !IsMouseInWindow() )
1172 {
1173 // Generate a LEAVE event
1174 m_mouseInWindow = FALSE;
1175
1176 // Unfortunately the mouse button and keyboard state may have
1177 // changed by the time the OnIdle function is called, so 'state'
1178 // may be meaningless.
1179 int state = 0;
1180 if ( wxIsShiftDown() )
1181 state |= MK_SHIFT;
1182 if ( wxIsCtrlDown() )
1183 state |= MK_CONTROL;
1184 if ( GetKeyState( VK_LBUTTON ) )
1185 state |= MK_LBUTTON;
1186 if ( GetKeyState( VK_MBUTTON ) )
1187 state |= MK_MBUTTON;
1188 if ( GetKeyState( VK_RBUTTON ) )
1189 state |= MK_RBUTTON;
1190
1191 POINT pt;
1192 if ( !::GetCursorPos(&pt) )
1193 {
1194 wxLogLastError(_T("GetCursorPos"));
1195 }
1196
1197 // we need to have client coordinates here for symmetry with
1198 // wxEVT_ENTER_WINDOW
1199 RECT rect = wxGetWindowRect(GetHwnd());
1200 pt.x -= rect.left;
1201 pt.y -= rect.top;
1202
1203 wxMouseEvent event2(wxEVT_LEAVE_WINDOW);
1204 InitMouseEvent(event2, pt.x, pt.y, state);
1205
1206 (void)GetEventHandler()->ProcessEvent(event2);
1207 }
1208 }
1209
1210 UpdateWindowUI();
1211}
1212
1213// Set this window to be the child of 'parent'.
1214bool wxWindowMSW::Reparent(wxWindowBase *parent)
1215{
1216 if ( !wxWindowBase::Reparent(parent) )
1217 return FALSE;
1218
1219 HWND hWndChild = GetHwnd();
1220 HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
1221
1222 ::SetParent(hWndChild, hWndParent);
1223
1224 return TRUE;
1225}
1226
1227void wxWindowMSW::Clear()
1228{
1229 wxClientDC dc((wxWindow *)this);
1230 wxBrush brush(GetBackgroundColour(), wxSOLID);
1231 dc.SetBackground(brush);
1232 dc.Clear();
1233}
1234
1235static inline void SendSetRedraw(HWND hwnd, bool on)
1236{
1237 ::SendMessage(hwnd, WM_SETREDRAW, (WPARAM)on, 0);
1238}
1239
1240void wxWindowMSW::Freeze()
1241{
1242 SendSetRedraw(GetHwnd(), FALSE);
1243}
1244
1245void wxWindowMSW::Thaw()
1246{
1247 SendSetRedraw(GetHwnd(), TRUE);
1248
1249 // we need to refresh everything or otherwise he invalidated area is not
1250 // repainted
1251 Refresh();
1252}
1253
1254void wxWindowMSW::Refresh(bool eraseBack, const wxRect *rect)
1255{
1256 HWND hWnd = GetHwnd();
1257 if ( hWnd )
1258 {
1259 if ( rect )
1260 {
1261 RECT mswRect;
1262 mswRect.left = rect->x;
1263 mswRect.top = rect->y;
1264 mswRect.right = rect->x + rect->width;
1265 mswRect.bottom = rect->y + rect->height;
1266
1267 ::InvalidateRect(hWnd, &mswRect, eraseBack);
1268 }
1269 else
1270 ::InvalidateRect(hWnd, NULL, eraseBack);
1271 }
1272}
1273
1274void wxWindowMSW::Update()
1275{
1276 if ( !::UpdateWindow(GetHwnd()) )
1277 {
1278 wxLogLastError(_T("UpdateWindow"));
1279 }
1280
1281#if defined(__WIN32__) && !defined(__WXMICROWIN__)
1282 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1283 // handler needs to be really drawn right now
1284 (void)::GdiFlush();
1285#endif // __WIN32__
1286}
1287
1288// ---------------------------------------------------------------------------
1289// drag and drop
1290// ---------------------------------------------------------------------------
1291
1292#if wxUSE_DRAG_AND_DROP
1293
1294void wxWindowMSW::SetDropTarget(wxDropTarget *pDropTarget)
1295{
1296 if ( m_dropTarget != 0 ) {
1297 m_dropTarget->Revoke(m_hWnd);
1298 delete m_dropTarget;
1299 }
1300
1301 m_dropTarget = pDropTarget;
1302 if ( m_dropTarget != 0 )
1303 m_dropTarget->Register(m_hWnd);
1304}
1305
1306#endif // wxUSE_DRAG_AND_DROP
1307
1308// old style file-manager drag&drop support: we retain the old-style
1309// DragAcceptFiles in parallel with SetDropTarget.
1310void wxWindowMSW::DragAcceptFiles(bool accept)
1311{
1312 HWND hWnd = GetHwnd();
1313 if ( hWnd )
1314 ::DragAcceptFiles(hWnd, (BOOL)accept);
1315}
1316
1317// ----------------------------------------------------------------------------
1318// tooltips
1319// ----------------------------------------------------------------------------
1320
1321#if wxUSE_TOOLTIPS
1322
1323void wxWindowMSW::DoSetToolTip(wxToolTip *tooltip)
1324{
1325 wxWindowBase::DoSetToolTip(tooltip);
1326
1327 if ( m_tooltip )
1328 m_tooltip->SetWindow(this);
1329}
1330
1331#endif // wxUSE_TOOLTIPS
1332
1333// ---------------------------------------------------------------------------
1334// moving and resizing
1335// ---------------------------------------------------------------------------
1336
1337// Get total size
1338void wxWindowMSW::DoGetSize(int *x, int *y) const
1339{
1340 RECT rect = wxGetWindowRect(GetHwnd());
1341
1342 if ( x )
1343 *x = rect.right - rect.left;
1344 if ( y )
1345 *y = rect.bottom - rect.top;
1346}
1347
1348// Get size *available for subwindows* i.e. excluding menu bar etc.
1349void wxWindowMSW::DoGetClientSize(int *x, int *y) const
1350{
1351 RECT rect = wxGetClientRect(GetHwnd());
1352
1353 if ( x )
1354 *x = rect.right;
1355 if ( y )
1356 *y = rect.bottom;
1357}
1358
1359void wxWindowMSW::DoGetPosition(int *x, int *y) const
1360{
1361 RECT rect = wxGetWindowRect(GetHwnd());
1362
1363 POINT point;
1364 point.x = rect.left;
1365 point.y = rect.top;
1366
1367 // we do the adjustments with respect to the parent only for the "real"
1368 // children, not for the dialogs/frames
1369 if ( !IsTopLevel() )
1370 {
1371 HWND hParentWnd = 0;
1372 wxWindow *parent = GetParent();
1373 if ( parent )
1374 hParentWnd = GetWinHwnd(parent);
1375
1376 // Since we now have the absolute screen coords, if there's a parent we
1377 // must subtract its top left corner
1378 if ( hParentWnd )
1379 {
1380 ::ScreenToClient(hParentWnd, &point);
1381 }
1382
1383 if ( parent )
1384 {
1385 // We may be faking the client origin. So a window that's really at (0,
1386 // 30) may appear (to wxWin apps) to be at (0, 0).
1387 wxPoint pt(parent->GetClientAreaOrigin());
1388 point.x -= pt.x;
1389 point.y -= pt.y;
1390 }
1391 }
1392
1393 if ( x )
1394 *x = point.x;
1395 if ( y )
1396 *y = point.y;
1397}
1398
1399void wxWindowMSW::DoScreenToClient(int *x, int *y) const
1400{
1401 POINT pt;
1402 if ( x )
1403 pt.x = *x;
1404 if ( y )
1405 pt.y = *y;
1406
1407 ::ScreenToClient(GetHwnd(), &pt);
1408
1409 if ( x )
1410 *x = pt.x;
1411 if ( y )
1412 *y = pt.y;
1413}
1414
1415void wxWindowMSW::DoClientToScreen(int *x, int *y) const
1416{
1417 POINT pt;
1418 if ( x )
1419 pt.x = *x;
1420 if ( y )
1421 pt.y = *y;
1422
1423 ::ClientToScreen(GetHwnd(), &pt);
1424
1425 if ( x )
1426 *x = pt.x;
1427 if ( y )
1428 *y = pt.y;
1429}
1430
1431void wxWindowMSW::DoMoveWindow(int x, int y, int width, int height)
1432{
1433 if ( !::MoveWindow(GetHwnd(), x, y, width, height, TRUE) )
1434 {
1435 wxLogLastError(wxT("MoveWindow"));
1436 }
1437}
1438
1439// set the size of the window: if the dimensions are positive, just use them,
1440// but if any of them is equal to -1, it means that we must find the value for
1441// it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1442// which case -1 is a valid value for x and y)
1443//
1444// If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1445// the width/height to best suit our contents, otherwise we reuse the current
1446// width/height
1447void wxWindowMSW::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1448{
1449 // get the current size and position...
1450 int currentX, currentY;
1451 GetPosition(&currentX, &currentY);
1452 int currentW,currentH;
1453 GetSize(&currentW, &currentH);
1454
1455 // ... and don't do anything (avoiding flicker) if it's already ok
1456 if ( x == currentX && y == currentY &&
1457 width == currentW && height == currentH )
1458 {
1459 return;
1460 }
1461
1462 if ( x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1463 x = currentX;
1464 if ( y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1465 y = currentY;
1466
1467 AdjustForParentClientOrigin(x, y, sizeFlags);
1468
1469 wxSize size(-1, -1);
1470 if ( width == -1 )
1471 {
1472 if ( sizeFlags & wxSIZE_AUTO_WIDTH )
1473 {
1474 size = DoGetBestSize();
1475 width = size.x;
1476 }
1477 else
1478 {
1479 // just take the current one
1480 width = currentW;
1481 }
1482 }
1483
1484 if ( height == -1 )
1485 {
1486 if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
1487 {
1488 if ( size.x == -1 )
1489 {
1490 size = DoGetBestSize();
1491 }
1492 //else: already called DoGetBestSize() above
1493
1494 height = size.y;
1495 }
1496 else
1497 {
1498 // just take the current one
1499 height = currentH;
1500 }
1501 }
1502
1503 DoMoveWindow(x, y, width, height);
1504}
1505
1506void wxWindowMSW::DoSetClientSize(int width, int height)
1507{
1508 wxWindow *parent = GetParent();
1509 HWND hWnd = GetHwnd();
1510 HWND hParentWnd = (HWND) 0;
1511 if ( parent )
1512 hParentWnd = (HWND) parent->GetHWND();
1513
1514 RECT rect;
1515 ::GetClientRect(hWnd, &rect);
1516
1517 RECT rect2;
1518 GetWindowRect(hWnd, &rect2);
1519
1520 // Find the difference between the entire window (title bar and all)
1521 // and the client area; add this to the new client size to move the
1522 // window
1523 int actual_width = rect2.right - rect2.left - rect.right + width;
1524 int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
1525
1526 // If there's a parent, must subtract the parent's top left corner
1527 // since MoveWindow moves relative to the parent
1528
1529 POINT point;
1530 point.x = rect2.left;
1531 point.y = rect2.top;
1532 if ( parent )
1533 {
1534 ::ScreenToClient(hParentWnd, &point);
1535 }
1536
1537 DoMoveWindow(point.x, point.y, actual_width, actual_height);
1538
1539 wxSizeEvent event(wxSize(width, height), m_windowId);
1540 event.SetEventObject(this);
1541 GetEventHandler()->ProcessEvent(event);
1542}
1543
1544// For implementation purposes - sometimes decorations make the client area
1545// smaller
1546wxPoint wxWindowMSW::GetClientAreaOrigin() const
1547{
1548 return wxPoint(0, 0);
1549}
1550
1551// ---------------------------------------------------------------------------
1552// text metrics
1553// ---------------------------------------------------------------------------
1554
1555int wxWindowMSW::GetCharHeight() const
1556{
1557 return wxGetTextMetrics(this).tmHeight;
1558}
1559
1560int wxWindowMSW::GetCharWidth() const
1561{
1562 // +1 is needed because Windows apparently adds it when calculating the
1563 // dialog units size in pixels
1564#if wxDIALOG_UNIT_COMPATIBILITY
1565 return wxGetTextMetrics(this).tmAveCharWidth;
1566#else
1567 return wxGetTextMetrics(this).tmAveCharWidth + 1;
1568#endif
1569}
1570
1571void wxWindowMSW::GetTextExtent(const wxString& string,
1572 int *x, int *y,
1573 int *descent, int *externalLeading,
1574 const wxFont *theFont) const
1575{
1576 const wxFont *fontToUse = theFont;
1577 if ( !fontToUse )
1578 fontToUse = &m_font;
1579
1580 HWND hWnd = GetHwnd();
1581 HDC dc = ::GetDC(hWnd);
1582
1583 HFONT fnt = 0;
1584 HFONT hfontOld = 0;
1585 if ( fontToUse && fontToUse->Ok() )
1586 {
1587 fnt = (HFONT)((wxFont *)fontToUse)->GetResourceHandle(); // const_cast
1588 if ( fnt )
1589 hfontOld = (HFONT)SelectObject(dc,fnt);
1590 }
1591
1592 SIZE sizeRect;
1593 TEXTMETRIC tm;
1594 GetTextExtentPoint(dc, string, (int)string.Length(), &sizeRect);
1595 GetTextMetrics(dc, &tm);
1596
1597 if ( fontToUse && fnt && hfontOld )
1598 SelectObject(dc, hfontOld);
1599
1600 ReleaseDC(hWnd, dc);
1601
1602 if ( x )
1603 *x = sizeRect.cx;
1604 if ( y )
1605 *y = sizeRect.cy;
1606 if ( descent )
1607 *descent = tm.tmDescent;
1608 if ( externalLeading )
1609 *externalLeading = tm.tmExternalLeading;
1610}
1611
1612#if wxUSE_CARET && WXWIN_COMPATIBILITY
1613// ---------------------------------------------------------------------------
1614// Caret manipulation
1615// ---------------------------------------------------------------------------
1616
1617void wxWindowMSW::CreateCaret(int w, int h)
1618{
1619 SetCaret(new wxCaret(this, w, h));
1620}
1621
1622void wxWindowMSW::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
1623{
1624 wxFAIL_MSG("not implemented");
1625}
1626
1627void wxWindowMSW::ShowCaret(bool show)
1628{
1629 wxCHECK_RET( m_caret, "no caret to show" );
1630
1631 m_caret->Show(show);
1632}
1633
1634void wxWindowMSW::DestroyCaret()
1635{
1636 SetCaret(NULL);
1637}
1638
1639void wxWindowMSW::SetCaretPos(int x, int y)
1640{
1641 wxCHECK_RET( m_caret, "no caret to move" );
1642
1643 m_caret->Move(x, y);
1644}
1645
1646void wxWindowMSW::GetCaretPos(int *x, int *y) const
1647{
1648 wxCHECK_RET( m_caret, "no caret to get position of" );
1649
1650 m_caret->GetPosition(x, y);
1651}
1652#endif // wxUSE_CARET
1653
1654// ---------------------------------------------------------------------------
1655// popup menu
1656// ---------------------------------------------------------------------------
1657
1658#if wxUSE_MENUS_NATIVE
1659
1660// yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1661// immediately, without waiting for the next event loop iteration
1662//
1663// NB: this function should probably be made public later as it can almost
1664// surely replace wxYield() elsewhere as well
1665static void wxYieldForCommandsOnly()
1666{
1667 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1668 // want to process it here)
1669 MSG msg;
1670 while ( ::PeekMessage(&msg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE)
1671 && msg.message != WM_QUIT )
1672 {
1673 wxTheApp->DoMessage((WXMSG *)&msg);
1674 }
1675}
1676
1677bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
1678{
1679 menu->SetInvokingWindow(this);
1680 menu->UpdateUI();
1681
1682 HWND hWnd = GetHwnd();
1683 HMENU hMenu = GetHmenuOf(menu);
1684 POINT point;
1685 point.x = x;
1686 point.y = y;
1687 ::ClientToScreen(hWnd, &point);
1688 wxCurrentPopupMenu = menu;
1689 ::TrackPopupMenu(hMenu, TPM_RIGHTBUTTON, point.x, point.y, 0, hWnd, NULL);
1690
1691 // we need to do it righ now as otherwise the events are never going to be
1692 // sent to wxCurrentPopupMenu from HandleCommand()
1693 //
1694 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1695 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1696 // destroyed as soon as we return (it can be a local variable in the caller
1697 // for example) and so we do need to process the event immediately
1698 wxYieldForCommandsOnly();
1699
1700 wxCurrentPopupMenu = NULL;
1701
1702 menu->SetInvokingWindow(NULL);
1703
1704 return TRUE;
1705}
1706
1707#endif // wxUSE_MENUS_NATIVE
1708
1709// ===========================================================================
1710// pre/post message processing
1711// ===========================================================================
1712
1713long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1714{
1715 if ( m_oldWndProc )
1716 return ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
1717 else
1718 return ::DefWindowProc(GetHwnd(), nMsg, wParam, lParam);
1719}
1720
1721bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
1722{
1723 // wxUniversal implements tab traversal itself
1724#ifndef __WXUNIVERSAL__
1725 if ( m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL) )
1726 {
1727 // intercept dialog navigation keys
1728 MSG *msg = (MSG *)pMsg;
1729
1730 // here we try to do all the job which ::IsDialogMessage() usually does
1731 // internally
1732#if 1
1733 bool bProcess = TRUE;
1734 if ( msg->message != WM_KEYDOWN )
1735 bProcess = FALSE;
1736
1737 if ( bProcess && (HIWORD(msg->lParam) & KF_ALTDOWN) == KF_ALTDOWN )
1738 bProcess = FALSE;
1739
1740 if ( bProcess )
1741 {
1742 bool bCtrlDown = wxIsCtrlDown();
1743 bool bShiftDown = wxIsShiftDown();
1744
1745 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1746 // don't process it if it's the case (except for Ctrl-Tab/Enter
1747 // combinations which are always processed)
1748 LONG lDlgCode = 0;
1749 if ( !bCtrlDown )
1750 {
1751 lDlgCode = ::SendMessage(msg->hwnd, WM_GETDLGCODE, 0, 0);
1752 }
1753
1754 bool bForward = TRUE,
1755 bWindowChange = FALSE;
1756
1757 switch ( msg->wParam )
1758 {
1759 case VK_TAB:
1760 // assume that nobody wants Shift-TAB for himself - if we
1761 // don't do it there is no easy way for a control to grab
1762 // TABs but still let Shift-TAB work as navugation key
1763 if ( (lDlgCode & DLGC_WANTTAB) && !bShiftDown ) {
1764 bProcess = FALSE;
1765 }
1766 else {
1767 // Ctrl-Tab cycles thru notebook pages
1768 bWindowChange = bCtrlDown;
1769 bForward = !bShiftDown;
1770 }
1771 break;
1772
1773 case VK_UP:
1774 case VK_LEFT:
1775 if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
1776 bProcess = FALSE;
1777 else
1778 bForward = FALSE;
1779 break;
1780
1781 case VK_DOWN:
1782 case VK_RIGHT:
1783 if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
1784 bProcess = FALSE;
1785 break;
1786
1787 case VK_RETURN:
1788 {
1789 if ( (lDlgCode & DLGC_WANTMESSAGE) && !bCtrlDown )
1790 {
1791 // control wants to process Enter itself, don't
1792 // call IsDialogMessage() which would interpret
1793 // it
1794 return FALSE;
1795 }
1796 else if ( lDlgCode & DLGC_BUTTON )
1797 {
1798 // let IsDialogMessage() handle this for all
1799 // buttons except the owner-drawn ones which it
1800 // just seems to ignore
1801 long style = ::GetWindowLong(msg->hwnd, GWL_STYLE);
1802 if ( (style & BS_OWNERDRAW) == BS_OWNERDRAW )
1803 {
1804 // emulate the button click
1805 wxWindow *btn = wxFindWinFromHandle((WXHWND)msg->hwnd);
1806 if ( btn )
1807 btn->MSWCommand(BN_CLICKED, 0 /* unused */);
1808 }
1809
1810 bProcess = FALSE;
1811 }
1812 // FIXME: this should be handled by
1813 // wxNavigationKeyEvent handler and not here!!
1814 else
1815 {
1816#if wxUSE_BUTTON
1817 wxButton *btn = wxDynamicCast(GetDefaultItem(),
1818 wxButton);
1819 if ( btn && btn->IsEnabled() )
1820 {
1821 // if we do have a default button, do press it
1822 btn->MSWCommand(BN_CLICKED, 0 /* unused */);
1823
1824 return TRUE;
1825 }
1826 else // no default button
1827#endif // wxUSE_BUTTON
1828 {
1829 // no special function for enter and don't even
1830 // let IsDialogMessage() have it: it seems to
1831 // do something really strange with it
1832 return FALSE;
1833 }
1834 }
1835 }
1836 break;
1837
1838 default:
1839 bProcess = FALSE;
1840 }
1841
1842 if ( bProcess )
1843 {
1844 wxNavigationKeyEvent event;
1845 event.SetDirection(bForward);
1846 event.SetWindowChange(bWindowChange);
1847 event.SetEventObject(this);
1848
1849 if ( GetEventHandler()->ProcessEvent(event) )
1850 {
1851 return TRUE;
1852 }
1853 }
1854 }
1855#else // 0
1856 // let ::IsDialogMessage() do almost everything and handle just the
1857 // things it doesn't here: Ctrl-TAB for switching notebook pages
1858 if ( msg->message == WM_KEYDOWN )
1859 {
1860 // don't process system keys here
1861 if ( !(HIWORD(msg->lParam) & KF_ALTDOWN) )
1862 {
1863 if ( (msg->wParam == VK_TAB) && wxIsCtrlDown() )
1864 {
1865 // find the first notebook parent and change its page
1866 wxWindow *win = this;
1867 wxNotebook *nbook = NULL;
1868 while ( win && !nbook )
1869 {
1870 nbook = wxDynamicCast(win, wxNotebook);
1871 win = win->GetParent();
1872 }
1873
1874 if ( nbook )
1875 {
1876 bool forward = !wxIsShiftDown();
1877
1878 nbook->AdvanceSelection(forward);
1879 }
1880 }
1881 }
1882 }
1883#endif // 1/0
1884
1885 if ( ::IsDialogMessage(GetHwnd(), msg) )
1886 {
1887 // IsDialogMessage() did something...
1888 return TRUE;
1889 }
1890 }
1891#endif // __WXUNIVERSAL__
1892
1893#if wxUSE_TOOLTIPS
1894 if ( m_tooltip )
1895 {
1896 // relay mouse move events to the tooltip control
1897 MSG *msg = (MSG *)pMsg;
1898 if ( msg->message == WM_MOUSEMOVE )
1899 m_tooltip->RelayEvent(pMsg);
1900 }
1901#endif // wxUSE_TOOLTIPS
1902
1903 return FALSE;
1904}
1905
1906bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
1907{
1908#if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
1909 return m_acceleratorTable.Translate(this, pMsg);
1910#else
1911 return FALSE;
1912#endif // wxUSE_ACCEL
1913}
1914
1915bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* pMsg)
1916{
1917 // preprocess all messages by default
1918 return TRUE;
1919}
1920
1921// ---------------------------------------------------------------------------
1922// message params unpackers (different for Win16 and Win32)
1923// ---------------------------------------------------------------------------
1924
1925#ifdef __WIN32__
1926
1927void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
1928 WORD *id, WXHWND *hwnd, WORD *cmd)
1929{
1930 *id = LOWORD(wParam);
1931 *hwnd = (WXHWND)lParam;
1932 *cmd = HIWORD(wParam);
1933}
1934
1935void wxWindowMSW::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
1936 WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
1937{
1938 *state = LOWORD(wParam);
1939 *minimized = HIWORD(wParam);
1940 *hwnd = (WXHWND)lParam;
1941}
1942
1943void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
1944 WXWORD *code, WXWORD *pos, WXHWND *hwnd)
1945{
1946 *code = LOWORD(wParam);
1947 *pos = HIWORD(wParam);
1948 *hwnd = (WXHWND)lParam;
1949}
1950
1951void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
1952 WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
1953{
1954#ifndef __WXMICROWIN__
1955 *nCtlColor = CTLCOLOR_BTN;
1956 *hwnd = (WXHWND)lParam;
1957 *hdc = (WXHDC)wParam;
1958#endif
1959}
1960
1961void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
1962 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
1963{
1964 *item = (WXWORD)wParam;
1965 *flags = HIWORD(wParam);
1966 *hmenu = (WXHMENU)lParam;
1967}
1968
1969#else // Win16
1970
1971void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
1972 WXWORD *id, WXHWND *hwnd, WXWORD *cmd)
1973{
1974 *id = (WXWORD)wParam;
1975 *hwnd = (WXHWND)LOWORD(lParam);
1976 *cmd = HIWORD(lParam);
1977}
1978
1979void wxWindowMSW::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
1980 WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
1981{
1982 *state = (WXWORD)wParam;
1983 *minimized = LOWORD(lParam);
1984 *hwnd = (WXHWND)HIWORD(lParam);
1985}
1986
1987void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
1988 WXWORD *code, WXWORD *pos, WXHWND *hwnd)
1989{
1990 *code = (WXWORD)wParam;
1991 *pos = LOWORD(lParam);
1992 *hwnd = (WXHWND)HIWORD(lParam);
1993}
1994
1995void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
1996 WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
1997{
1998 *hwnd = (WXHWND)LOWORD(lParam);
1999 *nCtlColor = (int)HIWORD(lParam);
2000 *hdc = (WXHDC)wParam;
2001}
2002
2003void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
2004 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
2005{
2006 *item = (WXWORD)wParam;
2007 *flags = LOWORD(lParam);
2008 *hmenu = (WXHMENU)HIWORD(lParam);
2009}
2010
2011#endif // Win32/16
2012
2013// ---------------------------------------------------------------------------
2014// Main wxWindows window proc and the window proc for wxWindow
2015// ---------------------------------------------------------------------------
2016
2017// Hook for new window just as it's being created, when the window isn't yet
2018// associated with the handle
2019static wxWindowMSW *gs_winBeingCreated = NULL;
2020
2021// implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2022// window being created and insures that it's always unset back later
2023wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW *winBeingCreated)
2024{
2025 gs_winBeingCreated = winBeingCreated;
2026}
2027
2028wxWindowCreationHook::~wxWindowCreationHook()
2029{
2030 gs_winBeingCreated = NULL;
2031}
2032
2033// Main window proc
2034LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
2035{
2036 // trace all messages - useful for the debugging
2037#ifdef __WXDEBUG__
2038 wxLogTrace(wxTraceMessages, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
2039 wxGetMessageName(message), wParam, lParam);
2040#endif // __WXDEBUG__
2041
2042 wxWindowMSW *wnd = wxFindWinFromHandle((WXHWND) hWnd);
2043
2044 // when we get the first message for the HWND we just created, we associate
2045 // it with wxWindow stored in gs_winBeingCreated
2046 if ( !wnd && gs_winBeingCreated )
2047 {
2048 wxAssociateWinWithHandle(hWnd, gs_winBeingCreated);
2049 wnd = gs_winBeingCreated;
2050 gs_winBeingCreated = NULL;
2051 wnd->SetHWND((WXHWND)hWnd);
2052 }
2053
2054 LRESULT rc;
2055
2056 if ( wnd )
2057 rc = wnd->MSWWindowProc(message, wParam, lParam);
2058 else
2059 rc = ::DefWindowProc(hWnd, message, wParam, lParam);
2060
2061 return rc;
2062}
2063
2064long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
2065{
2066 // did we process the message?
2067 bool processed = FALSE;
2068
2069 // the return value
2070 union
2071 {
2072 bool allow;
2073 long result;
2074 WXHICON hIcon;
2075 WXHBRUSH hBrush;
2076 } rc;
2077
2078 // for most messages we should return 0 when we do process the message
2079 rc.result = 0;
2080
2081 switch ( message )
2082 {
2083 case WM_CREATE:
2084 {
2085 bool mayCreate;
2086 processed = HandleCreate((WXLPCREATESTRUCT)lParam, &mayCreate);
2087 if ( processed )
2088 {
2089 // return 0 to allow window creation
2090 rc.result = mayCreate ? 0 : -1;
2091 }
2092 }
2093 break;
2094
2095 case WM_DESTROY:
2096 // never set processed to TRUE and *always* pass WM_DESTROY to
2097 // DefWindowProc() as Windows may do some internal cleanup when
2098 // processing it and failing to pass the message along may cause
2099 // memory and resource leaks!
2100 (void)HandleDestroy();
2101 break;
2102
2103 case WM_MOVE:
2104 processed = HandleMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
2105 break;
2106
2107 case WM_SIZE:
2108 switch ( wParam )
2109 {
2110 case SIZE_MAXHIDE:
2111 case SIZE_MAXSHOW:
2112 // we're not interested in these messages at all
2113 break;
2114
2115 case SIZE_MINIMIZED:
2116 // we shouldn't send sizev events for these messages as the
2117 // client size may be negative which breaks existing code
2118 //
2119 // OTOH we might send another (wxMinimizedEvent?) one or
2120 // add an additional parameter to wxSizeEvent if this is
2121 // useful to anybody
2122 break;
2123
2124 default:
2125 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2126 // fall through nevertheless
2127
2128 case SIZE_MAXIMIZED:
2129 case SIZE_RESTORED:
2130 processed = HandleSize(LOWORD(lParam), HIWORD(lParam),
2131 wParam);
2132 }
2133 break;
2134
2135#ifndef __WXMICROWIN__
2136 case WM_ACTIVATEAPP:
2137 wxTheApp->SetActive(wParam != 0, FindFocus());
2138 break;
2139#endif
2140
2141 case WM_ACTIVATE:
2142 {
2143 WXWORD state, minimized;
2144 WXHWND hwnd;
2145 UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
2146
2147 processed = HandleActivate(state, minimized != 0, (WXHWND)hwnd);
2148 }
2149 break;
2150
2151 case WM_SETFOCUS:
2152 processed = HandleSetFocus((WXHWND)(HWND)wParam);
2153 break;
2154
2155 case WM_KILLFOCUS:
2156 processed = HandleKillFocus((WXHWND)(HWND)wParam);
2157 break;
2158
2159 case WM_PAINT:
2160 processed = HandlePaint();
2161 break;
2162
2163 case WM_CLOSE:
2164 // don't let the DefWindowProc() destroy our window - we'll do it
2165 // ourselves in ~wxWindow
2166 processed = TRUE;
2167 rc.result = TRUE;
2168 break;
2169
2170 case WM_SHOWWINDOW:
2171 processed = HandleShow(wParam != 0, (int)lParam);
2172 break;
2173
2174 case WM_MOUSEMOVE:
2175 processed = HandleMouseMove(GET_X_LPARAM(lParam),
2176 GET_Y_LPARAM(lParam),
2177 wParam);
2178 break;
2179
2180#if wxUSE_MOUSEWHEEL
2181 case WM_MOUSEWHEEL:
2182 processed = HandleMouseWheel(wParam, lParam);
2183 break;
2184#endif
2185
2186 case WM_LBUTTONDOWN:
2187 case WM_LBUTTONUP:
2188 case WM_LBUTTONDBLCLK:
2189 case WM_RBUTTONDOWN:
2190 case WM_RBUTTONUP:
2191 case WM_RBUTTONDBLCLK:
2192 case WM_MBUTTONDOWN:
2193 case WM_MBUTTONUP:
2194 case WM_MBUTTONDBLCLK:
2195 {
2196 processed = FALSE;
2197#ifdef __WXMICROWIN__
2198 // MicroWindows seems to ignore the fact that a window is
2199 // disabled. So catch mouse events and throw them away if
2200 // necessary.
2201 wxWindowMSW* win = this;
2202 while (win)
2203 {
2204 if (!win->IsEnabled())
2205 {
2206 processed = TRUE;
2207 break;
2208 }
2209 win = win->GetParent();
2210 if (win && win->IsTopLevel())
2211 break;
2212 }
2213#endif // __WXMICROWIN__
2214 if (!processed)
2215 {
2216 if (message == WM_LBUTTONDOWN && AcceptsFocus())
2217 SetFocus();
2218 processed = HandleMouseEvent(message,
2219 GET_X_LPARAM(lParam),
2220 GET_Y_LPARAM(lParam),
2221 wParam);
2222 }
2223 break;
2224 }
2225
2226#ifdef __WXMICROWIN__
2227 case WM_NCLBUTTONDOWN:
2228 case WM_NCLBUTTONUP:
2229 case WM_NCLBUTTONDBLCLK:
2230 case WM_NCRBUTTONDOWN:
2231 case WM_NCRBUTTONUP:
2232 case WM_NCRBUTTONDBLCLK:
2233#if 0
2234 case WM_NCMBUTTONDOWN:
2235 case WM_NCMBUTTONUP:
2236 case WM_NCMBUTTONDBLCLK:
2237#endif
2238 {
2239 // MicroWindows seems to ignore the fact that a window
2240 // is disabled. So catch mouse events and throw them away if necessary.
2241 processed = FALSE;
2242 wxWindowMSW* win = this;
2243 while (win)
2244 {
2245 if (!win->IsEnabled())
2246 {
2247 processed = TRUE;
2248 break;
2249 }
2250 win = win->GetParent();
2251 if (win && win->IsTopLevel())
2252 break;
2253 }
2254 break;
2255 }
2256#endif // __WXMICROWIN__
2257
2258#ifdef MM_JOY1MOVE
2259 case MM_JOY1MOVE:
2260 case MM_JOY2MOVE:
2261 case MM_JOY1ZMOVE:
2262 case MM_JOY2ZMOVE:
2263 case MM_JOY1BUTTONDOWN:
2264 case MM_JOY2BUTTONDOWN:
2265 case MM_JOY1BUTTONUP:
2266 case MM_JOY2BUTTONUP:
2267 processed = HandleJoystickEvent(message,
2268 GET_X_LPARAM(lParam),
2269 GET_Y_LPARAM(lParam),
2270 wParam);
2271 break;
2272#endif // __WXMICROWIN__
2273
2274 case WM_SYSCOMMAND:
2275 processed = HandleSysCommand(wParam, lParam);
2276 break;
2277
2278 case WM_COMMAND:
2279 {
2280 WORD id, cmd;
2281 WXHWND hwnd;
2282 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
2283
2284 processed = HandleCommand(id, cmd, hwnd);
2285 }
2286 break;
2287
2288#ifdef __WIN95__
2289 case WM_NOTIFY:
2290 processed = HandleNotify((int)wParam, lParam, &rc.result);
2291 break;
2292#endif // Win95
2293
2294 // for these messages we must return TRUE if process the message
2295#ifdef WM_DRAWITEM
2296 case WM_DRAWITEM:
2297 case WM_MEASUREITEM:
2298 {
2299 int idCtrl = (UINT)wParam;
2300 if ( message == WM_DRAWITEM )
2301 {
2302 processed = MSWOnDrawItem(idCtrl,
2303 (WXDRAWITEMSTRUCT *)lParam);
2304 }
2305 else
2306 {
2307 processed = MSWOnMeasureItem(idCtrl,
2308 (WXMEASUREITEMSTRUCT *)lParam);
2309 }
2310
2311 if ( processed )
2312 rc.result = TRUE;
2313 }
2314 break;
2315#endif // defined(WM_DRAWITEM)
2316
2317 case WM_GETDLGCODE:
2318 if ( m_lDlgCode )
2319 {
2320 rc.result = m_lDlgCode;
2321 processed = TRUE;
2322 }
2323 //else: get the dlg code from the DefWindowProc()
2324 break;
2325
2326 case WM_SYSKEYDOWN:
2327 case WM_KEYDOWN:
2328 // If this has been processed by an event handler,
2329 // return 0 now (we've handled it).
2330 if ( HandleKeyDown((WORD) wParam, lParam) )
2331 {
2332 processed = TRUE;
2333
2334 break;
2335 }
2336
2337 // we consider these message "not interesting" to OnChar
2338 if ( wParam == VK_SHIFT || wParam == VK_CONTROL )
2339 {
2340 processed = TRUE;
2341
2342 break;
2343 }
2344
2345 switch ( wParam )
2346 {
2347 // avoid duplicate messages to OnChar for these ASCII keys: they
2348 // will be translated by TranslateMessage() and received in WM_CHAR
2349 case VK_ESCAPE:
2350 case VK_SPACE:
2351 case VK_RETURN:
2352 case VK_BACK:
2353 case VK_TAB:
2354 case VK_ADD:
2355 case VK_SUBTRACT:
2356 // but set processed to FALSE, not TRUE to still pass them to
2357 // the control's default window proc - otherwise built-in
2358 // keyboard handling won't work
2359 processed = FALSE;
2360
2361 break;
2362
2363#ifdef VK_APPS
2364 // special case of VK_APPS: treat it the same as right mouse
2365 // click because both usually pop up a context menu
2366 case VK_APPS:
2367 {
2368 WPARAM flags;
2369 int x, y;
2370
2371 TranslateKbdEventToMouse(this, &x, &y, &flags);
2372 processed = HandleMouseEvent(WM_RBUTTONDOWN, x, y, flags);
2373 }
2374 break;
2375#endif // VK_APPS
2376
2377 case VK_LEFT:
2378 case VK_RIGHT:
2379 case VK_DOWN:
2380 case VK_UP:
2381 default:
2382 processed = HandleChar((WORD)wParam, lParam);
2383 }
2384 break;
2385
2386 case WM_SYSKEYUP:
2387 case WM_KEYUP:
2388#ifdef VK_APPS
2389 // special case of VK_APPS: treat it the same as right mouse button
2390 if ( wParam == VK_APPS )
2391 {
2392 WPARAM flags;
2393 int x, y;
2394
2395 TranslateKbdEventToMouse(this, &x, &y, &flags);
2396 processed = HandleMouseEvent(WM_RBUTTONUP, x, y, flags);
2397 }
2398 else
2399#endif // VK_APPS
2400 {
2401 processed = HandleKeyUp((WORD) wParam, lParam);
2402 }
2403 break;
2404
2405 case WM_SYSCHAR:
2406 case WM_CHAR: // Always an ASCII character
2407 processed = HandleChar((WORD)wParam, lParam, TRUE);
2408 break;
2409
2410 case WM_HSCROLL:
2411 case WM_VSCROLL:
2412 {
2413 WXWORD code, pos;
2414 WXHWND hwnd;
2415 UnpackScroll(wParam, lParam, &code, &pos, &hwnd);
2416
2417 processed = MSWOnScroll(message == WM_HSCROLL ? wxHORIZONTAL
2418 : wxVERTICAL,
2419 code, pos, hwnd);
2420 }
2421 break;
2422
2423 // CTLCOLOR messages are sent by children to query the parent for their
2424 // colors#ifndef __WXMICROWIN__
2425#ifndef __WXMICROWIN__
2426#ifdef __WIN32__
2427 case WM_CTLCOLORMSGBOX:
2428 case WM_CTLCOLOREDIT:
2429 case WM_CTLCOLORLISTBOX:
2430 case WM_CTLCOLORBTN:
2431 case WM_CTLCOLORDLG:
2432 case WM_CTLCOLORSCROLLBAR:
2433 case WM_CTLCOLORSTATIC:
2434#else // Win16
2435 case WM_CTLCOLOR:
2436#endif // Win32/16
2437 {
2438 WXWORD nCtlColor;
2439 WXHDC hdc;
2440 WXHWND hwnd;
2441 UnpackCtlColor(wParam, lParam, &nCtlColor, &hdc, &hwnd);
2442
2443 processed = HandleCtlColor(&rc.hBrush,
2444 (WXHDC)hdc,
2445 (WXHWND)hwnd,
2446 nCtlColor,
2447 message,
2448 wParam,
2449 lParam);
2450 }
2451 break;
2452#endif // !__WXMICROWIN__
2453
2454 // the return value for this message is ignored
2455 case WM_SYSCOLORCHANGE:
2456 processed = HandleSysColorChange();
2457 break;
2458
2459 case WM_PALETTECHANGED:
2460 processed = HandlePaletteChanged((WXHWND) (HWND) wParam);
2461 break;
2462
2463 case WM_QUERYNEWPALETTE:
2464 processed = HandleQueryNewPalette();
2465 break;
2466
2467 case WM_ERASEBKGND:
2468 processed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
2469 if ( processed )
2470 {
2471 // we processed the message, i.e. erased the background
2472 rc.result = TRUE;
2473 }
2474 break;
2475
2476 case WM_DROPFILES:
2477 processed = HandleDropFiles(wParam);
2478 break;
2479
2480 case WM_INITDIALOG:
2481 processed = HandleInitDialog((WXHWND)(HWND)wParam);
2482
2483 if ( processed )
2484 {
2485 // we never set focus from here
2486 rc.result = FALSE;
2487 }
2488 break;
2489
2490 case WM_QUERYENDSESSION:
2491 processed = HandleQueryEndSession(lParam, &rc.allow);
2492 break;
2493
2494 case WM_ENDSESSION:
2495 processed = HandleEndSession(wParam != 0, lParam);
2496 break;
2497
2498 case WM_GETMINMAXINFO:
2499 processed = HandleGetMinMaxInfo((MINMAXINFO*)lParam);
2500 break;
2501
2502 case WM_SETCURSOR:
2503 processed = HandleSetCursor((WXHWND)(HWND)wParam,
2504 LOWORD(lParam), // hit test
2505 HIWORD(lParam)); // mouse msg
2506
2507 if ( processed )
2508 {
2509 // returning TRUE stops the DefWindowProc() from further
2510 // processing this message - exactly what we need because we've
2511 // just set the cursor.
2512 rc.result = TRUE;
2513 }
2514 break;
2515
2516#if defined(__WIN32__) && defined(WM_HELP)
2517 case WM_HELP:
2518 {
2519 HELPINFO* info = (HELPINFO*) lParam;
2520 // Don't yet process menu help events, just windows
2521 if (info->iContextType == HELPINFO_WINDOW)
2522 {
2523 wxWindowMSW* subjectOfHelp = this;
2524 bool eventProcessed = FALSE;
2525 while (subjectOfHelp && !eventProcessed)
2526 {
2527 wxHelpEvent helpEvent(wxEVT_HELP,
2528 subjectOfHelp->GetId(),
2529 wxPoint(info->MousePos.x,
2530 info->MousePos.y) );
2531 helpEvent.SetEventObject(this);
2532 eventProcessed =
2533 GetEventHandler()->ProcessEvent(helpEvent);
2534
2535 // Go up the window hierarchy until the event is
2536 // handled (or not)
2537 subjectOfHelp = subjectOfHelp->GetParent();
2538 }
2539
2540 processed = eventProcessed;
2541 }
2542 else if (info->iContextType == HELPINFO_MENUITEM)
2543 {
2544 wxHelpEvent helpEvent(wxEVT_HELP, info->iCtrlId);
2545 helpEvent.SetEventObject(this);
2546 processed = GetEventHandler()->ProcessEvent(helpEvent);
2547
2548 }
2549 //else: processed is already FALSE
2550 }
2551 break;
2552
2553 case WM_CONTEXTMENU:
2554 {
2555 // we don't convert from screen to client coordinates as
2556 // the event may be handled by a parent window
2557 wxPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
2558
2559 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
2560 processed = GetEventHandler()->ProcessEvent(evtCtx);
2561 }
2562 break;
2563#endif // __WIN32__
2564
2565 // unfortunately this doesn't really work as then window which
2566 // doesn't accept focus doesn't get any mouse events neither which
2567 // means it can't get any input at all
2568#if 0 //def __WXUNIVERSAL__
2569 case WM_NCHITTEST:
2570 // we shouldn't allow the windows which don't want to get focus to
2571 // get it
2572 if ( !AcceptsFocus() )
2573 {
2574 rc.result = HTTRANSPARENT;
2575 processed = TRUE;
2576 }
2577 break;
2578#endif // __WXUNIVERSAL__
2579 }
2580
2581 if ( !processed )
2582 {
2583#ifdef __WXDEBUG__
2584 wxLogTrace(wxTraceMessages, wxT("Forwarding %s to DefWindowProc."),
2585 wxGetMessageName(message));
2586#endif // __WXDEBUG__
2587 rc.result = MSWDefWindowProc(message, wParam, lParam);
2588 }
2589
2590 return rc.result;
2591}
2592
2593// ----------------------------------------------------------------------------
2594// wxWindow <-> HWND map
2595// ----------------------------------------------------------------------------
2596
2597wxList *wxWinHandleList = NULL;
2598
2599wxWindow *wxFindWinFromHandle(WXHWND hWnd)
2600{
2601 wxNode *node = wxWinHandleList->Find((long)hWnd);
2602 if ( !node )
2603 return NULL;
2604 return (wxWindow *)node->Data();
2605}
2606
2607void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win)
2608{
2609 // adding NULL hWnd is (first) surely a result of an error and
2610 // (secondly) breaks menu command processing
2611 wxCHECK_RET( hWnd != (HWND)NULL,
2612 wxT("attempt to add a NULL hWnd to window list ignored") );
2613
2614 wxWindow *oldWin = wxFindWinFromHandle((WXHWND) hWnd);
2615#ifdef __WXDEBUG__
2616 if ( oldWin && (oldWin != win) )
2617 {
2618 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2619 hWnd, win->GetClassInfo()->GetClassName());
2620 }
2621 else
2622#endif // __WXDEBUG__
2623 if (!oldWin)
2624 {
2625 wxWinHandleList->Append((long)hWnd, win);
2626 }
2627}
2628
2629void wxRemoveHandleAssociation(wxWindowMSW *win)
2630{
2631 wxWinHandleList->DeleteObject(win);
2632}
2633
2634// ----------------------------------------------------------------------------
2635// various MSW speciic class dependent functions
2636// ----------------------------------------------------------------------------
2637
2638// Default destroyer - override if you destroy it in some other way
2639// (e.g. with MDI child windows)
2640void wxWindowMSW::MSWDestroyWindow()
2641{
2642}
2643
2644void wxWindowMSW::MSWDetachWindowMenu()
2645{
2646#ifndef __WXUNIVERSAL__
2647 if ( m_hMenu )
2648 {
2649 wxChar buf[1024];
2650 HMENU hMenu = (HMENU)m_hMenu;
2651
2652 int N = ::GetMenuItemCount(hMenu);
2653 for ( int i = 0; i < N; i++ )
2654 {
2655 if ( !::GetMenuString(hMenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) )
2656 {
2657 wxLogLastError(wxT("GetMenuString"));
2658
2659 continue;
2660 }
2661
2662 if ( wxStrcmp(buf, _("&Window")) == 0 )
2663 {
2664 if ( !::RemoveMenu(hMenu, i, MF_BYPOSITION) )
2665 {
2666 wxLogLastError(wxT("RemoveMenu"));
2667 }
2668
2669 break;
2670 }
2671 }
2672 }
2673#endif // __WXUNIVERSAL__
2674}
2675
2676bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
2677 const wxSize& size,
2678 int& x, int& y,
2679 int& w, int& h) const
2680{
2681 bool nonDefault = FALSE;
2682
2683 if ( pos.x == -1 )
2684 {
2685 // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2686 // just as well set it to CW_USEDEFAULT as well
2687 x =
2688 y = CW_USEDEFAULT;
2689 }
2690 else
2691 {
2692 x = pos.x;
2693 y = pos.y == -1 ? CW_USEDEFAULT : pos.y;
2694
2695 nonDefault = TRUE;
2696 }
2697
2698 /*
2699 NB: there used to be some code here which set the initial size of the
2700 window to the client size of the parent if no explicit size was
2701 specified. This was wrong because wxWindows programs often assume
2702 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2703 it. To see why, you should understand that Windows sends WM_SIZE from
2704 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2705 from some base class ctor and so this WM_SIZE is not processed in the
2706 real class' OnSize() (because it's not fully constructed yet and the
2707 event goes to some base class OnSize() instead). So the WM_SIZE we
2708 rely on is the one sent when the parent frame resizes its children
2709 but here is the problem: if the child already has just the right
2710 size, nothing will happen as both wxWindows and Windows check for
2711 this and ignore any attempts to change the window size to the size it
2712 already has - so no WM_SIZE would be sent.
2713 */
2714 if ( size.x == -1 )
2715 {
2716 // as abobe, h is not used at all in this case anyhow
2717 w =
2718 h = CW_USEDEFAULT;
2719 }
2720 else
2721 {
2722 w = size.x;
2723 h = size.y == -1 ? CW_USEDEFAULT : size.y;
2724
2725 nonDefault = TRUE;
2726 }
2727
2728 return nonDefault;
2729}
2730
2731bool wxWindowMSW::MSWCreate(const wxChar *wclass,
2732 const wxChar *title,
2733 const wxPoint& pos,
2734 const wxSize& size,
2735 WXDWORD style,
2736 WXDWORD extendedStyle)
2737{
2738 // choose the position/size for the new window
2739 int x, y, w, h;
2740 (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
2741
2742 // find the correct parent HWND
2743 wxWindow *parent = GetParent();
2744 bool isChild = (style & WS_CHILD) != 0;
2745 HWND hParent;
2746 if ( GetWindowStyleFlag() & wxPOPUP_WINDOW )
2747 {
2748 // popup windows should have desktop as parent because they shouldn't
2749 // be limited to the parents client area as child windows usually are
2750 hParent = ::GetDesktopWindow();
2751 }
2752 else // !popup
2753 {
2754 if ( (isChild || HasFlag(wxFRAME_TOOL_WINDOW)) && parent )
2755 {
2756 // this is either a normal child window or a top level window with
2757 // wxFRAME_TOOL_WINDOW style (see below)
2758 hParent = GetHwndOf(parent);
2759 }
2760 else
2761 {
2762 // this is either a window for which no parent was specified (not
2763 // much we can do then) or a frame without wxFRAME_TOOL_WINDOW
2764 // style: we should use NULL parent HWND for it or it would be
2765 // always on top of its parent which is not what we usually want
2766 // (in fact, we only want it for frames with the special
2767 // wxFRAME_TOOL_WINDOW as above)
2768 hParent = NULL;
2769 }
2770
2771 }
2772
2773 // controlId is menu handle for the top level windows, so set it to 0
2774 // unless we're creating a child window
2775 int controlId;
2776 if ( isChild )
2777 {
2778 controlId = GetId();
2779
2780 if ( GetWindowStyleFlag() & wxCLIP_SIBLINGS )
2781 {
2782 style |= WS_CLIPSIBLINGS;
2783 }
2784 }
2785 else // !child
2786 {
2787 controlId = 0;
2788 }
2789
2790 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
2791 // which is the same but without CS_[HV]REDRAW class styles so using it
2792 // ensures that the window is not fully repainted on each resize
2793 wxString className(wclass);
2794 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE )
2795 {
2796 className += wxT("NR");
2797 }
2798
2799 // do create the window
2800 wxWindowCreationHook hook(this);
2801
2802 m_hWnd = (WXHWND)::CreateWindowEx
2803 (
2804 extendedStyle,
2805 className,
2806 title ? title : wxT(""),
2807 style,
2808 x, y, w, h,
2809 hParent,
2810 (HMENU)controlId,
2811 wxGetInstance(),
2812 NULL // no extra data
2813 );
2814
2815 if ( !m_hWnd )
2816 {
2817 wxLogSysError(_("Can't create window of class %s"), wclass);
2818
2819 return FALSE;
2820 }
2821
2822 SubclassWin(m_hWnd);
2823
2824 SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
2825
2826 return TRUE;
2827}
2828
2829// ===========================================================================
2830// MSW message handlers
2831// ===========================================================================
2832
2833// ---------------------------------------------------------------------------
2834// WM_NOTIFY
2835// ---------------------------------------------------------------------------
2836
2837#ifdef __WIN95__
2838// FIXME: VZ: I'm not sure at all that the order of processing is correct
2839bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
2840{
2841#ifndef __WXMICROWIN__
2842 LPNMHDR hdr = (LPNMHDR)lParam;
2843 HWND hWnd = hdr->hwndFrom;
2844 wxWindow *win = wxFindWinFromHandle((WXHWND)hWnd);
2845
2846 // is this one of our windows?
2847 if ( win )
2848 {
2849 return win->MSWOnNotify(idCtrl, lParam, result);
2850 }
2851
2852 // try all our children
2853 wxWindowList::Node *node = GetChildren().GetFirst();
2854 while ( node )
2855 {
2856 wxWindow *child = node->GetData();
2857 if ( child->MSWOnNotify(idCtrl, lParam, result) )
2858 {
2859 return TRUE;
2860 }
2861
2862 node = node->GetNext();
2863 }
2864
2865 // finally try this window too (catches toolbar case)
2866 return MSWOnNotify(idCtrl, lParam, result);
2867#else // __WXMICROWIN__
2868 return FALSE;
2869#endif
2870}
2871
2872bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
2873 WXLPARAM lParam,
2874 WXLPARAM* WXUNUSED(result))
2875{
2876#if wxUSE_TOOLTIPS
2877 NMHDR* hdr = (NMHDR *)lParam;
2878 if ( (int)hdr->code == TTN_NEEDTEXT && m_tooltip )
2879 {
2880 TOOLTIPTEXT *ttt = (TOOLTIPTEXT *)lParam;
2881 ttt->lpszText = (wxChar *)m_tooltip->GetTip().c_str();
2882
2883 // processed
2884 return TRUE;
2885 }
2886#endif // wxUSE_TOOLTIPS
2887
2888 return FALSE;
2889}
2890#endif // __WIN95__
2891
2892// ---------------------------------------------------------------------------
2893// end session messages
2894// ---------------------------------------------------------------------------
2895
2896bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
2897{
2898 wxCloseEvent event(wxEVT_QUERY_END_SESSION, -1);
2899 event.SetEventObject(wxTheApp);
2900 event.SetCanVeto(TRUE);
2901 event.SetLoggingOff(logOff == (long)ENDSESSION_LOGOFF);
2902
2903 bool rc = wxTheApp->ProcessEvent(event);
2904
2905 if ( rc )
2906 {
2907 // we may end only if the app didn't veto session closing (double
2908 // negation...)
2909 *mayEnd = !event.GetVeto();
2910 }
2911
2912 return rc;
2913}
2914
2915bool wxWindowMSW::HandleEndSession(bool endSession, long logOff)
2916{
2917 // do nothing if the session isn't ending
2918 if ( !endSession )
2919 return FALSE;
2920
2921 // only send once
2922 if ( (this != wxTheApp->GetTopWindow()) )
2923 return FALSE;
2924
2925 wxCloseEvent event(wxEVT_END_SESSION, -1);
2926 event.SetEventObject(wxTheApp);
2927 event.SetCanVeto(FALSE);
2928 event.SetLoggingOff( (logOff == (long)ENDSESSION_LOGOFF) );
2929
2930 return wxTheApp->ProcessEvent(event);
2931}
2932
2933// ---------------------------------------------------------------------------
2934// window creation/destruction
2935// ---------------------------------------------------------------------------
2936
2937bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT WXUNUSED(cs), bool *mayCreate)
2938{
2939 // TODO: should generate this event from WM_NCCREATE
2940 wxWindowCreateEvent event((wxWindow *)this);
2941 (void)GetEventHandler()->ProcessEvent(event);
2942
2943 *mayCreate = TRUE;
2944
2945 return TRUE;
2946}
2947
2948bool wxWindowMSW::HandleDestroy()
2949{
2950 wxWindowDestroyEvent event((wxWindow *)this);
2951 (void)GetEventHandler()->ProcessEvent(event);
2952
2953 // delete our drop target if we've got one
2954#if wxUSE_DRAG_AND_DROP
2955 if ( m_dropTarget != NULL )
2956 {
2957 m_dropTarget->Revoke(m_hWnd);
2958
2959 delete m_dropTarget;
2960 m_dropTarget = NULL;
2961 }
2962#endif // wxUSE_DRAG_AND_DROP
2963
2964 // WM_DESTROY handled
2965 return TRUE;
2966}
2967
2968// ---------------------------------------------------------------------------
2969// activation/focus
2970// ---------------------------------------------------------------------------
2971
2972bool wxWindowMSW::HandleActivate(int state,
2973 bool WXUNUSED(minimized),
2974 WXHWND WXUNUSED(activate))
2975{
2976 wxActivateEvent event(wxEVT_ACTIVATE,
2977 (state == WA_ACTIVE) || (state == WA_CLICKACTIVE),
2978 m_windowId);
2979 event.SetEventObject(this);
2980
2981 return GetEventHandler()->ProcessEvent(event);
2982}
2983
2984bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
2985{
2986 // notify the parent keeping track of focus for the kbd navigation
2987 // purposes that we got it
2988 wxChildFocusEvent eventFocus((wxWindow *)this);
2989 (void)GetEventHandler()->ProcessEvent(eventFocus);
2990
2991#if wxUSE_CARET
2992 // Deal with caret
2993 if ( m_caret )
2994 {
2995 m_caret->OnSetFocus();
2996 }
2997#endif // wxUSE_CARET
2998
2999#if wxUSE_TEXTCTRL
3000 // If it's a wxTextCtrl don't send the event as it will be done
3001 // after the control gets to process it from EN_FOCUS handler
3002 if ( wxDynamicCastThis(wxTextCtrl) )
3003 {
3004 return FALSE;
3005 }
3006#endif // wxUSE_TEXTCTRL
3007
3008 wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
3009 event.SetEventObject(this);
3010
3011 // wxFindWinFromHandle() may return NULL, it is ok
3012 event.SetWindow(wxFindWinFromHandle(hwnd));
3013
3014 return GetEventHandler()->ProcessEvent(event);
3015}
3016
3017bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
3018{
3019#if wxUSE_CARET
3020 // Deal with caret
3021 if ( m_caret )
3022 {
3023 m_caret->OnKillFocus();
3024 }
3025#endif // wxUSE_CARET
3026
3027#if wxUSE_TEXTCTRL
3028 // If it's a wxTextCtrl don't send the event as it will be done
3029 // after the control gets to process it.
3030 wxTextCtrl *ctrl = wxDynamicCastThis(wxTextCtrl);
3031 if ( ctrl )
3032 {
3033 return FALSE;
3034 }
3035#endif
3036
3037 wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
3038 event.SetEventObject(this);
3039
3040 // wxFindWinFromHandle() may return NULL, it is ok
3041 event.SetWindow(wxFindWinFromHandle(hwnd));
3042
3043 return GetEventHandler()->ProcessEvent(event);
3044}
3045
3046// ---------------------------------------------------------------------------
3047// miscellaneous
3048// ---------------------------------------------------------------------------
3049
3050bool wxWindowMSW::HandleShow(bool show, int WXUNUSED(status))
3051{
3052 wxShowEvent event(GetId(), show);
3053 event.m_eventObject = this;
3054
3055 return GetEventHandler()->ProcessEvent(event);
3056}
3057
3058bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
3059{
3060 wxInitDialogEvent event(GetId());
3061 event.m_eventObject = this;
3062
3063 return GetEventHandler()->ProcessEvent(event);
3064}
3065
3066bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
3067{
3068#ifndef __WXMICROWIN__
3069 HDROP hFilesInfo = (HDROP) wParam;
3070 POINT dropPoint;
3071 DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
3072
3073 // Get the total number of files dropped
3074 WORD gwFilesDropped = (WORD)::DragQueryFile
3075 (
3076 (HDROP)hFilesInfo,
3077 (UINT)-1,
3078 (LPTSTR)0,
3079 (UINT)0
3080 );
3081
3082 wxString *files = new wxString[gwFilesDropped];
3083 int wIndex;
3084 for (wIndex=0; wIndex < (int)gwFilesDropped; wIndex++)
3085 {
3086 DragQueryFile (hFilesInfo, wIndex, (LPTSTR) wxBuffer, 1000);
3087 files[wIndex] = wxBuffer;
3088 }
3089 DragFinish (hFilesInfo);
3090
3091 wxDropFilesEvent event(wxEVT_DROP_FILES, gwFilesDropped, files);
3092 event.m_eventObject = this;
3093 event.m_pos.x = dropPoint.x;
3094 event.m_pos.y = dropPoint.y;
3095
3096 bool rc = GetEventHandler()->ProcessEvent(event);
3097
3098 delete[] files;
3099
3100 return rc;
3101#else // __WXMICROWIN__
3102 return FALSE;
3103#endif
3104}
3105
3106bool 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
3197bool 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
3240bool 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
3268bool wxWindowMSW::HandleSysColorChange()
3269{
3270 wxSysColourChangedEvent event;
3271 event.SetEventObject(this);
3272
3273 return GetEventHandler()->ProcessEvent(event);
3274}
3275
3276bool 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
3310WXHBRUSH 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
3320bool 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
3329bool 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.
3338void 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
3360bool 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
3395void 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
3408bool 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
3432void 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
3457bool wxWindowMSW::HandleMinimize()
3458{
3459 wxIconizeEvent event(m_windowId);
3460 event.SetEventObject(this);
3461
3462 return GetEventHandler()->ProcessEvent(event);
3463}
3464
3465bool wxWindowMSW::HandleMaximize()
3466{
3467 wxMaximizeEvent event(m_windowId);
3468 event.SetEventObject(this);
3469
3470 return GetEventHandler()->ProcessEvent(event);
3471}
3472
3473bool 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
3481bool 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
3489bool 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
3526bool wxWindowMSW::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
3527{
3528#if wxUSE_MENUS_NATIVE
3529 if ( 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 = (wxWindow*) 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
3588bool 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
3607void 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
3633bool 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
3659bool 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
3698bool 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
3746wxKeyEvent 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
3776bool 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
3829bool 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
3851bool 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
3875bool 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
3963bool 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
4046void 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.
4078int 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
4156int 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
4233wxWindow *wxGetActiveWindow()
4234{
4235 HWND hWnd = GetActiveWindow();
4236 if ( hWnd != 0 )
4237 {
4238 return wxFindWinFromHandle((WXHWND) hWnd);
4239 }
4240 return NULL;
4241}
4242
4243extern 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 if ( ::GetWindow(hwnd, GW_OWNER) )
4294 {
4295 // it's a dialog box, don't go upwards
4296 break;
4297 }
4298
4299 hwnd = ::GetParent(hwnd);
4300 win = wxFindWinFromHandle((WXHWND)hwnd);
4301 }
4302
4303 return win;
4304}
4305
4306#ifndef __WXMICROWIN__
4307
4308// Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4309// in active frames and dialogs, regardless of where the focus is.
4310static HHOOK wxTheKeyboardHook = 0;
4311static FARPROC wxTheKeyboardHookProc = 0;
4312int APIENTRY _EXPORT
4313wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
4314
4315void wxSetKeyboardHook(bool doIt)
4316{
4317 if ( doIt )
4318 {
4319 wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
4320 wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
4321
4322#if defined(__WIN32__) && !defined(__TWIN32__)
4323 GetCurrentThreadId()
4324 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
4325#else
4326 GetCurrentTask()
4327#endif
4328 );
4329 }
4330 else
4331 {
4332 UnhookWindowsHookEx(wxTheKeyboardHook);
4333
4334 // avoids warning about statement with no effect (FreeProcInstance
4335 // doesn't do anything under Win32)
4336#if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32__) && !defined(__NT__) && !defined(__GNUWIN32__)
4337 FreeProcInstance(wxTheKeyboardHookProc);
4338#endif
4339 }
4340}
4341
4342int APIENTRY _EXPORT
4343wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
4344{
4345 DWORD hiWord = HIWORD(lParam);
4346 if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
4347 {
4348 int id = wxCharCodeMSWToWX(wParam);
4349 if ( id != 0 )
4350 {
4351 wxKeyEvent event(wxEVT_CHAR_HOOK);
4352 if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
4353 event.m_altDown = TRUE;
4354
4355 event.m_eventObject = NULL;
4356 event.m_keyCode = id;
4357 event.m_shiftDown = wxIsShiftDown();
4358 event.m_controlDown = wxIsCtrlDown();
4359 event.SetTimestamp(s_currentMsg.time);
4360
4361 wxWindow *win = wxGetActiveWindow();
4362 wxEvtHandler *handler;
4363 if ( win )
4364 {
4365 handler = win->GetEventHandler();
4366 event.SetId(win->GetId());
4367 }
4368 else
4369 {
4370 handler = wxTheApp;
4371 event.SetId(-1);
4372 }
4373
4374 if ( handler && handler->ProcessEvent(event) )
4375 {
4376 // processed
4377 return 1;
4378 }
4379 }
4380 }
4381
4382 return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
4383}
4384
4385#endif // !__WXMICROWIN__
4386
4387#ifdef __WXDEBUG__
4388const char *wxGetMessageName(int message)
4389{
4390 switch ( message )
4391 {
4392 case 0x0000: return "WM_NULL";
4393 case 0x0001: return "WM_CREATE";
4394 case 0x0002: return "WM_DESTROY";
4395 case 0x0003: return "WM_MOVE";
4396 case 0x0005: return "WM_SIZE";
4397 case 0x0006: return "WM_ACTIVATE";
4398 case 0x0007: return "WM_SETFOCUS";
4399 case 0x0008: return "WM_KILLFOCUS";
4400 case 0x000A: return "WM_ENABLE";
4401 case 0x000B: return "WM_SETREDRAW";
4402 case 0x000C: return "WM_SETTEXT";
4403 case 0x000D: return "WM_GETTEXT";
4404 case 0x000E: return "WM_GETTEXTLENGTH";
4405 case 0x000F: return "WM_PAINT";
4406 case 0x0010: return "WM_CLOSE";
4407 case 0x0011: return "WM_QUERYENDSESSION";
4408 case 0x0012: return "WM_QUIT";
4409 case 0x0013: return "WM_QUERYOPEN";
4410 case 0x0014: return "WM_ERASEBKGND";
4411 case 0x0015: return "WM_SYSCOLORCHANGE";
4412 case 0x0016: return "WM_ENDSESSION";
4413 case 0x0017: return "WM_SYSTEMERROR";
4414 case 0x0018: return "WM_SHOWWINDOW";
4415 case 0x0019: return "WM_CTLCOLOR";
4416 case 0x001A: return "WM_WININICHANGE";
4417 case 0x001B: return "WM_DEVMODECHANGE";
4418 case 0x001C: return "WM_ACTIVATEAPP";
4419 case 0x001D: return "WM_FONTCHANGE";
4420 case 0x001E: return "WM_TIMECHANGE";
4421 case 0x001F: return "WM_CANCELMODE";
4422 case 0x0020: return "WM_SETCURSOR";
4423 case 0x0021: return "WM_MOUSEACTIVATE";
4424 case 0x0022: return "WM_CHILDACTIVATE";
4425 case 0x0023: return "WM_QUEUESYNC";
4426 case 0x0024: return "WM_GETMINMAXINFO";
4427 case 0x0026: return "WM_PAINTICON";
4428 case 0x0027: return "WM_ICONERASEBKGND";
4429 case 0x0028: return "WM_NEXTDLGCTL";
4430 case 0x002A: return "WM_SPOOLERSTATUS";
4431 case 0x002B: return "WM_DRAWITEM";
4432 case 0x002C: return "WM_MEASUREITEM";
4433 case 0x002D: return "WM_DELETEITEM";
4434 case 0x002E: return "WM_VKEYTOITEM";
4435 case 0x002F: return "WM_CHARTOITEM";
4436 case 0x0030: return "WM_SETFONT";
4437 case 0x0031: return "WM_GETFONT";
4438 case 0x0037: return "WM_QUERYDRAGICON";
4439 case 0x0039: return "WM_COMPAREITEM";
4440 case 0x0041: return "WM_COMPACTING";
4441 case 0x0044: return "WM_COMMNOTIFY";
4442 case 0x0046: return "WM_WINDOWPOSCHANGING";
4443 case 0x0047: return "WM_WINDOWPOSCHANGED";
4444 case 0x0048: return "WM_POWER";
4445
4446#ifdef __WIN32__
4447 case 0x004A: return "WM_COPYDATA";
4448 case 0x004B: return "WM_CANCELJOURNAL";
4449 case 0x004E: return "WM_NOTIFY";
4450 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
4451 case 0x0051: return "WM_INPUTLANGCHANGE";
4452 case 0x0052: return "WM_TCARD";
4453 case 0x0053: return "WM_HELP";
4454 case 0x0054: return "WM_USERCHANGED";
4455 case 0x0055: return "WM_NOTIFYFORMAT";
4456 case 0x007B: return "WM_CONTEXTMENU";
4457 case 0x007C: return "WM_STYLECHANGING";
4458 case 0x007D: return "WM_STYLECHANGED";
4459 case 0x007E: return "WM_DISPLAYCHANGE";
4460 case 0x007F: return "WM_GETICON";
4461 case 0x0080: return "WM_SETICON";
4462#endif //WIN32
4463
4464 case 0x0081: return "WM_NCCREATE";
4465 case 0x0082: return "WM_NCDESTROY";
4466 case 0x0083: return "WM_NCCALCSIZE";
4467 case 0x0084: return "WM_NCHITTEST";
4468 case 0x0085: return "WM_NCPAINT";
4469 case 0x0086: return "WM_NCACTIVATE";
4470 case 0x0087: return "WM_GETDLGCODE";
4471 case 0x00A0: return "WM_NCMOUSEMOVE";
4472 case 0x00A1: return "WM_NCLBUTTONDOWN";
4473 case 0x00A2: return "WM_NCLBUTTONUP";
4474 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
4475 case 0x00A4: return "WM_NCRBUTTONDOWN";
4476 case 0x00A5: return "WM_NCRBUTTONUP";
4477 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
4478 case 0x00A7: return "WM_NCMBUTTONDOWN";
4479 case 0x00A8: return "WM_NCMBUTTONUP";
4480 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
4481 case 0x0100: return "WM_KEYDOWN";
4482 case 0x0101: return "WM_KEYUP";
4483 case 0x0102: return "WM_CHAR";
4484 case 0x0103: return "WM_DEADCHAR";
4485 case 0x0104: return "WM_SYSKEYDOWN";
4486 case 0x0105: return "WM_SYSKEYUP";
4487 case 0x0106: return "WM_SYSCHAR";
4488 case 0x0107: return "WM_SYSDEADCHAR";
4489 case 0x0108: return "WM_KEYLAST";
4490
4491#ifdef __WIN32__
4492 case 0x010D: return "WM_IME_STARTCOMPOSITION";
4493 case 0x010E: return "WM_IME_ENDCOMPOSITION";
4494 case 0x010F: return "WM_IME_COMPOSITION";
4495#endif //WIN32
4496
4497 case 0x0110: return "WM_INITDIALOG";
4498 case 0x0111: return "WM_COMMAND";
4499 case 0x0112: return "WM_SYSCOMMAND";
4500 case 0x0113: return "WM_TIMER";
4501 case 0x0114: return "WM_HSCROLL";
4502 case 0x0115: return "WM_VSCROLL";
4503 case 0x0116: return "WM_INITMENU";
4504 case 0x0117: return "WM_INITMENUPOPUP";
4505 case 0x011F: return "WM_MENUSELECT";
4506 case 0x0120: return "WM_MENUCHAR";
4507 case 0x0121: return "WM_ENTERIDLE";
4508 case 0x0200: return "WM_MOUSEMOVE";
4509 case 0x0201: return "WM_LBUTTONDOWN";
4510 case 0x0202: return "WM_LBUTTONUP";
4511 case 0x0203: return "WM_LBUTTONDBLCLK";
4512 case 0x0204: return "WM_RBUTTONDOWN";
4513 case 0x0205: return "WM_RBUTTONUP";
4514 case 0x0206: return "WM_RBUTTONDBLCLK";
4515 case 0x0207: return "WM_MBUTTONDOWN";
4516 case 0x0208: return "WM_MBUTTONUP";
4517 case 0x0209: return "WM_MBUTTONDBLCLK";
4518 case 0x020A: return "WM_MOUSEWHEEL";
4519 case 0x0210: return "WM_PARENTNOTIFY";
4520 case 0x0211: return "WM_ENTERMENULOOP";
4521 case 0x0212: return "WM_EXITMENULOOP";
4522
4523#ifdef __WIN32__
4524 case 0x0213: return "WM_NEXTMENU";
4525 case 0x0214: return "WM_SIZING";
4526 case 0x0215: return "WM_CAPTURECHANGED";
4527 case 0x0216: return "WM_MOVING";
4528 case 0x0218: return "WM_POWERBROADCAST";
4529 case 0x0219: return "WM_DEVICECHANGE";
4530#endif //WIN32
4531
4532 case 0x0220: return "WM_MDICREATE";
4533 case 0x0221: return "WM_MDIDESTROY";
4534 case 0x0222: return "WM_MDIACTIVATE";
4535 case 0x0223: return "WM_MDIRESTORE";
4536 case 0x0224: return "WM_MDINEXT";
4537 case 0x0225: return "WM_MDIMAXIMIZE";
4538 case 0x0226: return "WM_MDITILE";
4539 case 0x0227: return "WM_MDICASCADE";
4540 case 0x0228: return "WM_MDIICONARRANGE";
4541 case 0x0229: return "WM_MDIGETACTIVE";
4542 case 0x0230: return "WM_MDISETMENU";
4543 case 0x0233: return "WM_DROPFILES";
4544
4545#ifdef __WIN32__
4546 case 0x0281: return "WM_IME_SETCONTEXT";
4547 case 0x0282: return "WM_IME_NOTIFY";
4548 case 0x0283: return "WM_IME_CONTROL";
4549 case 0x0284: return "WM_IME_COMPOSITIONFULL";
4550 case 0x0285: return "WM_IME_SELECT";
4551 case 0x0286: return "WM_IME_CHAR";
4552 case 0x0290: return "WM_IME_KEYDOWN";
4553 case 0x0291: return "WM_IME_KEYUP";
4554#endif //WIN32
4555
4556 case 0x0300: return "WM_CUT";
4557 case 0x0301: return "WM_COPY";
4558 case 0x0302: return "WM_PASTE";
4559 case 0x0303: return "WM_CLEAR";
4560 case 0x0304: return "WM_UNDO";
4561 case 0x0305: return "WM_RENDERFORMAT";
4562 case 0x0306: return "WM_RENDERALLFORMATS";
4563 case 0x0307: return "WM_DESTROYCLIPBOARD";
4564 case 0x0308: return "WM_DRAWCLIPBOARD";
4565 case 0x0309: return "WM_PAINTCLIPBOARD";
4566 case 0x030A: return "WM_VSCROLLCLIPBOARD";
4567 case 0x030B: return "WM_SIZECLIPBOARD";
4568 case 0x030C: return "WM_ASKCBFORMATNAME";
4569 case 0x030D: return "WM_CHANGECBCHAIN";
4570 case 0x030E: return "WM_HSCROLLCLIPBOARD";
4571 case 0x030F: return "WM_QUERYNEWPALETTE";
4572 case 0x0310: return "WM_PALETTEISCHANGING";
4573 case 0x0311: return "WM_PALETTECHANGED";
4574
4575#ifdef __WIN32__
4576 // common controls messages - although they're not strictly speaking
4577 // standard, it's nice to decode them nevertheless
4578
4579 // listview
4580 case 0x1000 + 0: return "LVM_GETBKCOLOR";
4581 case 0x1000 + 1: return "LVM_SETBKCOLOR";
4582 case 0x1000 + 2: return "LVM_GETIMAGELIST";
4583 case 0x1000 + 3: return "LVM_SETIMAGELIST";
4584 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
4585 case 0x1000 + 5: return "LVM_GETITEMA";
4586 case 0x1000 + 75: return "LVM_GETITEMW";
4587 case 0x1000 + 6: return "LVM_SETITEMA";
4588 case 0x1000 + 76: return "LVM_SETITEMW";
4589 case 0x1000 + 7: return "LVM_INSERTITEMA";
4590 case 0x1000 + 77: return "LVM_INSERTITEMW";
4591 case 0x1000 + 8: return "LVM_DELETEITEM";
4592 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
4593 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
4594 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
4595 case 0x1000 + 12: return "LVM_GETNEXTITEM";
4596 case 0x1000 + 13: return "LVM_FINDITEMA";
4597 case 0x1000 + 83: return "LVM_FINDITEMW";
4598 case 0x1000 + 14: return "LVM_GETITEMRECT";
4599 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
4600 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
4601 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
4602 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
4603 case 0x1000 + 18: return "LVM_HITTEST";
4604 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
4605 case 0x1000 + 20: return "LVM_SCROLL";
4606 case 0x1000 + 21: return "LVM_REDRAWITEMS";
4607 case 0x1000 + 22: return "LVM_ARRANGE";
4608 case 0x1000 + 23: return "LVM_EDITLABELA";
4609 case 0x1000 + 118: return "LVM_EDITLABELW";
4610 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
4611 case 0x1000 + 25: return "LVM_GETCOLUMNA";
4612 case 0x1000 + 95: return "LVM_GETCOLUMNW";
4613 case 0x1000 + 26: return "LVM_SETCOLUMNA";
4614 case 0x1000 + 96: return "LVM_SETCOLUMNW";
4615 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
4616 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
4617 case 0x1000 + 28: return "LVM_DELETECOLUMN";
4618 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
4619 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
4620 case 0x1000 + 31: return "LVM_GETHEADER";
4621 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
4622 case 0x1000 + 34: return "LVM_GETVIEWRECT";
4623 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
4624 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
4625 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
4626 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
4627 case 0x1000 + 39: return "LVM_GETTOPINDEX";
4628 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
4629 case 0x1000 + 41: return "LVM_GETORIGIN";
4630 case 0x1000 + 42: return "LVM_UPDATE";
4631 case 0x1000 + 43: return "LVM_SETITEMSTATE";
4632 case 0x1000 + 44: return "LVM_GETITEMSTATE";
4633 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
4634 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
4635 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
4636 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
4637 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
4638 case 0x1000 + 48: return "LVM_SORTITEMS";
4639 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
4640 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
4641 case 0x1000 + 51: return "LVM_GETITEMSPACING";
4642 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
4643 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
4644 case 0x1000 + 53: return "LVM_SETICONSPACING";
4645 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
4646 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
4647 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
4648 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
4649 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
4650 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
4651 case 0x1000 + 60: return "LVM_SETHOTITEM";
4652 case 0x1000 + 61: return "LVM_GETHOTITEM";
4653 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
4654 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
4655 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
4656 case 0x1000 + 65: return "LVM_SETWORKAREA";
4657
4658 // tree view
4659 case 0x1100 + 0: return "TVM_INSERTITEMA";
4660 case 0x1100 + 50: return "TVM_INSERTITEMW";
4661 case 0x1100 + 1: return "TVM_DELETEITEM";
4662 case 0x1100 + 2: return "TVM_EXPAND";
4663 case 0x1100 + 4: return "TVM_GETITEMRECT";
4664 case 0x1100 + 5: return "TVM_GETCOUNT";
4665 case 0x1100 + 6: return "TVM_GETINDENT";
4666 case 0x1100 + 7: return "TVM_SETINDENT";
4667 case 0x1100 + 8: return "TVM_GETIMAGELIST";
4668 case 0x1100 + 9: return "TVM_SETIMAGELIST";
4669 case 0x1100 + 10: return "TVM_GETNEXTITEM";
4670 case 0x1100 + 11: return "TVM_SELECTITEM";
4671 case 0x1100 + 12: return "TVM_GETITEMA";
4672 case 0x1100 + 62: return "TVM_GETITEMW";
4673 case 0x1100 + 13: return "TVM_SETITEMA";
4674 case 0x1100 + 63: return "TVM_SETITEMW";
4675 case 0x1100 + 14: return "TVM_EDITLABELA";
4676 case 0x1100 + 65: return "TVM_EDITLABELW";
4677 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
4678 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
4679 case 0x1100 + 17: return "TVM_HITTEST";
4680 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
4681 case 0x1100 + 19: return "TVM_SORTCHILDREN";
4682 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
4683 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
4684 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
4685 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
4686 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
4687 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
4688 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
4689
4690 // header
4691 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
4692 case 0x1200 + 1: return "HDM_INSERTITEMA";
4693 case 0x1200 + 10: return "HDM_INSERTITEMW";
4694 case 0x1200 + 2: return "HDM_DELETEITEM";
4695 case 0x1200 + 3: return "HDM_GETITEMA";
4696 case 0x1200 + 11: return "HDM_GETITEMW";
4697 case 0x1200 + 4: return "HDM_SETITEMA";
4698 case 0x1200 + 12: return "HDM_SETITEMW";
4699 case 0x1200 + 5: return "HDM_LAYOUT";
4700 case 0x1200 + 6: return "HDM_HITTEST";
4701 case 0x1200 + 7: return "HDM_GETITEMRECT";
4702 case 0x1200 + 8: return "HDM_SETIMAGELIST";
4703 case 0x1200 + 9: return "HDM_GETIMAGELIST";
4704 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
4705 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
4706 case 0x1200 + 17: return "HDM_GETORDERARRAY";
4707 case 0x1200 + 18: return "HDM_SETORDERARRAY";
4708 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
4709
4710 // tab control
4711 case 0x1300 + 2: return "TCM_GETIMAGELIST";
4712 case 0x1300 + 3: return "TCM_SETIMAGELIST";
4713 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
4714 case 0x1300 + 5: return "TCM_GETITEMA";
4715 case 0x1300 + 60: return "TCM_GETITEMW";
4716 case 0x1300 + 6: return "TCM_SETITEMA";
4717 case 0x1300 + 61: return "TCM_SETITEMW";
4718 case 0x1300 + 7: return "TCM_INSERTITEMA";
4719 case 0x1300 + 62: return "TCM_INSERTITEMW";
4720 case 0x1300 + 8: return "TCM_DELETEITEM";
4721 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
4722 case 0x1300 + 10: return "TCM_GETITEMRECT";
4723 case 0x1300 + 11: return "TCM_GETCURSEL";
4724 case 0x1300 + 12: return "TCM_SETCURSEL";
4725 case 0x1300 + 13: return "TCM_HITTEST";
4726 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
4727 case 0x1300 + 40: return "TCM_ADJUSTRECT";
4728 case 0x1300 + 41: return "TCM_SETITEMSIZE";
4729 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
4730 case 0x1300 + 43: return "TCM_SETPADDING";
4731 case 0x1300 + 44: return "TCM_GETROWCOUNT";
4732 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
4733 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
4734 case 0x1300 + 47: return "TCM_GETCURFOCUS";
4735 case 0x1300 + 48: return "TCM_SETCURFOCUS";
4736 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
4737 case 0x1300 + 50: return "TCM_DESELECTALL";
4738
4739 // toolbar
4740 case WM_USER+1: return "TB_ENABLEBUTTON";
4741 case WM_USER+2: return "TB_CHECKBUTTON";
4742 case WM_USER+3: return "TB_PRESSBUTTON";
4743 case WM_USER+4: return "TB_HIDEBUTTON";
4744 case WM_USER+5: return "TB_INDETERMINATE";
4745 case WM_USER+9: return "TB_ISBUTTONENABLED";
4746 case WM_USER+10: return "TB_ISBUTTONCHECKED";
4747 case WM_USER+11: return "TB_ISBUTTONPRESSED";
4748 case WM_USER+12: return "TB_ISBUTTONHIDDEN";
4749 case WM_USER+13: return "TB_ISBUTTONINDETERMINATE";
4750 case WM_USER+17: return "TB_SETSTATE";
4751 case WM_USER+18: return "TB_GETSTATE";
4752 case WM_USER+19: return "TB_ADDBITMAP";
4753 case WM_USER+20: return "TB_ADDBUTTONS";
4754 case WM_USER+21: return "TB_INSERTBUTTON";
4755 case WM_USER+22: return "TB_DELETEBUTTON";
4756 case WM_USER+23: return "TB_GETBUTTON";
4757 case WM_USER+24: return "TB_BUTTONCOUNT";
4758 case WM_USER+25: return "TB_COMMANDTOINDEX";
4759 case WM_USER+26: return "TB_SAVERESTOREA";
4760 case WM_USER+76: return "TB_SAVERESTOREW";
4761 case WM_USER+27: return "TB_CUSTOMIZE";
4762 case WM_USER+28: return "TB_ADDSTRINGA";
4763 case WM_USER+77: return "TB_ADDSTRINGW";
4764 case WM_USER+29: return "TB_GETITEMRECT";
4765 case WM_USER+30: return "TB_BUTTONSTRUCTSIZE";
4766 case WM_USER+31: return "TB_SETBUTTONSIZE";
4767 case WM_USER+32: return "TB_SETBITMAPSIZE";
4768 case WM_USER+33: return "TB_AUTOSIZE";
4769 case WM_USER+35: return "TB_GETTOOLTIPS";
4770 case WM_USER+36: return "TB_SETTOOLTIPS";
4771 case WM_USER+37: return "TB_SETPARENT";
4772 case WM_USER+39: return "TB_SETROWS";
4773 case WM_USER+40: return "TB_GETROWS";
4774 case WM_USER+42: return "TB_SETCMDID";
4775 case WM_USER+43: return "TB_CHANGEBITMAP";
4776 case WM_USER+44: return "TB_GETBITMAP";
4777 case WM_USER+45: return "TB_GETBUTTONTEXTA";
4778 case WM_USER+75: return "TB_GETBUTTONTEXTW";
4779 case WM_USER+46: return "TB_REPLACEBITMAP";
4780 case WM_USER+47: return "TB_SETINDENT";
4781 case WM_USER+48: return "TB_SETIMAGELIST";
4782 case WM_USER+49: return "TB_GETIMAGELIST";
4783 case WM_USER+50: return "TB_LOADIMAGES";
4784 case WM_USER+51: return "TB_GETRECT";
4785 case WM_USER+52: return "TB_SETHOTIMAGELIST";
4786 case WM_USER+53: return "TB_GETHOTIMAGELIST";
4787 case WM_USER+54: return "TB_SETDISABLEDIMAGELIST";
4788 case WM_USER+55: return "TB_GETDISABLEDIMAGELIST";
4789 case WM_USER+56: return "TB_SETSTYLE";
4790 case WM_USER+57: return "TB_GETSTYLE";
4791 case WM_USER+58: return "TB_GETBUTTONSIZE";
4792 case WM_USER+59: return "TB_SETBUTTONWIDTH";
4793 case WM_USER+60: return "TB_SETMAXTEXTROWS";
4794 case WM_USER+61: return "TB_GETTEXTROWS";
4795 case WM_USER+41: return "TB_GETBITMAPFLAGS";
4796
4797#endif //WIN32
4798
4799 default:
4800 static char s_szBuf[128];
4801 sprintf(s_szBuf, "<unknown message = %d>", message);
4802 return s_szBuf;
4803 }
4804}
4805#endif //__WXDEBUG__
4806
4807static void TranslateKbdEventToMouse(wxWindowMSW *win,
4808 int *x, int *y, WPARAM *flags)
4809{
4810 // construct the key mask
4811 WPARAM& fwKeys = *flags;
4812
4813 fwKeys = MK_RBUTTON;
4814 if ( wxIsCtrlDown() )
4815 fwKeys |= MK_CONTROL;
4816 if ( wxIsShiftDown() )
4817 fwKeys |= MK_SHIFT;
4818
4819 // simulate right mouse button click
4820 DWORD dwPos = ::GetMessagePos();
4821 *x = GET_X_LPARAM(dwPos);
4822 *y = GET_Y_LPARAM(dwPos);
4823
4824 win->ScreenToClient(x, y);
4825}
4826
4827static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
4828{
4829 // prepare the DC
4830 TEXTMETRIC tm;
4831 HWND hwnd = GetHwndOf(win);
4832 HDC hdc = ::GetDC(hwnd);
4833
4834#if !wxDIALOG_UNIT_COMPATIBILITY
4835 // and select the current font into it
4836 HFONT hfont = GetHfontOf(win->GetFont());
4837 if ( hfont )
4838 {
4839 hfont = (HFONT)::SelectObject(hdc, hfont);
4840 }
4841#endif
4842
4843 // finally retrieve the text metrics from it
4844 GetTextMetrics(hdc, &tm);
4845
4846#if !wxDIALOG_UNIT_COMPATIBILITY
4847 // and clean up
4848 if ( hfont )
4849 {
4850 (void)::SelectObject(hdc, hfont);
4851 }
4852#endif
4853
4854 ::ReleaseDC(hwnd, hdc);
4855
4856 return tm;
4857}
4858
4859// Find the wxWindow at the current mouse position, returning the mouse
4860// position.
4861wxWindow* wxFindWindowAtPointer(wxPoint& WXUNUSED(pt))
4862{
4863 return wxFindWindowAtPoint(wxGetMousePosition());
4864}
4865
4866wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
4867{
4868 POINT pt2;
4869 pt2.x = pt.x;
4870 pt2.y = pt.y;
4871 HWND hWndHit = ::WindowFromPoint(pt2);
4872
4873 wxWindow* win = wxFindWinFromHandle((WXHWND) hWndHit) ;
4874 HWND hWnd = hWndHit;
4875
4876 // Try to find a window with a wxWindow associated with it
4877 while (!win && (hWnd != 0))
4878 {
4879 hWnd = ::GetParent(hWnd);
4880 win = wxFindWinFromHandle((WXHWND) hWnd) ;
4881 }
4882 return win;
4883}
4884
4885// Get the current mouse position.
4886wxPoint wxGetMousePosition()
4887{
4888 POINT pt;
4889 GetCursorPos( & pt );
4890 return wxPoint(pt.x, pt.y);
4891}
4892
wxWidgets (Impactor)