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