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