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