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