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