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