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