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