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


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