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