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