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