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