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