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