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