]> git.saurik.com Git - wxWidgets.git/blob - src/msw/window.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
removed some duplicate code, no real changes
[wxWidgets.git] / src / msw / window.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/windows.cpp
3 // Purpose: wxWindow
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ===========================================================================
13 // declarations
14 // ===========================================================================
15
16 // ---------------------------------------------------------------------------
17 // headers
18 // ---------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "window.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include <windows.h>
33 #include "wx/msw/winundef.h"
34 #include "wx/window.h"
35 #include "wx/accel.h"
36 #include "wx/setup.h"
37 #include "wx/menu.h"
38 #include "wx/dc.h"
39 #include "wx/dcclient.h"
40 #include "wx/dcmemory.h"
41 #include "wx/utils.h"
42 #include "wx/app.h"
43 #include "wx/layout.h"
44 #include "wx/dialog.h"
45 #include "wx/frame.h"
46 #include "wx/listbox.h"
47 #include "wx/button.h"
48 #include "wx/msgdlg.h"
49 #include "wx/settings.h"
50 #include "wx/statbox.h"
51 #endif
52
53 #if wxUSE_OWNER_DRAWN
54 #include "wx/ownerdrw.h"
55 #endif
56
57 #if wxUSE_DRAG_AND_DROP
58 #include "wx/dnd.h"
59 #endif
60
61 #include "wx/menuitem.h"
62 #include "wx/log.h"
63
64 #include "wx/msw/private.h"
65
66 #if wxUSE_TOOLTIPS
67 #include "wx/tooltip.h"
68 #endif
69
70 #if wxUSE_CARET
71 #include "wx/caret.h"
72 #endif // wxUSE_CARET
73
74 #if wxUSE_SPINCTRL
75 #include "wx/spinctrl.h"
76 #endif // wxUSE_SPINCTRL
77
78 #include "wx/intl.h"
79 #include "wx/log.h"
80
81 #include "wx/textctrl.h"
82 #include "wx/notebook.h"
83
84 #include <string.h>
85
86 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
87 #include <shellapi.h>
88 #include <mmsystem.h>
89 #endif
90
91 #ifdef __WIN32__
92 #include <windowsx.h>
93 #endif
94
95 #if (!defined(__GNUWIN32_OLD__) && !defined(__TWIN32__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
96 #ifdef __WIN95__
97 #include <commctrl.h>
98 #endif
99 #elif !defined(__WXMICROWIN__) // broken compiler
100 #ifndef __TWIN32__
101 #include "wx/msw/gnuwin32/extra.h"
102 #endif
103 #endif
104
105 // ----------------------------------------------------------------------------
106 // standard constants not available with all compilers/headers
107 // ----------------------------------------------------------------------------
108
109 // This didn't appear in mingw until 2.95.2
110 #ifndef SIF_TRACKPOS
111 #define SIF_TRACKPOS 16
112 #endif
113
114 #if wxUSE_MOUSEWHEEL
115 #ifndef WM_MOUSEWHEEL
116 #define WM_MOUSEWHEEL 0x020A
117 #endif
118 #ifndef WHEEL_DELTA
119 #define WHEEL_DELTA 120
120 #endif
121 #ifndef SPI_GETWHEELSCROLLLINES
122 #define SPI_GETWHEELSCROLLLINES 104
123 #endif
124 #endif // wxUSE_MOUSEWHEEL
125
126 #ifndef VK_OEM_1
127 #define VK_OEM_1 0xBA
128 #define VK_OEM_PLUS 0xBB
129 #define VK_OEM_COMMA 0xBC
130 #define VK_OEM_MINUS 0xBD
131 #define VK_OEM_PERIOD 0xBE
132 #define VK_OEM_2 0xBF
133 #define VK_OEM_3 0xC0
134 #define VK_OEM_4 0xDB
135 #define VK_OEM_5 0xDC
136 #define VK_OEM_6 0xDD
137 #define VK_OEM_7 0xDE
138 #endif
139
140 // ---------------------------------------------------------------------------
141 // global variables
142 // ---------------------------------------------------------------------------
143
144 // the last Windows message we got (FIXME-MT)
145 extern MSG s_currentMsg;
146
147 #if wxUSE_MENUS_NATIVE
148 wxMenu *wxCurrentPopupMenu = NULL;
149 #endif // wxUSE_MENUS_NATIVE
150
151 extern const wxChar *wxCanvasClassName;
152
153 // true if we had already created the std colour map, used by
154 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
155 static bool gs_hasStdCmap = FALSE;
156
157 // ---------------------------------------------------------------------------
158 // private functions
159 // ---------------------------------------------------------------------------
160
161 // the window proc for all our windows
162 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
163 WPARAM wParam, LPARAM lParam);
164
165 #ifdef __WXDEBUG__
166 const char *wxGetMessageName(int message);
167 #endif //__WXDEBUG__
168
169 void wxRemoveHandleAssociation(wxWindowMSW *win);
170 void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
171 wxWindow *wxFindWinFromHandle(WXHWND hWnd);
172
173 // this magical function is used to translate VK_APPS key presses to right
174 // mouse clicks
175 static void TranslateKbdEventToMouse(wxWindowMSW *win,
176 int *x, int *y, WPARAM *flags);
177
178 // get the text metrics for the current font
179 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win);
180
181 // find the window for the mouse event at the specified position
182 static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y); //TW:REQ:Univ
183
184 // wrapper around BringWindowToTop() API
185 static inline void wxBringWindowToTop(HWND hwnd)
186 {
187 #ifdef __WXMICROWIN__
188 // It seems that MicroWindows brings the _parent_ of the window to the top,
189 // which can be the wrong one.
190
191 // activate (set focus to) specified window
192 ::SetFocus(hwnd);
193
194 // raise top level parent to top of z order
195 ::SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
196 #else // !__WXMICROWIN__
197 if ( !::BringWindowToTop(hwnd) )
198 {
199 wxLogLastError(_T("BringWindowToTop"));
200 }
201 #endif // __WXMICROWIN__/!__WXMICROWIN__
202 }
203
204 // ---------------------------------------------------------------------------
205 // event tables
206 // ---------------------------------------------------------------------------
207
208 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
209 // method
210 #ifdef __WXUNIVERSAL__
211 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW, wxWindowBase)
212 #else // __WXMSW__
213 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
214 #endif // __WXUNIVERSAL__/__WXMSW__
215
216 BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)
217 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
218 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
219 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
220 EVT_IDLE(wxWindowMSW::OnIdle)
221 END_EVENT_TABLE()
222
223 // ===========================================================================
224 // implementation
225 // ===========================================================================
226
227 // ---------------------------------------------------------------------------
228 // wxWindow utility functions
229 // ---------------------------------------------------------------------------
230
231 // Find an item given the MS Windows id
232 wxWindow *wxWindowMSW::FindItem(long id) const
233 {
234 #if wxUSE_CONTROLS
235 wxControl *item = wxDynamicCastThis(wxControl);
236 if ( item )
237 {
238 // is it we or one of our "internal" children?
239 if ( item->GetId() == id
240 #ifndef __WXUNIVERSAL__
241 || (item->GetSubcontrols().Index(id) != wxNOT_FOUND)
242 #endif // __WXUNIVERSAL__
243 )
244 {
245 return item;
246 }
247 }
248 #endif // wxUSE_CONTROLS
249
250 wxWindowList::Node *current = GetChildren().GetFirst();
251 while (current)
252 {
253 wxWindow *childWin = current->GetData();
254
255 wxWindow *wnd = childWin->FindItem(id);
256 if ( wnd )
257 return wnd;
258
259 current = current->GetNext();
260 }
261
262 return NULL;
263 }
264
265 // Find an item given the MS Windows handle
266 wxWindow *wxWindowMSW::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
267 {
268 wxWindowList::Node *current = GetChildren().GetFirst();
269 while (current)
270 {
271 wxWindow *parent = current->GetData();
272
273 // Do a recursive search.
274 wxWindow *wnd = parent->FindItemByHWND(hWnd);
275 if ( wnd )
276 return wnd;
277
278 if ( !controlOnly
279 #if wxUSE_CONTROLS
280 || parent->IsKindOf(CLASSINFO(wxControl))
281 #endif // wxUSE_CONTROLS
282 )
283 {
284 wxWindow *item = current->GetData();
285 if ( item->GetHWND() == hWnd )
286 return item;
287 else
288 {
289 if ( item->ContainsHWND(hWnd) )
290 return item;
291 }
292 }
293
294 current = current->GetNext();
295 }
296 return NULL;
297 }
298
299 // Default command handler
300 bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
301 {
302 return FALSE;
303 }
304
305 // ----------------------------------------------------------------------------
306 // constructors and such
307 // ----------------------------------------------------------------------------
308
309 void wxWindowMSW::Init()
310 {
311 // generic
312 InitBase();
313
314 // MSW specific
315 m_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 WXHWND wxWindowMSW::MSWGetParent() const
2907 {
2908 return m_parent ? m_parent->GetHWND() : NULL;
2909 }
2910
2911 bool wxWindowMSW::MSWCreate(const wxChar *wclass,
2912 const wxChar *title,
2913 const wxPoint& pos,
2914 const wxSize& size,
2915 WXDWORD style,
2916 WXDWORD extendedStyle)
2917 {
2918 // choose the position/size for the new window
2919 int x, y, w, h;
2920 (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
2921
2922 // controlId is menu handle for the top level windows, so set it to 0
2923 // unless we're creating a child window
2924 int controlId;
2925 if ( style & WS_CHILD )
2926 {
2927 controlId = GetId();
2928
2929 if ( GetWindowStyleFlag() & wxCLIP_SIBLINGS )
2930 {
2931 style |= WS_CLIPSIBLINGS;
2932 }
2933 }
2934 else // !child
2935 {
2936 controlId = 0;
2937 }
2938
2939 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
2940 // which is the same but without CS_[HV]REDRAW class styles so using it
2941 // ensures that the window is not fully repainted on each resize
2942 wxString className(wclass);
2943 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE )
2944 {
2945 className += wxT("NR");
2946 }
2947
2948 // do create the window
2949 wxWindowCreationHook hook(this);
2950
2951 m_hWnd = (WXHWND)::CreateWindowEx
2952 (
2953 extendedStyle,
2954 className,
2955 title ? title : wxT(""),
2956 style,
2957 x, y, w, h,
2958 (HWND)MSWGetParent(),
2959 (HMENU)controlId,
2960 wxGetInstance(),
2961 NULL // no extra data
2962 );
2963
2964 if ( !m_hWnd )
2965 {
2966 wxLogSysError(_("Can't create window of class %s"), wclass);
2967
2968 return FALSE;
2969 }
2970
2971 SubclassWin(m_hWnd);
2972
2973 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
2974
2975 return TRUE;
2976 }
2977
2978 // ===========================================================================
2979 // MSW message handlers
2980 // ===========================================================================
2981
2982 // ---------------------------------------------------------------------------
2983 // WM_NOTIFY
2984 // ---------------------------------------------------------------------------
2985
2986 #ifdef __WIN95__
2987 // FIXME: VZ: I'm not sure at all that the order of processing is correct
2988 bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
2989 {
2990 #ifndef __WXMICROWIN__
2991 LPNMHDR hdr = (LPNMHDR)lParam;
2992 HWND hWnd = hdr->hwndFrom;
2993 wxWindow *win = wxFindWinFromHandle((WXHWND)hWnd);
2994
2995 // is this one of our windows?
2996 if ( win )
2997 {
2998 return win->MSWOnNotify(idCtrl, lParam, result);
2999 }
3000
3001 // try all our children
3002 wxWindowList::Node *node = GetChildren().GetFirst();
3003 while ( node )
3004 {
3005 wxWindow *child = node->GetData();
3006 if ( child->MSWOnNotify(idCtrl, lParam, result) )
3007 {
3008 return TRUE;
3009 }
3010
3011 node = node->GetNext();
3012 }
3013
3014 // finally try this window too (catches toolbar case)
3015 return MSWOnNotify(idCtrl, lParam, result);
3016 #else // __WXMICROWIN__
3017 return FALSE;
3018 #endif
3019 }
3020
3021 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
3022 WXLPARAM lParam,
3023 WXLPARAM* WXUNUSED(result))
3024 {
3025 #if wxUSE_TOOLTIPS
3026 NMHDR* hdr = (NMHDR *)lParam;
3027 if ( (int)hdr->code == TTN_NEEDTEXT && m_tooltip )
3028 {
3029 TOOLTIPTEXT *ttt = (TOOLTIPTEXT *)lParam;
3030 ttt->lpszText = (wxChar *)m_tooltip->GetTip().c_str();
3031
3032 // processed
3033 return TRUE;
3034 }
3035 #endif // wxUSE_TOOLTIPS
3036
3037 return FALSE;
3038 }
3039 #endif // __WIN95__
3040
3041 // ---------------------------------------------------------------------------
3042 // end session messages
3043 // ---------------------------------------------------------------------------
3044
3045 bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
3046 {
3047 wxCloseEvent event(wxEVT_QUERY_END_SESSION, -1);
3048 event.SetEventObject(wxTheApp);
3049 event.SetCanVeto(TRUE);
3050 event.SetLoggingOff(logOff == (long)ENDSESSION_LOGOFF);
3051
3052 bool rc = wxTheApp->ProcessEvent(event);
3053
3054 if ( rc )
3055 {
3056 // we may end only if the app didn't veto session closing (double
3057 // negation...)
3058 *mayEnd = !event.GetVeto();
3059 }
3060
3061 return rc;
3062 }
3063
3064 bool wxWindowMSW::HandleEndSession(bool endSession, long logOff)
3065 {
3066 // do nothing if the session isn't ending
3067 if ( !endSession )
3068 return FALSE;
3069
3070 // only send once
3071 if ( (this != wxTheApp->GetTopWindow()) )
3072 return FALSE;
3073
3074 wxCloseEvent event(wxEVT_END_SESSION, -1);
3075 event.SetEventObject(wxTheApp);
3076 event.SetCanVeto(FALSE);
3077 event.SetLoggingOff( (logOff == (long)ENDSESSION_LOGOFF) );
3078
3079 return wxTheApp->ProcessEvent(event);
3080 }
3081
3082 // ---------------------------------------------------------------------------
3083 // window creation/destruction
3084 // ---------------------------------------------------------------------------
3085
3086 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT WXUNUSED(cs), bool *mayCreate)
3087 {
3088 // TODO: should generate this event from WM_NCCREATE
3089 wxWindowCreateEvent event((wxWindow *)this);
3090 (void)GetEventHandler()->ProcessEvent(event);
3091
3092 *mayCreate = TRUE;
3093
3094 return TRUE;
3095 }
3096
3097 bool wxWindowMSW::HandleDestroy()
3098 {
3099 wxWindowDestroyEvent event((wxWindow *)this);
3100 (void)GetEventHandler()->ProcessEvent(event);
3101
3102 // delete our drop target if we've got one
3103 #if wxUSE_DRAG_AND_DROP
3104 if ( m_dropTarget != NULL )
3105 {
3106 m_dropTarget->Revoke(m_hWnd);
3107
3108 delete m_dropTarget;
3109 m_dropTarget = NULL;
3110 }
3111 #endif // wxUSE_DRAG_AND_DROP
3112
3113 // WM_DESTROY handled
3114 return TRUE;
3115 }
3116
3117 // ---------------------------------------------------------------------------
3118 // activation/focus
3119 // ---------------------------------------------------------------------------
3120
3121 bool wxWindowMSW::HandleActivate(int state,
3122 bool WXUNUSED(minimized),
3123 WXHWND WXUNUSED(activate))
3124 {
3125 wxActivateEvent event(wxEVT_ACTIVATE,
3126 (state == WA_ACTIVE) || (state == WA_CLICKACTIVE),
3127 m_windowId);
3128 event.SetEventObject(this);
3129
3130 return GetEventHandler()->ProcessEvent(event);
3131 }
3132
3133 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
3134 {
3135 // notify the parent keeping track of focus for the kbd navigation
3136 // purposes that we got it
3137 wxChildFocusEvent eventFocus((wxWindow *)this);
3138 (void)GetEventHandler()->ProcessEvent(eventFocus);
3139
3140 #if wxUSE_CARET
3141 // Deal with caret
3142 if ( m_caret )
3143 {
3144 m_caret->OnSetFocus();
3145 }
3146 #endif // wxUSE_CARET
3147
3148 #if wxUSE_TEXTCTRL
3149 // If it's a wxTextCtrl don't send the event as it will be done
3150 // after the control gets to process it from EN_FOCUS handler
3151 if ( wxDynamicCastThis(wxTextCtrl) )
3152 {
3153 return FALSE;
3154 }
3155 #endif // wxUSE_TEXTCTRL
3156
3157 wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
3158 event.SetEventObject(this);
3159
3160 // wxFindWinFromHandle() may return NULL, it is ok
3161 event.SetWindow(wxFindWinFromHandle(hwnd));
3162
3163 return GetEventHandler()->ProcessEvent(event);
3164 }
3165
3166 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
3167 {
3168 #if wxUSE_CARET
3169 // Deal with caret
3170 if ( m_caret )
3171 {
3172 m_caret->OnKillFocus();
3173 }
3174 #endif // wxUSE_CARET
3175
3176 #if wxUSE_TEXTCTRL
3177 // If it's a wxTextCtrl don't send the event as it will be done
3178 // after the control gets to process it.
3179 wxTextCtrl *ctrl = wxDynamicCastThis(wxTextCtrl);
3180 if ( ctrl )
3181 {
3182 return FALSE;
3183 }
3184 #endif
3185
3186 wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
3187 event.SetEventObject(this);
3188
3189 // wxFindWinFromHandle() may return NULL, it is ok
3190 event.SetWindow(wxFindWinFromHandle(hwnd));
3191
3192 return GetEventHandler()->ProcessEvent(event);
3193 }
3194
3195 // ---------------------------------------------------------------------------
3196 // miscellaneous
3197 // ---------------------------------------------------------------------------
3198
3199 bool wxWindowMSW::HandleShow(bool show, int WXUNUSED(status))
3200 {
3201 wxShowEvent event(GetId(), show);
3202 event.m_eventObject = this;
3203
3204 return GetEventHandler()->ProcessEvent(event);
3205 }
3206
3207 bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
3208 {
3209 wxInitDialogEvent event(GetId());
3210 event.m_eventObject = this;
3211
3212 return GetEventHandler()->ProcessEvent(event);
3213 }
3214
3215 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
3216 {
3217 #ifndef __WXMICROWIN__
3218 HDROP hFilesInfo = (HDROP) wParam;
3219
3220 // Get the total number of files dropped
3221 UINT gwFilesDropped = ::DragQueryFile
3222 (
3223 (HDROP)hFilesInfo,
3224 (UINT)-1,
3225 (LPTSTR)0,
3226 (UINT)0
3227 );
3228
3229 wxString *files = new wxString[gwFilesDropped];
3230 for ( UINT wIndex = 0; wIndex < gwFilesDropped; wIndex++ )
3231 {
3232 // first get the needed buffer length (+1 for terminating NUL)
3233 size_t len = ::DragQueryFile(hFilesInfo, wIndex, NULL, 0) + 1;
3234
3235 // and now get the file name
3236 ::DragQueryFile(hFilesInfo, wIndex,
3237 files[wIndex].GetWriteBuf(len), len);
3238
3239 files[wIndex].UngetWriteBuf();
3240 }
3241 DragFinish (hFilesInfo);
3242
3243 wxDropFilesEvent event(wxEVT_DROP_FILES, gwFilesDropped, files);
3244 event.m_eventObject = this;
3245
3246 POINT dropPoint;
3247 DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
3248 event.m_pos.x = dropPoint.x;
3249 event.m_pos.y = dropPoint.y;
3250
3251 return GetEventHandler()->ProcessEvent(event);
3252 #else // __WXMICROWIN__
3253 return FALSE;
3254 #endif
3255 }
3256
3257 bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
3258 short nHitTest,
3259 int WXUNUSED(mouseMsg))
3260 {
3261 #ifndef __WXMICROWIN__
3262 // the logic is as follows:
3263 // -1. don't set cursor for non client area, including but not limited to
3264 // the title bar, scrollbars, &c
3265 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3266 // 1. if we have the cursor set it unless wxIsBusy()
3267 // 2. if we're a top level window, set some cursor anyhow
3268 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3269
3270 if ( nHitTest != HTCLIENT )
3271 {
3272 return FALSE;
3273 }
3274
3275 HCURSOR hcursor = 0;
3276
3277 // first ask the user code - it may wish to set the cursor in some very
3278 // specific way (for example, depending on the current position)
3279 POINT pt;
3280 #ifdef __WIN32__
3281 if ( !::GetCursorPos(&pt) )
3282 {
3283 wxLogLastError(wxT("GetCursorPos"));
3284 }
3285 #else
3286 // In WIN16 it doesn't return a value.
3287 ::GetCursorPos(&pt);
3288 #endif
3289
3290 int x = pt.x,
3291 y = pt.y;
3292 ScreenToClient(&x, &y);
3293 wxSetCursorEvent event(x, y);
3294
3295 bool processedEvtSetCursor = GetEventHandler()->ProcessEvent(event);
3296 if ( processedEvtSetCursor && event.HasCursor() )
3297 {
3298 hcursor = GetHcursorOf(event.GetCursor());
3299 }
3300
3301 if ( !hcursor )
3302 {
3303 bool isBusy = wxIsBusy();
3304
3305 // the test for processedEvtSetCursor is here to prevent using m_cursor
3306 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3307 // it - this is a way to say that our cursor shouldn't be used for this
3308 // point
3309 if ( !processedEvtSetCursor && m_cursor.Ok() )
3310 {
3311 hcursor = GetHcursorOf(m_cursor);
3312 }
3313
3314 if ( !GetParent() )
3315 {
3316 if ( isBusy )
3317 {
3318 hcursor = wxGetCurrentBusyCursor();
3319 }
3320 else if ( !hcursor )
3321 {
3322 const wxCursor *cursor = wxGetGlobalCursor();
3323 if ( cursor && cursor->Ok() )
3324 {
3325 hcursor = GetHcursorOf(*cursor);
3326 }
3327 }
3328 }
3329 }
3330
3331 if ( hcursor )
3332 {
3333 ::SetCursor(hcursor);
3334
3335 // cursor set, stop here
3336 return TRUE;
3337 }
3338 #endif // __WXMICROWIN__
3339
3340 // pass up the window chain
3341 return FALSE;
3342 }
3343
3344 // ---------------------------------------------------------------------------
3345 // owner drawn stuff
3346 // ---------------------------------------------------------------------------
3347
3348 bool wxWindowMSW::MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *itemStruct)
3349 {
3350 #if wxUSE_OWNER_DRAWN
3351
3352 #if wxUSE_MENUS_NATIVE
3353 // is it a menu item?
3354 DRAWITEMSTRUCT *pDrawStruct = (DRAWITEMSTRUCT *)itemStruct;
3355 if ( id == 0 && pDrawStruct->CtlType == ODT_MENU )
3356 {
3357 wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
3358
3359 wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
3360
3361 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3362 // the DC from being released
3363 wxDCTemp dc((WXHDC)pDrawStruct->hDC);
3364 wxRect rect(pDrawStruct->rcItem.left, pDrawStruct->rcItem.top,
3365 pDrawStruct->rcItem.right - pDrawStruct->rcItem.left,
3366 pDrawStruct->rcItem.bottom - pDrawStruct->rcItem.top);
3367
3368 return pMenuItem->OnDrawItem
3369 (
3370 dc,
3371 rect,
3372 (wxOwnerDrawn::wxODAction)pDrawStruct->itemAction,
3373 (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
3374 );
3375 }
3376 #endif // wxUSE_MENUS_NATIVE
3377
3378 #if wxUSE_CONTROLS
3379 wxWindow *item = FindItem(id);
3380 if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
3381 {
3382 return ((wxControl *)item)->MSWOnDraw(itemStruct);
3383 }
3384 #endif // wxUSE_CONTROLS
3385
3386 #endif // USE_OWNER_DRAWN
3387
3388 return FALSE;
3389 }
3390
3391 bool wxWindowMSW::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
3392 {
3393 #if wxUSE_OWNER_DRAWN
3394 // is it a menu item?
3395 MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
3396 if ( id == 0 && pMeasureStruct->CtlType == ODT_MENU )
3397 {
3398 wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
3399
3400 wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
3401
3402 return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
3403 &pMeasureStruct->itemHeight);
3404 }
3405
3406 wxWindow *item = FindItem(id);
3407 if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
3408 {
3409 return ((wxControl *)item)->MSWOnMeasure(itemStruct);
3410 }
3411 #endif // owner-drawn menus
3412 return FALSE;
3413 }
3414
3415 // ---------------------------------------------------------------------------
3416 // colours and palettes
3417 // ---------------------------------------------------------------------------
3418
3419 bool wxWindowMSW::HandleSysColorChange()
3420 {
3421 wxSysColourChangedEvent event;
3422 event.SetEventObject(this);
3423
3424 (void)GetEventHandler()->ProcessEvent(event);
3425
3426 // always let the system carry on the default processing to allow the
3427 // native controls to react to the colours update
3428 return FALSE;
3429 }
3430
3431 bool wxWindowMSW::HandleDisplayChange()
3432 {
3433 wxDisplayChangedEvent event;
3434 event.SetEventObject(this);
3435
3436 return GetEventHandler()->ProcessEvent(event);
3437 }
3438
3439 bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush,
3440 WXHDC pDC,
3441 WXHWND pWnd,
3442 WXUINT nCtlColor,
3443 WXUINT message,
3444 WXWPARAM wParam,
3445 WXLPARAM lParam)
3446 {
3447 #ifndef __WXMICROWIN__
3448 WXHBRUSH hBrush = 0;
3449
3450 if ( nCtlColor == CTLCOLOR_DLG )
3451 {
3452 hBrush = OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
3453 }
3454 #if wxUSE_CONTROLS
3455 else
3456 {
3457 wxControl *item = (wxControl *)FindItemByHWND(pWnd, TRUE);
3458 if ( item )
3459 hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
3460 }
3461 #endif // wxUSE_CONTROLS
3462
3463 if ( hBrush )
3464 *brush = hBrush;
3465
3466 return hBrush != 0;
3467 #else // __WXMICROWIN__
3468 return FALSE;
3469 #endif
3470 }
3471
3472 // Define for each class of dialog and control
3473 WXHBRUSH wxWindowMSW::OnCtlColor(WXHDC WXUNUSED(hDC),
3474 WXHWND WXUNUSED(hWnd),
3475 WXUINT WXUNUSED(nCtlColor),
3476 WXUINT WXUNUSED(message),
3477 WXWPARAM WXUNUSED(wParam),
3478 WXLPARAM WXUNUSED(lParam))
3479 {
3480 return (WXHBRUSH)0;
3481 }
3482
3483 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
3484 {
3485 #if wxUSE_PALETTE
3486 // same as below except we don't respond to our own messages
3487 if ( hWndPalChange != GetHWND() )
3488 {
3489 // check to see if we our our parents have a custom palette
3490 wxWindow *win = this;
3491 while ( win && !win->HasCustomPalette() )
3492 {
3493 win = win->GetParent();
3494 }
3495
3496 if ( win && win->HasCustomPalette() )
3497 {
3498 // realize the palette to see whether redrawing is needed
3499 HDC hdc = ::GetDC((HWND) hWndPalChange);
3500 win->m_palette.SetHPALETTE((WXHPALETTE)
3501 ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
3502
3503 int result = ::RealizePalette(hdc);
3504
3505 // restore the palette (before releasing the DC)
3506 win->m_palette.SetHPALETTE((WXHPALETTE)
3507 ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
3508 ::RealizePalette(hdc);
3509 ::ReleaseDC((HWND) hWndPalChange, hdc);
3510
3511 // now check for the need to redraw
3512 if (result > 0)
3513 InvalidateRect((HWND) hWndPalChange, NULL, TRUE);
3514 }
3515
3516 }
3517 #endif // wxUSE_PALETTE
3518
3519 wxPaletteChangedEvent event(GetId());
3520 event.SetEventObject(this);
3521 event.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
3522
3523 return GetEventHandler()->ProcessEvent(event);
3524 }
3525
3526 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture)
3527 {
3528 wxMouseCaptureChangedEvent event(GetId(), wxFindWinFromHandle(hWndGainedCapture));
3529 event.SetEventObject(this);
3530
3531 return GetEventHandler()->ProcessEvent(event);
3532 }
3533
3534 bool wxWindowMSW::HandleQueryNewPalette()
3535 {
3536
3537 #if wxUSE_PALETTE
3538 // check to see if we our our parents have a custom palette
3539 wxWindow *win = this;
3540 while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
3541 if (win->HasCustomPalette()) {
3542 /* realize the palette to see whether redrawing is needed */
3543 HDC hdc = GetDC((HWND) GetHWND());
3544 win->m_palette.SetHPALETTE( (WXHPALETTE)
3545 ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
3546
3547 int result = ::RealizePalette(hdc);
3548 /* restore the palette (before releasing the DC) */
3549 win->m_palette.SetHPALETTE( (WXHPALETTE)
3550 ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), TRUE) );
3551 ::RealizePalette(hdc);
3552 ::ReleaseDC((HWND) GetHWND(), hdc);
3553 /* now check for the need to redraw */
3554 if (result > 0)
3555 ::InvalidateRect((HWND) GetHWND(), NULL, TRUE);
3556 }
3557 #endif // wxUSE_PALETTE
3558
3559 wxQueryNewPaletteEvent event(GetId());
3560 event.SetEventObject(this);
3561
3562 return GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized();
3563 }
3564
3565 // Responds to colour changes: passes event on to children.
3566 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
3567 {
3568 // the top level window also reset the standard colour map as it might have
3569 // changed (there is no need to do it for the non top level windows as we
3570 // only have to do it once)
3571 if ( IsTopLevel() )
3572 {
3573 // FIXME-MT
3574 gs_hasStdCmap = FALSE;
3575 }
3576 wxWindowList::Node *node = GetChildren().GetFirst();
3577 while ( node )
3578 {
3579 // Only propagate to non-top-level windows because Windows already
3580 // sends this event to all top-level ones
3581 wxWindow *win = node->GetData();
3582 if ( !win->IsTopLevel() )
3583 {
3584 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3585 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3586 // the standard controls
3587 ::SendMessage(GetHwndOf(win), WM_SYSCOLORCHANGE, 0, 0);
3588 }
3589
3590 node = node->GetNext();
3591 }
3592
3593 // update the colours we use if they were not set explicitly by the user:
3594 // this must be done or OnCtlColor() would continue to use the old colours
3595 if ( !m_hasFgCol )
3596 {
3597 m_foregroundColour = wxSystemSettings::
3598 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT);
3599 }
3600
3601 if ( !m_hasBgCol )
3602 {
3603 m_backgroundColour = wxSystemSettings::
3604 GetSystemColour(wxSYS_COLOUR_BTNFACE);
3605 }
3606 }
3607
3608 extern wxCOLORMAP *wxGetStdColourMap()
3609 {
3610 static COLORREF s_stdColours[wxSTD_COL_MAX];
3611 static wxCOLORMAP s_cmap[wxSTD_COL_MAX];
3612
3613 if ( !gs_hasStdCmap )
3614 {
3615 static bool s_coloursInit = FALSE;
3616
3617 if ( !s_coloursInit )
3618 {
3619 // When a bitmap is loaded, the RGB values can change (apparently
3620 // because Windows adjusts them to care for the old programs always
3621 // using 0xc0c0c0 while the transparent colour for the new Windows
3622 // versions is different). But we do this adjustment ourselves so
3623 // we want to avoid Windows' "help" and for this we need to have a
3624 // reference bitmap which can tell us what the RGB values change
3625 // to.
3626 wxBitmap stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3627 if ( stdColourBitmap.Ok() )
3628 {
3629 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3630 wxASSERT_MSG( stdColourBitmap.GetWidth() == wxSTD_COL_MAX,
3631 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3632
3633 wxMemoryDC memDC;
3634 memDC.SelectObject(stdColourBitmap);
3635
3636 wxColour colour;
3637 for ( size_t i = 0; i < WXSIZEOF(s_stdColours); i++ )
3638 {
3639 memDC.GetPixel(i, 0, &colour);
3640 s_stdColours[i] = wxColourToRGB(colour);
3641 }
3642 }
3643 else // wxBITMAP_STD_COLOURS couldn't be loaded
3644 {
3645 s_stdColours[0] = RGB(000,000,000); // black
3646 s_stdColours[1] = RGB(128,128,128); // dark grey
3647 s_stdColours[2] = RGB(192,192,192); // light grey
3648 s_stdColours[3] = RGB(255,255,255); // white
3649 //s_stdColours[4] = RGB(000,000,255); // blue
3650 //s_stdColours[5] = RGB(255,000,255); // magenta
3651 }
3652
3653 s_coloursInit = TRUE;
3654 }
3655
3656 gs_hasStdCmap = TRUE;
3657
3658 // create the colour map
3659 #define INIT_CMAP_ENTRY(col) \
3660 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3661 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3662
3663 INIT_CMAP_ENTRY(BTNTEXT);
3664 INIT_CMAP_ENTRY(BTNSHADOW);
3665 INIT_CMAP_ENTRY(BTNFACE);
3666 INIT_CMAP_ENTRY(BTNHIGHLIGHT);
3667
3668 #undef INIT_CMAP_ENTRY
3669 }
3670
3671 return s_cmap;
3672 }
3673
3674 // ---------------------------------------------------------------------------
3675 // painting
3676 // ---------------------------------------------------------------------------
3677
3678 bool wxWindowMSW::HandlePaint()
3679 {
3680 #ifdef __WIN32__
3681 HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3682 if ( !hRegion )
3683 wxLogLastError(wxT("CreateRectRgn"));
3684 if ( ::GetUpdateRgn(GetHwnd(), hRegion, FALSE) == ERROR )
3685 wxLogLastError(wxT("GetUpdateRgn"));
3686
3687 m_updateRegion = wxRegion((WXHRGN) hRegion);
3688 #else // Win16
3689 RECT updateRect;
3690 ::GetUpdateRect(GetHwnd(), &updateRect, FALSE);
3691
3692 m_updateRegion = wxRegion(updateRect.left, updateRect.top,
3693 updateRect.right - updateRect.left,
3694 updateRect.bottom - updateRect.top);
3695 #endif // Win32/16
3696
3697 wxPaintEvent event(m_windowId);
3698 event.SetEventObject(this);
3699
3700 bool processed = GetEventHandler()->ProcessEvent(event);
3701
3702 // note that we must generate NC event after the normal one as otherwise
3703 // BeginPaint() will happily overwrite our decorations with the background
3704 // colour
3705 wxNcPaintEvent eventNc(m_windowId);
3706 eventNc.SetEventObject(this);
3707 GetEventHandler()->ProcessEvent(eventNc);
3708
3709 return processed;
3710 }
3711
3712 // Can be called from an application's OnPaint handler
3713 void wxWindowMSW::OnPaint(wxPaintEvent& event)
3714 {
3715 #ifdef __WXUNIVERSAL__
3716 event.Skip();
3717 #else
3718 HDC hDC = (HDC) wxPaintDC::FindDCInCache((wxWindow*) event.GetEventObject());
3719 if (hDC != 0)
3720 {
3721 MSWDefWindowProc(WM_PAINT, (WPARAM) hDC, 0);
3722 }
3723 #endif
3724 }
3725
3726 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
3727 {
3728 // Prevents flicker when dragging
3729 if ( ::IsIconic(GetHwnd()) )
3730 return TRUE;
3731
3732 wxDCTemp dc(hdc);
3733
3734 dc.SetHDC(hdc);
3735 dc.SetWindow((wxWindow *)this);
3736 dc.BeginDrawing();
3737
3738 wxEraseEvent event(m_windowId, &dc);
3739 event.SetEventObject(this);
3740 bool rc = GetEventHandler()->ProcessEvent(event);
3741
3742 dc.EndDrawing();
3743
3744 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3745 dc.SelectOldObjects(hdc);
3746
3747 return rc;
3748 }
3749
3750 void wxWindowMSW::OnEraseBackground(wxEraseEvent& event)
3751 {
3752 RECT rect;
3753 ::GetClientRect(GetHwnd(), &rect);
3754
3755 COLORREF ref = PALETTERGB(m_backgroundColour.Red(),
3756 m_backgroundColour.Green(),
3757 m_backgroundColour.Blue());
3758 HBRUSH hBrush = ::CreateSolidBrush(ref);
3759 if ( !hBrush )
3760 wxLogLastError(wxT("CreateSolidBrush"));
3761
3762 HDC hdc = (HDC)event.GetDC()->GetHDC();
3763
3764 int mode = ::SetMapMode(hdc, MM_TEXT);
3765
3766 ::FillRect(hdc, &rect, hBrush);
3767 ::DeleteObject(hBrush);
3768 ::SetMapMode(hdc, mode);
3769 }
3770
3771 // ---------------------------------------------------------------------------
3772 // moving and resizing
3773 // ---------------------------------------------------------------------------
3774
3775 bool wxWindowMSW::HandleMinimize()
3776 {
3777 wxIconizeEvent event(m_windowId);
3778 event.SetEventObject(this);
3779
3780 return GetEventHandler()->ProcessEvent(event);
3781 }
3782
3783 bool wxWindowMSW::HandleMaximize()
3784 {
3785 wxMaximizeEvent event(m_windowId);
3786 event.SetEventObject(this);
3787
3788 return GetEventHandler()->ProcessEvent(event);
3789 }
3790
3791 bool wxWindowMSW::HandleMove(int x, int y)
3792 {
3793 wxMoveEvent event(wxPoint(x, y), m_windowId);
3794 event.SetEventObject(this);
3795
3796 return GetEventHandler()->ProcessEvent(event);
3797 }
3798
3799 bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h),
3800 WXUINT WXUNUSED(flag))
3801 {
3802 // don't use w and h parameters as they specify the client size while
3803 // according to the docs EVT_SIZE handler is supposed to receive the total
3804 // size
3805 wxSizeEvent event(GetSize(), m_windowId);
3806 event.SetEventObject(this);
3807
3808 return GetEventHandler()->ProcessEvent(event);
3809 }
3810
3811 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo)
3812 {
3813 MINMAXINFO *info = (MINMAXINFO *)mmInfo;
3814
3815 bool rc = FALSE;
3816
3817 int minWidth = GetMinWidth(),
3818 minHeight = GetMinHeight(),
3819 maxWidth = GetMaxWidth(),
3820 maxHeight = GetMaxHeight();
3821
3822 if ( minWidth != -1 )
3823 {
3824 info->ptMinTrackSize.x = minWidth;
3825 rc = TRUE;
3826 }
3827
3828 if ( minHeight != -1 )
3829 {
3830 info->ptMinTrackSize.y = minHeight;
3831 rc = TRUE;
3832 }
3833
3834 if ( maxWidth != -1 )
3835 {
3836 info->ptMaxTrackSize.x = maxWidth;
3837 rc = TRUE;
3838 }
3839
3840 if ( maxHeight != -1 )
3841 {
3842 info->ptMaxTrackSize.y = maxHeight;
3843 rc = TRUE;
3844 }
3845
3846 return rc;
3847 }
3848
3849 // ---------------------------------------------------------------------------
3850 // command messages
3851 // ---------------------------------------------------------------------------
3852
3853 bool wxWindowMSW::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
3854 {
3855 #if wxUSE_MENUS_NATIVE
3856 if ( !cmd && wxCurrentPopupMenu )
3857 {
3858 wxMenu *popupMenu = wxCurrentPopupMenu;
3859 wxCurrentPopupMenu = NULL;
3860
3861 return popupMenu->MSWCommand(cmd, id);
3862 }
3863 #endif // wxUSE_MENUS_NATIVE
3864
3865 wxWindow *win = NULL;
3866
3867 // first try to find it from HWND - this works even with the broken
3868 // programs using the same ids for different controls
3869 if ( control )
3870 {
3871 win = wxFindWinFromHandle(control);
3872 }
3873
3874 // try the id
3875 if ( !win )
3876 {
3877 // must cast to a signed type before comparing with other ids!
3878 win = FindItem((signed short)id);
3879 }
3880
3881 if ( win )
3882 {
3883 return win->MSWCommand(cmd, id);
3884 }
3885
3886 // the messages sent from the in-place edit control used by the treectrl
3887 // for label editing have id == 0, but they should _not_ be treated as menu
3888 // messages (they are EN_XXX ones, in fact) so don't translate anything
3889 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
3890 if ( !control )
3891 {
3892 // If no child window, it may be an accelerator, e.g. for a popup menu
3893 // command
3894
3895 wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
3896 event.SetEventObject(this);
3897 event.SetId(id);
3898 event.SetInt(id);
3899
3900 return GetEventHandler()->ProcessEvent(event);
3901 }
3902 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
3903 else
3904 {
3905 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
3906 // notifications to its parent which we want to reflect back to
3907 // wxSpinCtrl
3908 wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
3909 if ( spin && spin->ProcessTextCommand(cmd, id) )
3910 return TRUE;
3911 }
3912 #endif // wxUSE_SPINCTRL
3913
3914 return FALSE;
3915 }
3916
3917 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam, WXLPARAM WXUNUSED(lParam))
3918 {
3919 // 4 bits are reserved
3920 switch ( wParam & 0xFFFFFFF0 )
3921 {
3922 case SC_MAXIMIZE:
3923 return HandleMaximize();
3924
3925 case SC_MINIMIZE:
3926 return HandleMinimize();
3927 }
3928
3929 return FALSE;
3930 }
3931
3932 // ---------------------------------------------------------------------------
3933 // mouse events
3934 // ---------------------------------------------------------------------------
3935
3936 void wxWindowMSW::InitMouseEvent(wxMouseEvent& event,
3937 int x, int y,
3938 WXUINT flags)
3939 {
3940 // our client coords are not quite the same as Windows ones
3941 wxPoint pt = GetClientAreaOrigin();
3942 event.m_x = x - pt.x;
3943 event.m_y = y - pt.y;
3944
3945 event.m_shiftDown = (flags & MK_SHIFT) != 0;
3946 event.m_controlDown = (flags & MK_CONTROL) != 0;
3947 event.m_leftDown = (flags & MK_LBUTTON) != 0;
3948 event.m_middleDown = (flags & MK_MBUTTON) != 0;
3949 event.m_rightDown = (flags & MK_RBUTTON) != 0;
3950 event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
3951
3952 event.SetTimestamp(s_currentMsg.time);
3953 event.m_eventObject = this;
3954 event.SetId(GetId());
3955
3956 #if wxUSE_MOUSEEVENT_HACK
3957 m_lastMouseX = x;
3958 m_lastMouseY = y;
3959 m_lastMouseEvent = event.GetEventType();
3960 #endif // wxUSE_MOUSEEVENT_HACK
3961 }
3962
3963 // Windows doesn't send the mouse events to the static controls (which are
3964 // transparent in the sense that their WM_NCHITTEST handler returns
3965 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
3966 // and so we manually check if we don't have a child window under mouse and if
3967 // we do, send the event to it instead of the window Windows had sent WM_XXX
3968 // to.
3969 //
3970 // Notice that this is not done for the mouse move events because this could
3971 // (would?) be too slow, but only for clicks which means that the static texts
3972 // still don't get move, enter nor leave events.
3973 static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y) //TW:REQ:Univ
3974 {
3975 wxCHECK_MSG( x && y, win, _T("NULL pointer in FindWindowForMouseEvent") );
3976
3977 // first try to find a non transparent child: this allows us to send events
3978 // to a static text which is inside a static box, for example
3979 POINT pt = { *x, *y };
3980 HWND hwnd = GetHwndOf(win),
3981 hwndUnderMouse;
3982
3983 #ifdef __WIN32__
3984 hwndUnderMouse = ::ChildWindowFromPointEx
3985 (
3986 hwnd,
3987 pt,
3988 CWP_SKIPINVISIBLE |
3989 CWP_SKIPDISABLED |
3990 CWP_SKIPTRANSPARENT
3991 );
3992
3993 if ( !hwndUnderMouse || hwndUnderMouse == hwnd )
3994 #endif // __WIN32__
3995 {
3996 // now try any child window at all
3997 hwndUnderMouse = ::ChildWindowFromPoint(hwnd, pt);
3998 }
3999
4000 // check that we have a child window which is susceptible to receive mouse
4001 // events: for this it must be shown and enabled
4002 if ( hwndUnderMouse &&
4003 hwndUnderMouse != hwnd &&
4004 ::IsWindowVisible(hwndUnderMouse) &&
4005 ::IsWindowEnabled(hwndUnderMouse) )
4006 {
4007 wxWindow *winUnderMouse = wxFindWinFromHandle((WXHWND)hwndUnderMouse);
4008 if ( winUnderMouse )
4009 {
4010 // translate the mouse coords to the other window coords
4011 win->ClientToScreen(x, y);
4012 winUnderMouse->ScreenToClient(x, y);
4013
4014 win = winUnderMouse;
4015 }
4016 }
4017
4018 return win;
4019 }
4020
4021 bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
4022 {
4023 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4024 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4025 // from the message id and take the value in the table to get wxWin event
4026 // id
4027 static const wxEventType eventsMouse[] =
4028 {
4029 wxEVT_MOTION,
4030 wxEVT_LEFT_DOWN,
4031 wxEVT_LEFT_UP,
4032 wxEVT_LEFT_DCLICK,
4033 wxEVT_RIGHT_DOWN,
4034 wxEVT_RIGHT_UP,
4035 wxEVT_RIGHT_DCLICK,
4036 wxEVT_MIDDLE_DOWN,
4037 wxEVT_MIDDLE_UP,
4038 wxEVT_MIDDLE_DCLICK
4039 };
4040
4041 wxMouseEvent event(eventsMouse[msg - WM_MOUSEMOVE]);
4042 InitMouseEvent(event, x, y, flags);
4043
4044 return GetEventHandler()->ProcessEvent(event);
4045 }
4046
4047 bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
4048 {
4049 if ( !m_mouseInWindow )
4050 {
4051 // it would be wrong to assume that just because we get a mouse move
4052 // event that the mouse is inside the window: although this is usually
4053 // true, it is not if we had captured the mouse, so we need to check
4054 // the mouse coordinates here
4055 if ( !HasCapture() || IsMouseInWindow() )
4056 {
4057 // Generate an ENTER event
4058 m_mouseInWindow = TRUE;
4059
4060 wxMouseEvent event(wxEVT_ENTER_WINDOW);
4061 InitMouseEvent(event, x, y, flags);
4062
4063 (void)GetEventHandler()->ProcessEvent(event);
4064 }
4065 }
4066
4067 #if wxUSE_MOUSEEVENT_HACK
4068 // Window gets a click down message followed by a mouse move message even
4069 // if position isn't changed! We want to discard the trailing move event
4070 // if x and y are the same.
4071 if ( (m_lastMouseEvent == wxEVT_RIGHT_DOWN ||
4072 m_lastMouseEvent == wxEVT_LEFT_DOWN ||
4073 m_lastMouseEvent == wxEVT_MIDDLE_DOWN) &&
4074 (m_lastMouseX == x && m_lastMouseY == y) )
4075 {
4076 m_lastMouseEvent = wxEVT_MOTION;
4077
4078 return FALSE;
4079 }
4080 #endif // wxUSE_MOUSEEVENT_HACK
4081
4082 return HandleMouseEvent(WM_MOUSEMOVE, x, y, flags);
4083 }
4084
4085
4086 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
4087 {
4088 #if wxUSE_MOUSEWHEEL
4089 wxMouseEvent event(wxEVT_MOUSEWHEEL);
4090 InitMouseEvent(event,
4091 GET_X_LPARAM(lParam),
4092 GET_Y_LPARAM(lParam),
4093 LOWORD(wParam));
4094 event.m_wheelRotation = (short)HIWORD(wParam);
4095 event.m_wheelDelta = WHEEL_DELTA;
4096
4097 #ifdef __WIN32__
4098 static int s_linesPerRotation = -1;
4099 if ( s_linesPerRotation == -1 )
4100 {
4101 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
4102 &s_linesPerRotation, 0))
4103 {
4104 // this is not supposed to happen
4105 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4106
4107 // the default is 3, so use it if SystemParametersInfo() failed
4108 s_linesPerRotation = 3;
4109 }
4110 }
4111 #else // Win16
4112 // no SystemParametersInfo() under Win16
4113 static const int s_linesPerRotation = 3;
4114 #endif
4115
4116 event.m_linesPerAction = s_linesPerRotation;
4117 return GetEventHandler()->ProcessEvent(event);
4118
4119 #else
4120 (void) wParam;
4121 (void) lParam;
4122
4123 return FALSE;
4124 #endif
4125 }
4126
4127
4128 // ---------------------------------------------------------------------------
4129 // keyboard handling
4130 // ---------------------------------------------------------------------------
4131
4132 // create the key event of the given type for the given key - used by
4133 // HandleChar and HandleKeyDown/Up
4134 wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
4135 int id,
4136 WXLPARAM lParam,
4137 WXWPARAM wParam) const
4138 {
4139 wxKeyEvent event(evType);
4140 event.SetId(GetId());
4141 event.m_shiftDown = wxIsShiftDown();
4142 event.m_controlDown = wxIsCtrlDown();
4143 event.m_altDown = (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN;
4144
4145 event.m_eventObject = (wxWindow *)this; // const_cast
4146 event.m_keyCode = id;
4147 event.m_rawCode = (wxUint32) wParam;
4148 event.m_rawFlags = (wxUint32) lParam;
4149 event.SetTimestamp(s_currentMsg.time);
4150
4151 // translate the position to client coords
4152 POINT pt;
4153 GetCursorPos(&pt);
4154 RECT rect;
4155 GetWindowRect(GetHwnd(),&rect);
4156 pt.x -= rect.left;
4157 pt.y -= rect.top;
4158
4159 event.m_x = pt.x;
4160 event.m_y = pt.y;
4161
4162 return event;
4163 }
4164
4165 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4166 // WM_KEYDOWN one
4167 bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
4168 {
4169 bool ctrlDown = FALSE;
4170
4171 int id;
4172 if ( isASCII )
4173 {
4174 // If 1 -> 26, translate to CTRL plus a letter.
4175 id = wParam;
4176 if ( (id > 0) && (id < 27) )
4177 {
4178 switch (id)
4179 {
4180 case 13:
4181 id = WXK_RETURN;
4182 break;
4183
4184 case 8:
4185 id = WXK_BACK;
4186 break;
4187
4188 case 9:
4189 id = WXK_TAB;
4190 break;
4191
4192 default:
4193 ctrlDown = TRUE;
4194 id = id + 'a' - 1;
4195 }
4196 }
4197 }
4198 else // we're called from WM_KEYDOWN
4199 {
4200 id = wxCharCodeMSWToWX(wParam);
4201 if ( id == 0 )
4202 {
4203 // it's ASCII and will be processed here only when called from
4204 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4205 return FALSE;
4206 }
4207 }
4208
4209 wxKeyEvent event(CreateKeyEvent(wxEVT_CHAR, id, lParam, wParam));
4210 if ( ctrlDown )
4211 {
4212 event.m_controlDown = TRUE;
4213 }
4214
4215 return GetEventHandler()->ProcessEvent(event);
4216 }
4217
4218 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
4219 {
4220 int id = wxCharCodeMSWToWX(wParam);
4221
4222 if ( !id )
4223 {
4224 // normal ASCII char
4225 id = wParam;
4226 }
4227
4228 if ( id != -1 ) // VZ: does this ever happen (FIXME)?
4229 {
4230 wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam, wParam));
4231 if ( GetEventHandler()->ProcessEvent(event) )
4232 {
4233 return TRUE;
4234 }
4235 }
4236
4237 return FALSE;
4238 }
4239
4240 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
4241 {
4242 int id = wxCharCodeMSWToWX(wParam);
4243
4244 if ( !id )
4245 {
4246 // normal ASCII char
4247 id = wParam;
4248 }
4249
4250 if ( id != -1 ) // VZ: does this ever happen (FIXME)?
4251 {
4252 wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam, wParam));
4253 if ( GetEventHandler()->ProcessEvent(event) )
4254 return TRUE;
4255 }
4256
4257 return FALSE;
4258 }
4259
4260 // ---------------------------------------------------------------------------
4261 // joystick
4262 // ---------------------------------------------------------------------------
4263
4264 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
4265 {
4266 #ifdef JOY_BUTTON1
4267 int change = 0;
4268 if ( flags & JOY_BUTTON1CHG )
4269 change = wxJOY_BUTTON1;
4270 if ( flags & JOY_BUTTON2CHG )
4271 change = wxJOY_BUTTON2;
4272 if ( flags & JOY_BUTTON3CHG )
4273 change = wxJOY_BUTTON3;
4274 if ( flags & JOY_BUTTON4CHG )
4275 change = wxJOY_BUTTON4;
4276
4277 int buttons = 0;
4278 if ( flags & JOY_BUTTON1 )
4279 buttons |= wxJOY_BUTTON1;
4280 if ( flags & JOY_BUTTON2 )
4281 buttons |= wxJOY_BUTTON2;
4282 if ( flags & JOY_BUTTON3 )
4283 buttons |= wxJOY_BUTTON3;
4284 if ( flags & JOY_BUTTON4 )
4285 buttons |= wxJOY_BUTTON4;
4286
4287 // the event ids aren't consecutive so we can't use table based lookup
4288 int joystick;
4289 wxEventType eventType;
4290 switch ( msg )
4291 {
4292 case MM_JOY1MOVE:
4293 joystick = 1;
4294 eventType = wxEVT_JOY_MOVE;
4295 break;
4296
4297 case MM_JOY2MOVE:
4298 joystick = 2;
4299 eventType = wxEVT_JOY_MOVE;
4300 break;
4301
4302 case MM_JOY1ZMOVE:
4303 joystick = 1;
4304 eventType = wxEVT_JOY_ZMOVE;
4305 break;
4306
4307 case MM_JOY2ZMOVE:
4308 joystick = 2;
4309 eventType = wxEVT_JOY_ZMOVE;
4310 break;
4311
4312 case MM_JOY1BUTTONDOWN:
4313 joystick = 1;
4314 eventType = wxEVT_JOY_BUTTON_DOWN;
4315 break;
4316
4317 case MM_JOY2BUTTONDOWN:
4318 joystick = 2;
4319 eventType = wxEVT_JOY_BUTTON_DOWN;
4320 break;
4321
4322 case MM_JOY1BUTTONUP:
4323 joystick = 1;
4324 eventType = wxEVT_JOY_BUTTON_UP;
4325 break;
4326
4327 case MM_JOY2BUTTONUP:
4328 joystick = 2;
4329 eventType = wxEVT_JOY_BUTTON_UP;
4330 break;
4331
4332 default:
4333 wxFAIL_MSG(wxT("no such joystick event"));
4334
4335 return FALSE;
4336 }
4337
4338 wxJoystickEvent event(eventType, buttons, joystick, change);
4339 event.SetPosition(wxPoint(x, y));
4340 event.SetEventObject(this);
4341
4342 return GetEventHandler()->ProcessEvent(event);
4343 #else
4344 return FALSE;
4345 #endif
4346 }
4347
4348 // ---------------------------------------------------------------------------
4349 // scrolling
4350 // ---------------------------------------------------------------------------
4351
4352 bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
4353 WXWORD pos, WXHWND control)
4354 {
4355 if ( control )
4356 {
4357 wxWindow *child = wxFindWinFromHandle(control);
4358 if ( child )
4359 return child->MSWOnScroll(orientation, wParam, pos, control);
4360 }
4361
4362 wxScrollWinEvent event;
4363 event.SetPosition(pos);
4364 event.SetOrientation(orientation);
4365 event.m_eventObject = this;
4366
4367 switch ( wParam )
4368 {
4369 case SB_TOP:
4370 event.m_eventType = wxEVT_SCROLLWIN_TOP;
4371 break;
4372
4373 case SB_BOTTOM:
4374 event.m_eventType = wxEVT_SCROLLWIN_BOTTOM;
4375 break;
4376
4377 case SB_LINEUP:
4378 event.m_eventType = wxEVT_SCROLLWIN_LINEUP;
4379 break;
4380
4381 case SB_LINEDOWN:
4382 event.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
4383 break;
4384
4385 case SB_PAGEUP:
4386 event.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
4387 break;
4388
4389 case SB_PAGEDOWN:
4390 event.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
4391 break;
4392
4393 case SB_THUMBPOSITION:
4394 case SB_THUMBTRACK:
4395 #ifdef __WIN32__
4396 // under Win32, the scrollbar range and position are 32 bit integers,
4397 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4398 // explicitly query the scrollbar for the correct position (this must
4399 // be done only for these two SB_ events as they are the only one
4400 // carrying the scrollbar position)
4401 {
4402 SCROLLINFO scrollInfo;
4403 wxZeroMemory(scrollInfo);
4404 scrollInfo.cbSize = sizeof(SCROLLINFO);
4405 scrollInfo.fMask = SIF_TRACKPOS;
4406
4407 if ( !::GetScrollInfo(GetHwnd(),
4408 orientation == wxHORIZONTAL ? SB_HORZ
4409 : SB_VERT,
4410 &scrollInfo) )
4411 {
4412 wxLogLastError(_T("GetScrollInfo"));
4413 }
4414
4415 event.SetPosition(scrollInfo.nTrackPos);
4416 }
4417 #endif // Win32
4418
4419 event.m_eventType = wParam == SB_THUMBPOSITION
4420 ? wxEVT_SCROLLWIN_THUMBRELEASE
4421 : wxEVT_SCROLLWIN_THUMBTRACK;
4422 break;
4423
4424 default:
4425 return FALSE;
4426 }
4427
4428 return GetEventHandler()->ProcessEvent(event);
4429 }
4430
4431 // ===========================================================================
4432 // global functions
4433 // ===========================================================================
4434
4435 void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
4436 {
4437 TEXTMETRIC tm;
4438 HDC dc = ::GetDC((HWND) wnd);
4439 HFONT fnt =0;
4440 HFONT was = 0;
4441 if ( the_font )
4442 {
4443 // the_font->UseResource();
4444 // the_font->RealizeResource();
4445 fnt = (HFONT)((wxFont *)the_font)->GetResourceHandle(); // const_cast
4446 if ( fnt )
4447 was = (HFONT) SelectObject(dc,fnt);
4448 }
4449 GetTextMetrics(dc, &tm);
4450 if ( the_font && fnt && was )
4451 {
4452 SelectObject(dc,was);
4453 }
4454 ReleaseDC((HWND)wnd, dc);
4455
4456 if ( x )
4457 *x = tm.tmAveCharWidth;
4458 if ( y )
4459 *y = tm.tmHeight + tm.tmExternalLeading;
4460
4461 // if ( the_font )
4462 // the_font->ReleaseResource();
4463 }
4464
4465 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4466 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4467 int wxCharCodeMSWToWX(int keySym)
4468 {
4469 int id;
4470 switch (keySym)
4471 {
4472 case VK_CANCEL: id = WXK_CANCEL; break;
4473 case VK_BACK: id = WXK_BACK; break;
4474 case VK_TAB: id = WXK_TAB; break;
4475 case VK_CLEAR: id = WXK_CLEAR; break;
4476 case VK_RETURN: id = WXK_RETURN; break;
4477 case VK_SHIFT: id = WXK_SHIFT; break;
4478 case VK_CONTROL: id = WXK_CONTROL; break;
4479 case VK_MENU : id = WXK_MENU; break;
4480 case VK_PAUSE: id = WXK_PAUSE; break;
4481 case VK_CAPITAL: id = WXK_CAPITAL; break;
4482 case VK_SPACE: id = WXK_SPACE; break;
4483 case VK_ESCAPE: id = WXK_ESCAPE; break;
4484 case VK_PRIOR: id = WXK_PRIOR; break;
4485 case VK_NEXT : id = WXK_NEXT; break;
4486 case VK_END: id = WXK_END; break;
4487 case VK_HOME : id = WXK_HOME; break;
4488 case VK_LEFT : id = WXK_LEFT; break;
4489 case VK_UP: id = WXK_UP; break;
4490 case VK_RIGHT: id = WXK_RIGHT; break;
4491 case VK_DOWN : id = WXK_DOWN; break;
4492 case VK_SELECT: id = WXK_SELECT; break;
4493 case VK_PRINT: id = WXK_PRINT; break;
4494 case VK_EXECUTE: id = WXK_EXECUTE; break;
4495 case VK_INSERT: id = WXK_INSERT; break;
4496 case VK_DELETE: id = WXK_DELETE; break;
4497 case VK_HELP : id = WXK_HELP; break;
4498 case VK_NUMPAD0: id = WXK_NUMPAD0; break;
4499 case VK_NUMPAD1: id = WXK_NUMPAD1; break;
4500 case VK_NUMPAD2: id = WXK_NUMPAD2; break;
4501 case VK_NUMPAD3: id = WXK_NUMPAD3; break;
4502 case VK_NUMPAD4: id = WXK_NUMPAD4; break;
4503 case VK_NUMPAD5: id = WXK_NUMPAD5; break;
4504 case VK_NUMPAD6: id = WXK_NUMPAD6; break;
4505 case VK_NUMPAD7: id = WXK_NUMPAD7; break;
4506 case VK_NUMPAD8: id = WXK_NUMPAD8; break;
4507 case VK_NUMPAD9: id = WXK_NUMPAD9; break;
4508 case VK_MULTIPLY: id = WXK_NUMPAD_MULTIPLY; break;
4509 case VK_ADD: id = WXK_NUMPAD_ADD; break;
4510 case VK_SUBTRACT: id = WXK_NUMPAD_SUBTRACT; break;
4511 case VK_DECIMAL: id = WXK_NUMPAD_DECIMAL; break;
4512 case VK_DIVIDE: id = WXK_NUMPAD_DIVIDE; break;
4513 case VK_F1: id = WXK_F1; break;
4514 case VK_F2: id = WXK_F2; break;
4515 case VK_F3: id = WXK_F3; break;
4516 case VK_F4: id = WXK_F4; break;
4517 case VK_F5: id = WXK_F5; break;
4518 case VK_F6: id = WXK_F6; break;
4519 case VK_F7: id = WXK_F7; break;
4520 case VK_F8: id = WXK_F8; break;
4521 case VK_F9: id = WXK_F9; break;
4522 case VK_F10: id = WXK_F10; break;
4523 case VK_F11: id = WXK_F11; break;
4524 case VK_F12: id = WXK_F12; break;
4525 case VK_F13: id = WXK_F13; break;
4526 case VK_F14: id = WXK_F14; break;
4527 case VK_F15: id = WXK_F15; break;
4528 case VK_F16: id = WXK_F16; break;
4529 case VK_F17: id = WXK_F17; break;
4530 case VK_F18: id = WXK_F18; break;
4531 case VK_F19: id = WXK_F19; break;
4532 case VK_F20: id = WXK_F20; break;
4533 case VK_F21: id = WXK_F21; break;
4534 case VK_F22: id = WXK_F22; break;
4535 case VK_F23: id = WXK_F23; break;
4536 case VK_F24: id = WXK_F24; break;
4537 case VK_NUMLOCK: id = WXK_NUMLOCK; break;
4538 case VK_SCROLL: id = WXK_SCROLL; break;
4539
4540 case VK_OEM_1: id = ';'; break;
4541 case VK_OEM_PLUS: id = '+'; break;
4542 case VK_OEM_COMMA: id = ','; break;
4543 case VK_OEM_MINUS: id = '-'; break;
4544 case VK_OEM_PERIOD: id = '.'; break;
4545 case VK_OEM_2: id = '/'; break;
4546 case VK_OEM_3: id = '~'; break;
4547 case VK_OEM_4: id = '['; break;
4548 case VK_OEM_5: id = '\\'; break;
4549 case VK_OEM_6: id = ']'; break;
4550 case VK_OEM_7: id = '\''; break;
4551
4552 default:
4553 id = 0;
4554 }
4555
4556 return id;
4557 }
4558
4559 int wxCharCodeWXToMSW(int id, bool *isVirtual)
4560 {
4561 *isVirtual = TRUE;
4562 int keySym = 0;
4563 switch (id)
4564 {
4565 case WXK_CANCEL: keySym = VK_CANCEL; break;
4566 case WXK_CLEAR: keySym = VK_CLEAR; break;
4567 case WXK_SHIFT: keySym = VK_SHIFT; break;
4568 case WXK_CONTROL: keySym = VK_CONTROL; break;
4569 case WXK_MENU : keySym = VK_MENU; break;
4570 case WXK_PAUSE: keySym = VK_PAUSE; break;
4571 case WXK_PRIOR: keySym = VK_PRIOR; break;
4572 case WXK_NEXT : keySym = VK_NEXT; break;
4573 case WXK_END: keySym = VK_END; break;
4574 case WXK_HOME : keySym = VK_HOME; break;
4575 case WXK_LEFT : keySym = VK_LEFT; break;
4576 case WXK_UP: keySym = VK_UP; break;
4577 case WXK_RIGHT: keySym = VK_RIGHT; break;
4578 case WXK_DOWN : keySym = VK_DOWN; break;
4579 case WXK_SELECT: keySym = VK_SELECT; break;
4580 case WXK_PRINT: keySym = VK_PRINT; break;
4581 case WXK_EXECUTE: keySym = VK_EXECUTE; break;
4582 case WXK_INSERT: keySym = VK_INSERT; break;
4583 case WXK_DELETE: keySym = VK_DELETE; break;
4584 case WXK_HELP : keySym = VK_HELP; break;
4585 case WXK_NUMPAD0: keySym = VK_NUMPAD0; break;
4586 case WXK_NUMPAD1: keySym = VK_NUMPAD1; break;
4587 case WXK_NUMPAD2: keySym = VK_NUMPAD2; break;
4588 case WXK_NUMPAD3: keySym = VK_NUMPAD3; break;
4589 case WXK_NUMPAD4: keySym = VK_NUMPAD4; break;
4590 case WXK_NUMPAD5: keySym = VK_NUMPAD5; break;
4591 case WXK_NUMPAD6: keySym = VK_NUMPAD6; break;
4592 case WXK_NUMPAD7: keySym = VK_NUMPAD7; break;
4593 case WXK_NUMPAD8: keySym = VK_NUMPAD8; break;
4594 case WXK_NUMPAD9: keySym = VK_NUMPAD9; break;
4595 case WXK_NUMPAD_MULTIPLY: keySym = VK_MULTIPLY; break;
4596 case WXK_NUMPAD_ADD: keySym = VK_ADD; break;
4597 case WXK_NUMPAD_SUBTRACT: keySym = VK_SUBTRACT; break;
4598 case WXK_NUMPAD_DECIMAL: keySym = VK_DECIMAL; break;
4599 case WXK_NUMPAD_DIVIDE: keySym = VK_DIVIDE; break;
4600 case WXK_F1: keySym = VK_F1; break;
4601 case WXK_F2: keySym = VK_F2; break;
4602 case WXK_F3: keySym = VK_F3; break;
4603 case WXK_F4: keySym = VK_F4; break;
4604 case WXK_F5: keySym = VK_F5; break;
4605 case WXK_F6: keySym = VK_F6; break;
4606 case WXK_F7: keySym = VK_F7; break;
4607 case WXK_F8: keySym = VK_F8; break;
4608 case WXK_F9: keySym = VK_F9; break;
4609 case WXK_F10: keySym = VK_F10; break;
4610 case WXK_F11: keySym = VK_F11; break;
4611 case WXK_F12: keySym = VK_F12; break;
4612 case WXK_F13: keySym = VK_F13; break;
4613 case WXK_F14: keySym = VK_F14; break;
4614 case WXK_F15: keySym = VK_F15; break;
4615 case WXK_F16: keySym = VK_F16; break;
4616 case WXK_F17: keySym = VK_F17; break;
4617 case WXK_F18: keySym = VK_F18; break;
4618 case WXK_F19: keySym = VK_F19; break;
4619 case WXK_F20: keySym = VK_F20; break;
4620 case WXK_F21: keySym = VK_F21; break;
4621 case WXK_F22: keySym = VK_F22; break;
4622 case WXK_F23: keySym = VK_F23; break;
4623 case WXK_F24: keySym = VK_F24; break;
4624 case WXK_NUMLOCK: keySym = VK_NUMLOCK; break;
4625 case WXK_SCROLL: keySym = VK_SCROLL; break;
4626 default:
4627 {
4628 *isVirtual = FALSE;
4629 keySym = id;
4630 break;
4631 }
4632 }
4633 return keySym;
4634 }
4635
4636 wxWindow *wxGetActiveWindow()
4637 {
4638 HWND hWnd = GetActiveWindow();
4639 if ( hWnd != 0 )
4640 {
4641 return wxFindWinFromHandle((WXHWND) hWnd);
4642 }
4643 return NULL;
4644 }
4645
4646 extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
4647 {
4648 HWND hwnd = (HWND)hWnd;
4649
4650 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4651 // by code in msw/radiobox.cpp), for all the others we just search up the
4652 // window hierarchy
4653 wxWindow *win = (wxWindow *)NULL;
4654 if ( hwnd )
4655 {
4656 win = wxFindWinFromHandle((WXHWND)hwnd);
4657 if ( !win )
4658 {
4659 // all these hacks only work under Win32 anyhow
4660 #ifdef __WIN32__
4661
4662 #if wxUSE_RADIOBOX
4663 // native radiobuttons return DLGC_RADIOBUTTON here and for any
4664 // wxWindow class which overrides WM_GETDLGCODE processing to
4665 // do it as well, win would be already non NULL
4666 if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
4667 {
4668 win = (wxWindow *)::GetWindowLong(hwnd, GWL_USERDATA);
4669 }
4670 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
4671 #endif // wxUSE_RADIOBOX
4672
4673 // spin control text buddy window should be mapped to spin ctrl
4674 // itself so try it too
4675 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4676 if ( !win )
4677 {
4678 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
4679 }
4680 #endif // wxUSE_SPINCTRL
4681
4682 #endif // Win32
4683 }
4684 }
4685
4686 while ( hwnd && !win )
4687 {
4688 // this is a really ugly hack needed to avoid mistakenly returning the
4689 // parent frame wxWindow for the find/replace modeless dialog HWND -
4690 // this, in turn, is needed to call IsDialogMessage() from
4691 // wxApp::ProcessMessage() as for this we must return NULL from here
4692 //
4693 // FIXME: this is clearly not the best way to do it but I think we'll
4694 // need to change HWND <-> wxWindow code more heavily than I can
4695 // do it now to fix it
4696 #ifndef __WXMICROWIN__
4697 if ( ::GetWindow(hwnd, GW_OWNER) )
4698 {
4699 // it's a dialog box, don't go upwards
4700 break;
4701 }
4702 #endif
4703
4704 hwnd = ::GetParent(hwnd);
4705 win = wxFindWinFromHandle((WXHWND)hwnd);
4706 }
4707
4708 return win;
4709 }
4710
4711 #ifndef __WXMICROWIN__
4712
4713 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4714 // in active frames and dialogs, regardless of where the focus is.
4715 static HHOOK wxTheKeyboardHook = 0;
4716 static FARPROC wxTheKeyboardHookProc = 0;
4717 int APIENTRY _EXPORT
4718 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
4719
4720 void wxSetKeyboardHook(bool doIt)
4721 {
4722 if ( doIt )
4723 {
4724 wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
4725 wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
4726
4727 #if defined(__WIN32__) && !defined(__TWIN32__)
4728 GetCurrentThreadId()
4729 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
4730 #else
4731 GetCurrentTask()
4732 #endif
4733 );
4734 }
4735 else
4736 {
4737 UnhookWindowsHookEx(wxTheKeyboardHook);
4738
4739 // avoids warning about statement with no effect (FreeProcInstance
4740 // doesn't do anything under Win32)
4741 #if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32__) && !defined(__NT__) && !defined(__GNUWIN32__)
4742 FreeProcInstance(wxTheKeyboardHookProc);
4743 #endif
4744 }
4745 }
4746
4747 int APIENTRY _EXPORT
4748 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
4749 {
4750 DWORD hiWord = HIWORD(lParam);
4751 if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
4752 {
4753 int id = wxCharCodeMSWToWX(wParam);
4754 if ( id != 0 )
4755 {
4756 wxKeyEvent event(wxEVT_CHAR_HOOK);
4757 if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
4758 event.m_altDown = TRUE;
4759
4760 event.m_eventObject = NULL;
4761 event.m_keyCode = id;
4762 event.m_shiftDown = wxIsShiftDown();
4763 event.m_controlDown = wxIsCtrlDown();
4764 event.SetTimestamp(s_currentMsg.time);
4765
4766 wxWindow *win = wxGetActiveWindow();
4767 wxEvtHandler *handler;
4768 if ( win )
4769 {
4770 handler = win->GetEventHandler();
4771 event.SetId(win->GetId());
4772 }
4773 else
4774 {
4775 handler = wxTheApp;
4776 event.SetId(-1);
4777 }
4778
4779 if ( handler && handler->ProcessEvent(event) )
4780 {
4781 // processed
4782 return 1;
4783 }
4784 }
4785 }
4786
4787 return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
4788 }
4789
4790 #endif // !__WXMICROWIN__
4791
4792 #ifdef __WXDEBUG__
4793 const char *wxGetMessageName(int message)
4794 {
4795 switch ( message )
4796 {
4797 case 0x0000: return "WM_NULL";
4798 case 0x0001: return "WM_CREATE";
4799 case 0x0002: return "WM_DESTROY";
4800 case 0x0003: return "WM_MOVE";
4801 case 0x0005: return "WM_SIZE";
4802 case 0x0006: return "WM_ACTIVATE";
4803 case 0x0007: return "WM_SETFOCUS";
4804 case 0x0008: return "WM_KILLFOCUS";
4805 case 0x000A: return "WM_ENABLE";
4806 case 0x000B: return "WM_SETREDRAW";
4807 case 0x000C: return "WM_SETTEXT";
4808 case 0x000D: return "WM_GETTEXT";
4809 case 0x000E: return "WM_GETTEXTLENGTH";
4810 case 0x000F: return "WM_PAINT";
4811 case 0x0010: return "WM_CLOSE";
4812 case 0x0011: return "WM_QUERYENDSESSION";
4813 case 0x0012: return "WM_QUIT";
4814 case 0x0013: return "WM_QUERYOPEN";
4815 case 0x0014: return "WM_ERASEBKGND";
4816 case 0x0015: return "WM_SYSCOLORCHANGE";
4817 case 0x0016: return "WM_ENDSESSION";
4818 case 0x0017: return "WM_SYSTEMERROR";
4819 case 0x0018: return "WM_SHOWWINDOW";
4820 case 0x0019: return "WM_CTLCOLOR";
4821 case 0x001A: return "WM_WININICHANGE";
4822 case 0x001B: return "WM_DEVMODECHANGE";
4823 case 0x001C: return "WM_ACTIVATEAPP";
4824 case 0x001D: return "WM_FONTCHANGE";
4825 case 0x001E: return "WM_TIMECHANGE";
4826 case 0x001F: return "WM_CANCELMODE";
4827 case 0x0020: return "WM_SETCURSOR";
4828 case 0x0021: return "WM_MOUSEACTIVATE";
4829 case 0x0022: return "WM_CHILDACTIVATE";
4830 case 0x0023: return "WM_QUEUESYNC";
4831 case 0x0024: return "WM_GETMINMAXINFO";
4832 case 0x0026: return "WM_PAINTICON";
4833 case 0x0027: return "WM_ICONERASEBKGND";
4834 case 0x0028: return "WM_NEXTDLGCTL";
4835 case 0x002A: return "WM_SPOOLERSTATUS";
4836 case 0x002B: return "WM_DRAWITEM";
4837 case 0x002C: return "WM_MEASUREITEM";
4838 case 0x002D: return "WM_DELETEITEM";
4839 case 0x002E: return "WM_VKEYTOITEM";
4840 case 0x002F: return "WM_CHARTOITEM";
4841 case 0x0030: return "WM_SETFONT";
4842 case 0x0031: return "WM_GETFONT";
4843 case 0x0037: return "WM_QUERYDRAGICON";
4844 case 0x0039: return "WM_COMPAREITEM";
4845 case 0x0041: return "WM_COMPACTING";
4846 case 0x0044: return "WM_COMMNOTIFY";
4847 case 0x0046: return "WM_WINDOWPOSCHANGING";
4848 case 0x0047: return "WM_WINDOWPOSCHANGED";
4849 case 0x0048: return "WM_POWER";
4850
4851 #ifdef __WIN32__
4852 case 0x004A: return "WM_COPYDATA";
4853 case 0x004B: return "WM_CANCELJOURNAL";
4854 case 0x004E: return "WM_NOTIFY";
4855 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
4856 case 0x0051: return "WM_INPUTLANGCHANGE";
4857 case 0x0052: return "WM_TCARD";
4858 case 0x0053: return "WM_HELP";
4859 case 0x0054: return "WM_USERCHANGED";
4860 case 0x0055: return "WM_NOTIFYFORMAT";
4861 case 0x007B: return "WM_CONTEXTMENU";
4862 case 0x007C: return "WM_STYLECHANGING";
4863 case 0x007D: return "WM_STYLECHANGED";
4864 case 0x007E: return "WM_DISPLAYCHANGE";
4865 case 0x007F: return "WM_GETICON";
4866 case 0x0080: return "WM_SETICON";
4867 #endif //WIN32
4868
4869 case 0x0081: return "WM_NCCREATE";
4870 case 0x0082: return "WM_NCDESTROY";
4871 case 0x0083: return "WM_NCCALCSIZE";
4872 case 0x0084: return "WM_NCHITTEST";
4873 case 0x0085: return "WM_NCPAINT";
4874 case 0x0086: return "WM_NCACTIVATE";
4875 case 0x0087: return "WM_GETDLGCODE";
4876 case 0x00A0: return "WM_NCMOUSEMOVE";
4877 case 0x00A1: return "WM_NCLBUTTONDOWN";
4878 case 0x00A2: return "WM_NCLBUTTONUP";
4879 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
4880 case 0x00A4: return "WM_NCRBUTTONDOWN";
4881 case 0x00A5: return "WM_NCRBUTTONUP";
4882 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
4883 case 0x00A7: return "WM_NCMBUTTONDOWN";
4884 case 0x00A8: return "WM_NCMBUTTONUP";
4885 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
4886 case 0x0100: return "WM_KEYDOWN";
4887 case 0x0101: return "WM_KEYUP";
4888 case 0x0102: return "WM_CHAR";
4889 case 0x0103: return "WM_DEADCHAR";
4890 case 0x0104: return "WM_SYSKEYDOWN";
4891 case 0x0105: return "WM_SYSKEYUP";
4892 case 0x0106: return "WM_SYSCHAR";
4893 case 0x0107: return "WM_SYSDEADCHAR";
4894 case 0x0108: return "WM_KEYLAST";
4895
4896 #ifdef __WIN32__
4897 case 0x010D: return "WM_IME_STARTCOMPOSITION";
4898 case 0x010E: return "WM_IME_ENDCOMPOSITION";
4899 case 0x010F: return "WM_IME_COMPOSITION";
4900 #endif //WIN32
4901
4902 case 0x0110: return "WM_INITDIALOG";
4903 case 0x0111: return "WM_COMMAND";
4904 case 0x0112: return "WM_SYSCOMMAND";
4905 case 0x0113: return "WM_TIMER";
4906 case 0x0114: return "WM_HSCROLL";
4907 case 0x0115: return "WM_VSCROLL";
4908 case 0x0116: return "WM_INITMENU";
4909 case 0x0117: return "WM_INITMENUPOPUP";
4910 case 0x011F: return "WM_MENUSELECT";
4911 case 0x0120: return "WM_MENUCHAR";
4912 case 0x0121: return "WM_ENTERIDLE";
4913 case 0x0200: return "WM_MOUSEMOVE";
4914 case 0x0201: return "WM_LBUTTONDOWN";
4915 case 0x0202: return "WM_LBUTTONUP";
4916 case 0x0203: return "WM_LBUTTONDBLCLK";
4917 case 0x0204: return "WM_RBUTTONDOWN";
4918 case 0x0205: return "WM_RBUTTONUP";
4919 case 0x0206: return "WM_RBUTTONDBLCLK";
4920 case 0x0207: return "WM_MBUTTONDOWN";
4921 case 0x0208: return "WM_MBUTTONUP";
4922 case 0x0209: return "WM_MBUTTONDBLCLK";
4923 case 0x020A: return "WM_MOUSEWHEEL";
4924 case 0x0210: return "WM_PARENTNOTIFY";
4925 case 0x0211: return "WM_ENTERMENULOOP";
4926 case 0x0212: return "WM_EXITMENULOOP";
4927
4928 #ifdef __WIN32__
4929 case 0x0213: return "WM_NEXTMENU";
4930 case 0x0214: return "WM_SIZING";
4931 case 0x0215: return "WM_CAPTURECHANGED";
4932 case 0x0216: return "WM_MOVING";
4933 case 0x0218: return "WM_POWERBROADCAST";
4934 case 0x0219: return "WM_DEVICECHANGE";
4935 #endif //WIN32
4936
4937 case 0x0220: return "WM_MDICREATE";
4938 case 0x0221: return "WM_MDIDESTROY";
4939 case 0x0222: return "WM_MDIACTIVATE";
4940 case 0x0223: return "WM_MDIRESTORE";
4941 case 0x0224: return "WM_MDINEXT";
4942 case 0x0225: return "WM_MDIMAXIMIZE";
4943 case 0x0226: return "WM_MDITILE";
4944 case 0x0227: return "WM_MDICASCADE";
4945 case 0x0228: return "WM_MDIICONARRANGE";
4946 case 0x0229: return "WM_MDIGETACTIVE";
4947 case 0x0230: return "WM_MDISETMENU";
4948 case 0x0233: return "WM_DROPFILES";
4949
4950 #ifdef __WIN32__
4951 case 0x0281: return "WM_IME_SETCONTEXT";
4952 case 0x0282: return "WM_IME_NOTIFY";
4953 case 0x0283: return "WM_IME_CONTROL";
4954 case 0x0284: return "WM_IME_COMPOSITIONFULL";
4955 case 0x0285: return "WM_IME_SELECT";
4956 case 0x0286: return "WM_IME_CHAR";
4957 case 0x0290: return "WM_IME_KEYDOWN";
4958 case 0x0291: return "WM_IME_KEYUP";
4959 #endif //WIN32
4960
4961 case 0x0300: return "WM_CUT";
4962 case 0x0301: return "WM_COPY";
4963 case 0x0302: return "WM_PASTE";
4964 case 0x0303: return "WM_CLEAR";
4965 case 0x0304: return "WM_UNDO";
4966 case 0x0305: return "WM_RENDERFORMAT";
4967 case 0x0306: return "WM_RENDERALLFORMATS";
4968 case 0x0307: return "WM_DESTROYCLIPBOARD";
4969 case 0x0308: return "WM_DRAWCLIPBOARD";
4970 case 0x0309: return "WM_PAINTCLIPBOARD";
4971 case 0x030A: return "WM_VSCROLLCLIPBOARD";
4972 case 0x030B: return "WM_SIZECLIPBOARD";
4973 case 0x030C: return "WM_ASKCBFORMATNAME";
4974 case 0x030D: return "WM_CHANGECBCHAIN";
4975 case 0x030E: return "WM_HSCROLLCLIPBOARD";
4976 case 0x030F: return "WM_QUERYNEWPALETTE";
4977 case 0x0310: return "WM_PALETTEISCHANGING";
4978 case 0x0311: return "WM_PALETTECHANGED";
4979
4980 #ifdef __WIN32__
4981 // common controls messages - although they're not strictly speaking
4982 // standard, it's nice to decode them nevertheless
4983
4984 // listview
4985 case 0x1000 + 0: return "LVM_GETBKCOLOR";
4986 case 0x1000 + 1: return "LVM_SETBKCOLOR";
4987 case 0x1000 + 2: return "LVM_GETIMAGELIST";
4988 case 0x1000 + 3: return "LVM_SETIMAGELIST";
4989 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
4990 case 0x1000 + 5: return "LVM_GETITEMA";
4991 case 0x1000 + 75: return "LVM_GETITEMW";
4992 case 0x1000 + 6: return "LVM_SETITEMA";
4993 case 0x1000 + 76: return "LVM_SETITEMW";
4994 case 0x1000 + 7: return "LVM_INSERTITEMA";
4995 case 0x1000 + 77: return "LVM_INSERTITEMW";
4996 case 0x1000 + 8: return "LVM_DELETEITEM";
4997 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
4998 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
4999 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5000 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5001 case 0x1000 + 13: return "LVM_FINDITEMA";
5002 case 0x1000 + 83: return "LVM_FINDITEMW";
5003 case 0x1000 + 14: return "LVM_GETITEMRECT";
5004 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5005 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5006 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5007 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5008 case 0x1000 + 18: return "LVM_HITTEST";
5009 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5010 case 0x1000 + 20: return "LVM_SCROLL";
5011 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5012 case 0x1000 + 22: return "LVM_ARRANGE";
5013 case 0x1000 + 23: return "LVM_EDITLABELA";
5014 case 0x1000 + 118: return "LVM_EDITLABELW";
5015 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5016 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5017 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5018 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5019 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5020 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5021 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5022 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5023 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5024 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5025 case 0x1000 + 31: return "LVM_GETHEADER";
5026 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5027 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5028 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5029 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5030 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5031 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5032 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5033 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5034 case 0x1000 + 41: return "LVM_GETORIGIN";
5035 case 0x1000 + 42: return "LVM_UPDATE";
5036 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5037 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5038 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5039 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5040 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5041 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5042 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5043 case 0x1000 + 48: return "LVM_SORTITEMS";
5044 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5045 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5046 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5047 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5048 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5049 case 0x1000 + 53: return "LVM_SETICONSPACING";
5050 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5051 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5052 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5053 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5054 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5055 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5056 case 0x1000 + 60: return "LVM_SETHOTITEM";
5057 case 0x1000 + 61: return "LVM_GETHOTITEM";
5058 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5059 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5060 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5061 case 0x1000 + 65: return "LVM_SETWORKAREA";
5062
5063 // tree view
5064 case 0x1100 + 0: return "TVM_INSERTITEMA";
5065 case 0x1100 + 50: return "TVM_INSERTITEMW";
5066 case 0x1100 + 1: return "TVM_DELETEITEM";
5067 case 0x1100 + 2: return "TVM_EXPAND";
5068 case 0x1100 + 4: return "TVM_GETITEMRECT";
5069 case 0x1100 + 5: return "TVM_GETCOUNT";
5070 case 0x1100 + 6: return "TVM_GETINDENT";
5071 case 0x1100 + 7: return "TVM_SETINDENT";
5072 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5073 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5074 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5075 case 0x1100 + 11: return "TVM_SELECTITEM";
5076 case 0x1100 + 12: return "TVM_GETITEMA";
5077 case 0x1100 + 62: return "TVM_GETITEMW";
5078 case 0x1100 + 13: return "TVM_SETITEMA";
5079 case 0x1100 + 63: return "TVM_SETITEMW";
5080 case 0x1100 + 14: return "TVM_EDITLABELA";
5081 case 0x1100 + 65: return "TVM_EDITLABELW";
5082 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5083 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5084 case 0x1100 + 17: return "TVM_HITTEST";
5085 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5086 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5087 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5088 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5089 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5090 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5091 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5092 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5093 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5094
5095 // header
5096 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5097 case 0x1200 + 1: return "HDM_INSERTITEMA";
5098 case 0x1200 + 10: return "HDM_INSERTITEMW";
5099 case 0x1200 + 2: return "HDM_DELETEITEM";
5100 case 0x1200 + 3: return "HDM_GETITEMA";
5101 case 0x1200 + 11: return "HDM_GETITEMW";
5102 case 0x1200 + 4: return "HDM_SETITEMA";
5103 case 0x1200 + 12: return "HDM_SETITEMW";
5104 case 0x1200 + 5: return "HDM_LAYOUT";
5105 case 0x1200 + 6: return "HDM_HITTEST";
5106 case 0x1200 + 7: return "HDM_GETITEMRECT";
5107 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5108 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5109 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5110 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5111 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5112 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5113 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5114
5115 // tab control
5116 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5117 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5118 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5119 case 0x1300 + 5: return "TCM_GETITEMA";
5120 case 0x1300 + 60: return "TCM_GETITEMW";
5121 case 0x1300 + 6: return "TCM_SETITEMA";
5122 case 0x1300 + 61: return "TCM_SETITEMW";
5123 case 0x1300 + 7: return "TCM_INSERTITEMA";
5124 case 0x1300 + 62: return "TCM_INSERTITEMW";
5125 case 0x1300 + 8: return "TCM_DELETEITEM";
5126 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5127 case 0x1300 + 10: return "TCM_GETITEMRECT";
5128 case 0x1300 + 11: return "TCM_GETCURSEL";
5129 case 0x1300 + 12: return "TCM_SETCURSEL";
5130 case 0x1300 + 13: return "TCM_HITTEST";
5131 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5132 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5133 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5134 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5135 case 0x1300 + 43: return "TCM_SETPADDING";
5136 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5137 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5138 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5139 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5140 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5141 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5142 case 0x1300 + 50: return "TCM_DESELECTALL";
5143
5144 // toolbar
5145 case WM_USER+1: return "TB_ENABLEBUTTON";
5146 case WM_USER+2: return "TB_CHECKBUTTON";
5147 case WM_USER+3: return "TB_PRESSBUTTON";
5148 case WM_USER+4: return "TB_HIDEBUTTON";
5149 case WM_USER+5: return "TB_INDETERMINATE";
5150 case WM_USER+9: return "TB_ISBUTTONENABLED";
5151 case WM_USER+10: return "TB_ISBUTTONCHECKED";
5152 case WM_USER+11: return "TB_ISBUTTONPRESSED";
5153 case WM_USER+12: return "TB_ISBUTTONHIDDEN";
5154 case WM_USER+13: return "TB_ISBUTTONINDETERMINATE";
5155 case WM_USER+17: return "TB_SETSTATE";
5156 case WM_USER+18: return "TB_GETSTATE";
5157 case WM_USER+19: return "TB_ADDBITMAP";
5158 case WM_USER+20: return "TB_ADDBUTTONS";
5159 case WM_USER+21: return "TB_INSERTBUTTON";
5160 case WM_USER+22: return "TB_DELETEBUTTON";
5161 case WM_USER+23: return "TB_GETBUTTON";
5162 case WM_USER+24: return "TB_BUTTONCOUNT";
5163 case WM_USER+25: return "TB_COMMANDTOINDEX";
5164 case WM_USER+26: return "TB_SAVERESTOREA";
5165 case WM_USER+76: return "TB_SAVERESTOREW";
5166 case WM_USER+27: return "TB_CUSTOMIZE";
5167 case WM_USER+28: return "TB_ADDSTRINGA";
5168 case WM_USER+77: return "TB_ADDSTRINGW";
5169 case WM_USER+29: return "TB_GETITEMRECT";
5170 case WM_USER+30: return "TB_BUTTONSTRUCTSIZE";
5171 case WM_USER+31: return "TB_SETBUTTONSIZE";
5172 case WM_USER+32: return "TB_SETBITMAPSIZE";
5173 case WM_USER+33: return "TB_AUTOSIZE";
5174 case WM_USER+35: return "TB_GETTOOLTIPS";
5175 case WM_USER+36: return "TB_SETTOOLTIPS";
5176 case WM_USER+37: return "TB_SETPARENT";
5177 case WM_USER+39: return "TB_SETROWS";
5178 case WM_USER+40: return "TB_GETROWS";
5179 case WM_USER+42: return "TB_SETCMDID";
5180 case WM_USER+43: return "TB_CHANGEBITMAP";
5181 case WM_USER+44: return "TB_GETBITMAP";
5182 case WM_USER+45: return "TB_GETBUTTONTEXTA";
5183 case WM_USER+75: return "TB_GETBUTTONTEXTW";
5184 case WM_USER+46: return "TB_REPLACEBITMAP";
5185 case WM_USER+47: return "TB_SETINDENT";
5186 case WM_USER+48: return "TB_SETIMAGELIST";
5187 case WM_USER+49: return "TB_GETIMAGELIST";
5188 case WM_USER+50: return "TB_LOADIMAGES";
5189 case WM_USER+51: return "TB_GETRECT";
5190 case WM_USER+52: return "TB_SETHOTIMAGELIST";
5191 case WM_USER+53: return "TB_GETHOTIMAGELIST";
5192 case WM_USER+54: return "TB_SETDISABLEDIMAGELIST";
5193 case WM_USER+55: return "TB_GETDISABLEDIMAGELIST";
5194 case WM_USER+56: return "TB_SETSTYLE";
5195 case WM_USER+57: return "TB_GETSTYLE";
5196 case WM_USER+58: return "TB_GETBUTTONSIZE";
5197 case WM_USER+59: return "TB_SETBUTTONWIDTH";
5198 case WM_USER+60: return "TB_SETMAXTEXTROWS";
5199 case WM_USER+61: return "TB_GETTEXTROWS";
5200 case WM_USER+41: return "TB_GETBITMAPFLAGS";
5201
5202 #endif //WIN32
5203
5204 default:
5205 static char s_szBuf[128];
5206 sprintf(s_szBuf, "<unknown message = %d>", message);
5207 return s_szBuf;
5208 }
5209 }
5210 #endif //__WXDEBUG__
5211
5212 static void TranslateKbdEventToMouse(wxWindowMSW *win,
5213 int *x, int *y, WPARAM *flags)
5214 {
5215 // construct the key mask
5216 WPARAM& fwKeys = *flags;
5217
5218 fwKeys = MK_RBUTTON;
5219 if ( wxIsCtrlDown() )
5220 fwKeys |= MK_CONTROL;
5221 if ( wxIsShiftDown() )
5222 fwKeys |= MK_SHIFT;
5223
5224 // simulate right mouse button click
5225 DWORD dwPos = ::GetMessagePos();
5226 *x = GET_X_LPARAM(dwPos);
5227 *y = GET_Y_LPARAM(dwPos);
5228
5229 win->ScreenToClient(x, y);
5230 }
5231
5232 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
5233 {
5234 // prepare the DC
5235 TEXTMETRIC tm;
5236 HWND hwnd = GetHwndOf(win);
5237 HDC hdc = ::GetDC(hwnd);
5238
5239 #if !wxDIALOG_UNIT_COMPATIBILITY
5240 // and select the current font into it
5241 HFONT hfont = GetHfontOf(win->GetFont());
5242 if ( hfont )
5243 {
5244 hfont = (HFONT)::SelectObject(hdc, hfont);
5245 }
5246 #endif
5247
5248 // finally retrieve the text metrics from it
5249 GetTextMetrics(hdc, &tm);
5250
5251 #if !wxDIALOG_UNIT_COMPATIBILITY
5252 // and clean up
5253 if ( hfont )
5254 {
5255 (void)::SelectObject(hdc, hfont);
5256 }
5257 #endif
5258
5259 ::ReleaseDC(hwnd, hdc);
5260
5261 return tm;
5262 }
5263
5264 // Find the wxWindow at the current mouse position, returning the mouse
5265 // position.
5266 wxWindow* wxFindWindowAtPointer(wxPoint& WXUNUSED(pt))
5267 {
5268 return wxFindWindowAtPoint(wxGetMousePosition());
5269 }
5270
5271 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
5272 {
5273 POINT pt2;
5274 pt2.x = pt.x;
5275 pt2.y = pt.y;
5276 HWND hWndHit = ::WindowFromPoint(pt2);
5277
5278 wxWindow* win = wxFindWinFromHandle((WXHWND) hWndHit) ;
5279 HWND hWnd = hWndHit;
5280
5281 // Try to find a window with a wxWindow associated with it
5282 while (!win && (hWnd != 0))
5283 {
5284 hWnd = ::GetParent(hWnd);
5285 win = wxFindWinFromHandle((WXHWND) hWnd) ;
5286 }
5287 return win;
5288 }
5289
5290 // Get the current mouse position.
5291 wxPoint wxGetMousePosition()
5292 {
5293 POINT pt;
5294 GetCursorPos( & pt );
5295
5296 return wxPoint(pt.x, pt.y);
5297 }
5298
wxWidgets (Impactor)