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