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