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