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