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