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


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