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