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