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