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