]> git.saurik.com Git - wxWidgets.git/blame - src/msw/window.cpp
CVS cleanups.
[wxWidgets.git] / src / msw / window.cpp
CommitLineData
2bda0e17
KB
1/////////////////////////////////////////////////////////////////////////////
2// Name: windows.cpp
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"
34 #include "wx/accel.h"
3a19e16d
VZ
35 #include "wx/setup.h"
36 #include "wx/menu.h"
37 #include "wx/dc.h"
38 #include "wx/dcclient.h"
39 #include "wx/utils.h"
40 #include "wx/app.h"
41 #include "wx/panel.h"
42 #include "wx/layout.h"
43 #include "wx/dialog.h"
44 #include "wx/frame.h"
45 #include "wx/listbox.h"
46 #include "wx/button.h"
3a19e16d 47 #include "wx/msgdlg.h"
341c92a8
VZ
48
49 #include <stdio.h>
2bda0e17
KB
50#endif
51
47d67540 52#if wxUSE_OWNER_DRAWN
09914df7 53 #include "wx/ownerdrw.h"
2bda0e17
KB
54#endif
55
47d67540 56#if wxUSE_DRAG_AND_DROP
3f480da3 57 #include "wx/dataobj.h"
09914df7 58 #include "wx/msw/ole/droptgt.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
dbda9e86
JS
74#include "wx/intl.h"
75#include "wx/log.h"
3a19e16d 76
2bda0e17 77
2a47d3c1
JS
78#include "wx/textctrl.h"
79
2bda0e17
KB
80#include <string.h>
81
82#ifndef __GNUWIN32__
3a19e16d
VZ
83 #include <shellapi.h>
84 #include <mmsystem.h>
2bda0e17
KB
85#endif
86
87#ifdef __WIN32__
3a19e16d 88 #include <windowsx.h>
2bda0e17
KB
89#endif
90
cc2b7472 91#if ( defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__ )
42e69d6b 92 #include <commctrl.h>
acbd13a3 93#endif
3a19e16d 94
57c208c5 95#ifndef __TWIN32__
3a19e16d
VZ
96 #ifdef __GNUWIN32__
97 #include <wx/msw/gnuwin32/extra.h>
98 #endif
57c208c5 99#endif
2bda0e17 100
a23fd0e1
VZ
101// ---------------------------------------------------------------------------
102// macros
103// ---------------------------------------------------------------------------
104
105// standard macros missing from some compilers headers
106#ifndef GET_X_LPARAM
c6eba8f8
VZ
107 #define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
108 #define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
a23fd0e1
VZ
109#endif // GET_X_LPARAM
110
111// ---------------------------------------------------------------------------
42e69d6b 112// global variables
a23fd0e1 113// ---------------------------------------------------------------------------
47cbd6da 114
42e69d6b
VZ
115// the last Windows message we got (MT-UNSAFE)
116extern MSG s_currentMsg;
2bda0e17
KB
117
118wxMenu *wxCurrentPopupMenu = NULL;
cde9f08e 119extern wxList WXDLLEXPORT wxPendingDelete;
42e69d6b
VZ
120extern char wxCanvasClassName[];
121
c6eba8f8
VZ
122#ifdef __WXDEBUG__
123 // see comments in dcclient.cpp where g_isPainting is defined
124 extern bool g_isPainting;
125
126 inline static void wxStartPainting() { g_isPainting = TRUE; }
127 inline static void wxEndPainting() { g_isPainting = FALSE; }
128#else // !debug
129 inline static void wxStartPainting() { }
130 inline static void wxEndPainting() { }
131#endif // debug/!debug
132
42e69d6b
VZ
133// ---------------------------------------------------------------------------
134// private functions
135// ---------------------------------------------------------------------------
136
137// the window proc for all our windows
138LRESULT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
139 WPARAM wParam, LPARAM lParam);
140
141#ifdef __WXDEBUG__
142 const char *wxGetMessageName(int message);
143#endif //__WXDEBUG__
2bda0e17
KB
144
145void wxRemoveHandleAssociation(wxWindow *win);
146void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
147wxWindow *wxFindWinFromHandle(WXHWND hWnd);
148
a23fd0e1
VZ
149// ---------------------------------------------------------------------------
150// event tables
151// ---------------------------------------------------------------------------
152
42e69d6b
VZ
153#if !USE_SHARED_LIBRARY
154 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
155#endif
156
cc2b7472 157BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
cf65ad8d
VZ
158 EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
159 EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
160 EVT_INIT_DIALOG(wxWindow::OnInitDialog)
161 EVT_IDLE(wxWindow::OnIdle)
2bda0e17
KB
162END_EVENT_TABLE()
163
a23fd0e1
VZ
164// ===========================================================================
165// implementation
166// ===========================================================================
167
42e69d6b
VZ
168// ---------------------------------------------------------------------------
169// wxWindow utility functions
170// ---------------------------------------------------------------------------
171
2bda0e17 172// Find an item given the MS Windows id
debe6624 173wxWindow *wxWindow::FindItem(int id) const
2bda0e17 174{
42e69d6b 175 wxWindowList::Node *current = GetChildren().GetFirst();
2d0a075d
JS
176 while (current)
177 {
42e69d6b 178 wxWindow *childWin = current->GetData();
2bda0e17 179
42e69d6b 180 wxWindow *wnd = childWin->FindItem(id);
cc2b7472 181 if ( wnd )
42e69d6b 182 return wnd;
2bda0e17 183
cc2b7472 184 if ( childWin->IsKindOf(CLASSINFO(wxControl)) )
2d0a075d
JS
185 {
186 wxControl *item = (wxControl *)childWin;
cc2b7472 187 if ( item->GetId() == id )
2d0a075d
JS
188 return item;
189 else
190 {
191 // In case it's a 'virtual' control (e.g. radiobox)
cc2b7472 192 if ( item->GetSubcontrols().Member((wxObject *)id) )
2d0a075d
JS
193 return item;
194 }
195 }
42e69d6b
VZ
196
197 current = current->GetNext();
2bda0e17 198 }
42e69d6b 199
2d0a075d 200 return NULL;
2bda0e17
KB
201}
202
203// Find an item given the MS Windows handle
debe6624 204wxWindow *wxWindow::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
2bda0e17 205{
42e69d6b 206 wxWindowList::Node *current = GetChildren().GetFirst();
2d0a075d 207 while (current)
2bda0e17 208 {
42e69d6b
VZ
209 wxWindow *parent = current->GetData();
210
2d0a075d 211 // Do a recursive search.
42e69d6b 212 wxWindow *wnd = parent->FindItemByHWND(hWnd);
cc2b7472 213 if ( wnd )
42e69d6b 214 return wnd;
2d0a075d 215
42e69d6b 216 if ( !controlOnly || parent->IsKindOf(CLASSINFO(wxControl)) )
2d0a075d 217 {
42e69d6b
VZ
218 wxWindow *item = current->GetData();
219 if ( item->GetHWND() == hWnd )
2d0a075d
JS
220 return item;
221 else
222 {
223 if ( item->ContainsHWND(hWnd) )
224 return item;
225 }
226 }
42e69d6b
VZ
227
228 current = current->GetNext();
2bda0e17 229 }
2d0a075d 230 return NULL;
2bda0e17
KB
231}
232
233// Default command handler
debe6624 234bool wxWindow::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
2bda0e17 235{
2d0a075d 236 return FALSE;
2bda0e17
KB
237}
238
fd3f686c
VZ
239// ----------------------------------------------------------------------------
240// constructors and such
241// ----------------------------------------------------------------------------
242
243void wxWindow::Init()
2bda0e17 244{
cc2b7472
VZ
245 // generic
246 InitBase();
634903fd 247
cc2b7472 248 // MSW specific
42e69d6b 249 m_doubleClickAllowed = 0;
2d0a075d 250 m_winCaptured = FALSE;
cc2b7472 251
2d0a075d
JS
252 m_isBeingDeleted = FALSE;
253 m_oldWndProc = 0;
2d0a075d 254 m_useCtl3D = FALSE;
fd3f686c 255 m_mouseInWindow = FALSE;
2bda0e17 256
2d0a075d 257 // wxWnd
2d0a075d 258 m_hMenu = 0;
2bda0e17 259
2d0a075d
JS
260 m_xThumbSize = 0;
261 m_yThumbSize = 0;
262 m_backgroundTransparent = FALSE;
2bda0e17 263
85d10d9b
VZ
264 // as all windows are created with WS_VISIBLE style...
265 m_isShown = TRUE;
266
a23fd0e1 267#if wxUSE_MOUSEEVENT_HACK
cc2b7472
VZ
268 m_lastMouseX =
269 m_lastMouseY = -1;
270 m_lastMouseEvent = -1;
a23fd0e1 271#endif // wxUSE_MOUSEEVENT_HACK
fd3f686c
VZ
272}
273
2bda0e17 274// Destructor
fd3f686c 275wxWindow::~wxWindow()
2bda0e17 276{
2d0a075d 277 m_isBeingDeleted = TRUE;
2bda0e17 278
2d0a075d 279 MSWDetachWindowMenu();
2bda0e17 280
a23fd0e1
VZ
281 if ( m_parent )
282 m_parent->RemoveChild(this);
283
284 DestroyChildren();
285
cc2b7472 286 if ( m_hWnd )
42e69d6b
VZ
287 {
288 if ( !::DestroyWindow(GetHwnd()) )
289 wxLogLastError("DestroyWindow");
290 }
2bda0e17 291
cc2b7472
VZ
292 // Restore old Window proc, if required and remove hWnd <-> wxWindow
293 // association
2d0a075d 294 UnsubclassWin();
2bda0e17
KB
295}
296
fd3f686c 297// real construction (Init() must have been called before!)
debe6624 298bool wxWindow::Create(wxWindow *parent, wxWindowID id,
2d0a075d
JS
299 const wxPoint& pos,
300 const wxSize& size,
301 long style,
302 const wxString& name)
303{
fd3f686c 304 wxCHECK_MSG( parent, FALSE, "can't create wxWindow without parent" );
2bda0e17 305
42e69d6b
VZ
306 CreateBase(parent, id, pos, size, style, name);
307
fd3f686c 308 parent->AddChild(this);
2bda0e17 309
2d0a075d 310 DWORD msflags = 0;
cc2b7472 311 if ( style & wxBORDER )
2d0a075d 312 msflags |= WS_BORDER;
cc2b7472 313 if ( style & wxTHICK_FRAME )
2d0a075d 314 msflags |= WS_THICKFRAME;
1c089c47 315
2d0a075d 316 msflags |= WS_CHILD | WS_VISIBLE;
cc2b7472 317 if ( style & wxCLIP_CHILDREN )
2d0a075d 318 msflags |= WS_CLIPCHILDREN;
2bda0e17 319
2d0a075d 320 bool want3D;
42e69d6b 321 WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D);
2bda0e17 322
2d0a075d
JS
323 // Even with extended styles, need to combine with WS_BORDER
324 // for them to look right.
cc2b7472 325 if ( want3D || (m_windowStyle & wxSIMPLE_BORDER) || (m_windowStyle & wxRAISED_BORDER ) ||
2d0a075d 326 (m_windowStyle & wxSUNKEN_BORDER) || (m_windowStyle & wxDOUBLE_BORDER))
cc2b7472 327 {
2d0a075d 328 msflags |= WS_BORDER;
cc2b7472 329 }
2bda0e17 330
2d0a075d 331 MSWCreate(m_windowId, parent, wxCanvasClassName, this, NULL,
cc2b7472
VZ
332 pos.x, pos.y,
333 WidthDefault(size.x), HeightDefault(size.y),
334 msflags, NULL, exStyle);
2bda0e17 335
2d0a075d 336 return TRUE;
2bda0e17
KB
337}
338
42e69d6b
VZ
339// ---------------------------------------------------------------------------
340// basic operations
341// ---------------------------------------------------------------------------
342
fd3f686c 343void wxWindow::SetFocus()
2bda0e17 344{
a23fd0e1 345 HWND hWnd = GetHwnd();
cc2b7472 346 if ( hWnd )
2d0a075d 347 ::SetFocus(hWnd);
2bda0e17
KB
348}
349
42e69d6b
VZ
350// Get the window with the focus
351wxWindow *wxWindowBase::FindFocus()
352{
353 HWND hWnd = ::GetFocus();
354 if ( hWnd )
355 {
356 return wxFindWinFromHandle((WXHWND) hWnd);
357 }
358
359 return NULL;
360}
361
cc2b7472 362bool wxWindow::Enable(bool enable)
2bda0e17 363{
cc2b7472
VZ
364 if ( !wxWindowBase::Enable(enable) )
365 return FALSE;
366
a23fd0e1 367 HWND hWnd = GetHwnd();
cc2b7472 368 if ( hWnd )
2d0a075d 369 ::EnableWindow(hWnd, (BOOL)enable);
cc2b7472
VZ
370
371 return TRUE;
2bda0e17
KB
372}
373
42e69d6b
VZ
374bool wxWindow::Show(bool show)
375{
376 if ( !wxWindowBase::Show(show) )
377 return FALSE;
378
379 HWND hWnd = GetHwnd();
380 int cshow = show ? SW_SHOW : SW_HIDE;
381 ::ShowWindow(hWnd, cshow);
382
383 if ( show )
384 {
385 BringWindowToTop(hWnd);
386 }
387
388 return TRUE;
389}
390
391// Raise the window to the top of the Z order
392void wxWindow::Raise()
393{
394 ::BringWindowToTop(GetHwnd());
395}
396
397// Lower the window to the bottom of the Z order
398void wxWindow::Lower()
399{
400 ::SetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0,
401 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
402}
403
404void wxWindow::SetTitle( const wxString& title)
405{
406 SetWindowText(GetHwnd(), title.c_str());
407}
408
409wxString wxWindow::GetTitle() const
410{
411 return wxGetWindowText(GetHWND());
412}
413
fd3f686c 414void wxWindow::CaptureMouse()
2bda0e17 415{
a23fd0e1 416 HWND hWnd = GetHwnd();
cc2b7472 417 if ( hWnd && !m_winCaptured )
2d0a075d
JS
418 {
419 SetCapture(hWnd);
420 m_winCaptured = TRUE;
421 }
2bda0e17
KB
422}
423
fd3f686c 424void wxWindow::ReleaseMouse()
2bda0e17 425{
cc2b7472 426 if ( m_winCaptured )
2d0a075d
JS
427 {
428 ReleaseCapture();
429 m_winCaptured = FALSE;
430 }
2bda0e17
KB
431}
432
42e69d6b 433bool wxWindow::SetFont(const wxFont& font)
2bda0e17 434{
42e69d6b
VZ
435 if ( !wxWindowBase::SetFont(font) )
436 {
437 // nothing to do
438 return FALSE;
2d0a075d 439 }
195896c7 440
42e69d6b
VZ
441 HWND hWnd = GetHwnd();
442 if ( hWnd != 0 )
443 {
444 WXHANDLE hFont = m_font.GetResourceHandle();
2bda0e17 445
42e69d6b 446 wxASSERT_MSG( hFont, _T("should have valid font") );
3a19e16d 447
42e69d6b
VZ
448 ::SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, TRUE);
449 }
2bda0e17 450
42e69d6b
VZ
451 return TRUE;
452}
453bool wxWindow::SetCursor(const wxCursor& cursor)
2bda0e17 454{
42e69d6b
VZ
455 if ( !wxWindowBase::SetCursor(cursor) )
456 {
457 // no change
458 return FALSE;
459 }
460
461 wxASSERT_MSG( m_cursor.Ok(),
462 _T("cursor must be valid after call to the base version"));
463
a23fd0e1 464 HWND hWnd = GetHwnd();
2bda0e17 465
42e69d6b
VZ
466 // Change the cursor NOW if we're within the correct window
467 POINT point;
468 ::GetCursorPos(&point);
3a19e16d 469
42e69d6b
VZ
470 RECT rect;
471 ::GetWindowRect(hWnd, &rect);
cb1a1dc9 472
42e69d6b
VZ
473 if ( ::PtInRect(&rect, point) && !wxIsBusy() )
474 ::SetCursor((HCURSOR)m_cursor.GetHCURSOR());
3a19e16d 475
42e69d6b 476 return TRUE;
3a19e16d
VZ
477}
478
42e69d6b 479void wxWindow::WarpPointer (int x_pos, int y_pos)
2bda0e17 480{
42e69d6b
VZ
481 // Move the pointer to (x_pos,y_pos) coordinates. They are expressed in
482 // pixel coordinates, relatives to the canvas -- So, we first need to
483 // substract origin of the window, then convert to screen position
484
485 int x = x_pos; int y = y_pos;
2d0a075d 486 RECT rect;
42e69d6b 487 GetWindowRect (GetHwnd(), &rect);
cc2b7472 488
42e69d6b
VZ
489 x += rect.left;
490 y += rect.top;
491
492 SetCursorPos (x, y);
2bda0e17
KB
493}
494
42e69d6b
VZ
495#if WXWIN_COMPATIBILITY
496void wxWindow::MSWDeviceToLogical (float *x, float *y) const
2bda0e17 497{
42e69d6b
VZ
498}
499#endif // WXWIN_COMPATIBILITY
81d66cf3 500
42e69d6b
VZ
501// ---------------------------------------------------------------------------
502// scrolling stuff
503// ---------------------------------------------------------------------------
2d0a075d 504
42e69d6b
VZ
505#if WXWIN_COMPATIBILITY
506void wxWindow::SetScrollRange(int orient, int range, bool refresh)
507{
508#if defined(__WIN95__)
509
510 int range1 = range;
511
512 // Try to adjust the range to cope with page size > 1
513 // - a Windows API quirk
514 int pageSize = GetScrollPage(orient);
515 if ( pageSize > 1 && range > 0)
2d0a075d 516 {
42e69d6b 517 range1 += (pageSize - 1);
2d0a075d
JS
518 }
519
42e69d6b
VZ
520 SCROLLINFO info;
521 int dir;
522
523 if ( orient == wxHORIZONTAL ) {
524 dir = SB_HORZ;
525 } else {
526 dir = SB_VERT;
2d0a075d 527 }
cc2b7472 528
42e69d6b
VZ
529 info.cbSize = sizeof(SCROLLINFO);
530 info.nPage = pageSize; // Have to set this, or scrollbar goes awry
531 info.nMin = 0;
532 info.nMax = range1;
533 info.nPos = 0;
534 info.fMask = SIF_RANGE | SIF_PAGE;
535
536 HWND hWnd = GetHwnd();
537 if ( hWnd )
538 ::SetScrollInfo(hWnd, dir, &info, refresh);
539#else
540 int wOrient;
541 if ( orient == wxHORIZONTAL )
542 wOrient = SB_HORZ;
543 else
544 wOrient = SB_VERT;
545
546 HWND hWnd = GetHwnd();
547 if ( hWnd )
548 ::SetScrollRange(hWnd, wOrient, 0, range, refresh);
549#endif
2bda0e17
KB
550}
551
42e69d6b 552void wxWindow::SetScrollPage(int orient, int page, bool refresh)
2bda0e17 553{
42e69d6b
VZ
554#if defined(__WIN95__)
555 SCROLLINFO info;
556 int dir;
2d0a075d 557
42e69d6b
VZ
558 if ( orient == wxHORIZONTAL ) {
559 dir = SB_HORZ;
560 m_xThumbSize = page;
561 } else {
562 dir = SB_VERT;
563 m_yThumbSize = page;
564 }
0757d27c 565
42e69d6b
VZ
566 info.cbSize = sizeof(SCROLLINFO);
567 info.nPage = page;
568 info.nMin = 0;
569 info.fMask = SIF_PAGE;
570
571 HWND hWnd = GetHwnd();
572 if ( hWnd )
573 ::SetScrollInfo(hWnd, dir, &info, refresh);
574#else
575 if ( orient == wxHORIZONTAL )
576 m_xThumbSize = page;
577 else
578 m_yThumbSize = page;
579#endif
2bda0e17
KB
580}
581
42e69d6b 582int wxWindow::OldGetScrollRange(int orient) const
2bda0e17 583{
42e69d6b
VZ
584 int wOrient;
585 if ( orient == wxHORIZONTAL )
586 wOrient = SB_HORZ;
587 else
588 wOrient = SB_VERT;
2d0a075d 589
42e69d6b
VZ
590#if __WATCOMC__ && defined(__WINDOWS_386__)
591 short minPos, maxPos;
592#else
593 int minPos, maxPos;
594#endif
a23fd0e1 595 HWND hWnd = GetHwnd();
42e69d6b
VZ
596 if ( hWnd )
597 {
598 ::GetScrollRange(hWnd, wOrient, &minPos, &maxPos);
599#if defined(__WIN95__)
600 // Try to adjust the range to cope with page size > 1
601 // - a Windows API quirk
602 int pageSize = GetScrollPage(orient);
603 if ( pageSize > 1 )
604 {
605 maxPos -= (pageSize - 1);
606 }
607#endif
608 return maxPos;
609 }
610 else
611 return 0;
612}
2bda0e17 613
42e69d6b
VZ
614int wxWindow::GetScrollPage(int orient) const
615{
616 if ( orient == wxHORIZONTAL )
617 return m_xThumbSize;
618 else
619 return m_yThumbSize;
2bda0e17
KB
620}
621
42e69d6b
VZ
622#endif // WXWIN_COMPATIBILITY
623
624int wxWindow::GetScrollPos(int orient) const
2bda0e17 625{
42e69d6b
VZ
626 int wOrient;
627 if ( orient == wxHORIZONTAL )
628 wOrient = SB_HORZ;
629 else
630 wOrient = SB_VERT;
631 HWND hWnd = GetHwnd();
632 if ( hWnd )
2d0a075d 633 {
42e69d6b 634 return ::GetScrollPos(hWnd, wOrient);
cc2b7472 635 }
42e69d6b
VZ
636 else
637 return 0;
638}
2bda0e17 639
42e69d6b
VZ
640// This now returns the whole range, not just the number
641// of positions that we can scroll.
642int wxWindow::GetScrollRange(int orient) const
643{
644 int wOrient;
645 if ( orient == wxHORIZONTAL )
646 wOrient = SB_HORZ;
647 else
648 wOrient = SB_VERT;
2bda0e17 649
42e69d6b
VZ
650#if __WATCOMC__ && defined(__WINDOWS_386__)
651 short minPos, maxPos;
652#else
653 int minPos, maxPos;
654#endif
a23fd0e1 655 HWND hWnd = GetHwnd();
42e69d6b
VZ
656 if ( hWnd )
657 {
658 ::GetScrollRange(hWnd, wOrient, &minPos, &maxPos);
659#if defined(__WIN95__)
660 // Try to adjust the range to cope with page size > 1
661 // - a Windows API quirk
662 int pageSize = GetScrollThumb(orient);
663 if ( pageSize > 1 )
664 {
665 maxPos -= (pageSize - 1);
666 }
667 // October 10th: new range concept.
668 maxPos += pageSize;
669#endif
2bda0e17 670
42e69d6b
VZ
671 return maxPos;
672 }
673 else
674 return 0;
cc2b7472 675}
2bda0e17 676
42e69d6b 677int wxWindow::GetScrollThumb(int orient) const
2bda0e17 678{
42e69d6b
VZ
679 if ( orient == wxHORIZONTAL )
680 return m_xThumbSize;
681 else
682 return m_yThumbSize;
2bda0e17
KB
683}
684
42e69d6b 685void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
2bda0e17 686{
42e69d6b
VZ
687#if defined(__WIN95__)
688 SCROLLINFO info;
689 int dir;
72fd19a1 690
42e69d6b
VZ
691 if ( orient == wxHORIZONTAL ) {
692 dir = SB_HORZ;
693 } else {
694 dir = SB_VERT;
695 }
2d0a075d 696
42e69d6b
VZ
697 info.cbSize = sizeof(SCROLLINFO);
698 info.nPage = 0;
699 info.nMin = 0;
700 info.nPos = pos;
701 info.fMask = SIF_POS;
2d0a075d 702
42e69d6b
VZ
703 HWND hWnd = GetHwnd();
704 if ( hWnd )
705 ::SetScrollInfo(hWnd, dir, &info, refresh);
706#else
707 int wOrient;
708 if ( orient == wxHORIZONTAL )
709 wOrient = SB_HORZ;
710 else
711 wOrient = SB_VERT;
81d66cf3 712
a23fd0e1 713 HWND hWnd = GetHwnd();
cc2b7472 714 if ( hWnd )
42e69d6b
VZ
715 ::SetScrollPos(hWnd, wOrient, pos, refresh);
716#endif
2bda0e17
KB
717}
718
42e69d6b
VZ
719// New function that will replace some of the above.
720void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
721 int range, bool refresh)
2bda0e17 722{
42e69d6b
VZ
723#if defined(__WIN95__)
724 int oldRange = range - thumbVisible;
2bda0e17 725
42e69d6b 726 int range1 = oldRange;
2bda0e17 727
42e69d6b
VZ
728 // Try to adjust the range to cope with page size > 1
729 // - a Windows API quirk
730 int pageSize = thumbVisible;
731 if ( pageSize > 1 && range > 0)
732 {
733 range1 += (pageSize - 1);
734 }
2bda0e17 735
42e69d6b
VZ
736 SCROLLINFO info;
737 int dir;
2bda0e17 738
42e69d6b
VZ
739 if ( orient == wxHORIZONTAL ) {
740 dir = SB_HORZ;
741 } else {
742 dir = SB_VERT;
2d0a075d 743 }
2bda0e17 744
42e69d6b
VZ
745 info.cbSize = sizeof(SCROLLINFO);
746 info.nPage = pageSize; // Have to set this, or scrollbar goes awry
747 info.nMin = 0;
748 info.nMax = range1;
749 info.nPos = pos;
750 info.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
2bda0e17 751
42e69d6b
VZ
752 HWND hWnd = GetHwnd();
753 if ( hWnd )
754 ::SetScrollInfo(hWnd, dir, &info, refresh);
755#else
756 int wOrient;
757 if ( orient == wxHORIZONTAL )
758 wOrient = SB_HORZ;
759 else
760 wOrient = SB_VERT;
81d66cf3 761
42e69d6b
VZ
762 HWND hWnd = GetHwnd();
763 if ( hWnd )
81d66cf3 764 {
42e69d6b
VZ
765 ::SetScrollRange(hWnd, wOrient, 0, range, FALSE);
766 ::SetScrollPos(hWnd, wOrient, pos, refresh);
767 }
768#endif
769 if ( orient == wxHORIZONTAL ) {
770 m_xThumbSize = thumbVisible;
771 } else {
772 m_yThumbSize = thumbVisible;
81d66cf3
JS
773 }
774}
775
42e69d6b 776void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
2bda0e17 777{
42e69d6b
VZ
778 RECT rect2;
779 if ( rect )
2d0a075d 780 {
42e69d6b
VZ
781 rect2.left = rect->x;
782 rect2.top = rect->y;
783 rect2.right = rect->x + rect->width;
784 rect2.bottom = rect->y + rect->height;
2d0a075d 785 }
2bda0e17 786
42e69d6b
VZ
787 if ( rect )
788 ::ScrollWindow(GetHwnd(), dx, dy, &rect2, NULL);
789 else
790 ::ScrollWindow(GetHwnd(), dx, dy, NULL, NULL);
2bda0e17
KB
791}
792
42e69d6b
VZ
793// ---------------------------------------------------------------------------
794// subclassing
795// ---------------------------------------------------------------------------
796
797void wxWindow::SubclassWin(WXHWND hWnd)
2bda0e17 798{
42e69d6b 799 wxASSERT_MSG( !m_oldWndProc, "subclassing window twice?" );
2bda0e17 800
42e69d6b 801 wxAssociateWinWithHandle((HWND)hWnd, this);
2bda0e17 802
42e69d6b
VZ
803 m_oldWndProc = (WXFARPROC) GetWindowLong((HWND) hWnd, GWL_WNDPROC);
804 SetWindowLong((HWND) hWnd, GWL_WNDPROC, (LONG) wxWndProc);
2bda0e17
KB
805}
806
42e69d6b 807void wxWindow::UnsubclassWin()
2bda0e17 808{
42e69d6b 809 wxRemoveHandleAssociation(this);
2bda0e17 810
42e69d6b
VZ
811 // Restore old Window proc
812 if ( GetHwnd() )
813 {
814 FARPROC farProc = (FARPROC) GetWindowLong(GetHwnd(), GWL_WNDPROC);
815 if ( (m_oldWndProc != 0) && (farProc != (FARPROC) m_oldWndProc) )
816 {
817 SetWindowLong(GetHwnd(), GWL_WNDPROC, (LONG) m_oldWndProc);
818 m_oldWndProc = 0;
819 }
2bda0e17 820
42e69d6b
VZ
821 m_hWnd = 0;
822 }
2bda0e17
KB
823}
824
42e69d6b
VZ
825// Make a Windows extended style from the given wxWindows window style
826WXDWORD wxWindow::MakeExtendedStyle(long style, bool eliminateBorders)
2bda0e17 827{
42e69d6b
VZ
828 WXDWORD exStyle = 0;
829 if ( style & wxTRANSPARENT_WINDOW )
830 exStyle |= WS_EX_TRANSPARENT;
2bda0e17 831
42e69d6b 832 if ( !eliminateBorders )
2d0a075d 833 {
42e69d6b
VZ
834 if ( style & wxSUNKEN_BORDER )
835 exStyle |= WS_EX_CLIENTEDGE;
836 if ( style & wxDOUBLE_BORDER )
837 exStyle |= WS_EX_DLGMODALFRAME;
838#if defined(__WIN95__)
839 if ( style & wxRAISED_BORDER )
840 exStyle |= WS_EX_WINDOWEDGE;
841 if ( style & wxSTATIC_BORDER )
842 exStyle |= WS_EX_STATICEDGE;
843#endif
2d0a075d 844 }
42e69d6b 845 return exStyle;
2bda0e17
KB
846}
847
42e69d6b
VZ
848// Determines whether native 3D effects or CTL3D should be used,
849// applying a default border style if required, and returning an extended
850// style to pass to CreateWindowEx.
851WXDWORD wxWindow::Determine3DEffects(WXDWORD defaultBorderStyle, bool *want3D)
2bda0e17 852{
42e69d6b
VZ
853 // If matches certain criteria, then assume no 3D effects
854 // unless specifically requested (dealt with in MakeExtendedStyle)
855 if ( !GetParent() || !IsKindOf(CLASSINFO(wxControl)) || (m_windowStyle & wxNO_BORDER) )
2bda0e17 856 {
42e69d6b
VZ
857 *want3D = FALSE;
858 return MakeExtendedStyle(m_windowStyle, FALSE);
2bda0e17 859 }
2bda0e17 860
42e69d6b
VZ
861 // Determine whether we should be using 3D effects or not.
862 bool nativeBorder = FALSE; // by default, we don't want a Win95 effect
a02eb1d2 863
42e69d6b
VZ
864 // 1) App can specify global 3D effects
865 *want3D = wxTheApp->GetAuto3D();
2bda0e17 866
42e69d6b
VZ
867 // 2) If the parent is being drawn with user colours, or simple border specified,
868 // switch effects off. TODO: replace wxUSER_COLOURS with wxNO_3D
869 if ( GetParent() && (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) || (m_windowStyle & wxSIMPLE_BORDER) )
870 *want3D = FALSE;
a23fd0e1 871
42e69d6b
VZ
872 // 3) Control can override this global setting by defining
873 // a border style, e.g. wxSUNKEN_BORDER
874 if ( m_windowStyle & wxSUNKEN_BORDER )
875 *want3D = TRUE;
2bda0e17 876
42e69d6b
VZ
877 // 4) If it's a special border, CTL3D can't cope so we want a native border
878 if ( (m_windowStyle & wxDOUBLE_BORDER) || (m_windowStyle & wxRAISED_BORDER) ||
879 (m_windowStyle & wxSTATIC_BORDER) )
2d0a075d 880 {
42e69d6b
VZ
881 *want3D = TRUE;
882 nativeBorder = TRUE;
2d0a075d 883 }
ea57084d 884
42e69d6b
VZ
885 // 5) If this isn't a Win95 app, and we are using CTL3D, remove border
886 // effects from extended style
887#if wxUSE_CTL3D
888 if ( *want3D )
889 nativeBorder = FALSE;
890#endif
a23fd0e1 891
42e69d6b 892 DWORD exStyle = MakeExtendedStyle(m_windowStyle, !nativeBorder);
2bda0e17 893
42e69d6b
VZ
894 // If we want 3D, but haven't specified a border here,
895 // apply the default border style specified.
896 // TODO what about non-Win95 WIN32? Does it have borders?
897#if defined(__WIN95__) && !wxUSE_CTL3D
898 if ( defaultBorderStyle && (*want3D) && ! ((m_windowStyle & wxDOUBLE_BORDER) || (m_windowStyle & wxRAISED_BORDER ) ||
899 (m_windowStyle & wxSTATIC_BORDER) || (m_windowStyle & wxSIMPLE_BORDER) ))
900 exStyle |= defaultBorderStyle; // WS_EX_CLIENTEDGE;
901#endif
902
903 return exStyle;
a23fd0e1 904}
2bda0e17 905
42e69d6b
VZ
906#if WXWIN_COMPATIBILITY_2
907// If nothing defined for this, try the parent.
908// E.g. we may be a button loaded from a resource, with no callback function
909// defined.
910void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
2bda0e17 911{
42e69d6b
VZ
912 if ( GetEventHandler()->ProcessEvent(event) )
913 return;
914 if ( m_parent )
915 m_parent->GetEventHandler()->OnCommand(win, event);
916}
917#endif // WXWIN_COMPATIBILITY_2
c085e333 918
42e69d6b
VZ
919#if WXWIN_COMPATIBILITY
920wxObject* wxWindow::GetChild(int number) const
921{
922 // Return a pointer to the Nth object in the Panel
923 wxNode *node = GetChildren().First();
924 int n = number;
925 while (node && n--)
926 node = node->Next();
927 if ( node )
928 {
929 wxObject *obj = (wxObject *)node->Data();
930 return(obj);
931 }
932 else
933 return NULL;
934}
935#endif // WXWIN_COMPATIBILITY
2bda0e17 936
42e69d6b
VZ
937// Setup background and foreground colours correctly
938void wxWindow::SetupColours()
939{
940 if ( GetParent() )
941 SetBackgroundColour(GetParent()->GetBackgroundColour());
942}
a23fd0e1 943
42e69d6b
VZ
944void wxWindow::OnIdle(wxIdleEvent& event)
945{
946 // Check if we need to send a LEAVE event
947 if ( m_mouseInWindow )
2d0a075d 948 {
42e69d6b
VZ
949 POINT pt;
950 ::GetCursorPos(&pt);
951 if ( ::WindowFromPoint(pt) != GetHwnd() )
952 {
953 // Generate a LEAVE event
954 m_mouseInWindow = FALSE;
2bda0e17 955
42e69d6b
VZ
956 // Unfortunately the mouse button and keyboard state may have changed
957 // by the time the OnIdle function is called, so 'state' may be
958 // meaningless.
959 int state = 0;
960 if ( ::GetKeyState(VK_SHIFT) != 0 )
961 state |= MK_SHIFT;
962 if ( ::GetKeyState(VK_CONTROL) != 0 )
963 state |= MK_CONTROL;
a23fd0e1 964
42e69d6b
VZ
965 wxMouseEvent event(wxEVT_LEAVE_WINDOW);
966 InitMouseEvent(event, pt.x, pt.y, state);
c085e333 967
42e69d6b
VZ
968 (void)GetEventHandler()->ProcessEvent(event);
969 }
970 }
c085e333 971
42e69d6b
VZ
972 UpdateWindowUI();
973}
568cb543 974
42e69d6b
VZ
975// Set this window to be the child of 'parent'.
976bool wxWindow::Reparent(wxWindow *parent)
977{
978 if ( !wxWindowBase::Reparent(parent) )
979 return FALSE;
c085e333 980
42e69d6b
VZ
981 HWND hWndChild = GetHwnd();
982 HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
a23fd0e1 983
42e69d6b 984 ::SetParent(hWndChild, hWndParent);
a23fd0e1 985
42e69d6b
VZ
986 return TRUE;
987}
a23fd0e1 988
42e69d6b
VZ
989void wxWindow::Clear()
990{
991 wxClientDC dc(this);
992 wxBrush brush(GetBackgroundColour(), wxSOLID);
993 dc.SetBackground(brush);
994 dc.Clear();
995}
a23fd0e1 996
42e69d6b
VZ
997void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
998{
999 HWND hWnd = GetHwnd();
1000 if ( hWnd )
1001 {
1002 if ( rect )
1003 {
1004 RECT mswRect;
1005 mswRect.left = rect->x;
1006 mswRect.top = rect->y;
1007 mswRect.right = rect->x + rect->width;
1008 mswRect.bottom = rect->y + rect->height;
a23fd0e1 1009
42e69d6b
VZ
1010 ::InvalidateRect(hWnd, &mswRect, eraseBack);
1011 }
1012 else
1013 ::InvalidateRect(hWnd, NULL, eraseBack);
1014 }
1015}
a23fd0e1 1016
42e69d6b
VZ
1017// ---------------------------------------------------------------------------
1018// drag and drop
1019// ---------------------------------------------------------------------------
a23fd0e1 1020
42e69d6b 1021#if wxUSE_DRAG_AND_DROP
a23fd0e1 1022
42e69d6b
VZ
1023void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
1024{
1025 if ( m_dropTarget != 0 ) {
1026 m_dropTarget->Revoke(m_hWnd);
1027 delete m_dropTarget;
1028 }
a23fd0e1 1029
42e69d6b
VZ
1030 m_dropTarget = pDropTarget;
1031 if ( m_dropTarget != 0 )
1032 m_dropTarget->Register(m_hWnd);
1033}
a23fd0e1 1034
42e69d6b 1035#endif // wxUSE_DRAG_AND_DROP
2a47d3c1 1036
42e69d6b
VZ
1037// old style file-manager drag&drop support: we retain the old-style
1038// DragAcceptFiles in parallel with SetDropTarget.
1039void wxWindow::DragAcceptFiles(bool accept)
1040{
1041 HWND hWnd = GetHwnd();
1042 if ( hWnd )
1043 ::DragAcceptFiles(hWnd, (BOOL)accept);
1044}
a23fd0e1 1045
42e69d6b
VZ
1046// ----------------------------------------------------------------------------
1047// tooltips
1048// ----------------------------------------------------------------------------
dbda9e86 1049
42e69d6b 1050#if wxUSE_TOOLTIPS
2d0a075d 1051
42e69d6b
VZ
1052void wxWindow::DoSetToolTip(wxToolTip *tooltip)
1053{
1054 wxWindowBase::DoSetToolTip(tooltip);
839b865d 1055
42e69d6b
VZ
1056 if ( m_tooltip )
1057 m_tooltip->SetWindow(this);
1058}
9a05fd8d 1059
42e69d6b 1060#endif // wxUSE_TOOLTIPS
9a05fd8d 1061
42e69d6b
VZ
1062// ---------------------------------------------------------------------------
1063// moving and resizing
1064// ---------------------------------------------------------------------------
839b865d 1065
42e69d6b
VZ
1066// Get total size
1067void wxWindow::DoGetSize(int *x, int *y) const
1068{
1069 HWND hWnd = GetHwnd();
1070 RECT rect;
1071 GetWindowRect(hWnd, &rect);
1072
1073 if ( x )
1074 *x = rect.right - rect.left;
1075 if ( y )
1076 *y = rect.bottom - rect.top;
1077}
1078
1079void wxWindow::DoGetPosition(int *x, int *y) const
1080{
1081 HWND hWnd = GetHwnd();
1082 HWND hParentWnd = 0;
1083 if ( GetParent() )
1084 hParentWnd = (HWND) GetParent()->GetHWND();
1085
1086 RECT rect;
1087 GetWindowRect(hWnd, &rect);
1088
1089 // Since we now have the absolute screen coords, if there's a parent we
1090 // must subtract its top left corner
1091 POINT point;
1092 point.x = rect.left;
1093 point.y = rect.top;
1094 if ( hParentWnd )
1095 {
1096 ::ScreenToClient(hParentWnd, &point);
1097 }
1098
1099 // We may be faking the client origin. So a window that's really at (0,
1100 // 30) may appear (to wxWin apps) to be at (0, 0).
1101 if ( GetParent() )
1102 {
1103 wxPoint pt(GetParent()->GetClientAreaOrigin());
1104 point.x -= pt.x;
1105 point.y -= pt.y;
1106 }
1107
1108 if ( x )
1109 *x = point.x;
1110 if ( y )
1111 *y = point.y;
1112}
54bdd8b0 1113
dabc0cd5 1114void wxWindow::DoScreenToClient(int *x, int *y) const
42e69d6b
VZ
1115{
1116 POINT pt;
1117 if ( x )
1118 pt.x = *x;
1119 if ( y )
1120 pt.y = *y;
54bdd8b0 1121
42e69d6b
VZ
1122 HWND hWnd = GetHwnd();
1123 ::ScreenToClient(hWnd, &pt);
a23fd0e1 1124
42e69d6b
VZ
1125 if ( x )
1126 *x = pt.x;
1127 if ( y )
1128 *y = pt.y;
1129}
a23fd0e1 1130
dabc0cd5 1131void wxWindow::DoClientToScreen(int *x, int *y) const
42e69d6b
VZ
1132{
1133 POINT pt;
1134 if ( x )
1135 pt.x = *x;
1136 if ( y )
1137 pt.y = *y;
54bdd8b0 1138
42e69d6b
VZ
1139 HWND hWnd = GetHwnd();
1140 ::ClientToScreen(hWnd, &pt);
a23fd0e1 1141
42e69d6b
VZ
1142 if ( x )
1143 *x = pt.x;
1144 if ( y )
1145 *y = pt.y;
1146}
a23fd0e1 1147
42e69d6b
VZ
1148// Get size *available for subwindows* i.e. excluding menu bar etc.
1149void wxWindow::DoGetClientSize(int *x, int *y) const
1150{
1151 HWND hWnd = GetHwnd();
1152 RECT rect;
1153 ::GetClientRect(hWnd, &rect);
1154 if ( x )
1155 *x = rect.right;
1156 if ( y )
1157 *y = rect.bottom;
1158}
a23fd0e1 1159
42e69d6b
VZ
1160void wxWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1161{
1162 int currentX, currentY;
1163 GetPosition(&currentX, &currentY);
1164 int currentW,currentH;
1165 GetSize(&currentW, &currentH);
a23fd0e1 1166
42e69d6b
VZ
1167 if ( x == currentX && y == currentY && width == currentW && height == currentH )
1168 return;
a23fd0e1 1169
42e69d6b
VZ
1170 int actualWidth = width;
1171 int actualHeight = height;
1172 int actualX = x;
1173 int actualY = y;
1174 if ( x == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1175 actualX = currentX;
1176 if ( y == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1177 actualY = currentY;
a23fd0e1 1178
42e69d6b 1179 AdjustForParentClientOrigin(actualX, actualY, sizeFlags);
a23fd0e1 1180
42e69d6b
VZ
1181 if ( width == -1 )
1182 actualWidth = currentW;
1183 if ( height == -1 )
1184 actualHeight = currentH;
a23fd0e1 1185
42e69d6b
VZ
1186 HWND hWnd = GetHwnd();
1187 if ( hWnd )
1188 MoveWindow(hWnd, actualX, actualY, actualWidth, actualHeight, (BOOL)TRUE);
1189}
a23fd0e1 1190
42e69d6b
VZ
1191void wxWindow::DoSetClientSize(int width, int height)
1192{
1193 wxWindow *parent = GetParent();
1194 HWND hWnd = GetHwnd();
1195 HWND hParentWnd = (HWND) 0;
1196 if ( parent )
1197 hParentWnd = (HWND) parent->GetHWND();
2bda0e17 1198
42e69d6b
VZ
1199 RECT rect;
1200 ::GetClientRect(hWnd, &rect);
a23fd0e1 1201
42e69d6b
VZ
1202 RECT rect2;
1203 GetWindowRect(hWnd, &rect2);
a23fd0e1 1204
42e69d6b
VZ
1205 // Find the difference between the entire window (title bar and all)
1206 // and the client area; add this to the new client size to move the
1207 // window
1208 int actual_width = rect2.right - rect2.left - rect.right + width;
1209 int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
a23fd0e1 1210
42e69d6b
VZ
1211 // If there's a parent, must subtract the parent's top left corner
1212 // since MoveWindow moves relative to the parent
a23fd0e1 1213
42e69d6b
VZ
1214 POINT point;
1215 point.x = rect2.left;
1216 point.y = rect2.top;
1217 if ( parent )
1218 {
1219 ::ScreenToClient(hParentWnd, &point);
1220 }
387a3b02 1221
42e69d6b 1222 MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)TRUE);
a23fd0e1 1223
42e69d6b
VZ
1224 wxSizeEvent event(wxSize(width, height), m_windowId);
1225 event.SetEventObject(this);
1226 GetEventHandler()->ProcessEvent(event);
1227}
a23fd0e1 1228
42e69d6b
VZ
1229// For implementation purposes - sometimes decorations make the client area
1230// smaller
1231wxPoint wxWindow::GetClientAreaOrigin() const
1232{
1233 return wxPoint(0, 0);
1234}
a23fd0e1 1235
42e69d6b
VZ
1236// Makes an adjustment to the window position (for example, a frame that has
1237// a toolbar that it manages itself).
1238void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
1239{
1240 if ( ((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent() )
1241 {
1242 wxPoint pt(GetParent()->GetClientAreaOrigin());
1243 x += pt.x; y += pt.y;
1244 }
1245}
a23fd0e1 1246
42e69d6b
VZ
1247// ---------------------------------------------------------------------------
1248// text metrics
1249// ---------------------------------------------------------------------------
a23fd0e1 1250
42e69d6b
VZ
1251int wxWindow::GetCharHeight() const
1252{
1253 TEXTMETRIC lpTextMetric;
1254 HWND hWnd = GetHwnd();
1255 HDC dc = ::GetDC(hWnd);
a23fd0e1 1256
42e69d6b
VZ
1257 GetTextMetrics(dc, &lpTextMetric);
1258 ::ReleaseDC(hWnd, dc);
3eddf563 1259
42e69d6b
VZ
1260 return lpTextMetric.tmHeight;
1261}
3eddf563 1262
42e69d6b
VZ
1263int wxWindow::GetCharWidth() const
1264{
1265 TEXTMETRIC lpTextMetric;
1266 HWND hWnd = GetHwnd();
1267 HDC dc = ::GetDC(hWnd);
3eddf563 1268
42e69d6b
VZ
1269 GetTextMetrics(dc, &lpTextMetric);
1270 ::ReleaseDC(hWnd, dc);
3eddf563 1271
42e69d6b
VZ
1272 return lpTextMetric.tmAveCharWidth;
1273}
f4621a09 1274
42e69d6b
VZ
1275void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
1276 int *descent, int *externalLeading,
1277 const wxFont *theFont) const
1278{
1279 const wxFont *fontToUse = theFont;
1280 if ( !fontToUse )
1281 fontToUse = &m_font;
634903fd 1282
42e69d6b
VZ
1283 HWND hWnd = GetHwnd();
1284 HDC dc = ::GetDC(hWnd);
634903fd 1285
42e69d6b
VZ
1286 HFONT fnt = 0;
1287 HFONT hfontOld = 0;
1288 if ( fontToUse && fontToUse->Ok() )
1289 {
1290 fnt = (HFONT)((wxFont *)fontToUse)->GetResourceHandle(); // const_cast
1291 if ( fnt )
1292 hfontOld = (HFONT)SelectObject(dc,fnt);
2bda0e17 1293 }
341c92a8 1294
42e69d6b
VZ
1295 SIZE sizeRect;
1296 TEXTMETRIC tm;
1297 GetTextExtentPoint(dc, (const char *)string, (int)string.Length(), &sizeRect);
1298 GetTextMetrics(dc, &tm);
1299
1300 if ( fontToUse && fnt && hfontOld )
1301 SelectObject(dc, hfontOld);
1302
1303 ReleaseDC(hWnd, dc);
1304
1305 if ( x ) *x = sizeRect.cx;
1306 if ( y ) *y = sizeRect.cy;
1307 if ( descent ) *descent = tm.tmDescent;
1308 if ( externalLeading ) *externalLeading = tm.tmExternalLeading;
2bda0e17
KB
1309}
1310
789295bf 1311#if wxUSE_CARET
42e69d6b
VZ
1312// ---------------------------------------------------------------------------
1313// Caret manipulation
1314// ---------------------------------------------------------------------------
1315
1316void wxWindow::CreateCaret(int w, int h)
2bda0e17 1317{
789295bf 1318 SetCaret(new wxCaret(this, w, h));
2bda0e17
KB
1319}
1320
42e69d6b 1321void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
2bda0e17 1322{
789295bf 1323 wxFAIL_MSG("not implemented");
2bda0e17
KB
1324}
1325
42e69d6b 1326void wxWindow::ShowCaret(bool show)
2bda0e17 1327{
789295bf
VZ
1328 wxCHECK_RET( m_caret, "no caret to show" );
1329
1330 m_caret->Show(show);
2bda0e17
KB
1331}
1332
42e69d6b 1333void wxWindow::DestroyCaret()
2bda0e17 1334{
789295bf 1335 SetCaret(NULL);
2bda0e17
KB
1336}
1337
42e69d6b 1338void wxWindow::SetCaretPos(int x, int y)
2bda0e17 1339{
789295bf
VZ
1340 wxCHECK_RET( m_caret, "no caret to move" );
1341
1342 m_caret->Move(x, y);
2bda0e17
KB
1343}
1344
42e69d6b 1345void wxWindow::GetCaretPos(int *x, int *y) const
2d0a075d 1346{
789295bf
VZ
1347 wxCHECK_RET( m_caret, "no caret to get position of" );
1348
1349 m_caret->GetPosition(x, y);
42e69d6b 1350}
789295bf 1351#endif // wxUSE_CARET
2bda0e17 1352
42e69d6b
VZ
1353// ===========================================================================
1354// pre/post message processing
1355// ===========================================================================
2bda0e17 1356
42e69d6b
VZ
1357long wxWindow::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1358{
1359 if ( m_oldWndProc )
1360 return ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
1361 else
1362 return ::DefWindowProc(GetHwnd(), nMsg, wParam, lParam);
1363}
2bda0e17 1364
42e69d6b
VZ
1365bool wxWindow::MSWProcessMessage(WXMSG* pMsg)
1366{
1367 if ( m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL) )
2d0a075d 1368 {
42e69d6b
VZ
1369 // intercept dialog navigation keys
1370 MSG *msg = (MSG *)pMsg;
1371 bool bProcess = TRUE;
1372 if ( msg->message != WM_KEYDOWN )
1373 bProcess = FALSE;
c085e333 1374
42e69d6b
VZ
1375 if ( bProcess && (HIWORD(msg->lParam) & KF_ALTDOWN) == KF_ALTDOWN )
1376 bProcess = FALSE;
a23fd0e1 1377
42e69d6b
VZ
1378 if ( bProcess )
1379 {
1380 bool bCtrlDown = (::GetKeyState(VK_CONTROL) & 0x100) != 0;
a23fd0e1 1381
42e69d6b
VZ
1382 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1383 // don't process it if it's the case (except for Ctrl-Tab/Enter
1384 // combinations which are always processed)
1385 LONG lDlgCode = 0;
1386 if ( !bCtrlDown )
1387 {
1388 lDlgCode = ::SendMessage(msg->hwnd, WM_GETDLGCODE, 0, 0);
1389 }
a23fd0e1 1390
42e69d6b
VZ
1391 bool bForward = TRUE,
1392 bWindowChange = FALSE;
a23fd0e1 1393
9145664b 1394 switch ( msg->wParam )
42e69d6b
VZ
1395 {
1396 case VK_TAB:
1397 if ( lDlgCode & DLGC_WANTTAB ) {
1398 bProcess = FALSE;
1399 }
1400 else {
1401 // Ctrl-Tab cycles thru notebook pages
1402 bWindowChange = bCtrlDown;
1403 bForward = !(::GetKeyState(VK_SHIFT) & 0x100);
1404 }
1405 break;
a23fd0e1 1406
42e69d6b
VZ
1407 case VK_UP:
1408 case VK_LEFT:
1409 if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
1410 bProcess = FALSE;
1411 else
1412 bForward = FALSE;
1413 break;
a02eb1d2 1414
42e69d6b
VZ
1415 case VK_DOWN:
1416 case VK_RIGHT:
1417 if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
1418 bProcess = FALSE;
1419 break;
2bda0e17 1420
42e69d6b
VZ
1421 case VK_RETURN:
1422 {
1423 if ( lDlgCode & DLGC_WANTMESSAGE )
1424 {
1425 // control wants to process Enter itself, don't
1426 // call IsDialogMessage() which would interpret
1427 // it
1428 return FALSE;
1429 }
1430#ifndef __WIN16__
1431 wxButton *btnDefault = GetDefaultItem();
1432 if ( btnDefault && !bCtrlDown )
1433 {
1434 // if there is a default button, Enter should
1435 // press it
1436 (void)::SendMessage((HWND)btnDefault->GetHWND(),
1437 BM_CLICK, 0, 0);
1438 return TRUE;
1439 }
1440 // else: but if there is not it makes sense to make it
1441 // work like a TAB - and that's what we do.
1442 // Note that Ctrl-Enter always works this way.
1443#endif
1444 }
1445 break;
2bda0e17 1446
42e69d6b
VZ
1447 default:
1448 bProcess = FALSE;
1449 }
2bda0e17 1450
42e69d6b
VZ
1451 if ( bProcess )
1452 {
1453 wxNavigationKeyEvent event;
1454 event.SetDirection(bForward);
1455 event.SetWindowChange(bWindowChange);
1456 event.SetEventObject(this);
3572173c 1457
42e69d6b
VZ
1458 if ( GetEventHandler()->ProcessEvent(event) )
1459 return TRUE;
1460 }
1461 }
a23fd0e1 1462
42e69d6b
VZ
1463 if ( ::IsDialogMessage(GetHwnd(), msg) )
1464 return TRUE;
1465 }
a23fd0e1 1466
42e69d6b
VZ
1467#if wxUSE_TOOLTIPS
1468 if ( m_tooltip )
387a3b02 1469 {
42e69d6b
VZ
1470 // relay mouse move events to the tooltip control
1471 MSG *msg = (MSG *)pMsg;
1472 if ( msg->message == WM_MOUSEMOVE )
1473 m_tooltip->RelayEvent(pMsg);
387a3b02 1474 }
42e69d6b 1475#endif // wxUSE_TOOLTIPS
a23fd0e1 1476
42e69d6b 1477 return FALSE;
387a3b02
JS
1478}
1479
42e69d6b 1480bool wxWindow::MSWTranslateMessage(WXMSG* pMsg)
387a3b02 1481{
42e69d6b
VZ
1482 return m_acceleratorTable.Ok() &&
1483 ::TranslateAccelerator(GetHwnd(),
1484 GetTableHaccel(m_acceleratorTable),
1485 (MSG *)pMsg);
387a3b02
JS
1486}
1487
42e69d6b
VZ
1488// ---------------------------------------------------------------------------
1489// message params unpackers (different for Win16 and Win32)
1490// ---------------------------------------------------------------------------
2bda0e17 1491
42e69d6b 1492#ifdef __WIN32__
c085e333 1493
42e69d6b
VZ
1494void wxWindow::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
1495 WORD *id, WXHWND *hwnd, WORD *cmd)
1496{
1497 *id = LOWORD(wParam);
1498 *hwnd = (WXHWND)lParam;
1499 *cmd = HIWORD(wParam);
2bda0e17
KB
1500}
1501
42e69d6b
VZ
1502void wxWindow::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
1503 WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
2bda0e17 1504{
42e69d6b
VZ
1505 *state = LOWORD(wParam);
1506 *minimized = HIWORD(wParam);
1507 *hwnd = (WXHWND)lParam;
2bda0e17
KB
1508}
1509
42e69d6b
VZ
1510void wxWindow::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
1511 WXWORD *code, WXWORD *pos, WXHWND *hwnd)
2bda0e17 1512{
42e69d6b
VZ
1513 *code = LOWORD(wParam);
1514 *pos = HIWORD(wParam);
1515 *hwnd = (WXHWND)lParam;
1516}
a23fd0e1 1517
42e69d6b
VZ
1518void wxWindow::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
1519 WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
1520{
1521 *nCtlColor = CTLCOLOR_BTN;
1522 *hwnd = (WXHWND)lParam;
1523 *hdc = (WXHDC)wParam;
2bda0e17
KB
1524}
1525
42e69d6b
VZ
1526void wxWindow::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
1527 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
2bda0e17 1528{
42e69d6b
VZ
1529 *item = (WXWORD)wParam;
1530 *flags = HIWORD(wParam);
1531 *hmenu = (WXHMENU)lParam;
1532}
c085e333 1533
42e69d6b 1534#else // Win16
341c92a8 1535
42e69d6b
VZ
1536void wxWindow::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
1537 WXWORD *id, WXHWND *hwnd, WXWORD *cmd)
1538{
1539 *id = (WXWORD)wParam;
1540 *hwnd = (WXHWND)LOWORD(lParam);
1541 *cmd = HIWORD(lParam);
2bda0e17
KB
1542}
1543
42e69d6b
VZ
1544void wxWindow::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
1545 WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
2bda0e17 1546{
42e69d6b
VZ
1547 *state = (WXWORD)wParam;
1548 *minimized = LOWORD(lParam);
1549 *hwnd = (WXHWND)HIWORD(lParam);
2bda0e17
KB
1550}
1551
42e69d6b
VZ
1552void wxWindow::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
1553 WXWORD *code, WXWORD *pos, WXHWND *hwnd)
2bda0e17 1554{
42e69d6b
VZ
1555 *code = (WXWORD)wParam;
1556 *pos = LOWORD(lParam);
1557 *hwnd = (WXHWND)HIWORD(lParam);
1558}
c085e333 1559
42e69d6b
VZ
1560void wxWindow::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
1561 WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
1562{
1563 *control = (WXHWND)LOWORD(lParam);
1564 *nCtlColor = (int)HIWORD(lParam);
1565 *hdc = (WXHDC)wParam;
2bda0e17
KB
1566}
1567
42e69d6b
VZ
1568void wxWindow::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
1569 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
2bda0e17 1570{
42e69d6b
VZ
1571 *item = (WXWORD)wParam;
1572 *flags = LOWORD(lParam);
1573 *hmenu = (WXHMENU)HIWORD(lParam);
1574}
2d0a075d 1575
42e69d6b 1576#endif // Win32/16
c085e333 1577
42e69d6b
VZ
1578// ---------------------------------------------------------------------------
1579// Main wxWindows window proc and the window proc for wxWindow
1580// ---------------------------------------------------------------------------
2bda0e17 1581
42e69d6b
VZ
1582// Hook for new window just as it's being created, when the window isn't yet
1583// associated with the handle
1584wxWindow *wxWndHook = NULL;
1585
1586// Main window proc
1587LRESULT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
2bda0e17 1588{
42e69d6b
VZ
1589 // trace all messages - useful for the debugging
1590#ifdef __WXDEBUG__
1591 wxLogTrace(wxTraceMessages, "Processing %s(wParam=%8lx, lParam=%8lx)",
1592 wxGetMessageName(message), wParam, lParam);
1593#endif // __WXDEBUG__
2bda0e17 1594
42e69d6b 1595 wxWindow *wnd = wxFindWinFromHandle((WXHWND) hWnd);
c085e333 1596
42e69d6b
VZ
1597 // when we get the first message for the HWND we just created, we associate
1598 // it with wxWindow stored in wxWndHook
1599 if ( !wnd && wxWndHook )
2d0a075d 1600 {
42e69d6b
VZ
1601 wxAssociateWinWithHandle(hWnd, wxWndHook);
1602 wnd = wxWndHook;
1603 wxWndHook = NULL;
1604 wnd->SetHWND((WXHWND)hWnd);
2d0a075d 1605 }
2bda0e17 1606
42e69d6b 1607 LRESULT rc;
a23fd0e1 1608
42e69d6b
VZ
1609 // Stop right here if we don't have a valid handle in our wxWindow object.
1610 if ( wnd && !wnd->GetHWND() )
2d0a075d 1611 {
42e69d6b
VZ
1612 // FIXME: why do we do this?
1613 wnd->SetHWND((WXHWND) hWnd);
1614 rc = wnd->MSWDefWindowProc(message, wParam, lParam );
1615 wnd->SetHWND(0);
a23fd0e1
VZ
1616 }
1617 else
1618 {
42e69d6b
VZ
1619 if ( wnd )
1620 rc = wnd->MSWWindowProc(message, wParam, lParam);
1621 else
1622 rc = DefWindowProc( hWnd, message, wParam, lParam );
2d0a075d 1623 }
2bda0e17 1624
42e69d6b 1625 return rc;
f7bd2698
JS
1626}
1627
42e69d6b 1628long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
f7bd2698 1629{
42e69d6b
VZ
1630 // did we process the message?
1631 bool processed = FALSE;
f7bd2698 1632
42e69d6b
VZ
1633 // the return value
1634 union
2bda0e17 1635 {
42e69d6b
VZ
1636 bool allow;
1637 long result;
1638 WXHICON hIcon;
1639 WXHBRUSH hBrush;
1640 } rc;
2bda0e17 1641
42e69d6b
VZ
1642 // for most messages we should return 0 when we do process the message
1643 rc.result = 0;
2bda0e17 1644
42e69d6b 1645 switch ( message )
39136494 1646 {
42e69d6b
VZ
1647 case WM_CREATE:
1648 {
1649 bool mayCreate;
1650 processed = HandleCreate((WXLPCREATESTRUCT)lParam, &mayCreate);
1651 if ( processed )
1652 {
1653 // return 0 to allow window creation
1654 rc.result = mayCreate ? 0 : -1;
1655 }
1656 }
1657 break;
47cbd6da 1658
42e69d6b
VZ
1659 case WM_DESTROY:
1660 processed = HandleDestroy();
1661 break;
1662
1663 case WM_MOVE:
1664 processed = HandleMove(LOWORD(lParam), HIWORD(lParam));
1665 break;
47cbd6da 1666
42e69d6b
VZ
1667 case WM_SIZE:
1668 processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam);
1669 break;
47cbd6da 1670
42e69d6b 1671 case WM_ACTIVATE:
341c92a8 1672 {
42e69d6b
VZ
1673 WXWORD state, minimized;
1674 WXHWND hwnd;
1675 UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
1676
1677 processed = HandleActivate(state, minimized != 0, (WXHWND)hwnd);
341c92a8 1678 }
42e69d6b 1679 break;
341c92a8 1680
42e69d6b
VZ
1681 case WM_SETFOCUS:
1682 processed = HandleSetFocus((WXHWND)(HWND)wParam);
1683 break;
47cbd6da 1684
42e69d6b
VZ
1685 case WM_KILLFOCUS:
1686 processed = HandleKillFocus((WXHWND)(HWND)wParam);
1687 break;
47cbd6da 1688
42e69d6b 1689 case WM_PAINT:
c6eba8f8 1690 wxStartPainting();
42e69d6b 1691 processed = HandlePaint();
c6eba8f8 1692 wxEndPainting();
42e69d6b 1693 break;
47cbd6da 1694
42e69d6b
VZ
1695 case WM_CLOSE:
1696 // don't let the DefWindowProc() destroy our window - we'll do it
1697 // ourselves in ~wxWindow
1698 processed = TRUE;
1699 rc.result = TRUE;
1700 break;
47cbd6da 1701
42e69d6b
VZ
1702 case WM_SHOWWINDOW:
1703 processed = HandleShow(wParam != 0, (int)lParam);
1704 break;
3a19e16d 1705
42e69d6b
VZ
1706 case WM_MOUSEMOVE:
1707 case WM_LBUTTONDOWN:
1708 case WM_LBUTTONUP:
1709 case WM_LBUTTONDBLCLK:
1710 case WM_RBUTTONDOWN:
1711 case WM_RBUTTONUP:
1712 case WM_RBUTTONDBLCLK:
1713 case WM_MBUTTONDOWN:
1714 case WM_MBUTTONUP:
1715 case WM_MBUTTONDBLCLK:
1716 {
1717 int x = LOWORD(lParam);
1718 int y = HIWORD(lParam);
1719
1720 processed = HandleMouseEvent(message, x, y, wParam);
2d0a075d 1721 }
42e69d6b 1722 break;
47cbd6da 1723
42e69d6b
VZ
1724 case MM_JOY1MOVE:
1725 case MM_JOY2MOVE:
1726 case MM_JOY1ZMOVE:
1727 case MM_JOY2ZMOVE:
1728 case MM_JOY1BUTTONDOWN:
1729 case MM_JOY2BUTTONDOWN:
1730 case MM_JOY1BUTTONUP:
1731 case MM_JOY2BUTTONUP:
341c92a8 1732 {
42e69d6b
VZ
1733 int x = LOWORD(lParam);
1734 int y = HIWORD(lParam);
47cbd6da 1735
42e69d6b 1736 processed = HandleJoystickEvent(message, x, y, wParam);
341c92a8 1737 }
42e69d6b 1738 break;
47cbd6da 1739
42e69d6b
VZ
1740 case WM_SYSCOMMAND:
1741 processed = HandleSysCommand(wParam, lParam);
1742 break;
2a47d3c1 1743
42e69d6b
VZ
1744 case WM_COMMAND:
1745 {
1746 WORD id, cmd;
1747 WXHWND hwnd;
1748 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
47cbd6da 1749
42e69d6b
VZ
1750 processed = HandleCommand(id, cmd, hwnd);
1751 }
1752 break;
7d532b0c 1753
42e69d6b
VZ
1754#ifdef __WIN95__
1755 case WM_NOTIFY:
1756 processed = HandleNotify((int)wParam, lParam, &rc.result);
1757 break;
1758#endif // Win95
2bda0e17 1759
42e69d6b
VZ
1760 // for these messages we must return TRUE if process the message
1761 case WM_DRAWITEM:
1762 case WM_MEASUREITEM:
1763 {
1764 int idCtrl = (UINT)wParam;
1765 if ( message == WM_DRAWITEM )
1766 {
1767 processed = MSWOnDrawItem(idCtrl,
1768 (WXDRAWITEMSTRUCT *)lParam);
1769 }
1770 else
1771 {
1772 processed = MSWOnMeasureItem(idCtrl,
1773 (WXMEASUREITEMSTRUCT *)lParam);
1774 }
57a7b7c1 1775
42e69d6b
VZ
1776 if ( processed )
1777 rc.result = TRUE;
1778 }
1779 break;
1780
9bf84618
VZ
1781 case WM_GETDLGCODE:
1782 if ( GetWindowStyleFlag() & wxWANTS_CHARS )
1783 {
1784 rc.result = DLGC_WANTARROWS | DLGC_WANTCHARS | DLGC_WANTTAB;
1785 processed = TRUE;
1786 }
1787 break;
1788
42e69d6b
VZ
1789 case WM_KEYDOWN:
1790 // If this has been processed by an event handler,
1791 // return 0 now (we've handled it).
1792 if ( HandleKeyDown((WORD) wParam, lParam) )
2d0a075d 1793 {
42e69d6b
VZ
1794 processed = TRUE;
1795
2d0a075d
JS
1796 break;
1797 }
81d66cf3 1798
42e69d6b
VZ
1799 // we consider these message "not interesting" to OnChar
1800 if ( wParam == VK_SHIFT || wParam == VK_CONTROL )
1801 {
1802 processed = TRUE;
81d66cf3 1803
42e69d6b
VZ
1804 break;
1805 }
debe6624 1806
42e69d6b
VZ
1807 switch ( wParam )
1808 {
1809 // avoid duplicate messages to OnChar for these ASCII keys: they
1810 // will be translated by TranslateMessage() and received in WM_CHAR
1811 case VK_ESCAPE:
1812 case VK_SPACE:
1813 case VK_RETURN:
1814 case VK_BACK:
1815 case VK_TAB:
1816 processed = TRUE;
2bda0e17 1817
42e69d6b 1818 break;
2bda0e17 1819
42e69d6b
VZ
1820#ifdef VK_APPS
1821 // special case of VK_APPS: treat it the same as right mouse
1822 // click because both usually pop up a context menu
1823 case VK_APPS:
1824 {
1825 // construct the key mask
1826 WPARAM fwKeys = MK_RBUTTON;
1827 if ( (::GetKeyState(VK_CONTROL) & 0x100) != 0 )
1828 fwKeys |= MK_CONTROL;
1829 if ( (::GetKeyState(VK_SHIFT) & 0x100) != 0 )
1830 fwKeys |= MK_SHIFT;
2bda0e17 1831
42e69d6b
VZ
1832 // simulate right mouse button click
1833 DWORD dwPos = ::GetMessagePos();
1834 int x = GET_X_LPARAM(dwPos),
1835 y = GET_Y_LPARAM(dwPos);
debe6624 1836
42e69d6b
VZ
1837 ScreenToClient(&x, &y);
1838 processed = HandleMouseEvent(WM_RBUTTONDOWN, x, y, fwKeys);
1839 }
1840 break;
1841#endif // VK_APPS
2bda0e17 1842
42e69d6b
VZ
1843 case VK_LEFT:
1844 case VK_RIGHT:
1845 case VK_DOWN:
1846 case VK_UP:
1847 default:
1848 processed = HandleChar((WORD)wParam, lParam);
1849 }
1850 break;
2bda0e17 1851
42e69d6b
VZ
1852 case WM_KEYUP:
1853 processed = HandleKeyUp((WORD) wParam, lParam);
1854 break;
debe6624 1855
42e69d6b
VZ
1856 case WM_CHAR: // Always an ASCII character
1857 processed = HandleChar((WORD)wParam, lParam, TRUE);
1858 break;
2bda0e17 1859
42e69d6b
VZ
1860 case WM_HSCROLL:
1861 case WM_VSCROLL:
a23fd0e1 1862 {
42e69d6b
VZ
1863 WXWORD code, pos;
1864 WXHWND hwnd;
1865 UnpackScroll(wParam, lParam, &code, &pos, &hwnd);
2bda0e17 1866
42e69d6b
VZ
1867 processed = MSWOnScroll(message == WM_HSCROLL ? wxHORIZONTAL
1868 : wxVERTICAL,
1869 code, pos, hwnd);
a23fd0e1 1870 }
42e69d6b 1871 break;
a23fd0e1 1872
42e69d6b
VZ
1873 // CTLCOLOR messages are sent by children to query the parent for their
1874 // colors
1875#ifdef __WIN32__
1876 case WM_CTLCOLORMSGBOX:
1877 case WM_CTLCOLOREDIT:
1878 case WM_CTLCOLORLISTBOX:
1879 case WM_CTLCOLORBTN:
1880 case WM_CTLCOLORDLG:
1881 case WM_CTLCOLORSCROLLBAR:
1882 case WM_CTLCOLORSTATIC:
1883#else // Win16
1884 case WM_CTLCOLOR:
1885#endif // Win32/16
a23fd0e1 1886 {
42e69d6b
VZ
1887 WXWORD nCtlColor;
1888 WXHDC hdc;
1889 WXHWND hwnd;
1890 UnpackCtlColor(wParam, lParam, &nCtlColor, &hdc, &hwnd);
1891
1892 processed = HandleCtlColor(&rc.hBrush,
1893 (WXHDC)hdc,
1894 (WXHWND)hwnd,
1895 nCtlColor,
1896 message,
1897 wParam,
1898 lParam);
a23fd0e1 1899 }
42e69d6b 1900 break;
debe6624 1901
42e69d6b
VZ
1902 // the return value for this message is ignored
1903 case WM_SYSCOLORCHANGE:
1904 processed = HandleSysColorChange();
1905 break;
2bda0e17 1906
42e69d6b
VZ
1907 case WM_PALETTECHANGED:
1908 processed = HandlePaletteChanged((WXHWND) (HWND) wParam);
1909 break;
2bda0e17 1910
42e69d6b
VZ
1911 case WM_QUERYNEWPALETTE:
1912 processed = HandleQueryNewPalette();
1913 break;
2bda0e17 1914
42e69d6b
VZ
1915 case WM_ERASEBKGND:
1916 processed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
1917 if ( processed )
1918 {
1919 // we processed the message, i.e. erased the background
1920 rc.result = TRUE;
1921 }
1922 break;
debe6624 1923
42e69d6b
VZ
1924 case WM_DROPFILES:
1925 processed = HandleDropFiles(wParam);
1926 break;
2bda0e17 1927
42e69d6b
VZ
1928 case WM_INITDIALOG:
1929 processed = HandleInitDialog((WXHWND)(HWND)wParam);
a23fd0e1 1930
42e69d6b
VZ
1931 if ( processed )
1932 {
1933 // we never set focus from here
1934 rc.result = FALSE;
1935 }
1936 break;
a23fd0e1 1937
42e69d6b
VZ
1938 case WM_QUERYENDSESSION:
1939 processed = HandleQueryEndSession(lParam, &rc.allow);
1940 break;
2bda0e17 1941
42e69d6b
VZ
1942 case WM_ENDSESSION:
1943 processed = HandleEndSession(wParam != 0, lParam);
1944 break;
2bda0e17 1945
42e69d6b
VZ
1946 case WM_GETMINMAXINFO:
1947 processed = HandleGetMinMaxInfo((LPMINMAXINFO)lParam);
1948 break;
debe6624 1949
42e69d6b
VZ
1950 case WM_SETCURSOR:
1951 processed = HandleSetCursor((WXHWND)(HWND)wParam,
1952 LOWORD(lParam), // hit test
1953 HIWORD(lParam)); // mouse msg
1954
1955 if ( processed )
1956 {
1957 // returning TRUE stops the DefWindowProc() from further
1958 // processing this message - exactly what we need because we've
1959 // just set the cursor.
1960 rc.result = TRUE;
1961 }
1962 break;
a23fd0e1 1963 }
2d0a075d 1964
42e69d6b 1965 if ( !processed )
2d0a075d 1966 {
42e69d6b
VZ
1967#ifdef __WXDEBUG__
1968 wxLogTrace(wxTraceMessages, "Forwarding %s to DefWindowProc.",
1969 wxGetMessageName(message));
1970#endif // __WXDEBUG__
1971 rc.result = MSWDefWindowProc(message, wParam, lParam);
a23fd0e1 1972 }
2bda0e17 1973
42e69d6b 1974 return rc.result;
2bda0e17
KB
1975}
1976
42e69d6b
VZ
1977// Dialog window proc
1978LONG APIENTRY _EXPORT
1979wxDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
2bda0e17 1980{
42e69d6b 1981 if ( message == WM_INITDIALOG )
2bda0e17 1982 {
42e69d6b
VZ
1983 // for this message, returning TRUE tells system to set focus to the
1984 // first control in the dialog box
1985 return TRUE;
2d0a075d 1986 }
42e69d6b 1987 else
2d0a075d 1988 {
42e69d6b
VZ
1989 // for all the other ones, FALSE means that we didn't process the
1990 // message
1991 return 0;
2d0a075d 1992 }
2bda0e17
KB
1993}
1994
42e69d6b
VZ
1995wxList *wxWinHandleList = NULL;
1996wxWindow *wxFindWinFromHandle(WXHWND hWnd)
4ce81a75 1997{
42e69d6b
VZ
1998 wxNode *node = wxWinHandleList->Find((long)hWnd);
1999 if ( !node )
2000 return NULL;
2001 return (wxWindow *)node->Data();
2002}
4ce81a75 2003
42e69d6b
VZ
2004void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win)
2005{
2006 // adding NULL hWnd is (first) surely a result of an error and
2007 // (secondly) breaks menu command processing
2008 wxCHECK_RET( hWnd != (HWND)NULL,
2009 "attempt to add a NULL hWnd to window list ignored" );
4ce81a75 2010
42e69d6b
VZ
2011 if ( !wxWinHandleList->Find((long)hWnd) )
2012 wxWinHandleList->Append((long)hWnd, win);
2013}
4ce81a75 2014
42e69d6b
VZ
2015void wxRemoveHandleAssociation(wxWindow *win)
2016{
2017 wxWinHandleList->DeleteObject(win);
4ce81a75
JS
2018}
2019
42e69d6b
VZ
2020// Default destroyer - override if you destroy it in some other way
2021// (e.g. with MDI child windows)
2022void wxWindow::MSWDestroyWindow()
4ce81a75 2023{
42e69d6b 2024}
4ce81a75 2025
42e69d6b
VZ
2026void wxWindow::MSWDetachWindowMenu()
2027{
2028 if ( m_hMenu )
4ce81a75 2029 {
42e69d6b 2030 HMENU hMenu = (HMENU)m_hMenu;
4ce81a75 2031
42e69d6b
VZ
2032 int N = ::GetMenuItemCount(hMenu);
2033 int i;
2034 for (i = 0; i < N; i++)
2035 {
2036 char buf[100];
2037 int chars = GetMenuString(hMenu, i, buf, 100, MF_BYPOSITION);
2038 if ( !chars )
2039 {
2040 wxLogLastError("GetMenuString");
4ce81a75 2041
42e69d6b
VZ
2042 continue;
2043 }
4ce81a75 2044
42e69d6b
VZ
2045 if ( strcmp(buf, "&Window") == 0 )
2046 {
2047 RemoveMenu(hMenu, i, MF_BYPOSITION);
4ce81a75 2048
42e69d6b
VZ
2049 break;
2050 }
2051 }
4ce81a75
JS
2052 }
2053}
2054
42e69d6b
VZ
2055bool wxWindow::MSWCreate(int id,
2056 wxWindow *parent,
2057 const char *wclass,
2058 wxWindow *wx_win,
2059 const char *title,
2060 int x,
2061 int y,
2062 int width,
2063 int height,
2064 WXDWORD style,
2065 const char *dialog_template,
2066 WXDWORD extendedStyle)
2bda0e17 2067{
42e69d6b
VZ
2068 int x1 = CW_USEDEFAULT;
2069 int y1 = 0;
2070 int width1 = CW_USEDEFAULT;
2071 int height1 = 100;
c085e333 2072
42e69d6b
VZ
2073 // Find parent's size, if it exists, to set up a possible default
2074 // panel size the size of the parent window
2075 RECT parent_rect;
2076 if ( parent )
a23fd0e1 2077 {
42e69d6b 2078 ::GetClientRect((HWND) parent->GetHWND(), &parent_rect);
c085e333 2079
42e69d6b
VZ
2080 width1 = parent_rect.right - parent_rect.left;
2081 height1 = parent_rect.bottom - parent_rect.top;
2082 }
2bda0e17 2083
42e69d6b
VZ
2084 if ( x > -1 ) x1 = x;
2085 if ( y > -1 ) y1 = y;
2086 if ( width > -1 ) width1 = width;
2087 if ( height > -1 ) height1 = height;
c085e333 2088
42e69d6b
VZ
2089 HWND hParent = NULL;
2090 if ( parent )
2091 hParent = (HWND) parent->GetHWND();
c085e333 2092
42e69d6b 2093 wxWndHook = this;
c085e333 2094
42e69d6b
VZ
2095 if ( dialog_template )
2096 {
2097 m_hWnd = (WXHWND)::CreateDialog(wxGetInstance(),
2098 dialog_template,
2099 hParent,
2100 (DLGPROC)wxDlgProc);
2bda0e17 2101
42e69d6b
VZ
2102 if ( m_hWnd == 0 )
2103 {
2104 wxLogError(_("Can't find dummy dialog template!\n"
2105 "Check resource include path for finding wx.rc."));
c085e333 2106
42e69d6b
VZ
2107 return FALSE;
2108 }
c085e333 2109
789295bf
VZ
2110 // ::SetWindowLong(GWL_EXSTYLE) doesn't work for the dialogs, so try
2111 // to take care of (at least some) extended style flags ourselves
2112 if ( extendedStyle & WS_EX_TOPMOST )
2113 {
2114 if ( !::SetWindowPos(GetHwnd(), HWND_TOPMOST, 0, 0, 0, 0,
2115 SWP_NOSIZE | SWP_NOMOVE) )
2116 {
2117 wxLogLastError("SetWindowPos");
2118 }
2119 }
2120
2121 // move the dialog to its initial position without forcing repainting
2122 if ( !::MoveWindow(GetHwnd(), x1, y1, width1, height1, FALSE) )
2123 {
2124 wxLogLastError("MoveWindow");
2125 }
42e69d6b
VZ
2126 }
2127 else
2128 {
2129 int controlId = 0;
2130 if ( style & WS_CHILD )
2131 controlId = id;
2132
2133 m_hWnd = (WXHWND)CreateWindowEx(extendedStyle,
2134 wclass,
2135 title ? title : "",
2136 style,
2137 x1, y1,
2138 width1, height1,
2139 hParent, (HMENU)controlId,
2140 wxGetInstance(),
2141 NULL);
2142
2143 if ( !m_hWnd )
2144 {
2145 wxLogError(_("Can't create window of class %s!\n"
2146 "Possible Windows 3.x compatibility problem?"),
2147 wclass);
2bda0e17 2148
a23fd0e1 2149 return FALSE;
42e69d6b 2150 }
a23fd0e1 2151 }
c085e333 2152
42e69d6b
VZ
2153 wxWndHook = NULL;
2154 wxWinHandleList->Append((long)m_hWnd, this);
c085e333 2155
42e69d6b 2156 return TRUE;
2bda0e17
KB
2157}
2158
42e69d6b
VZ
2159// ===========================================================================
2160// MSW message handlers
2161// ===========================================================================
2162
2163// ---------------------------------------------------------------------------
2164// WM_NOTIFY
2165// ---------------------------------------------------------------------------
2166
2167#ifdef __WIN95__
2168// FIXME: VZ: I'm not sure at all that the order of processing is correct
2169bool wxWindow::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
2bda0e17 2170{
42e69d6b
VZ
2171 LPNMHDR hdr = (LPNMHDR)lParam;
2172 HWND hWnd = hdr->hwndFrom;
2173 wxWindow *win = wxFindWinFromHandle((WXHWND)hWnd);
2174
2175 // is this one of our windows?
2176 if ( win )
564b2609 2177 {
42e69d6b 2178 return win->MSWOnNotify(idCtrl, lParam, result);
564b2609 2179 }
2bda0e17 2180
42e69d6b
VZ
2181 // try all our children
2182 wxWindowList::Node *node = GetChildren().GetFirst();
2183 while ( node )
564b2609 2184 {
42e69d6b
VZ
2185 wxWindow *child = node->GetData();
2186 if ( child->MSWOnNotify(idCtrl, lParam, result) )
2187 {
2188 return TRUE;
2d0a075d 2189
42e69d6b
VZ
2190 break;
2191 }
2d0a075d 2192
42e69d6b
VZ
2193 node = node->GetNext();
2194 }
2d0a075d 2195
42e69d6b
VZ
2196 // finally try this window too (catches toolbar case)
2197 return MSWOnNotify(idCtrl, lParam, result);
2198}
2d0a075d 2199
42e69d6b
VZ
2200bool wxWindow::MSWOnNotify(int WXUNUSED(idCtrl),
2201 WXLPARAM lParam,
2202 WXLPARAM* WXUNUSED(result))
2203{
2204#if wxUSE_TOOLTIPS
2205 NMHDR* hdr = (NMHDR *)lParam;
2206 if ( hdr->code == TTN_NEEDTEXT && m_tooltip )
2207 {
2208 TOOLTIPTEXT *ttt = (TOOLTIPTEXT *)lParam;
2209 ttt->lpszText = (char *)m_tooltip->GetTip().c_str();
2d0a075d 2210
42e69d6b
VZ
2211 // processed
2212 return TRUE;
2213 }
2214#endif // wxUSE_TOOLTIPS
2215
2216 return FALSE;
2217}
2218#endif // __WIN95__
2219
2220// ---------------------------------------------------------------------------
2221// end session messages
2222// ---------------------------------------------------------------------------
2d0a075d 2223
42e69d6b
VZ
2224bool wxWindow::HandleQueryEndSession(long logOff, bool *mayEnd)
2225{
2226 wxCloseEvent event(wxEVT_QUERY_END_SESSION, -1);
2227 event.SetEventObject(wxTheApp);
2228 event.SetCanVeto(TRUE);
2229 event.SetLoggingOff(logOff == ENDSESSION_LOGOFF);
2d0a075d 2230
42e69d6b
VZ
2231 bool rc = wxTheApp->ProcessEvent(event);
2232
2233 if ( rc )
2234 {
2235 // we may end only if the app didn't veto session closing (double
2236 // negation...)
2237 *mayEnd = !event.GetVeto();
2d0a075d
JS
2238 }
2239
42e69d6b 2240 return rc;
2bda0e17
KB
2241}
2242
42e69d6b 2243bool wxWindow::HandleEndSession(bool endSession, long logOff)
2bda0e17 2244{
42e69d6b
VZ
2245 // do nothing if the session isn't ending
2246 if ( !endSession )
2247 return FALSE;
a23fd0e1 2248
42e69d6b
VZ
2249 wxCloseEvent event(wxEVT_END_SESSION, -1);
2250 event.SetEventObject(wxTheApp);
2251 event.SetCanVeto(FALSE);
2252 event.SetLoggingOff( (logOff == ENDSESSION_LOGOFF) );
2253 if ( (this == wxTheApp->GetTopWindow()) && // Only send once
2254 wxTheApp->ProcessEvent(event))
2255 {
2256 }
2257 return TRUE;
2bda0e17
KB
2258}
2259
42e69d6b
VZ
2260// ---------------------------------------------------------------------------
2261// window creation/destruction
2262// ---------------------------------------------------------------------------
2263
2264bool wxWindow::HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate)
2bda0e17 2265{
42e69d6b
VZ
2266 // TODO: should generate this event from WM_NCCREATE
2267 wxWindowCreateEvent event(this);
2268 (void)GetEventHandler()->ProcessEvent(event);
a23fd0e1 2269
42e69d6b
VZ
2270 *mayCreate = TRUE;
2271
2272 return TRUE;
2bda0e17
KB
2273}
2274
42e69d6b 2275bool wxWindow::HandleDestroy()
2bda0e17 2276{
42e69d6b
VZ
2277 wxWindowDestroyEvent event(this);
2278 (void)GetEventHandler()->ProcessEvent(event);
2279
2280 // delete our drop target if we've got one
2281#if wxUSE_DRAG_AND_DROP
2282 if ( m_dropTarget != NULL )
2d0a075d 2283 {
42e69d6b
VZ
2284 m_dropTarget->Revoke(m_hWnd);
2285
2286 delete m_dropTarget;
2287 m_dropTarget = NULL;
2d0a075d 2288 }
42e69d6b 2289#endif // wxUSE_DRAG_AND_DROP
2bda0e17 2290
42e69d6b
VZ
2291 // WM_DESTROY handled
2292 return TRUE;
2bda0e17
KB
2293}
2294
42e69d6b
VZ
2295// ---------------------------------------------------------------------------
2296// activation/focus
2297// ---------------------------------------------------------------------------
2298
2299bool wxWindow::HandleActivate(int state,
2300 bool WXUNUSED(minimized),
2301 WXHWND WXUNUSED(activate))
2bda0e17 2302{
42e69d6b
VZ
2303 wxActivateEvent event(wxEVT_ACTIVATE,
2304 (state == WA_ACTIVE) || (state == WA_CLICKACTIVE),
2305 m_windowId);
2306 event.SetEventObject(this);
2307
2308 return GetEventHandler()->ProcessEvent(event);
2309}
2310
2311bool wxWindow::HandleSetFocus(WXHWND WXUNUSED(hwnd))
2312{
789295bf 2313#if wxUSE_CARET
42e69d6b 2314 // Deal with caret
789295bf 2315 if ( m_caret )
2d0a075d 2316 {
789295bf 2317 m_caret->OnSetFocus();
2bda0e17 2318 }
789295bf 2319#endif // wxUSE_CARET
42e69d6b
VZ
2320
2321 // panel wants to track the window which was the last to have focus in it
2322 wxWindow *parent = GetParent();
2323 if ( parent && parent->IsKindOf(CLASSINFO(wxPanel)) )
2324 {
2325 ((wxPanel *)parent)->SetLastFocus(GetId());
2326 }
2327
2328 wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
2329 event.SetEventObject(this);
2330
2331 return GetEventHandler()->ProcessEvent(event);
2bda0e17
KB
2332}
2333
42e69d6b 2334bool wxWindow::HandleKillFocus(WXHWND WXUNUSED(hwnd))
2bda0e17 2335{
789295bf 2336#if wxUSE_CARET
42e69d6b 2337 // Deal with caret
789295bf 2338 if ( m_caret )
2d0a075d 2339 {
789295bf 2340 m_caret->OnKillFocus();
2bda0e17 2341 }
789295bf 2342#endif // wxUSE_CARET
42e69d6b
VZ
2343
2344 wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
2345 event.SetEventObject(this);
2346
2347 return GetEventHandler()->ProcessEvent(event);
2bda0e17
KB
2348}
2349
42e69d6b
VZ
2350// ---------------------------------------------------------------------------
2351// miscellaneous
2352// ---------------------------------------------------------------------------
2353
2354bool wxWindow::HandleShow(bool show, int status)
2bda0e17 2355{
42e69d6b
VZ
2356 wxShowEvent event(GetId(), show);
2357 event.m_eventObject = this;
2358
2359 return GetEventHandler()->ProcessEvent(event);
2bda0e17
KB
2360}
2361
42e69d6b 2362bool wxWindow::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
2bda0e17 2363{
42e69d6b
VZ
2364 wxInitDialogEvent event(GetId());
2365 event.m_eventObject = this;
2366
2367 return GetEventHandler()->ProcessEvent(event);
2bda0e17
KB
2368}
2369
42e69d6b 2370bool wxWindow::HandleDropFiles(WXWPARAM wParam)
2bda0e17 2371{
42e69d6b
VZ
2372 HDROP hFilesInfo = (HDROP) wParam;
2373 POINT dropPoint;
2374 DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
2375
2376 // Get the total number of files dropped
2377 WORD gwFilesDropped = (WORD)DragQueryFile ((HDROP)hFilesInfo,
2378 (UINT)-1,
2379 (LPSTR)0,
2380 (UINT)0);
2381
2382 wxString *files = new wxString[gwFilesDropped];
2383 int wIndex;
2384 for (wIndex=0; wIndex < (int)gwFilesDropped; wIndex++)
2d0a075d 2385 {
42e69d6b
VZ
2386 DragQueryFile (hFilesInfo, wIndex, (LPSTR) wxBuffer, 1000);
2387 files[wIndex] = wxBuffer;
2d0a075d 2388 }
42e69d6b 2389 DragFinish (hFilesInfo);
2bda0e17 2390
42e69d6b
VZ
2391 wxDropFilesEvent event(wxEVT_DROP_FILES, gwFilesDropped, files);
2392 event.m_eventObject = this;
2393 event.m_pos.x = dropPoint.x; event.m_pos.x = dropPoint.y;
2394
2395 bool rc = GetEventHandler()->ProcessEvent(event);
2396
2397 delete[] files;
2398
2399 return rc;
2bda0e17
KB
2400}
2401
42e69d6b
VZ
2402bool wxWindow::HandleSetCursor(WXHWND hWnd,
2403 short nHitTest,
2404 int WXUNUSED(mouseMsg))
2bda0e17 2405{
42e69d6b
VZ
2406 // don't set cursor for other windows, only for this one: this prevents
2407 // children of this window from getting the same cursor as the parent has
2408 // (don't forget that this message is propagated by default up the window
2409 // parent-child hierarchy)
2410 if ( GetHWND() == hWnd )
2411 {
2412 // don't set cursor when the mouse is not in the client part
2413 if ( nHitTest == HTCLIENT || nHitTest == HTERROR )
2414 {
2415 HCURSOR hcursor = 0;
2416 if ( wxIsBusy() )
2417 {
2418 // from msw\utils.cpp
2419 extern HCURSOR gs_wxBusyCursor;
2420
2421 hcursor = gs_wxBusyCursor;
2422 }
2423 else
2424 {
2425 wxCursor *cursor = NULL;
2426
2427 if ( m_cursor.Ok() )
2428 {
2429 cursor = &m_cursor;
2430 }
2431 else
2432 {
2433 // from msw\data.cpp
2434 extern wxCursor *g_globalCursor;
2435
2436 if ( g_globalCursor && g_globalCursor->Ok() )
2437 cursor = g_globalCursor;
2438 }
2439
2440 if ( cursor )
2441 hcursor = (HCURSOR)cursor->GetHCURSOR();
2442 }
2443
2444 if ( hcursor )
2445 {
2446 ::SetCursor(hcursor);
2447
2448 return TRUE;
2449 }
2450 }
2451 }
2452
2453 return FALSE;
2bda0e17
KB
2454}
2455
42e69d6b
VZ
2456#if wxUSE_OWNER_DRAWN
2457// ---------------------------------------------------------------------------
2458// owner drawn stuff
2459// ---------------------------------------------------------------------------
2460
2461bool wxWindow::MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *itemStruct)
2bda0e17 2462{
42e69d6b
VZ
2463 // is it a menu item?
2464 if ( id == 0 )
2465 {
2466 DRAWITEMSTRUCT *pDrawStruct = (DRAWITEMSTRUCT *)itemStruct;
2467 wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
2468
2469 wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
2470
2471 // prepare to call OnDrawItem()
2472 wxDC dc;
2473 dc.SetHDC((WXHDC)pDrawStruct->hDC, FALSE);
2474 wxRect rect(pDrawStruct->rcItem.left, pDrawStruct->rcItem.top,
2475 pDrawStruct->rcItem.right - pDrawStruct->rcItem.left,
2476 pDrawStruct->rcItem.bottom - pDrawStruct->rcItem.top);
2477
2478 return pMenuItem->OnDrawItem
2479 (
2480 dc, rect,
2481 (wxOwnerDrawn::wxODAction)pDrawStruct->itemAction,
2482 (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
2483 );
2484 }
2485
2486 wxWindow *item = FindItem(id);
2487 if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
2488 {
2489 return ((wxControl *)item)->MSWOnDraw(itemStruct);
2490 }
2491 else
2492 return FALSE;
2bda0e17
KB
2493}
2494
42e69d6b 2495bool wxWindow::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
2bda0e17 2496{
42e69d6b
VZ
2497 // is it a menu item?
2498 if ( id == 0 )
2d0a075d 2499 {
42e69d6b
VZ
2500 MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
2501 wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
2502
2503 wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
2504
2505 return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
2506 &pMeasureStruct->itemHeight);
2d0a075d 2507 }
42e69d6b
VZ
2508
2509 wxWindow *item = FindItem(id);
2510 if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
2511 {
2512 return ((wxControl *)item)->MSWOnMeasure(itemStruct);
2513 }
2514
2515 return FALSE;
2bda0e17 2516}
42e69d6b 2517#endif // owner-drawn menus
2bda0e17 2518
42e69d6b
VZ
2519// ---------------------------------------------------------------------------
2520// colours and palettes
2521// ---------------------------------------------------------------------------
2bda0e17 2522
42e69d6b 2523bool wxWindow::HandleSysColorChange()
2bda0e17 2524{
42e69d6b
VZ
2525 wxSysColourChangedEvent event;
2526 event.SetEventObject(this);
2527
2528 return GetEventHandler()->ProcessEvent(event);
2529}
2530
2531bool wxWindow::HandleCtlColor(WXHBRUSH *brush,
2532 WXHDC pDC,
2533 WXHWND pWnd,
2534 WXUINT nCtlColor,
2535 WXUINT message,
2536 WXWPARAM wParam,
2537 WXLPARAM lParam)
2538{
2539 WXHBRUSH hBrush = 0;
2540
2541 if ( nCtlColor == CTLCOLOR_DLG )
2d0a075d 2542 {
42e69d6b 2543 hBrush = OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
2d0a075d
JS
2544 }
2545 else
2546 {
42e69d6b
VZ
2547 wxControl *item = (wxControl *)FindItemByHWND(pWnd, TRUE);
2548 if ( item )
2549 hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
2d0a075d 2550 }
42e69d6b
VZ
2551
2552 if ( hBrush )
2553 *brush = hBrush;
2554
2555 return hBrush != 0;
2bda0e17
KB
2556}
2557
42e69d6b
VZ
2558// Define for each class of dialog and control
2559WXHBRUSH wxWindow::OnCtlColor(WXHDC hDC,
2560 WXHWND hWnd,
2561 WXUINT nCtlColor,
2562 WXUINT message,
2563 WXWPARAM wParam,
2564 WXLPARAM lParam)
2bda0e17 2565{
42e69d6b
VZ
2566 return (WXHBRUSH)0;
2567}
2d0a075d 2568
42e69d6b
VZ
2569bool wxWindow::HandlePaletteChanged(WXHWND hWndPalChange)
2570{
2571 wxPaletteChangedEvent event(GetId());
2572 event.SetEventObject(this);
2573 event.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
2d0a075d 2574
42e69d6b
VZ
2575 return GetEventHandler()->ProcessEvent(event);
2576}
2577
2578bool wxWindow::HandleQueryNewPalette()
2579{
2580 wxQueryNewPaletteEvent event(GetId());
2581 event.SetEventObject(this);
2582
2583 return GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized();
2584}
2585
2586// Responds to colour changes: passes event on to children.
2587void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
2588{
2589 wxNode *node = GetChildren().First();
2590 while ( node )
2591 {
2592 // Only propagate to non-top-level windows
2593 wxWindow *win = (wxWindow *)node->Data();
2594 if ( win->GetParent() )
2595 {
2596 wxSysColourChangedEvent event2;
2597 event.m_eventObject = win;
2598 win->GetEventHandler()->ProcessEvent(event2);
564b2609 2599 }
42e69d6b
VZ
2600
2601 node = node->Next();
2bda0e17 2602 }
2bda0e17
KB
2603}
2604
42e69d6b
VZ
2605// ---------------------------------------------------------------------------
2606// painting
2607// ---------------------------------------------------------------------------
2608
2609bool wxWindow::HandlePaint()
2bda0e17 2610{
42e69d6b
VZ
2611#ifdef __WIN32__
2612 HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
2613 if ( !hRegion )
2614 wxLogLastError("CreateRectRgn");
2615 if ( ::GetUpdateRgn(GetHwnd(), hRegion, FALSE) == ERROR )
2616 wxLogLastError("GetUpdateRgn");
c085e333 2617
42e69d6b
VZ
2618 m_updateRegion = wxRegion((WXHRGN) hRegion);
2619#else
2620 RECT updateRect;
2621 ::GetUpdateRect(GetHwnd(), & updateRect, FALSE);
c085e333 2622
42e69d6b
VZ
2623 m_updateRegion = wxRegion(updateRect.left, updateRect.top,
2624 updateRect.right - updateRect.left,
2625 updateRect.bottom - updateRect.top);
2626#endif
c085e333 2627
42e69d6b
VZ
2628 wxPaintEvent event(m_windowId);
2629 event.SetEventObject(this);
2bda0e17 2630
42e69d6b 2631 return GetEventHandler()->ProcessEvent(event);
2bda0e17
KB
2632}
2633
42e69d6b 2634bool wxWindow::HandleEraseBkgnd(WXHDC hdc)
a23fd0e1 2635{
42e69d6b
VZ
2636 // Prevents flicker when dragging
2637 if ( ::IsIconic(GetHwnd()) )
2638 return TRUE;
a23fd0e1 2639
a23fd0e1 2640 wxDC dc;
c085e333 2641
a23fd0e1 2642 dc.SetHDC(hdc);
564b2609
VZ
2643 dc.SetWindow(this);
2644 dc.BeginDrawing();
c085e333 2645
2bda0e17 2646 wxEraseEvent event(m_windowId, &dc);
42e69d6b 2647 event.SetEventObject(this);
a23fd0e1 2648 bool rc = GetEventHandler()->ProcessEvent(event);
c085e333 2649
a23fd0e1
VZ
2650 dc.EndDrawing();
2651 dc.SelectOldObjects(hdc);
2bda0e17 2652 dc.SetHDC((WXHDC) NULL);
a23fd0e1
VZ
2653
2654 return rc;
2bda0e17
KB
2655}
2656
2657void wxWindow::OnEraseBackground(wxEraseEvent& event)
2658{
2d0a075d 2659 RECT rect;
a23fd0e1 2660 ::GetClientRect(GetHwnd(), &rect);
2bda0e17 2661
42e69d6b
VZ
2662 COLORREF ref = PALETTERGB(m_backgroundColour.Red(),
2663 m_backgroundColour.Green(),
2664 m_backgroundColour.Blue());
ce3ed50d 2665 HBRUSH hBrush = ::CreateSolidBrush(ref);
42e69d6b
VZ
2666 if ( !hBrush )
2667 wxLogLastError("CreateSolidBrush");
2668
2669 HDC hdc = (HDC)event.GetDC()->GetHDC();
2bda0e17 2670
42e69d6b
VZ
2671 int mode = ::SetMapMode(hdc, MM_TEXT);
2672
2673 ::FillRect(hdc, &rect, hBrush);
2d0a075d 2674 ::DeleteObject(hBrush);
42e69d6b
VZ
2675 ::SetMapMode(hdc, mode);
2676}
2677
2678// ---------------------------------------------------------------------------
2679// moving and resizing
2680// ---------------------------------------------------------------------------
2681
2682bool wxWindow::HandleMinimize()
2683{
2684 wxIconizeEvent event(m_windowId);
2685 event.SetEventObject(this);
2d0a075d 2686
42e69d6b 2687 return GetEventHandler()->ProcessEvent(event);
2bda0e17
KB
2688}
2689
42e69d6b 2690bool wxWindow::HandleMaximize()
2bda0e17 2691{
42e69d6b
VZ
2692 wxMaximizeEvent event(m_windowId);
2693 event.SetEventObject(this);
c085e333 2694
42e69d6b
VZ
2695 return GetEventHandler()->ProcessEvent(event);
2696}
2bda0e17 2697
42e69d6b
VZ
2698bool wxWindow::HandleMove(int x, int y)
2699{
2700 wxMoveEvent event(wxPoint(x, y), m_windowId);
2701 event.SetEventObject(this);
2702
2703 return GetEventHandler()->ProcessEvent(event);
2704}
2705
2706bool wxWindow::HandleSize(int w, int h, WXUINT WXUNUSED(flag))
2707{
2708 wxSizeEvent event(wxSize(w, h), m_windowId);
2709 event.SetEventObject(this);
2710
2711 return GetEventHandler()->ProcessEvent(event);
2712}
2713
2714bool wxWindow::HandleGetMinMaxInfo(void *mmInfo)
2715{
2716 MINMAXINFO *info = (MINMAXINFO *)mmInfo;
2717
2718 bool rc = FALSE;
2719
2720 if ( m_minWidth != -1 )
2d0a075d 2721 {
42e69d6b
VZ
2722 info->ptMinTrackSize.x = m_minWidth;
2723 rc = TRUE;
2d0a075d 2724 }
2bda0e17 2725
42e69d6b
VZ
2726 if ( m_minHeight != -1 )
2727 {
2728 info->ptMinTrackSize.y = m_minHeight;
2729 rc = TRUE;
2730 }
2bda0e17 2731
42e69d6b
VZ
2732 if ( m_maxWidth != -1 )
2733 {
2734 info->ptMaxTrackSize.x = m_maxWidth;
2735 rc = TRUE;
2d0a075d 2736 }
2bda0e17 2737
42e69d6b
VZ
2738 if ( m_maxHeight != -1 )
2739 {
2740 info->ptMaxTrackSize.y = m_maxHeight;
2741 rc = TRUE;
2742 }
2bda0e17 2743
42e69d6b
VZ
2744 return rc;
2745}
2d0a075d 2746
42e69d6b
VZ
2747// ---------------------------------------------------------------------------
2748// command messages
2749// ---------------------------------------------------------------------------
2750
2751bool wxWindow::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
2752{
2753 if ( wxCurrentPopupMenu )
2754 {
2755 wxMenu *popupMenu = wxCurrentPopupMenu;
2756 wxCurrentPopupMenu = NULL;
2757
2758 return popupMenu->MSWCommand(cmd, id);
2759 }
2760
2761 wxWindow *win = FindItem(id);
2762 if ( !win )
2763 {
2764 win = wxFindWinFromHandle(control);
2765 }
2766
2767 if ( win )
2768 return win->MSWCommand(cmd, id);
2769
2770 return FALSE;
2bda0e17
KB
2771}
2772
42e69d6b 2773bool wxWindow::HandleSysCommand(WXWPARAM wParam, WXLPARAM lParam)
2bda0e17 2774{
42e69d6b
VZ
2775 // 4 bits are reserved
2776 switch ( wParam & 0xFFFFFFF0 )
2777 {
2778 case SC_MAXIMIZE:
2779 return HandleMaximize();
2d0a075d 2780
42e69d6b
VZ
2781 case SC_MINIMIZE:
2782 return HandleMinimize();
2d0a075d 2783 }
2bda0e17 2784
42e69d6b
VZ
2785 return FALSE;
2786}
2787
2788// ---------------------------------------------------------------------------
2789// mouse events
2790// ---------------------------------------------------------------------------
2791
2792void wxWindow::InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags)
2793{
2794 event.m_x = x;
2795 event.m_y = y;
2796 event.m_shiftDown = ((flags & MK_SHIFT) != 0);
2797 event.m_controlDown = ((flags & MK_CONTROL) != 0);
2798 event.m_leftDown = ((flags & MK_LBUTTON) != 0);
2799 event.m_middleDown = ((flags & MK_MBUTTON) != 0);
2800 event.m_rightDown = ((flags & MK_RBUTTON) != 0);
2801 event.SetTimestamp(s_currentMsg.time);
2802 event.m_eventObject = this;
2803
2804#if wxUSE_MOUSEEVENT_HACK
2805 m_lastMouseX = x;
2806 m_lastMouseY = y;
2807 m_lastMouseEvent = event.GetEventType();
2808#endif // wxUSE_MOUSEEVENT_HACK
2bda0e17 2809
2bda0e17
KB
2810}
2811
42e69d6b 2812bool wxWindow::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
2bda0e17 2813{
42e69d6b
VZ
2814 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
2815 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
2816 // from the message id and take the value in the table to get wxWin event
2817 // id
2818 static const wxEventType eventsMouse[] =
2819 {
2820 wxEVT_MOTION,
2821 wxEVT_LEFT_DOWN,
2822 wxEVT_LEFT_UP,
2823 wxEVT_LEFT_DCLICK,
2824 wxEVT_RIGHT_DOWN,
2825 wxEVT_RIGHT_UP,
2826 wxEVT_RIGHT_DCLICK,
2827 wxEVT_MIDDLE_DOWN,
2828 wxEVT_MIDDLE_UP,
2829 wxEVT_MIDDLE_DCLICK
2830 };
2bda0e17 2831
42e69d6b
VZ
2832 wxMouseEvent event(eventsMouse[msg - WM_MOUSEMOVE]);
2833 InitMouseEvent(event, x, y, flags);
2834
2835 return GetEventHandler()->ProcessEvent(event);
2836}
2837
2838bool wxWindow::HandleMouseMove(int x, int y, WXUINT flags)
2839{
2840 if ( !m_mouseInWindow )
2bda0e17 2841 {
42e69d6b
VZ
2842 // Generate an ENTER event
2843 m_mouseInWindow = TRUE;
2844
2845 wxMouseEvent event(wxEVT_ENTER_WINDOW);
2846 InitMouseEvent(event, x, y, flags);
2847
2848 (void)GetEventHandler()->ProcessEvent(event);
2849 }
2850
2851#if wxUSE_MOUSEEVENT_HACK
2852 // Window gets a click down message followed by a mouse move message even
2853 // if position isn't changed! We want to discard the trailing move event
2854 // if x and y are the same.
2855 if ( (m_lastMouseEvent == wxEVT_RIGHT_DOWN ||
2856 m_lastMouseEvent == wxEVT_LEFT_DOWN ||
2857 m_lastMouseEvent == wxEVT_MIDDLE_DOWN) &&
2858 (m_lastMouseX == event.m_x && m_lastMouseY == event.m_y) )
2859 {
2860 m_lastMouseEvent = wxEVT_MOTION;
2861
2862 return FALSE;
2863 }
2864#endif // wxUSE_MOUSEEVENT_HACK
2865
2866 return HandleMouseEvent(WM_MOUSEMOVE, x, y, flags);
2867}
2868
2869// ---------------------------------------------------------------------------
2870// keyboard handling
2871// ---------------------------------------------------------------------------
2872
2873// isASCII is TRUE only when we're called from WM_CHAR handler and not from
2874// WM_KEYDOWN one
2875bool wxWindow::HandleChar(WXWORD wParam, WXLPARAM lParam, bool isASCII)
2876{
2877 int id;
2878 bool tempControlDown = FALSE;
2879 if ( isASCII )
2880 {
2881 // If 1 -> 26, translate to CTRL plus a letter.
2882 id = wParam;
2883 if ( (id > 0) && (id < 27) )
2d0a075d 2884 {
42e69d6b
VZ
2885 switch (id)
2886 {
2887 case 13:
2888 {
2889 id = WXK_RETURN;
2890 break;
2891 }
2892 case 8:
2893 {
2894 id = WXK_BACK;
2895 break;
2896 }
2897 case 9:
2898 {
2899 id = WXK_TAB;
2900 break;
2901 }
2902 default:
2903 {
2904 tempControlDown = TRUE;
2905 id = id + 96;
2906 }
2907 }
2d0a075d 2908 }
2d0a075d 2909 }
42e69d6b
VZ
2910 else if ( (id = wxCharCodeMSWToWX(wParam)) == 0 ) {
2911 // it's ASCII and will be processed here only when called from
2912 // WM_CHAR (i.e. when isASCII = TRUE)
2913 id = -1;
2914 }
2bda0e17 2915
42e69d6b 2916 if ( id != -1 )
2d0a075d 2917 {
42e69d6b
VZ
2918 wxKeyEvent event(wxEVT_CHAR);
2919 event.m_shiftDown = (::GetKeyState(VK_SHIFT)&0x100?TRUE:FALSE);
2920 event.m_controlDown = (::GetKeyState(VK_CONTROL)&0x100?TRUE:FALSE);
2921 if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
2922 event.m_altDown = TRUE;
2923
2924 event.m_eventObject = this;
2925 event.m_keyCode = id;
2926 event.SetTimestamp(s_currentMsg.time);
2927
2928 POINT pt;
2929 GetCursorPos(&pt);
2930 RECT rect;
2931 GetWindowRect(GetHwnd(),&rect);
2932 pt.x -= rect.left;
2933 pt.y -= rect.top;
2934
2935 event.m_x = pt.x; event.m_y = pt.y;
2936
2937 if ( GetEventHandler()->ProcessEvent(event) )
2938 return TRUE;
2939 else
2940 return FALSE;
2d0a075d
JS
2941 }
2942 else
42e69d6b 2943 return FALSE;
2bda0e17
KB
2944}
2945
42e69d6b 2946bool wxWindow::HandleKeyDown(WXWORD wParam, WXLPARAM lParam)
2bda0e17 2947{
42e69d6b 2948 int id;
2bda0e17 2949
42e69d6b
VZ
2950 if ( (id = wxCharCodeMSWToWX(wParam)) == 0 ) {
2951 id = wParam;
2952 }
2953
2954 if ( id != -1 )
2bda0e17 2955 {
42e69d6b
VZ
2956 wxKeyEvent event(wxEVT_KEY_DOWN);
2957 event.m_shiftDown = (::GetKeyState(VK_SHIFT)&0x100?TRUE:FALSE);
2958 event.m_controlDown = (::GetKeyState(VK_CONTROL)&0x100?TRUE:FALSE);
2959 if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
2960 event.m_altDown = TRUE;
2961
2962 event.m_eventObject = this;
2963 event.m_keyCode = id;
2964 event.SetTimestamp(s_currentMsg.time);
2965
2966 POINT pt;
2967 GetCursorPos(&pt);
2968 RECT rect;
2969 GetWindowRect(GetHwnd(),&rect);
2970 pt.x -= rect.left;
2971 pt.y -= rect.top;
2972
2973 event.m_x = pt.x; event.m_y = pt.y;
2974
2975 if ( GetEventHandler()->ProcessEvent(event) )
2d0a075d 2976 {
42e69d6b 2977 return TRUE;
2d0a075d 2978 }
42e69d6b 2979 else return FALSE;
2d0a075d
JS
2980 }
2981 else
42e69d6b
VZ
2982 {
2983 return FALSE;
2984 }
2bda0e17
KB
2985}
2986
42e69d6b 2987bool wxWindow::HandleKeyUp(WXWORD wParam, WXLPARAM lParam)
2bda0e17 2988{
42e69d6b 2989 int id;
2bda0e17 2990
42e69d6b
VZ
2991 if ( (id = wxCharCodeMSWToWX(wParam)) == 0 ) {
2992 id = wParam;
2d0a075d 2993 }
2bda0e17 2994
42e69d6b
VZ
2995 if ( id != -1 )
2996 {
2997 wxKeyEvent event(wxEVT_KEY_UP);
2998 event.m_shiftDown = (::GetKeyState(VK_SHIFT)&0x100?TRUE:FALSE);
2999 event.m_controlDown = (::GetKeyState(VK_CONTROL)&0x100?TRUE:FALSE);
3000 if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
3001 event.m_altDown = TRUE;
2bda0e17 3002
42e69d6b
VZ
3003 event.m_eventObject = this;
3004 event.m_keyCode = id;
3005 event.SetTimestamp(s_currentMsg.time);
2d0a075d 3006
42e69d6b
VZ
3007 POINT pt;
3008 GetCursorPos(&pt);
3009 RECT rect;
3010 GetWindowRect(GetHwnd(),&rect);
3011 pt.x -= rect.left;
3012 pt.y -= rect.top;
3013
3014 event.m_x = pt.x; event.m_y = pt.y;
3015
3016 if ( GetEventHandler()->ProcessEvent(event) )
3017 return TRUE;
3018 else
3019 return FALSE;
3020 }
3021 else
3022 return FALSE;
2bda0e17
KB
3023}
3024
42e69d6b
VZ
3025// ---------------------------------------------------------------------------
3026// joystick
3027// ---------------------------------------------------------------------------
3028
3029bool wxWindow::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
2bda0e17 3030{
42e69d6b
VZ
3031 int change = 0;
3032 if ( flags & JOY_BUTTON1CHG )
3033 change = wxJOY_BUTTON1;
3034 if ( flags & JOY_BUTTON2CHG )
3035 change = wxJOY_BUTTON2;
3036 if ( flags & JOY_BUTTON3CHG )
3037 change = wxJOY_BUTTON3;
3038 if ( flags & JOY_BUTTON4CHG )
3039 change = wxJOY_BUTTON4;
2bda0e17 3040
42e69d6b
VZ
3041 int buttons = 0;
3042 if ( flags & JOY_BUTTON1 )
3043 buttons |= wxJOY_BUTTON1;
3044 if ( flags & JOY_BUTTON2 )
3045 buttons |= wxJOY_BUTTON2;
3046 if ( flags & JOY_BUTTON3 )
3047 buttons |= wxJOY_BUTTON3;
3048 if ( flags & JOY_BUTTON4 )
3049 buttons |= wxJOY_BUTTON4;
c085e333 3050
42e69d6b
VZ
3051 // the event ids aren't consecutive so we can't use table based lookup
3052 int joystick;
3053 wxEventType eventType;
3054 switch ( msg )
3055 {
3056 case MM_JOY1MOVE:
3057 joystick = 1;
3058 eventType = wxEVT_JOY_MOVE;
3059 break;
2bda0e17 3060
42e69d6b
VZ
3061 case MM_JOY2MOVE:
3062 joystick = 2;
3063 eventType = wxEVT_JOY_MOVE;
3064 break;
2bda0e17 3065
42e69d6b
VZ
3066 case MM_JOY1ZMOVE:
3067 joystick = 1;
3068 eventType = wxEVT_JOY_ZMOVE;
3069 break;
2bda0e17 3070
42e69d6b
VZ
3071 case MM_JOY2ZMOVE:
3072 joystick = 2;
3073 eventType = wxEVT_JOY_ZMOVE;
3074 break;
2bda0e17 3075
42e69d6b
VZ
3076 case MM_JOY1BUTTONDOWN:
3077 joystick = 1;
3078 eventType = wxEVT_JOY_BUTTON_DOWN;
3079 break;
2bda0e17 3080
42e69d6b
VZ
3081 case MM_JOY2BUTTONDOWN:
3082 joystick = 2;
3083 eventType = wxEVT_JOY_BUTTON_DOWN;
3084 break;
2bda0e17 3085
42e69d6b
VZ
3086 case MM_JOY1BUTTONUP:
3087 joystick = 1;
3088 eventType = wxEVT_JOY_BUTTON_UP;
3089 break;
3090
3091 case MM_JOY2BUTTONUP:
3092 joystick = 2;
3093 eventType = wxEVT_JOY_BUTTON_UP;
3094 break;
3095
3096 default:
3097 wxFAIL_MSG("no such joystick event");
2d0a075d 3098
42e69d6b 3099 return FALSE;
2d0a075d 3100 }
2bda0e17 3101
42e69d6b
VZ
3102 wxJoystickEvent event(eventType, buttons, joystick, change);
3103 event.SetPosition(wxPoint(x, y));
3104 event.SetEventObject(this);
c085e333 3105
42e69d6b 3106 return GetEventHandler()->ProcessEvent(event);
2bda0e17
KB
3107}
3108
42e69d6b
VZ
3109// ---------------------------------------------------------------------------
3110// scrolling
3111// ---------------------------------------------------------------------------
3112
3113bool wxWindow::MSWOnScroll(int orientation, WXWORD wParam,
3114 WXWORD pos, WXHWND control)
2bda0e17 3115{
42e69d6b 3116 if ( control )
cc2b7472 3117 {
42e69d6b
VZ
3118 wxWindow *child = wxFindWinFromHandle(control);
3119 if ( child )
3120 return child->MSWOnScroll(orientation, wParam, pos, control);
cc2b7472 3121 }
2bda0e17 3122
9145664b 3123 wxScrollWinEvent event;
42e69d6b
VZ
3124 event.SetPosition(pos);
3125 event.SetOrientation(orientation);
3126 event.m_eventObject = this;
cc2b7472 3127
42e69d6b
VZ
3128 switch ( wParam )
3129 {
3130 case SB_TOP:
9145664b 3131 event.m_eventType = wxEVT_SCROLLWIN_TOP;
42e69d6b 3132 break;
cc2b7472 3133
42e69d6b 3134 case SB_BOTTOM:
9145664b 3135 event.m_eventType = wxEVT_SCROLLWIN_BOTTOM;
42e69d6b 3136 break;
cc2b7472 3137
42e69d6b 3138 case SB_LINEUP:
9145664b 3139 event.m_eventType = wxEVT_SCROLLWIN_LINEUP;
42e69d6b 3140 break;
2bda0e17 3141
42e69d6b 3142 case SB_LINEDOWN:
9145664b 3143 event.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
42e69d6b 3144 break;
a02eb1d2 3145
42e69d6b 3146 case SB_PAGEUP:
9145664b 3147 event.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
42e69d6b 3148 break;
2bda0e17 3149
42e69d6b 3150 case SB_PAGEDOWN:
9145664b 3151 event.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
42e69d6b 3152 break;
2bda0e17 3153
42e69d6b
VZ
3154 case SB_THUMBTRACK:
3155 case SB_THUMBPOSITION:
9145664b 3156 event.m_eventType = wxEVT_SCROLLWIN_THUMBTRACK;
42e69d6b 3157 break;
c085e333 3158
42e69d6b
VZ
3159 default:
3160 return FALSE;
564b2609 3161 }
2bda0e17 3162
42e69d6b 3163 return GetEventHandler()->ProcessEvent(event);
2bda0e17
KB
3164}
3165
42e69d6b
VZ
3166// ===========================================================================
3167// global functions
3168// ===========================================================================
3169
3170void wxGetCharSize(WXHWND wnd, int *x, int *y,wxFont *the_font)
2bda0e17 3171{
42e69d6b
VZ
3172 TEXTMETRIC tm;
3173 HDC dc = ::GetDC((HWND) wnd);
3174 HFONT fnt =0;
3175 HFONT was = 0;
3176 if ( the_font )
2d0a075d 3177 {
42e69d6b
VZ
3178 // the_font->UseResource();
3179 // the_font->RealizeResource();
3180 fnt = (HFONT)the_font->GetResourceHandle();
3181 if ( fnt )
3182 was = (HFONT) SelectObject(dc,fnt);
2d0a075d 3183 }
42e69d6b
VZ
3184 GetTextMetrics(dc, &tm);
3185 if ( the_font && fnt && was )
2d0a075d 3186 {
42e69d6b 3187 SelectObject(dc,was);
2d0a075d 3188 }
42e69d6b
VZ
3189 ReleaseDC((HWND)wnd, dc);
3190 *x = tm.tmAveCharWidth;
3191 *y = tm.tmHeight + tm.tmExternalLeading;
2bda0e17 3192
42e69d6b
VZ
3193 // if ( the_font )
3194 // the_font->ReleaseResource();
3195}
c085e333 3196
42e69d6b
VZ
3197// Returns 0 if was a normal ASCII value, not a special key. This indicates that
3198// the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
3199int wxCharCodeMSWToWX(int keySym)
3200{
3201 int id = 0;
3202 switch (keySym)
3203 {
3204 case VK_CANCEL: id = WXK_CANCEL; break;
3205 case VK_BACK: id = WXK_BACK; break;
3206 case VK_TAB: id = WXK_TAB; break;
3207 case VK_CLEAR: id = WXK_CLEAR; break;
3208 case VK_RETURN: id = WXK_RETURN; break;
3209 case VK_SHIFT: id = WXK_SHIFT; break;
3210 case VK_CONTROL: id = WXK_CONTROL; break;
3211 case VK_MENU : id = WXK_MENU; break;
3212 case VK_PAUSE: id = WXK_PAUSE; break;
3213 case VK_SPACE: id = WXK_SPACE; break;
3214 case VK_ESCAPE: id = WXK_ESCAPE; break;
3215 case VK_PRIOR: id = WXK_PRIOR; break;
3216 case VK_NEXT : id = WXK_NEXT; break;
3217 case VK_END: id = WXK_END; break;
3218 case VK_HOME : id = WXK_HOME; break;
3219 case VK_LEFT : id = WXK_LEFT; break;
3220 case VK_UP: id = WXK_UP; break;
3221 case VK_RIGHT: id = WXK_RIGHT; break;
3222 case VK_DOWN : id = WXK_DOWN; break;
3223 case VK_SELECT: id = WXK_SELECT; break;
3224 case VK_PRINT: id = WXK_PRINT; break;
3225 case VK_EXECUTE: id = WXK_EXECUTE; break;
3226 case VK_INSERT: id = WXK_INSERT; break;
3227 case VK_DELETE: id = WXK_DELETE; break;
3228 case VK_HELP : id = WXK_HELP; break;
3229 case VK_NUMPAD0: id = WXK_NUMPAD0; break;
3230 case VK_NUMPAD1: id = WXK_NUMPAD1; break;
3231 case VK_NUMPAD2: id = WXK_NUMPAD2; break;
3232 case VK_NUMPAD3: id = WXK_NUMPAD3; break;
3233 case VK_NUMPAD4: id = WXK_NUMPAD4; break;
3234 case VK_NUMPAD5: id = WXK_NUMPAD5; break;
3235 case VK_NUMPAD6: id = WXK_NUMPAD6; break;
3236 case VK_NUMPAD7: id = WXK_NUMPAD7; break;
3237 case VK_NUMPAD8: id = WXK_NUMPAD8; break;
3238 case VK_NUMPAD9: id = WXK_NUMPAD9; break;
3239 case VK_MULTIPLY: id = WXK_MULTIPLY; break;
3240 case VK_ADD: id = WXK_ADD; break;
3241 case VK_SUBTRACT: id = WXK_SUBTRACT; break;
3242 case VK_DECIMAL: id = WXK_DECIMAL; break;
3243 case VK_DIVIDE: id = WXK_DIVIDE; break;
3244 case VK_F1: id = WXK_F1; break;
3245 case VK_F2: id = WXK_F2; break;
3246 case VK_F3: id = WXK_F3; break;
3247 case VK_F4: id = WXK_F4; break;
3248 case VK_F5: id = WXK_F5; break;
3249 case VK_F6: id = WXK_F6; break;
3250 case VK_F7: id = WXK_F7; break;
3251 case VK_F8: id = WXK_F8; break;
3252 case VK_F9: id = WXK_F9; break;
3253 case VK_F10: id = WXK_F10; break;
3254 case VK_F11: id = WXK_F11; break;
3255 case VK_F12: id = WXK_F12; break;
3256 case VK_F13: id = WXK_F13; break;
3257 case VK_F14: id = WXK_F14; break;
3258 case VK_F15: id = WXK_F15; break;
3259 case VK_F16: id = WXK_F16; break;
3260 case VK_F17: id = WXK_F17; break;
3261 case VK_F18: id = WXK_F18; break;
3262 case VK_F19: id = WXK_F19; break;
3263 case VK_F20: id = WXK_F20; break;
3264 case VK_F21: id = WXK_F21; break;
3265 case VK_F22: id = WXK_F22; break;
3266 case VK_F23: id = WXK_F23; break;
3267 case VK_F24: id = WXK_F24; break;
3268 case VK_NUMLOCK: id = WXK_NUMLOCK; break;
3269 case VK_SCROLL: id = WXK_SCROLL; break;
3270 default:
3271 {
3272 return 0;
3273 }
3274 }
3275 return id;
2bda0e17
KB
3276}
3277
42e69d6b 3278int wxCharCodeWXToMSW(int id, bool *isVirtual)
2bda0e17 3279{
42e69d6b
VZ
3280 *isVirtual = TRUE;
3281 int keySym = 0;
3282 switch (id)
2bda0e17 3283 {
42e69d6b
VZ
3284 case WXK_CANCEL: keySym = VK_CANCEL; break;
3285 case WXK_CLEAR: keySym = VK_CLEAR; break;
3286 case WXK_SHIFT: keySym = VK_SHIFT; break;
3287 case WXK_CONTROL: keySym = VK_CONTROL; break;
3288 case WXK_MENU : keySym = VK_MENU; break;
3289 case WXK_PAUSE: keySym = VK_PAUSE; break;
3290 case WXK_PRIOR: keySym = VK_PRIOR; break;
3291 case WXK_NEXT : keySym = VK_NEXT; break;
3292 case WXK_END: keySym = VK_END; break;
3293 case WXK_HOME : keySym = VK_HOME; break;
3294 case WXK_LEFT : keySym = VK_LEFT; break;
3295 case WXK_UP: keySym = VK_UP; break;
3296 case WXK_RIGHT: keySym = VK_RIGHT; break;
3297 case WXK_DOWN : keySym = VK_DOWN; break;
3298 case WXK_SELECT: keySym = VK_SELECT; break;
3299 case WXK_PRINT: keySym = VK_PRINT; break;
3300 case WXK_EXECUTE: keySym = VK_EXECUTE; break;
3301 case WXK_INSERT: keySym = VK_INSERT; break;
3302 case WXK_DELETE: keySym = VK_DELETE; break;
3303 case WXK_HELP : keySym = VK_HELP; break;
3304 case WXK_NUMPAD0: keySym = VK_NUMPAD0; break;
3305 case WXK_NUMPAD1: keySym = VK_NUMPAD1; break;
3306 case WXK_NUMPAD2: keySym = VK_NUMPAD2; break;
3307 case WXK_NUMPAD3: keySym = VK_NUMPAD3; break;
3308 case WXK_NUMPAD4: keySym = VK_NUMPAD4; break;
3309 case WXK_NUMPAD5: keySym = VK_NUMPAD5; break;
3310 case WXK_NUMPAD6: keySym = VK_NUMPAD6; break;
3311 case WXK_NUMPAD7: keySym = VK_NUMPAD7; break;
3312 case WXK_NUMPAD8: keySym = VK_NUMPAD8; break;
3313 case WXK_NUMPAD9: keySym = VK_NUMPAD9; break;
3314 case WXK_MULTIPLY: keySym = VK_MULTIPLY; break;
3315 case WXK_ADD: keySym = VK_ADD; break;
3316 case WXK_SUBTRACT: keySym = VK_SUBTRACT; break;
3317 case WXK_DECIMAL: keySym = VK_DECIMAL; break;
3318 case WXK_DIVIDE: keySym = VK_DIVIDE; break;
3319 case WXK_F1: keySym = VK_F1; break;
3320 case WXK_F2: keySym = VK_F2; break;
3321 case WXK_F3: keySym = VK_F3; break;
3322 case WXK_F4: keySym = VK_F4; break;
3323 case WXK_F5: keySym = VK_F5; break;
3324 case WXK_F6: keySym = VK_F6; break;
3325 case WXK_F7: keySym = VK_F7; break;
3326 case WXK_F8: keySym = VK_F8; break;
3327 case WXK_F9: keySym = VK_F9; break;
3328 case WXK_F10: keySym = VK_F10; break;
3329 case WXK_F11: keySym = VK_F11; break;
3330 case WXK_F12: keySym = VK_F12; break;
3331 case WXK_F13: keySym = VK_F13; break;
3332 case WXK_F14: keySym = VK_F14; break;
3333 case WXK_F15: keySym = VK_F15; break;
3334 case WXK_F16: keySym = VK_F16; break;
3335 case WXK_F17: keySym = VK_F17; break;
3336 case WXK_F18: keySym = VK_F18; break;
3337 case WXK_F19: keySym = VK_F19; break;
3338 case WXK_F20: keySym = VK_F20; break;
3339 case WXK_F21: keySym = VK_F21; break;
3340 case WXK_F22: keySym = VK_F22; break;
3341 case WXK_F23: keySym = VK_F23; break;
3342 case WXK_F24: keySym = VK_F24; break;
3343 case WXK_NUMLOCK: keySym = VK_NUMLOCK; break;
3344 case WXK_SCROLL: keySym = VK_SCROLL; break;
3345 default:
3346 {
3347 *isVirtual = FALSE;
3348 keySym = id;
3349 break;
3350 }
2bda0e17 3351 }
42e69d6b 3352 return keySym;
2bda0e17
KB
3353}
3354
42e69d6b 3355wxWindow *wxGetActiveWindow()
2bda0e17 3356{
42e69d6b
VZ
3357 HWND hWnd = GetActiveWindow();
3358 if ( hWnd != 0 )
2d0a075d 3359 {
42e69d6b 3360 return wxFindWinFromHandle((WXHWND) hWnd);
2d0a075d 3361 }
42e69d6b 3362 return NULL;
2bda0e17
KB
3363}
3364
42e69d6b
VZ
3365// Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
3366// in active frames and dialogs, regardless of where the focus is.
3367static HHOOK wxTheKeyboardHook = 0;
3368static FARPROC wxTheKeyboardHookProc = 0;
3369int APIENTRY _EXPORT
3370wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
2bda0e17 3371
42e69d6b 3372void wxSetKeyboardHook(bool doIt)
2bda0e17 3373{
42e69d6b 3374 if ( doIt )
2d0a075d 3375 {
42e69d6b
VZ
3376 wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
3377 wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
3378#if defined(__WIN32__) && !defined(__TWIN32__)
3379 GetCurrentThreadId());
3380 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
3381#else
3382 GetCurrentTask());
3383#endif
2d0a075d 3384 }
2d0a075d 3385 else
2d0a075d 3386 {
42e69d6b
VZ
3387 UnhookWindowsHookEx(wxTheKeyboardHook);
3388 FreeProcInstance(wxTheKeyboardHookProc);
2d0a075d 3389 }
2bda0e17
KB
3390}
3391
42e69d6b
VZ
3392int APIENTRY _EXPORT
3393wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
2bda0e17 3394{
42e69d6b
VZ
3395 DWORD hiWord = HIWORD(lParam);
3396 if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
43d811ea 3397 {
42e69d6b
VZ
3398 int id;
3399 if ( (id = wxCharCodeMSWToWX(wParam)) != 0 )
43d811ea 3400 {
42e69d6b
VZ
3401 wxKeyEvent event(wxEVT_CHAR_HOOK);
3402 if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
3403 event.m_altDown = TRUE;
c085e333 3404
42e69d6b
VZ
3405 event.m_eventObject = NULL;
3406 event.m_keyCode = id;
3407 /* begin Albert's fix for control and shift key 26.5 */
3408 event.m_shiftDown = (::GetKeyState(VK_SHIFT)&0x100?TRUE:FALSE);
3409 event.m_controlDown = (::GetKeyState(VK_CONTROL)&0x100?TRUE:FALSE);
3410 /* end Albert's fix for control and shift key 26.5 */
3411 event.SetTimestamp(s_currentMsg.time);
c085e333 3412
42e69d6b
VZ
3413 wxWindow *win = wxGetActiveWindow();
3414 if ( win )
3415 {
3416 if ( win->GetEventHandler()->ProcessEvent(event) )
3417 return 1;
3418 }
3419 else
3420 {
3421 if ( wxTheApp && wxTheApp->ProcessEvent(event) )
3422 return 1;
3423 }
43d811ea
JS
3424 }
3425 }
42e69d6b 3426 return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
4fabb575
JS
3427}
3428
b2aef89b 3429#ifdef __WXDEBUG__
f449ef69 3430const char *wxGetMessageName(int message)
47cbd6da 3431{
42e69d6b
VZ
3432 switch ( message )
3433 {
3434 case 0x0000: return "WM_NULL";
3435 case 0x0001: return "WM_CREATE";
3436 case 0x0002: return "WM_DESTROY";
3437 case 0x0003: return "WM_MOVE";
3438 case 0x0005: return "WM_SIZE";
3439 case 0x0006: return "WM_ACTIVATE";
3440 case 0x0007: return "WM_SETFOCUS";
3441 case 0x0008: return "WM_KILLFOCUS";
3442 case 0x000A: return "WM_ENABLE";
3443 case 0x000B: return "WM_SETREDRAW";
3444 case 0x000C: return "WM_SETTEXT";
3445 case 0x000D: return "WM_GETTEXT";
3446 case 0x000E: return "WM_GETTEXTLENGTH";
3447 case 0x000F: return "WM_PAINT";
3448 case 0x0010: return "WM_CLOSE";
3449 case 0x0011: return "WM_QUERYENDSESSION";
3450 case 0x0012: return "WM_QUIT";
3451 case 0x0013: return "WM_QUERYOPEN";
3452 case 0x0014: return "WM_ERASEBKGND";
3453 case 0x0015: return "WM_SYSCOLORCHANGE";
3454 case 0x0016: return "WM_ENDSESSION";
3455 case 0x0017: return "WM_SYSTEMERROR";
3456 case 0x0018: return "WM_SHOWWINDOW";
3457 case 0x0019: return "WM_CTLCOLOR";
3458 case 0x001A: return "WM_WININICHANGE";
3459 case 0x001B: return "WM_DEVMODECHANGE";
3460 case 0x001C: return "WM_ACTIVATEAPP";
3461 case 0x001D: return "WM_FONTCHANGE";
3462 case 0x001E: return "WM_TIMECHANGE";
3463 case 0x001F: return "WM_CANCELMODE";
3464 case 0x0020: return "WM_SETCURSOR";
3465 case 0x0021: return "WM_MOUSEACTIVATE";
3466 case 0x0022: return "WM_CHILDACTIVATE";
3467 case 0x0023: return "WM_QUEUESYNC";
3468 case 0x0024: return "WM_GETMINMAXINFO";
3469 case 0x0026: return "WM_PAINTICON";
3470 case 0x0027: return "WM_ICONERASEBKGND";
3471 case 0x0028: return "WM_NEXTDLGCTL";
3472 case 0x002A: return "WM_SPOOLERSTATUS";
3473 case 0x002B: return "WM_DRAWITEM";
3474 case 0x002C: return "WM_MEASUREITEM";
3475 case 0x002D: return "WM_DELETEITEM";
3476 case 0x002E: return "WM_VKEYTOITEM";
3477 case 0x002F: return "WM_CHARTOITEM";
3478 case 0x0030: return "WM_SETFONT";
3479 case 0x0031: return "WM_GETFONT";
3480 case 0x0037: return "WM_QUERYDRAGICON";
3481 case 0x0039: return "WM_COMPAREITEM";
3482 case 0x0041: return "WM_COMPACTING";
3483 case 0x0044: return "WM_COMMNOTIFY";
3484 case 0x0046: return "WM_WINDOWPOSCHANGING";
3485 case 0x0047: return "WM_WINDOWPOSCHANGED";
3486 case 0x0048: return "WM_POWER";
c085e333 3487
a02eb1d2 3488#ifdef __WIN32__
42e69d6b
VZ
3489 case 0x004A: return "WM_COPYDATA";
3490 case 0x004B: return "WM_CANCELJOURNAL";
3491 case 0x004E: return "WM_NOTIFY";
3492 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
3493 case 0x0051: return "WM_INPUTLANGCHANGE";
3494 case 0x0052: return "WM_TCARD";
3495 case 0x0053: return "WM_HELP";
3496 case 0x0054: return "WM_USERCHANGED";
3497 case 0x0055: return "WM_NOTIFYFORMAT";
3498 case 0x007B: return "WM_CONTEXTMENU";
3499 case 0x007C: return "WM_STYLECHANGING";
3500 case 0x007D: return "WM_STYLECHANGED";
3501 case 0x007E: return "WM_DISPLAYCHANGE";
3502 case 0x007F: return "WM_GETICON";
3503 case 0x0080: return "WM_SETICON";
a02eb1d2 3504#endif //WIN32
c085e333 3505
42e69d6b
VZ
3506 case 0x0081: return "WM_NCCREATE";
3507 case 0x0082: return "WM_NCDESTROY";
3508 case 0x0083: return "WM_NCCALCSIZE";
3509 case 0x0084: return "WM_NCHITTEST";
3510 case 0x0085: return "WM_NCPAINT";
3511 case 0x0086: return "WM_NCACTIVATE";
3512 case 0x0087: return "WM_GETDLGCODE";
3513 case 0x00A0: return "WM_NCMOUSEMOVE";
3514 case 0x00A1: return "WM_NCLBUTTONDOWN";
3515 case 0x00A2: return "WM_NCLBUTTONUP";
3516 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
3517 case 0x00A4: return "WM_NCRBUTTONDOWN";
3518 case 0x00A5: return "WM_NCRBUTTONUP";
3519 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
3520 case 0x00A7: return "WM_NCMBUTTONDOWN";
3521 case 0x00A8: return "WM_NCMBUTTONUP";
3522 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
3523 case 0x0100: return "WM_KEYDOWN";
3524 case 0x0101: return "WM_KEYUP";
3525 case 0x0102: return "WM_CHAR";
3526 case 0x0103: return "WM_DEADCHAR";
3527 case 0x0104: return "WM_SYSKEYDOWN";
3528 case 0x0105: return "WM_SYSKEYUP";
3529 case 0x0106: return "WM_SYSCHAR";
3530 case 0x0107: return "WM_SYSDEADCHAR";
3531 case 0x0108: return "WM_KEYLAST";
c085e333 3532
a02eb1d2 3533#ifdef __WIN32__
42e69d6b
VZ
3534 case 0x010D: return "WM_IME_STARTCOMPOSITION";
3535 case 0x010E: return "WM_IME_ENDCOMPOSITION";
3536 case 0x010F: return "WM_IME_COMPOSITION";
a02eb1d2 3537#endif //WIN32
c085e333 3538
42e69d6b
VZ
3539 case 0x0110: return "WM_INITDIALOG";
3540 case 0x0111: return "WM_COMMAND";
3541 case 0x0112: return "WM_SYSCOMMAND";
3542 case 0x0113: return "WM_TIMER";
3543 case 0x0114: return "WM_HSCROLL";
3544 case 0x0115: return "WM_VSCROLL";
3545 case 0x0116: return "WM_INITMENU";
3546 case 0x0117: return "WM_INITMENUPOPUP";
3547 case 0x011F: return "WM_MENUSELECT";
3548 case 0x0120: return "WM_MENUCHAR";
3549 case 0x0121: return "WM_ENTERIDLE";
3550 case 0x0200: return "WM_MOUSEMOVE";
3551 case 0x0201: return "WM_LBUTTONDOWN";
3552 case 0x0202: return "WM_LBUTTONUP";
3553 case 0x0203: return "WM_LBUTTONDBLCLK";
3554 case 0x0204: return "WM_RBUTTONDOWN";
3555 case 0x0205: return "WM_RBUTTONUP";
3556 case 0x0206: return "WM_RBUTTONDBLCLK";
3557 case 0x0207: return "WM_MBUTTONDOWN";
3558 case 0x0208: return "WM_MBUTTONUP";
3559 case 0x0209: return "WM_MBUTTONDBLCLK";
3560 case 0x0210: return "WM_PARENTNOTIFY";
3561 case 0x0211: return "WM_ENTERMENULOOP";
3562 case 0x0212: return "WM_EXITMENULOOP";
c085e333 3563
a02eb1d2 3564#ifdef __WIN32__
42e69d6b
VZ
3565 case 0x0213: return "WM_NEXTMENU";
3566 case 0x0214: return "WM_SIZING";
3567 case 0x0215: return "WM_CAPTURECHANGED";
3568 case 0x0216: return "WM_MOVING";
3569 case 0x0218: return "WM_POWERBROADCAST";
3570 case 0x0219: return "WM_DEVICECHANGE";
a02eb1d2 3571#endif //WIN32
c085e333 3572
42e69d6b
VZ
3573 case 0x0220: return "WM_MDICREATE";
3574 case 0x0221: return "WM_MDIDESTROY";
3575 case 0x0222: return "WM_MDIACTIVATE";
3576 case 0x0223: return "WM_MDIRESTORE";
3577 case 0x0224: return "WM_MDINEXT";
3578 case 0x0225: return "WM_MDIMAXIMIZE";
3579 case 0x0226: return "WM_MDITILE";
3580 case 0x0227: return "WM_MDICASCADE";
3581 case 0x0228: return "WM_MDIICONARRANGE";
3582 case 0x0229: return "WM_MDIGETACTIVE";
3583 case 0x0230: return "WM_MDISETMENU";
3584 case 0x0233: return "WM_DROPFILES";
c085e333 3585
a02eb1d2 3586#ifdef __WIN32__
42e69d6b
VZ
3587 case 0x0281: return "WM_IME_SETCONTEXT";
3588 case 0x0282: return "WM_IME_NOTIFY";
3589 case 0x0283: return "WM_IME_CONTROL";
3590 case 0x0284: return "WM_IME_COMPOSITIONFULL";
3591 case 0x0285: return "WM_IME_SELECT";
3592 case 0x0286: return "WM_IME_CHAR";
3593 case 0x0290: return "WM_IME_KEYDOWN";
3594 case 0x0291: return "WM_IME_KEYUP";
a02eb1d2 3595#endif //WIN32
c085e333 3596
42e69d6b
VZ
3597 case 0x0300: return "WM_CUT";
3598 case 0x0301: return "WM_COPY";
3599 case 0x0302: return "WM_PASTE";
3600 case 0x0303: return "WM_CLEAR";
3601 case 0x0304: return "WM_UNDO";
3602 case 0x0305: return "WM_RENDERFORMAT";
3603 case 0x0306: return "WM_RENDERALLFORMATS";
3604 case 0x0307: return "WM_DESTROYCLIPBOARD";
3605 case 0x0308: return "WM_DRAWCLIPBOARD";
3606 case 0x0309: return "WM_PAINTCLIPBOARD";
3607 case 0x030A: return "WM_VSCROLLCLIPBOARD";
3608 case 0x030B: return "WM_SIZECLIPBOARD";
3609 case 0x030C: return "WM_ASKCBFORMATNAME";
3610 case 0x030D: return "WM_CHANGECBCHAIN";
3611 case 0x030E: return "WM_HSCROLLCLIPBOARD";
3612 case 0x030F: return "WM_QUERYNEWPALETTE";
3613 case 0x0310: return "WM_PALETTEISCHANGING";
3614 case 0x0311: return "WM_PALETTECHANGED";
c085e333 3615
a02eb1d2 3616#ifdef __WIN32__
2d0a075d
JS
3617 // common controls messages - although they're not strictly speaking
3618 // standard, it's nice to decode them nevertheless
a02eb1d2 3619
2d0a075d 3620 // listview
42e69d6b
VZ
3621 case 0x1000 + 0: return "LVM_GETBKCOLOR";
3622 case 0x1000 + 1: return "LVM_SETBKCOLOR";
3623 case 0x1000 + 2: return "LVM_GETIMAGELIST";
3624 case 0x1000 + 3: return "LVM_SETIMAGELIST";
3625 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
3626 case 0x1000 + 5: return "LVM_GETITEMA";
3627 case 0x1000 + 75: return "LVM_GETITEMW";
3628 case 0x1000 + 6: return "LVM_SETITEMA";
3629 case 0x1000 + 76: return "LVM_SETITEMW";
3630 case 0x1000 + 7: return "LVM_INSERTITEMA";
3631 case 0x1000 + 77: return "LVM_INSERTITEMW";
3632 case 0x1000 + 8: return "LVM_DELETEITEM";
3633 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
3634 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
3635 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
3636 case 0x1000 + 12: return "LVM_GETNEXTITEM";
3637 case 0x1000 + 13: return "LVM_FINDITEMA";
3638 case 0x1000 + 83: return "LVM_FINDITEMW";
3639 case 0x1000 + 14: return "LVM_GETITEMRECT";
3640 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
3641 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
3642 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
3643 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
3644 case 0x1000 + 18: return "LVM_HITTEST";
3645 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
3646 case 0x1000 + 20: return "LVM_SCROLL";
3647 case 0x1000 + 21: return "LVM_REDRAWITEMS";
3648 case 0x1000 + 22: return "LVM_ARRANGE";
3649 case 0x1000 + 23: return "LVM_EDITLABELA";
3650 case 0x1000 + 118: return "LVM_EDITLABELW";
3651 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
3652 case 0x1000 + 25: return "LVM_GETCOLUMNA";
3653 case 0x1000 + 95: return "LVM_GETCOLUMNW";
3654 case 0x1000 + 26: return "LVM_SETCOLUMNA";
3655 case 0x1000 + 96: return "LVM_SETCOLUMNW";
3656 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
3657 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
3658 case 0x1000 + 28: return "LVM_DELETECOLUMN";
3659 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
3660 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
3661 case 0x1000 + 31: return "LVM_GETHEADER";
3662 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
3663 case 0x1000 + 34: return "LVM_GETVIEWRECT";
3664 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
3665 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
3666 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
3667 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
3668 case 0x1000 + 39: return "LVM_GETTOPINDEX";
3669 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
3670 case 0x1000 + 41: return "LVM_GETORIGIN";
3671 case 0x1000 + 42: return "LVM_UPDATE";
3672 case 0x1000 + 43: return "LVM_SETITEMSTATE";
3673 case 0x1000 + 44: return "LVM_GETITEMSTATE";
3674 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
3675 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
3676 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
3677 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
3678 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
3679 case 0x1000 + 48: return "LVM_SORTITEMS";
3680 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
3681 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
3682 case 0x1000 + 51: return "LVM_GETITEMSPACING";
3683 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
3684 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
3685 case 0x1000 + 53: return "LVM_SETICONSPACING";
3686 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
3687 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
3688 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
3689 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
3690 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
3691 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
3692 case 0x1000 + 60: return "LVM_SETHOTITEM";
3693 case 0x1000 + 61: return "LVM_GETHOTITEM";
3694 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
3695 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
3696 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
3697 case 0x1000 + 65: return "LVM_SETWORKAREA";
c085e333 3698
2d0a075d 3699 // tree view
42e69d6b
VZ
3700 case 0x1100 + 0: return "TVM_INSERTITEMA";
3701 case 0x1100 + 50: return "TVM_INSERTITEMW";
3702 case 0x1100 + 1: return "TVM_DELETEITEM";
3703 case 0x1100 + 2: return "TVM_EXPAND";
3704 case 0x1100 + 4: return "TVM_GETITEMRECT";
3705 case 0x1100 + 5: return "TVM_GETCOUNT";
3706 case 0x1100 + 6: return "TVM_GETINDENT";
3707 case 0x1100 + 7: return "TVM_SETINDENT";
3708 case 0x1100 + 8: return "TVM_GETIMAGELIST";
3709 case 0x1100 + 9: return "TVM_SETIMAGELIST";
3710 case 0x1100 + 10: return "TVM_GETNEXTITEM";
3711 case 0x1100 + 11: return "TVM_SELECTITEM";
3712 case 0x1100 + 12: return "TVM_GETITEMA";
3713 case 0x1100 + 62: return "TVM_GETITEMW";
3714 case 0x1100 + 13: return "TVM_SETITEMA";
3715 case 0x1100 + 63: return "TVM_SETITEMW";
3716 case 0x1100 + 14: return "TVM_EDITLABELA";
3717 case 0x1100 + 65: return "TVM_EDITLABELW";
3718 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
3719 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
3720 case 0x1100 + 17: return "TVM_HITTEST";
3721 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
3722 case 0x1100 + 19: return "TVM_SORTCHILDREN";
3723 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
3724 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
3725 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
3726 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
3727 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
3728 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
3729 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
c085e333 3730
2d0a075d 3731 // header
42e69d6b
VZ
3732 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
3733 case 0x1200 + 1: return "HDM_INSERTITEMA";
3734 case 0x1200 + 10: return "HDM_INSERTITEMW";
3735 case 0x1200 + 2: return "HDM_DELETEITEM";
3736 case 0x1200 + 3: return "HDM_GETITEMA";
3737 case 0x1200 + 11: return "HDM_GETITEMW";
3738 case 0x1200 + 4: return "HDM_SETITEMA";
3739 case 0x1200 + 12: return "HDM_SETITEMW";
3740 case 0x1200 + 5: return "HDM_LAYOUT";
3741 case 0x1200 + 6: return "HDM_HITTEST";
3742 case 0x1200 + 7: return "HDM_GETITEMRECT";
3743 case 0x1200 + 8: return "HDM_SETIMAGELIST";
3744 case 0x1200 + 9: return "HDM_GETIMAGELIST";
3745 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
3746 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
3747 case 0x1200 + 17: return "HDM_GETORDERARRAY";
3748 case 0x1200 + 18: return "HDM_SETORDERARRAY";
3749 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
c085e333 3750
2d0a075d 3751 // tab control
42e69d6b
VZ
3752 case 0x1300 + 2: return "TCM_GETIMAGELIST";
3753 case 0x1300 + 3: return "TCM_SETIMAGELIST";
3754 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
3755 case 0x1300 + 5: return "TCM_GETITEMA";
3756 case 0x1300 + 60: return "TCM_GETITEMW";
3757 case 0x1300 + 6: return "TCM_SETITEMA";
3758 case 0x1300 + 61: return "TCM_SETITEMW";
3759 case 0x1300 + 7: return "TCM_INSERTITEMA";
3760 case 0x1300 + 62: return "TCM_INSERTITEMW";
3761 case 0x1300 + 8: return "TCM_DELETEITEM";
3762 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
3763 case 0x1300 + 10: return "TCM_GETITEMRECT";
3764 case 0x1300 + 11: return "TCM_GETCURSEL";
3765 case 0x1300 + 12: return "TCM_SETCURSEL";
3766 case 0x1300 + 13: return "TCM_HITTEST";
3767 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
3768 case 0x1300 + 40: return "TCM_ADJUSTRECT";
3769 case 0x1300 + 41: return "TCM_SETITEMSIZE";
3770 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
3771 case 0x1300 + 43: return "TCM_SETPADDING";
3772 case 0x1300 + 44: return "TCM_GETROWCOUNT";
3773 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
3774 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
3775 case 0x1300 + 47: return "TCM_GETCURFOCUS";
3776 case 0x1300 + 48: return "TCM_SETCURFOCUS";
3777 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
3778 case 0x1300 + 50: return "TCM_DESELECTALL";
c085e333 3779
2d0a075d 3780 // toolbar
42e69d6b
VZ
3781 case WM_USER+1: return "TB_ENABLEBUTTON";
3782 case WM_USER+2: return "TB_CHECKBUTTON";
3783 case WM_USER+3: return "TB_PRESSBUTTON";
3784 case WM_USER+4: return "TB_HIDEBUTTON";
3785 case WM_USER+5: return "TB_INDETERMINATE";
3786 case WM_USER+9: return "TB_ISBUTTONENABLED";
3787 case WM_USER+10: return "TB_ISBUTTONCHECKED";
3788 case WM_USER+11: return "TB_ISBUTTONPRESSED";
3789 case WM_USER+12: return "TB_ISBUTTONHIDDEN";
3790 case WM_USER+13: return "TB_ISBUTTONINDETERMINATE";
3791 case WM_USER+17: return "TB_SETSTATE";
3792 case WM_USER+18: return "TB_GETSTATE";
3793 case WM_USER+19: return "TB_ADDBITMAP";
3794 case WM_USER+20: return "TB_ADDBUTTONS";
3795 case WM_USER+21: return "TB_INSERTBUTTON";
3796 case WM_USER+22: return "TB_DELETEBUTTON";
3797 case WM_USER+23: return "TB_GETBUTTON";
3798 case WM_USER+24: return "TB_BUTTONCOUNT";
3799 case WM_USER+25: return "TB_COMMANDTOINDEX";
3800 case WM_USER+26: return "TB_SAVERESTOREA";
3801 case WM_USER+76: return "TB_SAVERESTOREW";
3802 case WM_USER+27: return "TB_CUSTOMIZE";
3803 case WM_USER+28: return "TB_ADDSTRINGA";
3804 case WM_USER+77: return "TB_ADDSTRINGW";
3805 case WM_USER+29: return "TB_GETITEMRECT";
3806 case WM_USER+30: return "TB_BUTTONSTRUCTSIZE";
3807 case WM_USER+31: return "TB_SETBUTTONSIZE";
3808 case WM_USER+32: return "TB_SETBITMAPSIZE";
3809 case WM_USER+33: return "TB_AUTOSIZE";
3810 case WM_USER+35: return "TB_GETTOOLTIPS";
3811 case WM_USER+36: return "TB_SETTOOLTIPS";
3812 case WM_USER+37: return "TB_SETPARENT";
3813 case WM_USER+39: return "TB_SETROWS";
3814 case WM_USER+40: return "TB_GETROWS";
3815 case WM_USER+42: return "TB_SETCMDID";
3816 case WM_USER+43: return "TB_CHANGEBITMAP";
3817 case WM_USER+44: return "TB_GETBITMAP";
3818 case WM_USER+45: return "TB_GETBUTTONTEXTA";
3819 case WM_USER+75: return "TB_GETBUTTONTEXTW";
3820 case WM_USER+46: return "TB_REPLACEBITMAP";
3821 case WM_USER+47: return "TB_SETINDENT";
3822 case WM_USER+48: return "TB_SETIMAGELIST";
3823 case WM_USER+49: return "TB_GETIMAGELIST";
3824 case WM_USER+50: return "TB_LOADIMAGES";
3825 case WM_USER+51: return "TB_GETRECT";
3826 case WM_USER+52: return "TB_SETHOTIMAGELIST";
3827 case WM_USER+53: return "TB_GETHOTIMAGELIST";
3828 case WM_USER+54: return "TB_SETDISABLEDIMAGELIST";
3829 case WM_USER+55: return "TB_GETDISABLEDIMAGELIST";
3830 case WM_USER+56: return "TB_SETSTYLE";
3831 case WM_USER+57: return "TB_GETSTYLE";
3832 case WM_USER+58: return "TB_GETBUTTONSIZE";
3833 case WM_USER+59: return "TB_SETBUTTONWIDTH";
3834 case WM_USER+60: return "TB_SETMAXTEXTROWS";
3835 case WM_USER+61: return "TB_GETTEXTROWS";
3836 case WM_USER+41: return "TB_GETBITMAPFLAGS";
c085e333 3837
a02eb1d2 3838#endif //WIN32
c085e333 3839
42e69d6b
VZ
3840 default:
3841 static char s_szBuf[128];
3842 sprintf(s_szBuf, "<unknown message = %d>", message);
3843 return s_szBuf;
3844 }
47cbd6da 3845}
ea57084d 3846#endif //__WXDEBUG__