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