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