1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/mgl/window.cpp
4 // Author: Vaclav Slavik
5 // (based on GTK & MSW implementations)
7 // Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
11 // ===========================================================================
13 // ===========================================================================
15 // ---------------------------------------------------------------------------
17 // ---------------------------------------------------------------------------
19 // For compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
26 #include "wx/window.h"
29 #include "wx/msgdlg.h"
32 #include "wx/dcclient.h"
38 #include "wx/dcscreen.h"
42 #if wxUSE_DRAG_AND_DROP
46 #include "wx/sysopt.h"
47 #include "wx/mgl/private.h"
53 #include "wx/tooltip.h"
56 // ---------------------------------------------------------------------------
58 // ---------------------------------------------------------------------------
60 // MGL window manager and associated DC.
61 winmng_t
*g_winMng
= NULL
;
62 MGLDevCtx
*g_displayDC
= NULL
;
64 // the window that has keyboard focus:
65 static wxWindowMGL
*gs_focusedWindow
= NULL
;
66 // the window that is about to be focused after currently focused
68 static wxWindow
*gs_toBeFocusedWindow
= NULL
;
69 // the window that is currently under mouse cursor:
70 static wxWindowMGL
*gs_windowUnderMouse
= NULL
;
71 // the window that has mouse capture
72 static wxWindowMGL
*gs_mouseCapture
= NULL
;
73 // the frame that is currently active (i.e. its child has focus). It is
74 // used to generate wxActivateEvents
75 static wxWindowMGL
*gs_activeFrame
= NULL
;
76 // track the mouse button state for wxGetMouseState()
77 unsigned long g_buttonState
= 0;
79 // ---------------------------------------------------------------------------
81 // ---------------------------------------------------------------------------
83 // Custom identifiers used to distinguish between various event handlers
84 // and capture handlers passed to MGL_wm
87 wxMGL_CAPTURE_MOUSE
= 1,
88 wxMGL_CAPTURE_KEYB
= 2
92 // ---------------------------------------------------------------------------
94 // ---------------------------------------------------------------------------
96 // Returns toplevel grandparent of given window:
97 static wxWindowMGL
* wxGetTopLevelParent(wxWindowMGL
*win
)
100 while (p
&& !p
->IsTopLevel())
105 // An easy way to capture screenshots:
106 static void wxCaptureScreenshot(bool activeWindowOnly
)
109 #define SCREENSHOT_FILENAME wxT("sshot%03i.png")
111 #define SCREENSHOT_FILENAME wxT("screenshot-%03i.png")
113 static int screenshot_num
= 0;
118 screenshot
.Printf(SCREENSHOT_FILENAME
, screenshot_num
++);
119 } while ( wxFileExists(screenshot
) && screenshot_num
< 1000 );
121 wxRect
r(0, 0, g_displayDC
->sizex(), g_displayDC
->sizey());
123 if ( activeWindowOnly
&& gs_activeFrame
)
125 r
.Intersect(gs_activeFrame
->GetRect());
128 g_displayDC
->savePNGFromDC(screenshot
.mb_str(),
129 r
.x
, r
. y
, r
.x
+r
.width
, r
.y
+r
.height
);
131 wxMessageBox(wxString::Format(wxT("Screenshot captured: %s"),
132 screenshot
.c_str()));
135 // ---------------------------------------------------------------------------
137 // ---------------------------------------------------------------------------
139 static void MGLAPI
wxWindowPainter(window_t
*wnd
, MGLDC
*dc
)
141 wxWindowMGL
*w
= (wxWindow
*) wnd
->userData
;
143 if ( w
&& !(w
->GetWindowStyle() & wxTRANSPARENT_WINDOW
) )
146 w
->HandlePaint(&ctx
);
150 static ibool MGLAPI
wxWindowMouseHandler(window_t
*wnd
, event_t
*e
)
152 wxWindowMGL
*win
= (wxWindowMGL
*)MGL_wmGetWindowUserData(wnd
);
153 wxPoint
orig(win
->GetClientAreaOrigin());
156 g_buttonState
= e
->modifiers
;
158 MGL_wmCoordGlobalToLocal(win
->GetHandle(),
159 e
->where_x
, e
->where_y
, &where
.x
, &where
.y
);
161 for (wxWindowMGL
*w
= win
; w
; w
= w
->GetParent())
163 if ( !w
->IsEnabled() )
165 if ( w
->IsTopLevel() )
169 wxEventType type
= wxEVT_NULL
;
171 event
.SetEventObject(win
);
172 event
.SetTimestamp(e
->when
);
173 event
.m_x
= where
.x
- orig
.x
;
174 event
.m_y
= where
.y
- orig
.y
;
175 event
.m_shiftDown
= ( e
->modifiers
& EVT_SHIFTKEY
) != 0;
176 event
.m_controlDown
= ( e
->modifiers
& EVT_CTRLSTATE
) != 0;
177 event
.m_altDown
= ( e
->modifiers
& EVT_LEFTALT
) != 0;
178 event
.m_metaDown
= ( e
->modifiers
& EVT_RIGHTALT
) != 0;
179 event
.m_leftDown
= ( e
->modifiers
& EVT_LEFTBUT
) != 0;
180 event
.m_middleDown
= ( e
->modifiers
& EVT_MIDDLEBUT
) != 0;
181 event
.m_rightDown
= ( e
->modifiers
& EVT_RIGHTBUT
) != 0;
186 // Change focus if the user clicks outside focused window:
187 if ( win
->CanAcceptFocus() && wxWindow::FindFocus() != win
)
190 if ( e
->message
& EVT_DBLCLICK
)
192 if ( e
->message
& EVT_LEFTBMASK
)
193 type
= wxEVT_LEFT_DCLICK
;
194 else if ( e
->message
& EVT_MIDDLEBMASK
)
195 type
= wxEVT_MIDDLE_DCLICK
;
196 else if ( e
->message
& EVT_RIGHTBMASK
)
197 type
= wxEVT_RIGHT_DCLICK
;
201 if ( e
->message
& EVT_LEFTBMASK
)
202 type
= wxEVT_LEFT_DOWN
;
203 else if ( e
->message
& EVT_MIDDLEBMASK
)
204 type
= wxEVT_MIDDLE_DOWN
;
205 else if ( e
->message
& EVT_RIGHTBMASK
)
206 type
= wxEVT_RIGHT_DOWN
;
212 if ( e
->message
& EVT_LEFTBMASK
)
213 type
= wxEVT_LEFT_UP
;
214 else if ( e
->message
& EVT_MIDDLEBMASK
)
215 type
= wxEVT_MIDDLE_UP
;
216 else if ( e
->message
& EVT_RIGHTBMASK
)
217 type
= wxEVT_RIGHT_UP
;
221 if ( !gs_mouseCapture
)
223 if ( win
!= gs_windowUnderMouse
)
225 if ( gs_windowUnderMouse
)
227 wxMouseEvent
event2(event
);
228 MGL_wmCoordGlobalToLocal(gs_windowUnderMouse
->GetHandle(),
229 e
->where_x
, e
->where_y
,
230 &event2
.m_x
, &event2
.m_y
);
232 wxPoint
orig(gs_windowUnderMouse
->GetClientAreaOrigin());
233 event2
.m_x
-= orig
.x
;
234 event2
.m_y
-= orig
.y
;
236 event2
.SetEventObject(gs_windowUnderMouse
);
237 event2
.SetEventType(wxEVT_LEAVE_WINDOW
);
238 gs_windowUnderMouse
->HandleWindowEvent(event2
);
241 wxMouseEvent
event3(event
);
242 event3
.SetEventType(wxEVT_ENTER_WINDOW
);
243 win
->HandleWindowEvent(event3
);
245 gs_windowUnderMouse
= win
;
248 else // gs_mouseCapture
250 bool inside
= (where
.x
>= 0 &&
252 where
.x
< win
->GetSize().x
&&
253 where
.y
< win
->GetSize().y
);
254 if ( (inside
&& gs_windowUnderMouse
!= win
) ||
255 (!inside
&& gs_windowUnderMouse
== win
) )
257 wxMouseEvent
evt(inside
?
258 wxEVT_ENTER_WINDOW
: wxEVT_LEAVE_WINDOW
);
259 evt
.SetEventObject(win
);
260 win
->HandleWindowEvent(evt
);
261 gs_windowUnderMouse
= inside
? win
: NULL
;
272 if ( type
== wxEVT_NULL
)
278 event
.SetEventType(type
);
279 return win
->HandleWindowEvent(event
);
283 static long wxScanToKeyCode(event_t
*event
, bool translate
)
285 // VS: make it __WXDEBUG__-only, since we have lots of wxLogTrace calls
286 // here and the arguments would be stored in non-debug executable even
287 // though wxLogTrace would be no-op...
289 #define KEY(mgl_key,wx_key) \
291 wxLogTrace(wxT("keyevents"), \
292 wxT("key " #mgl_key ", mapped to " #wx_key)); \
296 #define KEY(mgl_key,wx_key) \
297 case mgl_key: key = wx_key; break;
304 bool numlock
= (event
->modifiers
& EVT_NUMLOCK
) != 0;
306 switch ( EVT_scanCode(event
->message
) )
308 KEY (KB_padMinus
, WXK_NUMPAD_SUBTRACT
)
309 KEY (KB_padPlus
, WXK_NUMPAD_ADD
)
310 KEY (KB_padTimes
, WXK_NUMPAD_MULTIPLY
)
311 KEY (KB_padDivide
, WXK_NUMPAD_DIVIDE
)
312 KEY (KB_padCenter
, numlock
? WXK_NUMPAD5
: WXK_NUMPAD_SEPARATOR
) // ?
313 KEY (KB_padLeft
, numlock
? WXK_NUMPAD4
: WXK_NUMPAD_LEFT
)
314 KEY (KB_padRight
, numlock
? WXK_NUMPAD6
: WXK_NUMPAD_RIGHT
)
315 KEY (KB_padUp
, numlock
? WXK_NUMPAD8
: WXK_NUMPAD_UP
)
316 KEY (KB_padDown
, numlock
? WXK_NUMPAD2
: WXK_NUMPAD_DOWN
)
317 KEY (KB_padInsert
, numlock
? WXK_NUMPAD0
: WXK_NUMPAD_INSERT
)
318 KEY (KB_padDelete
, numlock
? WXK_DECIMAL
: WXK_NUMPAD_DELETE
)
319 KEY (KB_padHome
, numlock
? WXK_NUMPAD7
: WXK_NUMPAD_HOME
)
320 KEY (KB_padEnd
, numlock
? WXK_NUMPAD1
: WXK_NUMPAD_END
)
321 KEY (KB_padPageUp
, numlock
? WXK_NUMPAD9
: WXK_NUMPAD_PAGEUP
)
322 KEY (KB_padPageDown
, numlock
? WXK_NUMPAD3
: WXK_NUMPAD_PAGEDOWN
)
333 KEY (KB_minus
, WXK_SUBTRACT
)
334 KEY (KB_equals
, WXK_ADD
)
335 KEY (KB_backSlash
, '\\')
346 KEY (KB_leftSquareBrace
,'[')
347 KEY (KB_rightSquareBrace
,']')
357 KEY (KB_semicolon
, ';')
358 KEY (KB_apostrophe
, '\'')
368 KEY (KB_divide
, WXK_DIVIDE
)
369 KEY (KB_space
, WXK_SPACE
)
378 switch ( EVT_scanCode(event
->message
) )
380 KEY (KB_padEnter
, WXK_NUMPAD_ENTER
)
390 KEY (KB_F10
, WXK_F10
)
391 KEY (KB_F11
, WXK_F11
)
392 KEY (KB_F12
, WXK_F12
)
393 KEY (KB_left
, WXK_LEFT
)
394 KEY (KB_right
, WXK_RIGHT
)
396 KEY (KB_down
, WXK_DOWN
)
397 KEY (KB_insert
, WXK_INSERT
)
398 KEY (KB_delete
, WXK_DELETE
)
399 KEY (KB_home
, WXK_HOME
)
400 KEY (KB_end
, WXK_END
)
401 KEY (KB_pageUp
, WXK_PAGEUP
)
402 KEY (KB_pageDown
, WXK_PAGEDOWN
)
403 KEY (KB_capsLock
, WXK_CAPITAL
)
404 KEY (KB_numLock
, WXK_NUMLOCK
)
405 KEY (KB_scrollLock
, WXK_SCROLL
)
406 KEY (KB_leftShift
, WXK_SHIFT
)
407 KEY (KB_rightShift
, WXK_SHIFT
)
408 KEY (KB_leftCtrl
, WXK_CONTROL
)
409 KEY (KB_rightCtrl
, WXK_CONTROL
)
410 KEY (KB_leftAlt
, WXK_ALT
)
411 KEY (KB_rightAlt
, WXK_ALT
)
412 KEY (KB_leftWindows
, WXK_START
)
413 KEY (KB_rightWindows
, WXK_START
)
414 KEY (KB_menu
, WXK_MENU
)
415 KEY (KB_sysReq
, WXK_SNAPSHOT
)
416 KEY (KB_esc
, WXK_ESCAPE
)
417 KEY (KB_backspace
, WXK_BACK
)
418 KEY (KB_tab
, WXK_TAB
)
419 KEY (KB_enter
, WXK_RETURN
)
422 key
= EVT_asciiCode(event
->message
);
432 static bool wxHandleSpecialKeys(wxKeyEvent
& event
)
434 // Add an easy way to capture screenshots:
435 if ( event
.m_keyCode
== WXK_SNAPSHOT
436 #ifdef __WXDEBUG__ // FIXME_MGL - remove when KB_sysReq works in MGL!
437 || (event
.m_keyCode
== WXK_F1
&&
438 event
.m_shiftDown
&& event
.m_controlDown
)
442 wxCaptureScreenshot(event
.m_altDown
/*only active wnd?*/);
449 static ibool MGLAPI
wxWindowKeybHandler(window_t
*wnd
, event_t
*e
)
451 wxWindowMGL
*win
= (wxWindowMGL
*)MGL_wmGetWindowUserData(wnd
);
453 if ( !win
->IsEnabled() ) return FALSE
;
456 MGL_wmCoordGlobalToLocal(win
->GetHandle(),
457 e
->where_x
, e
->where_y
, &where
.x
, &where
.y
);
460 event
.SetEventObject(win
);
461 event
.SetTimestamp(e
->when
);
462 event
.m_keyCode
= wxScanToKeyCode(e
, true);
465 event
.m_shiftDown
= ( e
->modifiers
& EVT_SHIFTKEY
) != 0;
466 event
.m_controlDown
= ( e
->modifiers
& EVT_CTRLSTATE
) != 0;
467 event
.m_altDown
= ( e
->modifiers
& EVT_LEFTALT
) != 0;
468 event
.m_metaDown
= ( e
->modifiers
& EVT_RIGHTALT
) != 0;
470 if ( e
->what
== EVT_KEYUP
)
472 event
.SetEventType(wxEVT_KEY_UP
);
473 return win
->HandleWindowEvent(event
);
480 event
.SetEventType(wxEVT_KEY_DOWN
);
483 ret
= win
->HandleWindowEvent(event
);
485 // wxMSW doesn't send char events with Alt pressed
486 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
487 // will only be sent if it is not in an accelerator table:
488 event2
.m_keyCode
= wxScanToKeyCode(e
, false);
489 if ( !ret
&& event2
.m_keyCode
!= 0 )
491 event2
.SetEventType(wxEVT_CHAR
);
492 ret
= win
->HandleWindowEvent(event2
);
495 // Synthetize navigation key event, but do it only if the TAB key
496 // wasn't handled yet:
497 if ( !ret
&& event
.m_keyCode
== WXK_TAB
&&
498 win
->GetParent() && win
->GetParent()->HasFlag(wxTAB_TRAVERSAL
) )
500 wxNavigationKeyEvent navEvent
;
501 navEvent
.SetEventObject(win
->GetParent());
502 // Shift-TAB goes in reverse direction:
503 navEvent
.SetDirection(!event
.m_shiftDown
);
504 // Ctrl-TAB changes the (parent) window, i.e. switch notebook page:
505 navEvent
.SetWindowChange(event
.m_controlDown
);
506 navEvent
.SetCurrentFocus(wxStaticCast(win
, wxWindow
));
507 ret
= win
->HandleWindowEvent(navEvent
);
510 // Finally, process special meaning keys that are usually
511 // a responsibility of OS or window manager:
513 ret
= wxHandleSpecialKeys(event
);
519 // ---------------------------------------------------------------------------
521 // ---------------------------------------------------------------------------
523 // in wxUniv this class is abstract because it doesn't have DoPopupMenu()
524 IMPLEMENT_ABSTRACT_CLASS(wxWindowMGL
, wxWindowBase
)
526 BEGIN_EVENT_TABLE(wxWindowMGL
, wxWindowBase
)
529 // ===========================================================================
531 // ===========================================================================
533 // ----------------------------------------------------------------------------
534 // constructors and such
535 // ----------------------------------------------------------------------------
537 extern wxVideoMode
wxGetDefaultDisplayMode();
539 void wxWindowMGL::Init()
541 // First of all, make sure window manager is up and running. If it is
542 // not the case, initialize it in default display mode
545 if ( !wxTheApp
->SetDisplayMode(wxGetDefaultDisplayMode()) )
547 wxLogFatalError(_("Cannot initialize display."));
555 m_eraseBackground
= -1;
559 wxWindowMGL::~wxWindowMGL()
563 if ( gs_mouseCapture
== this )
566 if (gs_activeFrame
== this)
568 gs_activeFrame
= NULL
;
569 // activate next frame in Z-order:
572 wxWindowMGL
*win
= (wxWindowMGL
*)m_wnd
->prev
->userData
;
575 else if ( m_wnd
->next
)
577 wxWindowMGL
*win
= (wxWindowMGL
*)m_wnd
->next
->userData
;
582 if ( gs_focusedWindow
== this )
585 if ( gs_windowUnderMouse
== this )
586 gs_windowUnderMouse
= NULL
;
591 MGL_wmDestroyWindow(m_wnd
);
594 // real construction (Init() must have been called before!)
595 bool wxWindowMGL::Create(wxWindow
*parent
,
600 const wxString
& name
)
602 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
606 parent
->AddChild(this);
609 x
= pos
.x
, y
= pos
.y
;
611 x
= 0; // FIXME_MGL, something better, see GTK+
613 y
= 0; // FIXME_MGL, something better, see GTK+
614 AdjustForParentClientOrigin(x
, y
, 0);
615 w
= WidthDefault(size
.x
);
616 h
= HeightDefault(size
.y
);
619 window_t
*wnd_parent
= parent
? parent
->GetHandle() : NULL
;
621 if ( style
& wxFULL_REPAINT_ON_RESIZE
)
623 mgl_style
|= MGL_WM_FULL_REPAINT_ON_RESIZE
;
625 if ( style
& wxSTAY_ON_TOP
)
627 mgl_style
|= MGL_WM_ALWAYS_ON_TOP
;
629 if ( style
& wxPOPUP_WINDOW
)
631 mgl_style
|= MGL_WM_ALWAYS_ON_TOP
;
632 // it is created hidden as other top level windows
637 window_t
*wnd
= MGL_wmCreateWindow(g_winMng
, wnd_parent
, x
, y
, w
, h
);
639 MGL_wmSetWindowFlags(wnd
, mgl_style
);
640 MGL_wmShowWindow(wnd
, m_isShown
);
647 void wxWindowMGL::SetMGLwindow_t(struct window_t
*wnd
)
650 MGL_wmDestroyWindow(m_wnd
);
653 if ( !m_wnd
) return;
655 m_isShown
= (bool)m_wnd
->visible
;
657 MGL_wmSetWindowUserData(m_wnd
, (void*) this);
658 MGL_wmSetWindowPainter(m_wnd
, wxWindowPainter
);
659 MGL_wmPushWindowEventHandler(m_wnd
, wxWindowMouseHandler
, EVT_MOUSEEVT
, 0);
660 MGL_wmPushWindowEventHandler(m_wnd
, wxWindowKeybHandler
, EVT_KEYEVT
, 0);
662 if ( m_cursor
.IsOk() )
663 MGL_wmSetWindowCursor(m_wnd
, *m_cursor
.GetMGLCursor());
665 MGL_wmSetWindowCursor(m_wnd
, *wxSTANDARD_CURSOR
->GetMGLCursor());
668 // ---------------------------------------------------------------------------
670 // ---------------------------------------------------------------------------
672 void wxWindowMGL::SetFocus()
674 if ( gs_focusedWindow
== this ) return;
676 wxWindowMGL
*oldFocusedWindow
= gs_focusedWindow
;
678 if ( gs_focusedWindow
)
680 gs_toBeFocusedWindow
= (wxWindow
*)this;
681 gs_focusedWindow
->KillFocus();
682 gs_toBeFocusedWindow
= NULL
;
685 gs_focusedWindow
= this;
687 MGL_wmCaptureEvents(GetHandle(), EVT_KEYEVT
, wxMGL_CAPTURE_KEYB
);
689 wxWindowMGL
*active
= wxGetTopLevelParent(this);
690 if ( !(m_windowStyle
& wxPOPUP_WINDOW
) && active
!= gs_activeFrame
)
692 if ( gs_activeFrame
)
694 wxActivateEvent
event(wxEVT_ACTIVATE
, false, gs_activeFrame
->GetId());
695 event
.SetEventObject(gs_activeFrame
);
696 gs_activeFrame
->HandleWindowEvent(event
);
699 gs_activeFrame
= active
;
700 wxActivateEvent
event(wxEVT_ACTIVATE
, true, gs_activeFrame
->GetId());
701 event
.SetEventObject(gs_activeFrame
);
702 gs_activeFrame
->HandleWindowEvent(event
);
705 // notify the parent keeping track of focus for the kbd navigation
706 // purposes that we got it
707 wxChildFocusEvent
eventFocus((wxWindow
*)this);
708 HandleWindowEvent(eventFocus
);
710 wxFocusEvent
event(wxEVT_SET_FOCUS
, GetId());
711 event
.SetEventObject(this);
712 event
.SetWindow((wxWindow
*)oldFocusedWindow
);
713 HandleWindowEvent(event
);
716 // caret needs to be informed about focus change
717 wxCaret
*caret
= GetCaret();
720 #endif // wxUSE_CARET
723 void wxWindowMGL::KillFocus()
725 if ( gs_focusedWindow
!= this ) return;
726 gs_focusedWindow
= NULL
;
728 if ( m_isBeingDeleted
) return;
730 MGL_wmUncaptureEvents(GetHandle(), wxMGL_CAPTURE_KEYB
);
733 // caret needs to be informed about focus change
734 wxCaret
*caret
= GetCaret();
736 caret
->OnKillFocus();
737 #endif // wxUSE_CARET
739 wxFocusEvent
event(wxEVT_KILL_FOCUS
, GetId());
740 event
.SetEventObject(this);
741 event
.SetWindow(gs_toBeFocusedWindow
);
742 HandleWindowEvent(event
);
745 // ----------------------------------------------------------------------------
746 // this wxWindowBase function is implemented here (in platform-specific file)
747 // because it is static and so couldn't be made virtual
748 // ----------------------------------------------------------------------------
749 wxWindow
*wxWindowBase::DoFindFocus()
751 return (wxWindow
*)gs_focusedWindow
;
754 bool wxWindowMGL::Show(bool show
)
756 if ( !wxWindowBase::Show(show
) )
759 MGL_wmShowWindow(m_wnd
, show
);
761 if (!show
&& gs_activeFrame
== this)
763 // activate next frame in Z-order:
766 wxWindowMGL
*win
= (wxWindowMGL
*)m_wnd
->prev
->userData
;
769 else if ( m_wnd
->next
)
771 wxWindowMGL
*win
= (wxWindowMGL
*)m_wnd
->next
->userData
;
776 gs_activeFrame
= NULL
;
783 // Raise the window to the top of the Z order
784 void wxWindowMGL::Raise()
786 MGL_wmRaiseWindow(m_wnd
);
789 // Lower the window to the bottom of the Z order
790 void wxWindowMGL::Lower()
792 MGL_wmLowerWindow(m_wnd
);
795 void wxWindowMGL::DoCaptureMouse()
797 if ( gs_mouseCapture
)
798 MGL_wmUncaptureEvents(gs_mouseCapture
->m_wnd
, wxMGL_CAPTURE_MOUSE
);
800 gs_mouseCapture
= this;
801 MGL_wmCaptureEvents(m_wnd
, EVT_MOUSEEVT
, wxMGL_CAPTURE_MOUSE
);
804 void wxWindowMGL::DoReleaseMouse()
806 wxASSERT_MSG( gs_mouseCapture
== this, wxT("attempt to release mouse, but this window hasn't captured it") );
808 MGL_wmUncaptureEvents(m_wnd
, wxMGL_CAPTURE_MOUSE
);
809 gs_mouseCapture
= NULL
;
812 /* static */ wxWindow
*wxWindowBase::GetCapture()
814 return (wxWindow
*)gs_mouseCapture
;
817 bool wxWindowMGL::SetCursor(const wxCursor
& cursor
)
819 if ( !wxWindowBase::SetCursor(cursor
) )
825 if ( m_cursor
.IsOk() )
826 MGL_wmSetWindowCursor(m_wnd
, *m_cursor
.GetMGLCursor());
828 MGL_wmSetWindowCursor(m_wnd
, *wxSTANDARD_CURSOR
->GetMGLCursor());
833 void wxWindowMGL::WarpPointer(int x
, int y
)
836 wxDisplaySize(&w
, &h
);
838 ClientToScreen(&x
, &y
);
848 EVT_setMousePos(x
, y
);
851 // Set this window to be the child of 'parent'.
852 bool wxWindowMGL::Reparent(wxWindowBase
*parent
)
854 if ( !wxWindowBase::Reparent(parent
) )
857 MGL_wmReparentWindow(m_wnd
, parent
->GetHandle());
863 // ---------------------------------------------------------------------------
865 // ---------------------------------------------------------------------------
867 #if wxUSE_DRAG_AND_DROP
869 void wxWindowMGL::SetDropTarget(wxDropTarget
*pDropTarget
)
871 if ( m_dropTarget
!= 0 ) {
872 m_dropTarget
->Revoke(m_hWnd
);
876 m_dropTarget
= pDropTarget
;
877 if ( m_dropTarget
!= 0 )
878 m_dropTarget
->Register(m_hWnd
);
881 #endif // wxUSE_DRAG_AND_DROP
883 // old style file-manager drag&drop support: we retain the old-style
884 // DragAcceptFiles in parallel with SetDropTarget.
885 void wxWindowMGL::DragAcceptFiles(bool WXUNUSED(accept
))
888 HWND hWnd
= GetHwnd();
890 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
894 // ---------------------------------------------------------------------------
895 // moving and resizing
896 // ---------------------------------------------------------------------------
899 void wxWindowMGL::DoGetSize(int *x
, int *y
) const
901 wxASSERT_MSG( m_wnd
, wxT("invalid window") );
903 if (x
) *x
= m_wnd
->width
;
904 if (y
) *y
= m_wnd
->height
;
907 void wxWindowMGL::DoGetPosition(int *x
, int *y
) const
909 wxASSERT_MSG( m_wnd
, wxT("invalid window") );
912 AdjustForParentClientOrigin(pX
, pY
, 0);
914 if (x
) *x
= m_wnd
->x
- pX
;
915 if (y
) *y
= m_wnd
->y
- pY
;
918 void wxWindowMGL::DoScreenToClient(int *x
, int *y
) const
921 MGL_wmCoordGlobalToLocal(m_wnd
, 0, 0, &ax
, &ay
);
928 void wxWindowMGL::DoClientToScreen(int *x
, int *y
) const
931 MGL_wmCoordLocalToGlobal(m_wnd
, 0, 0, &ax
, &ay
);
938 // Get size *available for subwindows* i.e. excluding menu bar etc.
939 void wxWindowMGL::DoGetClientSize(int *x
, int *y
) const
944 void wxWindowMGL::DoMoveWindow(int x
, int y
, int width
, int height
)
946 wxRect
rcClient(GetClientRect());
948 MGL_wmSetWindowPosition(m_wnd
, x
, y
, width
, height
);
950 // When the origin or a window stays fixed but the height or width
951 // changes, invalidate the old and new non-client areas
952 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) &&
953 m_wnd
->x
== x
&& m_wnd
->y
== y
&&
954 rcClient
.Intersect(GetClientRect()) != wxRect(0, 0, width
, height
) )
956 wxRegion
rgn(0, 0, width
, height
);
957 rgn
.Subtract(rcClient
);
959 // This should work I think, but doesn't seem to:
960 //MGL_wmInvalidateWindowRegion(m_wnd, rgn.GetMGLRegion().rgnPointer());
962 // Use MGL_wmInvalidateWindowRect instead:
963 for (wxRegionIterator
it(rgn
); it
; it
++)
968 rc
.right
= rc
.left
+ it
.GetW();
969 rc
.bottom
= rc
.top
+ it
.GetH();
970 MGL_wmInvalidateWindowRect(m_wnd
, &rc
);
975 // set the size of the window: if the dimensions are positive, just use them,
976 // but if any of them is equal to -1, it means that we must find the value for
977 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
978 // which case -1 is a valid value for x and y)
980 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
981 // the width/height to best suit our contents, otherwise we reuse the current
983 void wxWindowMGL::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
985 // get the current size and position...
986 int currentX
, currentY
;
987 GetPosition(¤tX
, ¤tY
);
988 int currentW
,currentH
;
989 GetSize(¤tW
, ¤tH
);
991 // ... and don't do anything (avoiding flicker) if it's already ok
992 if ( x
== currentX
&& y
== currentY
&&
993 width
== currentW
&& height
== currentH
)
998 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1000 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1003 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1005 wxSize
size(-1, -1);
1008 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1010 size
= DoGetBestSize();
1015 // just take the current one
1022 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1026 size
= DoGetBestSize();
1028 //else: already called DoGetBestSize() above
1034 // just take the current one
1039 int maxWidth
= GetMaxWidth(),
1040 minWidth
= GetMinWidth(),
1041 maxHeight
= GetMaxHeight(),
1042 minHeight
= GetMinHeight();
1044 if ( minWidth
!= -1 && width
< minWidth
) width
= minWidth
;
1045 if ( maxWidth
!= -1 && width
> maxWidth
) width
= maxWidth
;
1046 if ( minHeight
!= -1 && height
< minHeight
) height
= minHeight
;
1047 if ( maxHeight
!= -1 && height
> maxHeight
) height
= maxHeight
;
1049 if ( m_wnd
->x
!= x
|| m_wnd
->y
!= y
||
1050 (int)m_wnd
->width
!= width
|| (int)m_wnd
->height
!= height
)
1052 DoMoveWindow(x
, y
, width
, height
);
1054 wxSize
newSize(width
, height
);
1055 wxSizeEvent
event(newSize
, GetId());
1056 event
.SetEventObject(this);
1057 HandleWindowEvent(event
);
1061 void wxWindowMGL::DoSetClientSize(int width
, int height
)
1063 SetSize(width
, height
);
1066 // ---------------------------------------------------------------------------
1068 // ---------------------------------------------------------------------------
1070 int wxWindowMGL::GetCharHeight() const
1074 return dc
.GetCharHeight();
1077 int wxWindowMGL::GetCharWidth() const
1081 return dc
.GetCharWidth();
1084 void wxWindowMGL::DoGetTextExtent(const wxString
& string
,
1087 int *externalLeading
,
1088 const wxFont
*theFont
) const
1093 dc
.GetTextExtent(string
, x
, y
, descent
, externalLeading
, (wxFont
*)theFont
);
1097 // ---------------------------------------------------------------------------
1099 // ---------------------------------------------------------------------------
1101 void wxWindowMGL::Refresh(bool eraseBack
, const wxRect
*rect
)
1103 if ( m_eraseBackground
== -1 )
1104 m_eraseBackground
= eraseBack
;
1106 m_eraseBackground
|= eraseBack
;
1111 r
.left
= rect
->GetLeft(), r
.right
= rect
->GetRight();
1112 r
.top
= rect
->GetTop(), r
.bottom
= rect
->GetBottom();
1113 MGL_wmInvalidateWindowRect(GetHandle(), &r
);
1116 MGL_wmInvalidateWindow(GetHandle());
1119 void wxWindowMGL::Update()
1122 MGL_wmUpdateDC(g_winMng
);
1125 void wxWindowMGL::DoFreeze()
1127 m_refreshAfterThaw
= false;
1130 void wxWindowMGL::DoThaw()
1132 if ( m_refreshAfterThaw
)
1136 void wxWindowMGL::HandlePaint(MGLDevCtx
*dc
)
1140 // Don't paint anything if the window is frozen.
1141 m_refreshAfterThaw
= true;
1145 #if wxDEBUG_LEVEL >= 2
1146 // FIXME_MGL -- debugging stuff, to be removed!
1147 static int debugPaintEvents
= -1;
1148 if ( debugPaintEvents
== -1 )
1149 debugPaintEvents
= wxGetEnv(wxT("WXMGL_DEBUG_PAINT_EVENTS"), NULL
);
1150 if ( debugPaintEvents
)
1152 dc
->setColorRGB(255,0,255);
1153 dc
->fillRect(-1000,-1000,2000,2000);
1156 #endif // wxDEBUG_LEVEL >= 2
1159 dc
->getClipRegion(clip
);
1160 m_updateRegion
= wxRegion(clip
);
1164 // must hide caret temporarily, otherwise we'd get rendering artifacts
1165 wxCaret
*caret
= GetCaret();
1168 #endif // wxUSE_CARET
1170 if ( m_eraseBackground
!= 0 )
1172 wxWindowDC
dc((wxWindow
*)this);
1173 wxEraseEvent
eventEr(m_windowId
, &dc
);
1174 eventEr
.SetEventObject(this);
1175 HandleWindowEvent(eventEr
);
1177 m_eraseBackground
= -1;
1179 wxNcPaintEvent
eventNc(GetId());
1180 eventNc
.SetEventObject(this);
1181 HandleWindowEvent(eventNc
);
1183 wxPaintEvent
eventPt(GetId());
1184 eventPt
.SetEventObject(this);
1185 HandleWindowEvent(eventPt
);
1190 #endif // wxUSE_CARET
1192 m_paintMGLDC
= NULL
;
1193 m_updateRegion
.Clear();
1197 // Find the wxWindow at the current mouse position, returning the mouse
1199 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
1201 return wxFindWindowAtPoint(pt
= wxGetMousePosition());
1204 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
1206 window_t
*wnd
= MGL_wmGetWindowAtPosition(g_winMng
, pt
.x
, pt
.y
);
1207 return (wxWindow
*)wnd
->userData
;