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