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