VBoxConsoleView.cpp@ 28215

Last change on this file since 28215 was 28215, checked in by vboxsync, 15 years ago
IDisplay API changes for multimonitor (xTracker 4655)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 147.4 KB

Line
1	/* $Id: VBoxConsoleView.cpp 28215 2010-04-12 15:31:54Z vboxsync $ */
2	/** @file
3	*
4	* VBox frontends: Qt GUI ("VirtualBox"):
5	* VBoxConsoleView class implementation
6	*/
7
8	/*
9	* Copyright (C) 22006-2007 Sun Microsystems, Inc.
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20	* Clara, CA 95054 USA or visit http://www.sun.com if you need
21	* additional information or have any questions.
22	*/
23
24	#ifdef VBOX_WITH_PRECOMPILED_HEADERS
25	# include "precomp.h"
26	#else /* !VBOX_WITH_PRECOMPILED_HEADERS */
27	#include <VBox/VBoxVideo.h>
28
29	#include "VBoxConsoleView.h"
30	#include "VBoxConsoleWnd.h"
31	#include "VBoxUtils.h"
32
33	#include "VBoxFrameBuffer.h"
34	#include "VBoxGlobal.h"
35	#include "VBoxProblemReporter.h"
36
37	#ifdef Q_WS_PM
38	#include "QIHotKeyEdit.h"
39	#endif
40
41	/* Qt includes */
42	#include <QMenuBar>
43	#include <QDesktopWidget>
44	#include <QTimer>
45	#include <QStatusBar>
46	#include <QPainter>
47	#include <QBitmap>
48
49	#endif /* !VBOX_WITH_PRECOMPILED_HEADERS / /* @todo Move this further down! Requires some cleanup below though, so later. */
50
51	#ifdef Q_WS_WIN
52	// VBox/cdefs.h defines these:
53	#undef LOWORD
54	#undef HIWORD
55	#undef LOBYTE
56	#undef HIBYTE
57	#include <windows.h>
58	#endif
59
60	#ifdef Q_WS_X11
61	#include <QX11Info>
62	// We need to capture some X11 events directly which
63	// requires the XEvent structure to be defined. However,
64	// including the Xlib header file will cause some nasty
65	// conflicts with Qt. Therefore we use the following hack
66	// to redefine those conflicting identifiers.
67	#define XK_XKB_KEYS
68	#define XK_MISCELLANY
69	#include <X11/Xlib.h>
70	#include <X11/Xutil.h>
71	#include <X11/XKBlib.h>
72	#include <X11/keysym.h>
73	#ifdef KeyPress
74	const int XFocusOut = FocusOut;
75	const int XFocusIn = FocusIn;
76	const int XKeyPress = KeyPress;
77	const int XKeyRelease = KeyRelease;
78	#undef KeyRelease
79	#undef KeyPress
80	#undef FocusOut
81	#undef FocusIn
82	#endif
83	#include "XKeyboard.h"
84	#ifndef VBOX_WITHOUT_XCURSOR
85	# include <X11/Xcursor/Xcursor.h>
86	#endif
87	#endif // Q_WS_X11
88
89	#if defined (Q_WS_MAC)
90	# include "DockIconPreview.h"
91	# include "DarwinKeyboard.h"
92	# ifdef QT_MAC_USE_COCOA
93	# include "darwin/VBoxCocoaApplication.h"
94	# else /* QT_MAC_USE_COCOA */
95	# include <Carbon/Carbon.h>
96	# endif /* !QT_MAC_USE_COCOA */
97	# include <VBox/err.h>
98	#endif /* defined (Q_WS_MAC) */
99
100	#if defined (Q_WS_WIN32)
101
102	static HHOOK gKbdHook = NULL;
103	static VBoxConsoleView *gView = 0;
104
105	LRESULT CALLBACK VBoxConsoleView::lowLevelKeyboardProc (int nCode,
106	WPARAM wParam, LPARAM lParam)
107	{
108	Assert (gView);
109	if (gView && nCode == HC_ACTION &&
110	gView->winLowKeyboardEvent (wParam, (KBDLLHOOKSTRUCT ) lParam))
111	return 1;
112
113	return CallNextHookEx (NULL, nCode, wParam, lParam);
114	}
115
116	#endif
117
118	#if defined (Q_WS_MAC)
119	# if defined (QT_MAC_USE_COCOA)
120	/**
121	* Event handler callback for Mac OS X, Cocoa variant.
122	*
123	* (Registered with and called from VBoxCocoaApplication.)
124	*
125	* @returns true if the event should be dropped, false if it should be passed
126	* along.
127	* @param pvCocoaEvent The Cocoa event object.
128	* @param pvCarbonEvent The Carbon event object reference.
129	* @param pvUser The user argument.
130	*/
131	/* static */
132	bool VBoxConsoleView::darwinEventHandlerProc (const void *pvCocoaEvent,
133	const void *pvCarbonEvent,
134	void *pvUser)
135	{
136	VBoxConsoleView view = (VBoxConsoleView )pvUser;
137	EventRef inEvent = (EventRef)pvCarbonEvent;
138	UInt32 eventClass = ::GetEventClass (inEvent);
139
140	#if 0
141	/* For debugging events. */
142	if (eventClass != 'cute')
143	::VBoxCocoaApplication_printEvent ("view: ", pvCocoaEvent);
144	#endif
145	/* Check if this is an application key combo. In that case we will not pass
146	the event to the guest, but let the host process it. */
147	if (VBoxCocoaApplication_isApplicationCommand(pvCocoaEvent))
148	return false;
149
150	/*
151	* All keyboard class events needs to be handled.
152	*/
153	if (eventClass == kEventClassKeyboard)
154	{
155	if (view->darwinKeyboardEvent (pvCocoaEvent, inEvent))
156	return true;
157	}
158	/* Pass the event along. */
159	return false;
160	}
161
162	# else /* QT_MAC_USE_COCOA */
163	/**
164	* Event handler callback for Mac OS X.
165	*/
166	/* static */
167	pascal OSStatus VBoxConsoleView::darwinEventHandlerProc (EventHandlerCallRef inHandlerCallRef,
168	EventRef inEvent, void *inUserData)
169	{
170	VBoxConsoleView view = static_cast<VBoxConsoleView > (inUserData);
171	UInt32 eventClass = ::GetEventClass (inEvent);
172
173	/* For debugging events */
174	/*
175	if (eventClass != 'cute')
176	::darwinDebugPrintEvent ("view: ", inEvent);
177	*/
178
179	/* Not sure but this seems an triggered event if the spotlight searchbar is
180	* displayed. So flag that the host key isn't pressed alone. */
181	if ( eventClass == 'cgs '
182	&& view->mIsHostkeyPressed
183	&& ::GetEventKind (inEvent) == 0x15)
184	view->mIsHostkeyAlone = false;
185
186	if (eventClass == kEventClassKeyboard)
187	{
188	if (view->darwinKeyboardEvent (NULL, inEvent))
189	return 0;
190	}
191	/*
192	* Command-H and Command-Q aren't properly disabled yet, and it's still
193	* possible to use the left command key to invoke them when the keyboard
194	* is captured. We discard the events these if the keyboard is captured
195	* as a half measure to prevent unexpected behavior. However, we don't
196	* get any key down/up events, so these combinations are dead to the guest...
197	*/
198	else if (eventClass == kEventClassCommand)
199	{
200	if (view->mKbdCaptured)
201	return 0;
202	}
203	return ::CallNextEventHandler (inHandlerCallRef, inEvent);
204	}
205	# endif /* !QT_MAC_USE_COCOA */
206
207	#endif /* Q_WS_MAC */
208
209	/** Guest mouse pointer shape change event. */
210	class MousePointerChangeEvent : public QEvent
211	{
212	public:
213	MousePointerChangeEvent (bool visible, bool alpha, uint xhot, uint yhot,
214	uint width, uint height,
215	const uchar *shape) :
216	QEvent ((QEvent::Type) VBoxDefs::MousePointerChangeEventType),
217	vis (visible), alph (alpha), xh (xhot), yh (yhot), w (width), h (height),
218	data (NULL)
219	{
220	// make a copy of shape
221	uint dataSize = ((((width + 7) / 8 * height) + 3) & ~3) + width * 4 * height;
222
223	if (shape) {
224	data = new uchar [dataSize];
225	memcpy ((void ) data, (void ) shape, dataSize);
226	}
227	}
228	~MousePointerChangeEvent()
229	{
230	if (data) delete[] data;
231	}
232	bool isVisible() const { return vis; }
233	bool hasAlpha() const { return alph; }
234	uint xHot() const { return xh; }
235	uint yHot() const { return yh; }
236	uint width() const { return w; }
237	uint height() const { return h; }
238	const uchar *shapeData() const { return data; }
239	private:
240	bool vis, alph;
241	uint xh, yh, w, h;
242	const uchar *data;
243	};
244
245	/** Guest mouse absolute positioning capability change event. */
246	class MouseCapabilityEvent : public QEvent
247	{
248	public:
249	MouseCapabilityEvent (bool supportsAbsolute, bool supportsRelative, bool needsHostCursor) :
250	QEvent ((QEvent::Type) VBoxDefs::MouseCapabilityEventType),
251	can_abs (supportsAbsolute),
252	can_rel (supportsRelative),
253	needs_host_cursor (needsHostCursor) {}
254	bool supportsAbsolute() const { return can_abs; }
255	bool supportsRelative() const { return can_rel; }
256	bool needsHostCursor() const { return needs_host_cursor; }
257	private:
258	bool can_abs;
259	bool can_rel;
260	bool needs_host_cursor;
261	};
262
263	/** Machine state change. */
264	class StateChangeEvent : public QEvent
265	{
266	public:
267	StateChangeEvent (KMachineState state) :
268	QEvent ((QEvent::Type) VBoxDefs::MachineStateChangeEventType),
269	s (state) {}
270	KMachineState machineState() const { return s; }
271	private:
272	KMachineState s;
273	};
274
275	/** Guest Additions property changes. */
276	class GuestAdditionsEvent : public QEvent
277	{
278	public:
279	GuestAdditionsEvent (const QString &aOsTypeId,
280	const QString &aAddVersion,
281	bool aAddActive,
282	bool aSupportsSeamless,
283	bool aSupportsGraphics) :
284	QEvent ((QEvent::Type) VBoxDefs::AdditionsStateChangeEventType),
285	mOsTypeId (aOsTypeId), mAddVersion (aAddVersion),
286	mAddActive (aAddActive), mSupportsSeamless (aSupportsSeamless),
287	mSupportsGraphics (aSupportsGraphics) {}
288	const QString &osTypeId() const { return mOsTypeId; }
289	const QString &additionVersion() const { return mAddVersion; }
290	bool additionActive() const { return mAddActive; }
291	bool supportsSeamless() const { return mSupportsSeamless; }
292	bool supportsGraphics() const { return mSupportsGraphics; }
293	private:
294	QString mOsTypeId;
295	QString mAddVersion;
296	bool mAddActive;
297	bool mSupportsSeamless;
298	bool mSupportsGraphics;
299	};
300
301	/** DVD/Floppy drive change event */
302	class MediaDriveChangeEvent : public QEvent
303	{
304	public:
305	MediaDriveChangeEvent (VBoxDefs::MediumType aType)
306	: QEvent ((QEvent::Type) VBoxDefs::MediaDriveChangeEventType)
307	, mType (aType) {}
308	VBoxDefs::MediumType type() const { return mType; }
309	private:
310	VBoxDefs::MediumType mType;
311	};
312
313	/** Menu activation event */
314	class ActivateMenuEvent : public QEvent
315	{
316	public:
317	ActivateMenuEvent (QAction *aData) :
318	QEvent ((QEvent::Type) VBoxDefs::ActivateMenuEventType),
319	mAction (aData) {}
320	QAction *action() const { return mAction; }
321	private:
322	QAction *mAction;
323	};
324
325	/** VM Runtime error event */
326	class RuntimeErrorEvent : public QEvent
327	{
328	public:
329	RuntimeErrorEvent (bool aFatal, const QString &aErrorID,
330	const QString &aMessage) :
331	QEvent ((QEvent::Type) VBoxDefs::RuntimeErrorEventType),
332	mFatal (aFatal), mErrorID (aErrorID), mMessage (aMessage) {}
333	bool fatal() const { return mFatal; }
334	QString errorID() const { return mErrorID; }
335	QString message() const { return mMessage; }
336	private:
337	bool mFatal;
338	QString mErrorID;
339	QString mMessage;
340	};
341
342	/** Modifier key change event */
343	class ModifierKeyChangeEvent : public QEvent
344	{
345	public:
346	ModifierKeyChangeEvent (bool fNumLock, bool fCapsLock, bool fScrollLock) :
347	QEvent ((QEvent::Type) VBoxDefs::ModifierKeyChangeEventType),
348	mNumLock (fNumLock), mCapsLock (fCapsLock), mScrollLock (fScrollLock) {}
349	bool numLock() const { return mNumLock; }
350	bool capsLock() const { return mCapsLock; }
351	bool scrollLock() const { return mScrollLock; }
352	private:
353	bool mNumLock, mCapsLock, mScrollLock;
354	};
355
356	/** Network adapter change event */
357	class NetworkAdapterChangeEvent : public QEvent
358	{
359	public:
360	NetworkAdapterChangeEvent (INetworkAdapter *aAdapter) :
361	QEvent ((QEvent::Type) VBoxDefs::NetworkAdapterChangeEventType),
362	mAdapter (aAdapter) {}
363	INetworkAdapter* networkAdapter() { return mAdapter; }
364	private:
365	INetworkAdapter *mAdapter;
366	};
367
368	/** USB controller state change event */
369	class USBControllerStateChangeEvent : public QEvent
370	{
371	public:
372	USBControllerStateChangeEvent()
373	: QEvent ((QEvent::Type) VBoxDefs::USBCtlStateChangeEventType) {}
374	};
375
376	/** USB device state change event */
377	class USBDeviceStateChangeEvent : public QEvent
378	{
379	public:
380	USBDeviceStateChangeEvent (const CUSBDevice &aDevice, bool aAttached,
381	const CVirtualBoxErrorInfo &aError) :
382	QEvent ((QEvent::Type) VBoxDefs::USBDeviceStateChangeEventType),
383	mDevice (aDevice), mAttached (aAttached), mError (aError) {}
384	CUSBDevice device() const { return mDevice; }
385	bool attached() const { return mAttached; }
386	CVirtualBoxErrorInfo error() const { return mError; }
387	private:
388	CUSBDevice mDevice;
389	bool mAttached;
390	CVirtualBoxErrorInfo mError;
391	};
392
393	//
394	// VBoxConsoleCallback class
395	/////////////////////////////////////////////////////////////////////////////
396
397	class VBoxConsoleCallback : VBOX_SCRIPTABLE_IMPL(IConsoleCallback)
398	{
399	public:
400
401	VBoxConsoleCallback (VBoxConsoleView *v) {
402	#if defined (Q_WS_WIN)
403	mRefCnt = 0;
404	#endif
405	mView = v;
406	}
407
408	virtual ~VBoxConsoleCallback() {}
409
410	NS_DECL_ISUPPORTS
411
412	#if defined (Q_WS_WIN)
413	STDMETHOD_(ULONG, AddRef)() {
414	return ::InterlockedIncrement (&mRefCnt);
415	}
416	STDMETHOD_(ULONG, Release)()
417	{
418	long cnt = ::InterlockedDecrement (&mRefCnt);
419	if (cnt == 0)
420	delete this;
421	return cnt;
422	}
423	#endif
424	VBOX_SCRIPTABLE_DISPATCH_IMPL(IConsoleCallback)
425
426	STDMETHOD(OnMousePointerShapeChange) (BOOL visible, BOOL alpha,
427	ULONG xhot, ULONG yhot,
428	ULONG width, ULONG height,
429	BYTE *shape)
430	{
431	QApplication::postEvent (mView,
432	new MousePointerChangeEvent (visible, alpha,
433	xhot, yhot,
434	width, height, shape));
435	return S_OK;
436	}
437
438	STDMETHOD(OnMouseCapabilityChange)(BOOL supportsAbsolute, BOOL supportsRelative, BOOL needsHostCursor)
439	{
440	QApplication::postEvent (mView,
441	new MouseCapabilityEvent (supportsAbsolute,
442	supportsRelative,
443	needsHostCursor));
444	return S_OK;
445	}
446
447	STDMETHOD(OnKeyboardLedsChange)(BOOL fNumLock, BOOL fCapsLock, BOOL fScrollLock)
448	{
449	QApplication::postEvent (mView,
450	new ModifierKeyChangeEvent (fNumLock, fCapsLock,
451	fScrollLock));
452	return S_OK;
453	}
454
455	STDMETHOD(OnStateChange)(MachineState_T machineState)
456	{
457	LogFlowFunc (("machineState=%d\n", machineState));
458	QApplication::postEvent (mView,
459	new StateChangeEvent ((KMachineState) machineState));
460	return S_OK;
461	}
462
463	STDMETHOD(OnAdditionsStateChange)()
464	{
465	CGuest guest = mView->console().GetGuest();
466	LogFlowFunc (("ver=%s, active=%d\n",
467	guest.GetAdditionsVersion().toLatin1().constData(),
468	guest.GetAdditionsActive()));
469	QApplication::postEvent (mView,
470	new GuestAdditionsEvent (
471	guest.GetOSTypeId(),
472	guest.GetAdditionsVersion(),
473	guest.GetAdditionsActive(),
474	guest.GetSupportsSeamless(),
475	guest.GetSupportsGraphics()));
476	return S_OK;
477	}
478
479	STDMETHOD(OnNetworkAdapterChange) (INetworkAdapter *aNetworkAdapter)
480	{
481	QApplication::postEvent (mView,
482	new NetworkAdapterChangeEvent (aNetworkAdapter));
483	return S_OK;
484	}
485
486	STDMETHOD(OnStorageControllerChange) ()
487	{
488	/* @todo */
489	//QApplication::postEvent (mView,
490	// new StorageControllerChangeEvent ());
491	return S_OK;
492	}
493
494	STDMETHOD(OnMediumChange)(IMediumAttachment *aMediumAttachment)
495	{
496	CMediumAttachment att(aMediumAttachment);
497	switch (att.GetType())
498	{
499	case KDeviceType_Floppy:
500	QApplication::postEvent(mView,
501	new MediaDriveChangeEvent(VBoxDefs::MediumType_Floppy));
502	break;
503	case KDeviceType_DVD:
504	QApplication::postEvent(mView,
505	new MediaDriveChangeEvent(VBoxDefs::MediumType_DVD));
506	break;
507	default:
508	/* @todo later add hard disk change as well */
509	break;
510	}
511	return S_OK;
512	}
513
514	STDMETHOD(OnCPUChange)(ULONG aCPU, BOOL aRemove)
515	{
516	NOREF(aCPU);
517	NOREF(aRemove);
518	return S_OK;
519	}
520
521	STDMETHOD(OnSerialPortChange) (ISerialPort *aSerialPort)
522	{
523	NOREF(aSerialPort);
524	return S_OK;
525	}
526
527	STDMETHOD(OnParallelPortChange) (IParallelPort *aParallelPort)
528	{
529	NOREF(aParallelPort);
530	return S_OK;
531	}
532
533	STDMETHOD(OnVRDPServerChange)()
534	{
535	return S_OK;
536	}
537
538	STDMETHOD(OnRemoteDisplayInfoChange)()
539	{
540	return S_OK;
541	}
542
543	STDMETHOD(OnUSBControllerChange)()
544	{
545	QApplication::postEvent (mView,
546	new USBControllerStateChangeEvent());
547	return S_OK;
548	}
549
550	STDMETHOD(OnUSBDeviceStateChange)(IUSBDevice *aDevice, BOOL aAttached,
551	IVirtualBoxErrorInfo *aError)
552	{
553	QApplication::postEvent (mView,
554	new USBDeviceStateChangeEvent (
555	CUSBDevice (aDevice),
556	bool (aAttached),
557	CVirtualBoxErrorInfo (aError)));
558	return S_OK;
559	}
560
561	STDMETHOD(OnSharedFolderChange) (Scope_T aScope)
562	{
563	NOREF(aScope);
564	QApplication::postEvent (mView,
565	new QEvent ((QEvent::Type)
566	VBoxDefs::SharedFolderChangeEventType));
567	return S_OK;
568	}
569
570	STDMETHOD(OnRuntimeError)(BOOL fatal, IN_BSTR id, IN_BSTR message)
571	{
572	QApplication::postEvent (mView,
573	new RuntimeErrorEvent (!!fatal,
574	QString::fromUtf16 (id),
575	QString::fromUtf16 (message)));
576	return S_OK;
577	}
578
579	STDMETHOD(OnCanShowWindow) (BOOL *canShow)
580	{
581	if (!canShow)
582	return E_POINTER;
583
584	/* as long as there is VBoxConsoleView (which creates/destroys us), it
585	* can be shown */
586	*canShow = TRUE;
587	return S_OK;
588	}
589
590	STDMETHOD(OnShowWindow) (ULONG64 *winId)
591	{
592	if (!winId)
593	return E_POINTER;
594
595	#if defined (Q_WS_MAC)
596	/*
597	* Let's try the simple approach first - grab the focus.
598	* Getting a window out of the dock (minimized or whatever it's called)
599	* needs to be done on the GUI thread, so post it a note.
600	*/
601	*winId = 0;
602	if (!mView)
603	return S_OK;
604
605	ProcessSerialNumber psn = { 0, kCurrentProcess };
606	OSErr rc = ::SetFrontProcess (&psn);
607	if (!rc)
608	QApplication::postEvent (mView, new QEvent ((QEvent::Type)VBoxDefs::ShowWindowEventType));
609	else
610	{
611	/*
612	* It failed for some reason, send the other process our PSN so it can try.
613	* (This is just a precaution should Mac OS X start imposing the same sensible
614	* focus stealing restrictions that other window managers implement.)
615	*/
616	AssertMsgFailed(("SetFrontProcess -> %#x\n", rc));
617	if (::GetCurrentProcess (&psn))
618	*winId = RT_MAKE_U64 (psn.lowLongOfPSN, psn.highLongOfPSN);
619	}
620
621	#else
622	/* Return the ID of the top-level console window. */
623	*winId = (ULONG64) mView->window()->winId();
624	#endif
625
626	return S_OK;
627	}
628
629	protected:
630
631	VBoxConsoleView *mView;
632
633	#if defined (Q_WS_WIN)
634	private:
635	long mRefCnt;
636	#endif
637	};
638
639	#if !defined (Q_WS_WIN)
640	NS_DECL_CLASSINFO (VBoxConsoleCallback)
641	NS_IMPL_THREADSAFE_ISUPPORTS1_CI (VBoxConsoleCallback, IConsoleCallback)
642	#endif
643
644	class VBoxViewport: public QWidget
645	{
646	public:
647	VBoxViewport (QWidget *aParent)
648	: QWidget (aParent)
649	{
650	/* No need for background drawing */
651	setAttribute (Qt::WA_OpaquePaintEvent);
652	}
653	virtual QPaintEngine * paintEngine() const
654	{
655	if (testAttribute (Qt::WA_PaintOnScreen))
656	return NULL;
657	else
658	return QWidget::paintEngine();
659	}
660	};
661
662	//
663	// VBoxConsoleView class
664	/////////////////////////////////////////////////////////////////////////////
665
666	/** @class VBoxConsoleView
667	*
668	* The VBoxConsoleView class is a widget that implements a console
669	* for the running virtual machine.
670	*/
671
672	VBoxConsoleView::VBoxConsoleView (VBoxConsoleWnd *mainWnd,
673	const CConsole &console,
674	VBoxDefs::RenderMode rm,
675	#ifdef VBOX_WITH_VIDEOHWACCEL
676	bool accelerate2DVideo,
677	#endif
678	QWidget *parent)
679	: QAbstractScrollArea (parent)
680	, mMainWnd (mainWnd)
681	, mConsole (console)
682	, gs (vboxGlobal().settings())
683	, mAttached (false)
684	, mKbdCaptured (false)
685	, mMouseCaptured (false)
686	, mMouseCanAbsolute (false)
687	, mMouseCanRelative (true)
688	, mMouseNeedsHostCursor (false)
689	, mMouseIntegration (true)
690	, m_iLastMouseWheelDelta(0)
691	, mDisableAutoCapture (false)
692	, mIsHostkeyPressed (false)
693	, mIsHostkeyAlone (false)
694	, mIgnoreMainwndResize (true)
695	, mAutoresizeGuest (false)
696	, mIgnoreFrameBufferResize (false)
697	, mIgnoreGuestResize (false)
698	, mDoResize (false)
699	, mGuestSupportsGraphics (false)
700	, mNumLock (false)
701	, mScrollLock (false)
702	, mCapsLock (false)
703	, muNumLockAdaptionCnt (2)
704	, muCapsLockAdaptionCnt (2)
705	, mode (rm)
706	#ifdef VBOX_WITH_VIDEOHWACCEL
707	, mAccelerate2DVideo(accelerate2DVideo)
708	#endif
709	#if defined(Q_WS_WIN)
710	, mAlphaCursor (NULL)
711	#endif
712	#if defined(Q_WS_MAC)
713	# ifndef QT_MAC_USE_COCOA
714	, mDarwinEventHandlerRef (NULL)
715	# endif
716	, mDarwinKeyModifiers (0)
717	, mKeyboardGrabbed (false)
718	, mDockIconEnabled (true)
719	#endif
720	, mDesktopGeo (DesktopGeo_Invalid)
721	, mPassCAD (false)
722	/* Don't show a hardware pointer until we have one to show */
723	, mHideHostPointer (true)
724	{
725	Assert (!mConsole.isNull() &&
726	!mConsole.GetDisplay().isNull() &&
727	!mConsole.GetKeyboard().isNull() &&
728	!mConsole.GetMouse().isNull());
729
730	#ifdef Q_WS_MAC
731	/* Overlay logo for the dock icon */
732	QString osTypeId = mConsole.GetGuest().GetOSTypeId();
733	mDockIconPreview = new VBoxDockIconPreview (mMainWnd, vboxGlobal().vmGuestOSTypeIcon (osTypeId));
734
735	# ifndef QT_MAC_USE_COCOA
736	/* Install the event handler which will proceed external window handling */
737	EventHandlerUPP eventHandler = ::NewEventHandlerUPP (::darwinOverlayWindowHandler);
738	EventTypeSpec eventTypes[] =
739	{
740	{ kEventClassVBox, kEventVBoxShowWindow },
741	{ kEventClassVBox, kEventVBoxHideWindow },
742	{ kEventClassVBox, kEventVBoxMoveWindow },
743	{ kEventClassVBox, kEventVBoxResizeWindow },
744	{ kEventClassVBox, kEventVBoxDisposeWindow },
745	{ kEventClassVBox, kEventVBoxUpdateDock }
746	};
747
748	mDarwinWindowOverlayHandlerRef = NULL;
749	::InstallApplicationEventHandler (eventHandler, RT_ELEMENTS (eventTypes), &eventTypes[0],
750	this, &mDarwinWindowOverlayHandlerRef);
751	::DisposeEventHandlerUPP (eventHandler);
752	# endif /* !QT_MAC_USE_COCOA */
753	#endif /* QT_WS_MAC */
754
755	/* No frame around the view */
756	setFrameStyle (QFrame::NoFrame);
757
758	#ifdef VBOX_GUI_USE_QGLFB
759	QWidget *pViewport;
760	switch (mode)
761	{
762	case VBoxDefs::QGLMode:
763	pViewport = new VBoxGLWidget (mConsole, this, NULL);
764	break;
765	default:
766	pViewport = new VBoxViewport (this);
767	}
768	#else
769	VBoxViewport *pViewport = new VBoxViewport (this);
770	#endif
771	setViewport (pViewport);
772	// pViewport->vboxDoInit();
773
774	/* enable MouseMove events */
775	viewport()->setMouseTracking (true);
776
777	/*
778	* QScrollView does the below on its own, but let's do it anyway
779	* for the case it will not do it in the future.
780	*/
781	viewport()->installEventFilter (this);
782
783	/* to fix some focus issues */
784	mMainWnd->menuBar()->installEventFilter (this);
785
786	/* we want to be notified on some parent's events */
787	mMainWnd->installEventFilter (this);
788
789	#ifdef Q_WS_X11
790	/* initialize the X keyboard subsystem */
791	initMappedX11Keyboard(QX11Info::display(),
792	vboxGlobal().settings().publicProperty ("GUI/RemapScancodes"));
793	#endif
794
795	::memset (mPressedKeys, 0, sizeof (mPressedKeys));
796
797	/* setup rendering */
798
799	CDisplay display = mConsole.GetDisplay();
800	Assert (!display.isNull());
801
802	mFrameBuf = NULL;
803
804	LogFlowFunc (("Rendering mode: %d\n", mode));
805
806	switch (mode)
807	{
808	#if defined (VBOX_GUI_USE_QGLFB)
809	case VBoxDefs::QGLMode:
810	mFrameBuf = new VBoxQGLFrameBuffer (this);
811	break;
812	// case VBoxDefs::QGLOverlayMode:
813	// mFrameBuf = new VBoxQGLOverlayFrameBuffer (this);
814	// break;
815	#endif
816	#if defined (VBOX_GUI_USE_QIMAGE)
817	case VBoxDefs::QImageMode:
818	mFrameBuf =
819	#ifdef VBOX_WITH_VIDEOHWACCEL
820	/* these two additional template args is a workaround to this [VBox\|UI] duplication
821	* @todo: they are to be removed once VBox stuff is gone */
822	mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQImageFrameBuffer, VBoxConsoleView, VBoxResizeEvent> (this, &mainWnd->session(), 0) :
823	#endif
824	new VBoxQImageFrameBuffer (this);
825	break;
826	#endif
827	#if defined (VBOX_GUI_USE_SDL)
828	case VBoxDefs::SDLMode:
829	/* Indicate that we are doing all
830	* drawing stuff ourself */
831	pViewport->setAttribute (Qt::WA_PaintOnScreen);
832	# ifdef Q_WS_X11
833	/* This is somehow necessary to prevent strange X11 warnings on
834	* i386 and segfaults on x86_64. */
835	XFlush(QX11Info::display());
836	# endif
837	mFrameBuf =
838	#if defined(VBOX_WITH_VIDEOHWACCEL) && defined(DEBUG_misha) /* not tested yet */
839	/* these two additional template args is a workaround to this [VBox\|UI] duplication
840	* @todo: they are to be removed once VBox stuff is gone */
841	mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxSDLFrameBuffer, VBoxConsoleView, VBoxResizeEvent> (this, &mainWnd->session(), 0) :
842	#endif
843	new VBoxSDLFrameBuffer (this);
844	/*
845	* disable scrollbars because we cannot correctly draw in a
846	* scrolled window using SDL
847	*/
848	horizontalScrollBar()->setEnabled (false);
849	verticalScrollBar()->setEnabled (false);
850	break;
851	#endif
852	#if defined (VBOX_GUI_USE_DDRAW)
853	case VBoxDefs::DDRAWMode:
854	mFrameBuf = new VBoxDDRAWFrameBuffer (this);
855	break;
856	#endif
857	#if defined (VBOX_GUI_USE_QUARTZ2D)
858	case VBoxDefs::Quartz2DMode:
859	/* Indicate that we are doing all
860	* drawing stuff ourself */
861	pViewport->setAttribute (Qt::WA_PaintOnScreen);
862	mFrameBuf =
863	#ifdef VBOX_WITH_VIDEOHWACCEL
864	/* these two additional template args is a workaround to this [VBox\|UI] duplication
865	* @todo: they are to be removed once VBox stuff is gone */
866	mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQuartz2DFrameBuffer, VBoxConsoleView, VBoxResizeEvent> (this, &mainWnd->session(), 0) :
867	#endif
868	new VBoxQuartz2DFrameBuffer (this);
869	break;
870	#endif
871	default:
872	AssertReleaseMsgFailed (("Render mode must be valid: %d\n", mode));
873	LogRel (("Invalid render mode: %d\n", mode));
874	qApp->exit (1);
875	break;
876	}
877
878	#if defined (VBOX_GUI_USE_DDRAW)
879	if (!mFrameBuf \|\| mFrameBuf->address() == NULL)
880	{
881	if (mFrameBuf)
882	delete mFrameBuf;
883	mode = VBoxDefs::QImageMode;
884	mFrameBuf = new VBoxQImageFrameBuffer (this);
885	}
886	#endif
887
888	if (mFrameBuf)
889	{
890	mFrameBuf->AddRef();
891	display.SetFramebuffer (VBOX_VIDEO_PRIMARY_SCREEN, CFramebuffer (mFrameBuf));
892	}
893
894	/* setup the callback */
895	mCallback = CConsoleCallback (new VBoxConsoleCallback (this));
896	mConsole.RegisterCallback (mCallback);
897	AssertWrapperOk (mConsole);
898
899	QPalette palette (viewport()->palette());
900	palette.setColor (viewport()->backgroundRole(), Qt::black);
901	viewport()->setPalette (palette);
902
903	setSizePolicy (QSizePolicy (QSizePolicy::Maximum, QSizePolicy::Maximum));
904	setMaximumSize (sizeHint());
905
906	setFocusPolicy (Qt::WheelFocus);
907
908	/* Remember the desktop geometry and register for geometry change
909	events for telling the guest about video modes we like. */
910
911	QString desktopGeometry = vboxGlobal().settings()
912	.publicProperty ("GUI/MaxGuestResolution");
913	if ((desktopGeometry == QString::null) \|\|
914	(desktopGeometry == "auto"))
915	setDesktopGeometry (DesktopGeo_Automatic, 0, 0);
916	else if (desktopGeometry == "any")
917	setDesktopGeometry (DesktopGeo_Any, 0, 0);
918	else
919	{
920	int width = desktopGeometry.section (',', 0, 0).toInt();
921	int height = desktopGeometry.section (',', 1, 1).toInt();
922	setDesktopGeometry (DesktopGeo_Fixed, width, height);
923	}
924	connect (QApplication::desktop(), SIGNAL (resized (int)),
925	this, SLOT (doResizeDesktop (int)));
926
927	QString passCAD = mConsole.GetMachine().GetExtraData (VBoxDefs::GUI_PassCAD);
928	if (!passCAD.isEmpty() &&
929	((passCAD != "false") \|\| (passCAD != "no"))
930	)
931	mPassCAD = true;
932
933	#if defined (Q_WS_WIN)
934	gView = this;
935	#endif
936
937	#if defined (Q_WS_PM)
938	bool ok = VBoxHlpInstallKbdHook (0, winId(), UM_PREACCEL_CHAR);
939	Assert (ok);
940	NOREF (ok);
941	#endif
942	}
943
944	VBoxConsoleView::~VBoxConsoleView()
945	{
946	#if defined (Q_WS_PM)
947	bool ok = VBoxHlpUninstallKbdHook (0, winId(), UM_PREACCEL_CHAR);
948	Assert (ok);
949	NOREF (ok);
950	#endif
951
952	#if defined (Q_WS_WIN)
953	if (gKbdHook)
954	UnhookWindowsHookEx (gKbdHook);
955	gView = 0;
956	if (mAlphaCursor)
957	DestroyIcon (mAlphaCursor);
958	#endif
959
960	if (mFrameBuf)
961	{
962	/* detach our framebuffer from Display */
963	CDisplay display = mConsole.GetDisplay();
964	Assert (!display.isNull());
965	display.SetFramebuffer (VBOX_VIDEO_PRIMARY_SCREEN, CFramebuffer(NULL));
966	/* release the reference */
967	mFrameBuf->Release();
968	mFrameBuf = NULL;
969	}
970
971	mConsole.UnregisterCallback (mCallback);
972
973	#if defined (Q_WS_MAC)
974	# if !defined (QT_MAC_USE_COCOA)
975	if (mDarwinWindowOverlayHandlerRef)
976	{
977	::RemoveEventHandler (mDarwinWindowOverlayHandlerRef);
978	mDarwinWindowOverlayHandlerRef = NULL;
979	}
980	# endif
981	delete mDockIconPreview;
982	mDockIconPreview = NULL;
983	#endif
984	}
985
986	//
987	// Public members
988	/////////////////////////////////////////////////////////////////////////////
989
990	QSize VBoxConsoleView::sizeHint() const
991	{
992	#ifdef VBOX_WITH_DEBUGGER /** @todo figure out a more proper fix. */
993	/* HACK ALERT! Really ugly workaround for the resizing to 9x1 done
994	* by DevVGA if provoked before power on. */
995	QSize fb(mFrameBuf->width(), mFrameBuf->height());
996	if ( ( fb.width() < 16
997	\|\| fb.height() < 16)
998	&& ( vboxGlobal().isStartPausedEnabled()
999	\|\| vboxGlobal().isDebuggerAutoShowEnabled()) )
1000	fb = QSize(640, 480);
1001	return QSize (fb.width() + frameWidth() * 2,
1002	fb.height() + frameWidth() * 2);
1003	#else
1004	return QSize (mFrameBuf->width() + frameWidth() * 2,
1005	mFrameBuf->height() + frameWidth() * 2);
1006	#endif
1007	}
1008
1009	/**
1010	* Attaches this console view to the managed virtual machine.
1011	*
1012	* @note This method is not really necessary these days -- the only place where
1013	* it gets called is VBoxConsole::openView(), right after powering the
1014	* VM up. We leave it as is just in case attaching/detaching will become
1015	* necessary some day (there are useful attached checks everywhere in the
1016	* code).
1017	*/
1018	void VBoxConsoleView::attach()
1019	{
1020	if (!mAttached)
1021	{
1022	mAttached = true;
1023	}
1024	}
1025
1026	/**
1027	* Detaches this console view from the VM. Must be called to indicate
1028	* that the virtual machine managed by this instance will be no more valid
1029	* after this call.
1030	*
1031	* @note This method is not really necessary these days -- the only place where
1032	* it gets called is VBoxConsole::closeView(), when the VM is powered
1033	* down, before deleting VBoxConsoleView. We leave it as is just in case
1034	* attaching/detaching will become necessary some day (there are useful
1035	* attached checks everywhere in the code).
1036	*/
1037	void VBoxConsoleView::detach()
1038	{
1039	if (mAttached)
1040	{
1041	/* reuse the focus event handler to uncapture everything */
1042	focusEvent (false);
1043	mAttached = false;
1044	}
1045	}
1046
1047	/**
1048	* Resizes the toplevel widget to fit the console view w/o scrollbars.
1049	* If adjustPosition is true and such resize is not possible (because the
1050	* console view size is lagrer then the available screen space) the toplevel
1051	* widget is resized and moved to become as large as possible while staying
1052	* fully visible.
1053	*/
1054	void VBoxConsoleView::normalizeGeometry (bool adjustPosition /* = false */)
1055	{
1056	/* Make no normalizeGeometry in case we are in manual resize
1057	* mode or main window is maximized */
1058	if (mMainWnd->isWindowMaximized() \|\| mMainWnd->isWindowFullScreen())
1059	return;
1060
1061	QWidget *tlw = window();
1062
1063	/* calculate client window offsets */
1064	QRect fr = tlw->frameGeometry();
1065	QRect r = tlw->geometry();
1066	int dl = r.left() - fr.left();
1067	int dt = r.top() - fr.top();
1068	int dr = fr.right() - r.right();
1069	int db = fr.bottom() - r.bottom();
1070
1071	/* get the best size w/o scroll bars */
1072	QSize s = tlw->sizeHint();
1073
1074	/* resize the frame to fit the contents */
1075	s -= tlw->size();
1076	fr.setRight (fr.right() + s.width());
1077	fr.setBottom (fr.bottom() + s.height());
1078
1079	if (adjustPosition)
1080	{
1081	QRegion ar;
1082	QDesktopWidget *dwt = QApplication::desktop();
1083	if (dwt->isVirtualDesktop())
1084	/* Compose complex available region */
1085	for (int i = 0; i < dwt->numScreens(); ++ i)
1086	ar += dwt->availableGeometry (i);
1087	else
1088	/* Get just a simple available rectangle */
1089	ar = dwt->availableGeometry (tlw->pos());
1090
1091	fr = VBoxGlobal::normalizeGeometry (
1092	fr, ar, mode != VBoxDefs::SDLMode /* canResize */);
1093	}
1094
1095	#if 0
1096	/* center the frame on the desktop */
1097	fr.moveCenter (ar.center());
1098	#endif
1099
1100	/* finally, set the frame geometry */
1101	tlw->setGeometry (fr.left() + dl, fr.top() + dt,
1102	fr.width() - dl - dr, fr.height() - dt - db);
1103	}
1104
1105	/**
1106	* Pauses or resumes the VM execution.
1107	*/
1108	bool VBoxConsoleView::pause (bool on)
1109	{
1110	/* QAction::setOn() emits the toggled() signal, so avoid recursion when
1111	* QAction::setOn() is called from VBoxConsoleWnd::updateMachineState() */
1112	if (isPaused() == on)
1113	return true;
1114
1115	if (on)
1116	mConsole.Pause();
1117	else
1118	mConsole.Resume();
1119
1120	bool ok = mConsole.isOk();
1121	if (!ok)
1122	{
1123	if (on)
1124	vboxProblem().cannotPauseMachine (mConsole);
1125	else
1126	vboxProblem().cannotResumeMachine (mConsole);
1127	}
1128
1129	return ok;
1130	}
1131
1132	/**
1133	* Temporarily disables the mouse integration (or enables it back).
1134	*/
1135	void VBoxConsoleView::setMouseIntegrationEnabled (bool enabled)
1136	{
1137	if (mMouseIntegration == enabled)
1138	return;
1139
1140	if (mMouseCanAbsolute)
1141	captureMouse (!enabled, false);
1142
1143	/* Hiding host cursor in case we are entering mouse integration
1144	* mode until it's shape is set to the guest cursor shape in
1145	* OnMousePointerShapeChange event handler.
1146	*
1147	* This is necessary to avoid double-cursor issues where both the
1148	* guest and the host cursors are displayed in one place, one above the
1149	* other.
1150	*
1151	* This is a workaround because the correct decision would be to notify
1152	* the Guest Additions about we are entering the mouse integration
1153	* mode. The GuestOS should hide it's cursor to allow using of
1154	* host cursor for the guest's manipulation.
1155	*
1156	* This notification is not always possible though, as not all guests
1157	* support switching to a hardware pointer on demand. */
1158	if (enabled)
1159	{
1160	mHideHostPointer = true;
1161	updateHostCursor();
1162	}
1163
1164	mMouseIntegration = enabled;
1165
1166	emitMouseStateChanged();
1167	}
1168
1169	void VBoxConsoleView::updateHostCursor()
1170	{
1171	if (!mMouseIntegration && !mMouseCaptured)
1172	viewport()->unsetCursor();
1173	else if (mMouseCaptured \|\| (mMouseCanAbsolute && mHideHostPointer))
1174	viewport()->setCursor(Qt::BlankCursor);
1175	else
1176	viewport()->setCursor(mLastCursor);
1177	}
1178
1179	void VBoxConsoleView::setAutoresizeGuest (bool on, bool doHint)
1180	{
1181	if (mAutoresizeGuest != on)
1182	{
1183	mAutoresizeGuest = on;
1184
1185	maybeRestrictMinimumSize();
1186
1187	if (mGuestSupportsGraphics && mAutoresizeGuest && doHint)
1188	doResizeHint();
1189	}
1190	}
1191
1192	/**
1193	* This method is called by VBoxConsoleWnd after it does everything necessary
1194	* on its side to go to or from fullscreen, but before it is shown.
1195	*/
1196	void VBoxConsoleView::onFullscreenChange (bool /* on */)
1197	{
1198	/* Nothing to do here so far */
1199	}
1200
1201	/**
1202	* Notify the console scroll-view about the console-window is opened.
1203	*/
1204	void VBoxConsoleView::onViewOpened()
1205	{
1206	/* Variable mIgnoreMainwndResize was initially "true" to ignore QT
1207	* initial resize event in case of auto-resize feature is on.
1208	* Currently, initial resize event is already processed, so we set
1209	* mIgnoreMainwndResize to "false" to process all further resize
1210	* events as user-initiated window resize events. */
1211	mIgnoreMainwndResize = false;
1212	}
1213
1214	//
1215	// Protected Events
1216	/////////////////////////////////////////////////////////////////////////////
1217
1218	bool VBoxConsoleView::event (QEvent *e)
1219	{
1220	if (mAttached)
1221	{
1222	switch (e->type())
1223	{
1224	case QEvent::FocusIn:
1225	{
1226	if (isRunning())
1227	focusEvent (true);
1228	break;
1229	}
1230	case QEvent::FocusOut:
1231	{
1232	if (isRunning())
1233	focusEvent (false);
1234	else
1235	{
1236	/* release the host key and all other pressed keys too even
1237	* when paused (otherwise, we will get stuck keys in the
1238	* guest when doing sendChangedKeyStates() on resume because
1239	* key presses were already recorded in mPressedKeys but key
1240	* releases will most likely not reach us but the new focus
1241	* window instead). */
1242	releaseAllPressedKeys (true /* aReleaseHostKey */);
1243	}
1244	break;
1245	}
1246
1247	case VBoxDefs::ResizeEventType:
1248	{
1249	/* Some situations require initial VGA Resize Request
1250	* to be ignored at all, leaving previous framebuffer,
1251	* console widget and vm window size preserved. */
1252	if (mIgnoreGuestResize)
1253	return true;
1254
1255	bool oldIgnoreMainwndResize = mIgnoreMainwndResize;
1256	mIgnoreMainwndResize = true;
1257
1258	VBoxResizeEvent re = (VBoxResizeEvent ) e;
1259	LogRelFlowFunc (("VBoxDefs::ResizeEventType: %d x %d x %d bpp\n",
1260	re->width(), re->height(),
1261	re->bitsPerPixel()));
1262
1263	bool notifyMainWnd = mFrameBuf->width() != re->width()
1264	\|\| mFrameBuf->height() != re->height();
1265
1266	/* Store the new size to prevent unwanted resize hints being
1267	* sent back. */
1268	storeConsoleSize(re->width(), re->height());
1269	/* do frame buffer dependent resize */
1270
1271	/* restoreOverrideCursor() is broken in Qt 4.4.0 if WA_PaintOnScreen
1272	* widgets are present. This is the case on linux with SDL. As
1273	* workaround we restore the arrow cursor manually after the resize. See
1274	* http://trolltech.com/developer/task-tracker/index_html?id=206165&method=entry
1275	* for details.
1276	*/
1277	QCursor cursor;
1278	mFrameBuf->resizeEvent (re);
1279	updateHostCursor();
1280
1281	#ifdef Q_WS_MAC
1282	mDockIconPreview->setOriginalSize (re->width(), re->height());
1283	#endif /* Q_WS_MAC */
1284
1285	/* This event appears in case of guest video was changed
1286	* for somehow even without video resolution change.
1287	* In this last case the host VM window will not be resized
1288	* according this event and the host mouse cursor which was
1289	* unset to default here will not be hidden in capture state.
1290	* So it is necessary to perform updateMouseClipping() for
1291	* the guest resize event if the mouse cursor was captured. */
1292	if (mMouseCaptured)
1293	updateMouseClipping();
1294
1295	/* apply maximum size restriction */
1296	setMaximumSize (sizeHint());
1297
1298	maybeRestrictMinimumSize();
1299
1300	/* resize the guest canvas */
1301	if (!mIgnoreFrameBufferResize)
1302	resize (re->width(), re->height());
1303	updateSliders();
1304	/* Let our toplevel widget calculate its sizeHint properly. */
1305	#ifdef Q_WS_X11
1306	/* We use processEvents rather than sendPostedEvents & set the
1307	* time out value to max cause on X11 otherwise the layout
1308	* isn't calculated correctly. Dosn't find the bug in Qt, but
1309	* this could be triggered through the async nature of the X11
1310	* window event system. */
1311	QCoreApplication::processEvents (QEventLoop::AllEvents, INT_MAX);
1312	#else /* Q_WS_X11 */
1313	QCoreApplication::sendPostedEvents (0, QEvent::LayoutRequest);
1314	#endif /* Q_WS_X11 */
1315
1316	if (!mIgnoreFrameBufferResize)
1317	normalizeGeometry (true /* adjustPosition */);
1318
1319	/* report to the VM thread that we finished resizing */
1320	mConsole.GetDisplay().ResizeCompleted (0);
1321
1322	mIgnoreMainwndResize = oldIgnoreMainwndResize;
1323
1324	/* update geometry after entering fullscreen \| seamless */
1325	if (mMainWnd->isTrueFullscreen() \|\| mMainWnd->isTrueSeamless())
1326	updateGeometry();
1327
1328	/* make sure that all posted signals are processed */
1329	qApp->processEvents();
1330
1331	/* emit a signal about guest was resized */
1332	emit resizeHintDone();
1333
1334	/* We also recalculate the desktop geometry if this is determined
1335	* automatically. In fact, we only need this on the first resize,
1336	* but it is done every time to keep the code simpler. */
1337	calculateDesktopGeometry();
1338
1339	/* Enable frame-buffer resize watching. */
1340	if (mIgnoreFrameBufferResize)
1341	{
1342	mIgnoreFrameBufferResize = false;
1343	}
1344
1345	if (notifyMainWnd)
1346	mMainWnd->onDisplayResize (re->width(), re->height());
1347
1348	return true;
1349	}
1350
1351	/* See VBox[QImage\|SDL]FrameBuffer::NotifyUpdate(). */
1352	case VBoxDefs::RepaintEventType:
1353	{
1354	VBoxRepaintEvent re = (VBoxRepaintEvent ) e;
1355	viewport()->repaint (re->x() - contentsX(),
1356	re->y() - contentsY(),
1357	re->width(), re->height());
1358	/* mConsole.GetDisplay().UpdateCompleted(); - the event was acked already */
1359	return true;
1360	}
1361
1362	#ifdef VBOX_WITH_VIDEOHWACCEL
1363	case VBoxDefs::VHWACommandProcessType:
1364	{
1365	mFrameBuf->doProcessVHWACommand(e);
1366	return true;
1367	}
1368	#endif
1369
1370	case VBoxDefs::SetRegionEventType:
1371	{
1372	VBoxSetRegionEvent sre = (VBoxSetRegionEvent) e;
1373	if (mMainWnd->isTrueSeamless() &&
1374	sre->region() != mLastVisibleRegion)
1375	{
1376	mLastVisibleRegion = sre->region();
1377	mMainWnd->setMask (sre->region());
1378	}
1379	else if (!mLastVisibleRegion.isEmpty() &&
1380	!mMainWnd->isTrueSeamless())
1381	mLastVisibleRegion = QRegion();
1382	return true;
1383	}
1384
1385	case VBoxDefs::MousePointerChangeEventType:
1386	{
1387	MousePointerChangeEvent me = (MousePointerChangeEvent ) e;
1388	/* change cursor shape only when mouse integration is
1389	* supported (change mouse shape type event may arrive after
1390	* mouse capability change that disables integration */
1391	if (mMouseCanAbsolute)
1392	setPointerShape (me);
1393	else
1394	/* Note: actually we should still remember the requested
1395	* cursor shape. If we can't do that, at least remember
1396	* the requested visiblilty. */
1397	mHideHostPointer = !me->isVisible();
1398	return true;
1399	}
1400	case VBoxDefs::MouseCapabilityEventType:
1401	{
1402	MouseCapabilityEvent me = (MouseCapabilityEvent ) e;
1403	if (mMouseCanAbsolute != me->supportsAbsolute())
1404	{
1405	mMouseCanAbsolute = me->supportsAbsolute();
1406	/* correct the mouse capture state and reset the cursor
1407	* to the default shape if necessary */
1408	if (mMouseCanAbsolute)
1409	{
1410	CMouse mouse = mConsole.GetMouse();
1411	mouse.PutMouseEventAbsolute (-1, -1, 0,
1412	0 /* Horizontal wheel */,
1413	0);
1414	captureMouse (false, false);
1415	}
1416	updateHostCursor();
1417	emitMouseStateChanged();
1418	vboxProblem().remindAboutMouseIntegration (mMouseCanAbsolute);
1419	}
1420	mMouseCanRelative = me->supportsRelative();
1421	mMouseNeedsHostCursor = me->needsHostCursor();
1422	if (!me->supportsRelative() \|\| me->needsHostCursor())
1423	mMainWnd->setMouseIntegrationLocked (false);
1424	else
1425	mMainWnd->setMouseIntegrationLocked (true);
1426	return true;
1427	}
1428
1429	case VBoxDefs::ModifierKeyChangeEventType:
1430	{
1431	ModifierKeyChangeEvent me = (ModifierKeyChangeEvent )e;
1432	if (me->numLock() != mNumLock)
1433	muNumLockAdaptionCnt = 2;
1434	if (me->capsLock() != mCapsLock)
1435	muCapsLockAdaptionCnt = 2;
1436	mNumLock = me->numLock();
1437	mCapsLock = me->capsLock();
1438	mScrollLock = me->scrollLock();
1439	return true;
1440	}
1441
1442	case VBoxDefs::MachineStateChangeEventType:
1443	{
1444	StateChangeEvent me = (StateChangeEvent ) e;
1445	LogFlowFunc (("MachineStateChangeEventType: state=%d\n",
1446	me->machineState()));
1447	onStateChange (me->machineState());
1448	emit machineStateChanged (me->machineState());
1449	return true;
1450	}
1451
1452	case VBoxDefs::AdditionsStateChangeEventType:
1453	{
1454	GuestAdditionsEvent ge = (GuestAdditionsEvent ) e;
1455	LogFlowFunc (("AdditionsStateChangeEventType\n"));
1456
1457	/* Always send a size hint if we are in fullscreen or seamless
1458	* when the graphics capability is enabled, in case the host
1459	* resolution has changed since the VM was last run. */
1460	#if 0
1461	if (!mDoResize && !mGuestSupportsGraphics &&
1462	ge->supportsGraphics() &&
1463	(mMainWnd->isTrueSeamless() \|\| mMainWnd->isTrueFullscreen()))
1464	mDoResize = true;
1465	#endif
1466
1467	mGuestSupportsGraphics = ge->supportsGraphics();
1468
1469	maybeRestrictMinimumSize();
1470
1471	#if 0
1472	/* This will only be acted upon if mDoResize is true. */
1473	doResizeHint();
1474	#endif
1475
1476	emit additionsStateChanged (ge->additionVersion(),
1477	ge->additionActive(),
1478	ge->supportsSeamless(),
1479	ge->supportsGraphics());
1480	return true;
1481	}
1482
1483	case VBoxDefs::MediaDriveChangeEventType:
1484	{
1485	MediaDriveChangeEvent mce = (MediaDriveChangeEvent ) e;
1486	LogFlowFunc (("MediaChangeEvent\n"));
1487
1488	emit mediaDriveChanged (mce->type());
1489	return true;
1490	}
1491
1492	case VBoxDefs::ActivateMenuEventType:
1493	{
1494	ActivateMenuEvent ame = (ActivateMenuEvent ) e;
1495	ame->action()->trigger();
1496
1497	/*
1498	* The main window and its children can be destroyed at this
1499	* point (if, for example, the activated menu item closes the
1500	* main window). Detect this situation to prevent calls to
1501	* destroyed widgets.
1502	*/
1503	QWidgetList list = QApplication::topLevelWidgets();
1504	bool destroyed = list.indexOf (mMainWnd) < 0;
1505	if (!destroyed && mMainWnd->statusBar())
1506	mMainWnd->statusBar()->clearMessage();
1507
1508	return true;
1509	}
1510
1511	case VBoxDefs::NetworkAdapterChangeEventType:
1512	{
1513	/* no specific adapter information stored in this
1514	* event is currently used */
1515	emit networkStateChange();
1516	return true;
1517	}
1518
1519	case VBoxDefs::USBCtlStateChangeEventType:
1520	{
1521	emit usbStateChange();
1522	return true;
1523	}
1524
1525	case VBoxDefs::USBDeviceStateChangeEventType:
1526	{
1527	USBDeviceStateChangeEvent ue = (USBDeviceStateChangeEvent )e;
1528
1529	bool success = ue->error().isNull();
1530
1531	if (!success)
1532	{
1533	if (ue->attached())
1534	vboxProblem().cannotAttachUSBDevice (
1535	mConsole,
1536	vboxGlobal().details (ue->device()), ue->error());
1537	else
1538	vboxProblem().cannotDetachUSBDevice (
1539	mConsole,
1540	vboxGlobal().details (ue->device()), ue->error());
1541	}
1542
1543	emit usbStateChange();
1544
1545	return true;
1546	}
1547
1548	case VBoxDefs::SharedFolderChangeEventType:
1549	{
1550	emit sharedFoldersChanged();
1551	return true;
1552	}
1553
1554	case VBoxDefs::RuntimeErrorEventType:
1555	{
1556	RuntimeErrorEvent ee = (RuntimeErrorEvent ) e;
1557	vboxProblem().showRuntimeError (mConsole, ee->fatal(),
1558	ee->errorID(), ee->message());
1559	return true;
1560	}
1561
1562	case QEvent::KeyPress:
1563	case QEvent::KeyRelease:
1564	{
1565	QKeyEvent ke = (QKeyEvent ) e;
1566
1567	#ifdef Q_WS_PM
1568	/// @todo temporary solution to send Alt+Tab and friends to
1569	// the guest. The proper solution is to write a keyboard
1570	// driver that will steal these combos from the host (it's
1571	// impossible to do so using hooks on OS/2).
1572
1573	if (mIsHostkeyPressed)
1574	{
1575	bool pressed = e->type() == QEvent::KeyPress;
1576	CKeyboard keyboard = mConsole.GetKeyboard();
1577
1578	/* whether the host key is Shift so that it will modify
1579	* the hot key values? Note that we don't distinguish
1580	* between left and right shift here (too much hassle) */
1581	const bool kShift = (gs.hostKey() == VK_SHIFT \|\|
1582	gs.hostKey() == VK_LSHIFT) &&
1583	(ke->state() & Qt::ShiftModifier);
1584	/* define hot keys according to the Shift state */
1585	const int kAltTab = kShift ? Qt::Key_Exclam : Qt::Key_1;
1586	const int kAltShiftTab = kShift ? Qt::Key_At : Qt::Key_2;
1587	const int kCtrlEsc = kShift ? Qt::Key_AsciiTilde : Qt::Key_QuoteLeft;
1588
1589	/* Simulate Alt+Tab on Host+1 and Alt+Shift+Tab on Host+2 */
1590	if (ke->key() == kAltTab \|\| ke->key() == kAltShiftTab)
1591	{
1592	if (pressed)
1593	{
1594	/* Send the Alt press to the guest */
1595	if (!(mPressedKeysCopy [0x38] & IsKeyPressed))
1596	{
1597	/* store the press in *Copy to have it automatically
1598	* released when the Host key is released */
1599	mPressedKeysCopy [0x38] \|= IsKeyPressed;
1600	keyboard.PutScancode (0x38);
1601	}
1602
1603	/* Make sure Shift is pressed if it's Key_2 and released
1604	* if it's Key_1 */
1605	if (ke->key() == kAltTab &&
1606	(mPressedKeysCopy [0x2A] & IsKeyPressed))
1607	{
1608	mPressedKeysCopy [0x2A] &= ~IsKeyPressed;
1609	keyboard.PutScancode (0xAA);
1610	}
1611	else
1612	if (ke->key() == kAltShiftTab &&
1613	!(mPressedKeysCopy [0x2A] & IsKeyPressed))
1614	{
1615	mPressedKeysCopy [0x2A] \|= IsKeyPressed;
1616	keyboard.PutScancode (0x2A);
1617	}
1618	}
1619
1620	keyboard.PutScancode (pressed ? 0x0F : 0x8F);
1621
1622	ke->accept();
1623	return true;
1624	}
1625
1626	/* Simulate Ctrl+Esc on Host+Tilde */
1627	if (ke->key() == kCtrlEsc)
1628	{
1629	/* Send the Ctrl press to the guest */
1630	if (pressed && !(mPressedKeysCopy [0x1d] & IsKeyPressed))
1631	{
1632	/* store the press in *Copy to have it automatically
1633	* released when the Host key is released */
1634	mPressedKeysCopy [0x1d] \|= IsKeyPressed;
1635	keyboard.PutScancode (0x1d);
1636	}
1637
1638	keyboard.PutScancode (pressed ? 0x01 : 0x81);
1639
1640	ke->accept();
1641	return true;
1642	}
1643	}
1644
1645	/* fall through to normal processing */
1646
1647	#endif /* Q_WS_PM */
1648
1649	if (mIsHostkeyPressed && e->type() == QEvent::KeyPress)
1650	{
1651	if (ke->key() >= Qt::Key_F1 && ke->key() <= Qt::Key_F12)
1652	{
1653	QVector <LONG> combo (6);
1654	combo [0] = 0x1d; /* Ctrl down */
1655	combo [1] = 0x38; /* Alt down */
1656	combo [4] = 0xb8; /* Alt up */
1657	combo [5] = 0x9d; /* Ctrl up */
1658	if (ke->key() >= Qt::Key_F1 && ke->key() <= Qt::Key_F10)
1659	{
1660	combo [2] = 0x3b + (ke->key() - Qt::Key_F1); /* F1-F10 down */
1661	combo [3] = 0xbb + (ke->key() - Qt::Key_F1); /* F1-F10 up */
1662	}
1663	/* some scan slice */
1664	else if (ke->key() >= Qt::Key_F11 && ke->key() <= Qt::Key_F12)
1665	{
1666	combo [2] = 0x57 + (ke->key() - Qt::Key_F11); /* F11-F12 down */
1667	combo [3] = 0xd7 + (ke->key() - Qt::Key_F11); /* F11-F12 up */
1668	}
1669	else
1670	Assert (0);
1671
1672	CKeyboard keyboard = mConsole.GetKeyboard();
1673	keyboard.PutScancodes (combo);
1674	}
1675	else if (ke->key() == Qt::Key_Home)
1676	{
1677	/* Activate the main menu */
1678	if (mMainWnd->isTrueSeamless() \|\| mMainWnd->isTrueFullscreen())
1679	mMainWnd->popupMainMenu (mMouseCaptured);
1680	else
1681	{
1682	/* In Qt4 it is not enough to just set the focus to
1683	* menu-bar. So to get the menu-bar we have to send
1684	* Qt::Key_Alt press/release events directly. */
1685	QKeyEvent e1 (QEvent::KeyPress, Qt::Key_Alt,
1686	Qt::NoModifier);
1687	QKeyEvent e2 (QEvent::KeyRelease, Qt::Key_Alt,
1688	Qt::NoModifier);
1689	QApplication::sendEvent (mMainWnd->menuBar(), &e1);
1690	QApplication::sendEvent (mMainWnd->menuBar(), &e2);
1691	}
1692	}
1693	else
1694	{
1695	/* process hot keys not processed in keyEvent()
1696	* (as in case of non-alphanumeric keys) */
1697	processHotKey (QKeySequence (ke->key()),
1698	mMainWnd->menuBar()->actions());
1699	}
1700	}
1701	else if (!mIsHostkeyPressed && e->type() == QEvent::KeyRelease)
1702	{
1703	/* Show a possible warning on key release which seems to
1704	* be more expected by the end user */
1705
1706	if (isPaused())
1707	{
1708	/* if the reminder is disabled we pass the event to
1709	* Qt to enable normal keyboard functionality
1710	* (for example, menu access with Alt+Letter) */
1711	if (!vboxProblem().remindAboutPausedVMInput())
1712	break;
1713	}
1714	}
1715
1716	ke->accept();
1717	return true;
1718	}
1719
1720	#ifdef Q_WS_MAC
1721	/* posted OnShowWindow */
1722	case VBoxDefs::ShowWindowEventType:
1723	{
1724	/*
1725	* Dunno what Qt3 thinks a window that has minimized to the dock
1726	* should be - it is not hidden, neither is it minimized. OTOH it is
1727	* marked shown and visible, but not activated. This latter isn't of
1728	* much help though, since at this point nothing is marked activated.
1729	* I might have overlooked something, but I'm buggered what if I know
1730	* what. So, I'll just always show & activate the stupid window to
1731	* make it get out of the dock when the user wishes to show a VM.
1732	*/
1733	window()->show();
1734	window()->activateWindow();
1735	return true;
1736	}
1737	#endif
1738	default:
1739	break;
1740	}
1741	}
1742
1743	return QAbstractScrollArea::event (e);
1744	}
1745
1746	#ifdef VBOX_WITH_VIDEOHWACCEL
1747	void VBoxConsoleView::scrollContentsBy (int dx, int dy)
1748	{
1749	if (mAttached && mFrameBuf)
1750	{
1751	mFrameBuf->viewportScrolled(dx, dy);
1752	}
1753	QAbstractScrollArea::scrollContentsBy (dx, dy);
1754	}
1755	#endif
1756
1757
1758	bool VBoxConsoleView::eventFilter (QObject watched, QEvent e)
1759	{
1760	if (mAttached && watched == viewport())
1761	{
1762	switch (e->type())
1763	{
1764	case QEvent::MouseMove:
1765	case QEvent::MouseButtonPress:
1766	case QEvent::MouseButtonDblClick:
1767	case QEvent::MouseButtonRelease:
1768	{
1769	QMouseEvent me = (QMouseEvent ) e;
1770	m_iLastMouseWheelDelta = 0;
1771	if (mouseEvent (me->type(), me->pos(), me->globalPos(),
1772	me->buttons(), me->modifiers(),
1773	0, Qt::Horizontal))
1774	return true; /* stop further event handling */
1775	break;
1776	}
1777	case QEvent::Wheel:
1778	{
1779	QWheelEvent we = (QWheelEvent ) e;
1780	/* There are pointing devices which send smaller values for the
1781	* delta than 120. Here we sum them up until we are greater
1782	* than 120. This allows to have finer control over the speed
1783	* acceleration & enables such devices to send a valid wheel
1784	* event to our guest mouse device at all. */
1785	int iDelta = 0;
1786	m_iLastMouseWheelDelta += we->delta();
1787	if (qAbs(m_iLastMouseWheelDelta) >= 120)
1788	{
1789	iDelta = m_iLastMouseWheelDelta;
1790	m_iLastMouseWheelDelta = m_iLastMouseWheelDelta % 120;
1791	}
1792	if (mouseEvent (we->type(), we->pos(), we->globalPos(),
1793	#ifdef QT_MAC_USE_COCOA
1794	/* Qt Cocoa is buggy. It always reports a left
1795	* button pressed when the mouse wheel event
1796	* occurs. A workaround is to ask the
1797	* application which buttons are pressed
1798	* currently. */
1799	QApplication::mouseButtons(),
1800	#else /* QT_MAC_USE_COCOA */
1801	we->buttons(),
1802	#endif /* QT_MAC_USE_COCOA */
1803	we->modifiers(),
1804	iDelta, we->orientation()))
1805	return true; /* stop further event handling */
1806	break;
1807	}
1808	#ifdef Q_WS_MAC
1809	case QEvent::Leave:
1810	{
1811	/* Enable mouse event compression if we leave the VM view. This
1812	is necessary for having smooth resizing of the VM/other
1813	windows. */
1814	setMouseCoalescingEnabled (true);
1815	break;
1816	}
1817	case QEvent::Enter:
1818	{
1819	/* Disable mouse event compression if we enter the VM view. So
1820	all mouse events are registered in the VM. Only do this if
1821	the keyboard/mouse is grabbed (this is when we have a valid
1822	event handler). */
1823	setMouseCoalescingEnabled (false);
1824	break;
1825	}
1826	#endif /* Q_WS_MAC */
1827	case QEvent::Resize:
1828	{
1829	if (mMouseCaptured)
1830	updateMouseClipping();
1831	#ifdef VBOX_WITH_VIDEOHWACCEL
1832	if (mFrameBuf)
1833	{
1834	mFrameBuf->viewportResized((QResizeEvent*)e);
1835	}
1836	#endif
1837	break;
1838	}
1839	default:
1840	break;
1841	}
1842	}
1843	else if (watched == mMainWnd)
1844	{
1845	switch (e->type())
1846	{
1847	#if defined (Q_WS_WIN32)
1848	#if defined (VBOX_GUI_USE_DDRAW)
1849	case QEvent::Move:
1850	{
1851	/*
1852	* notification from our parent that it has moved. We need this
1853	* in order to possibly adjust the direct screen blitting.
1854	*/
1855	if (mFrameBuf)
1856	mFrameBuf->moveEvent ((QMoveEvent *) e);
1857	break;
1858	}
1859	#endif
1860	/*
1861	* install/uninstall low-level kbd hook on every
1862	* activation/deactivation to:
1863	* a) avoid excess hook calls when we're not active and
1864	* b) be always in front of any other possible hooks
1865	*/
1866	case QEvent::WindowActivate:
1867	{
1868	gKbdHook = SetWindowsHookEx (WH_KEYBOARD_LL, lowLevelKeyboardProc,
1869	GetModuleHandle (NULL), 0);
1870	AssertMsg (gKbdHook, ("SetWindowsHookEx(): err=%d", GetLastError()));
1871	break;
1872	}
1873	case QEvent::WindowDeactivate:
1874	{
1875	if (gKbdHook)
1876	{
1877	UnhookWindowsHookEx (gKbdHook);
1878	gKbdHook = NULL;
1879	}
1880	break;
1881	}
1882	#endif /* defined (Q_WS_WIN32) */
1883	#if defined (Q_WS_MAC)
1884	/*
1885	* Install/remove the keyboard event handler.
1886	*/
1887	case QEvent::WindowActivate:
1888	darwinGrabKeyboardEvents (true);
1889	break;
1890	case QEvent::WindowDeactivate:
1891	darwinGrabKeyboardEvents (false);
1892	break;
1893	#endif /* defined (Q_WS_MAC) */
1894	case QEvent::Resize:
1895	{
1896	/* Set the "guest needs to resize" hint. This hint is acted upon
1897	* when (and only when) the autoresize property is "true". */
1898	mDoResize = mGuestSupportsGraphics \|\| mMainWnd->isTrueFullscreen();
1899	if (!mIgnoreMainwndResize &&
1900	mGuestSupportsGraphics && mAutoresizeGuest)
1901	QTimer::singleShot (300, this, SLOT (doResizeHint()));
1902	break;
1903	}
1904	case QEvent::WindowStateChange:
1905	{
1906	/* During minimizing and state restoring mMainWnd gets the focus
1907	* which belongs to console view window, so returning it properly. */
1908	QWindowStateChangeEvent ev = static_cast <QWindowStateChangeEvent> (e);
1909	if (ev->oldState() & Qt::WindowMinimized)
1910	{
1911	if (QApplication::focusWidget())
1912	{
1913	QApplication::focusWidget()->clearFocus();
1914	qApp->processEvents();
1915	}
1916	QTimer::singleShot (0, this, SLOT (setFocus()));
1917	}
1918	break;
1919	}
1920
1921	default:
1922	break;
1923	}
1924	}
1925	else if (watched == mMainWnd->menuBar())
1926	{
1927	/*
1928	* sometimes when we press ESC in the menu it brings the
1929	* focus away (Qt bug?) causing no widget to have a focus,
1930	* or holds the focus itself, instead of returning the focus
1931	* to the console window. here we fix this.
1932	*/
1933	switch (e->type())
1934	{
1935	case QEvent::FocusOut:
1936	{
1937	if (qApp->focusWidget() == 0)
1938	setFocus();
1939	break;
1940	}
1941	case QEvent::KeyPress:
1942	{
1943	QKeyEvent ke = (QKeyEvent ) e;
1944	if (ke->key() == Qt::Key_Escape && (ke->modifiers() == Qt::NoModifier))
1945	if (mMainWnd->menuBar()->hasFocus())
1946	setFocus();
1947	break;
1948	}
1949	default:
1950	break;
1951	}
1952	}
1953
1954	return QAbstractScrollArea::eventFilter (watched, e);
1955	}
1956
1957	#if defined(Q_WS_WIN32)
1958
1959	/**
1960	* Low-level keyboard event handler,
1961	* @return
1962	* true to indicate that the message is processed and false otherwise
1963	*/
1964	bool VBoxConsoleView::winLowKeyboardEvent (UINT msg, const KBDLLHOOKSTRUCT &event)
1965	{
1966	#if 0
1967	LogFlow (("### vkCode=%08X, scanCode=%08X, flags=%08X, dwExtraInfo=%08X (mKbdCaptured=%d)\n",
1968	event.vkCode, event.scanCode, event.flags, event.dwExtraInfo, mKbdCaptured));
1969	char buf [256];
1970	sprintf (buf, "### vkCode=%08X, scanCode=%08X, flags=%08X, dwExtraInfo=%08X",
1971	event.vkCode, event.scanCode, event.flags, event.dwExtraInfo);
1972	mMainWnd->statusBar()->message (buf);
1973	#endif
1974
1975	/* Sometimes it happens that Win inserts additional events on some key
1976	* press/release. For example, it prepends ALT_GR in German layout with
1977	* the VK_LCONTROL vkey with curious 0x21D scan code (seems to be necessary
1978	* to specially treat ALT_GR to enter additional chars to regular apps).
1979	* These events are definitely unwanted in VM, so filter them out. */
1980	/* Note (michael): it also sometimes sends the VK_CAPITAL vkey with scan
1981	* code 0x23a. If this is not passed through then it is impossible to
1982	* cancel CapsLock on a French keyboard. I didn't find any other examples
1983	* of these strange events. Let's hope we are not missing anything else
1984	* of importance! */
1985	if (hasFocus() && (event.scanCode & ~0xFF))
1986	{
1987	if (event.vkCode == VK_CAPITAL)
1988	return false;
1989	else
1990	return true;
1991	}
1992
1993	if (!mKbdCaptured)
1994	return false;
1995
1996	/* it's possible that a key has been pressed while the keyboard was not
1997	* captured, but is being released under the capture. Detect this situation
1998	* and return false to let Windows process the message normally and update
1999	* its key state table (to avoid the stuck key effect). */
2000	uint8_t what_pressed = (event.flags & 0x01) && (event.vkCode != VK_RSHIFT)
2001	? IsExtKeyPressed
2002	: IsKeyPressed;
2003	if ((event.flags & 0x80) /* released */ &&
2004	((event.vkCode == gs.hostKey() && !hostkey_in_capture) \|\|
2005	(mPressedKeys [event.scanCode] & (IsKbdCaptured \| what_pressed)) == what_pressed))
2006	return false;
2007
2008	MSG message;
2009	message.hwnd = winId();
2010	message.message = msg;
2011	message.wParam = event.vkCode;
2012	message.lParam =
2013	1 \|
2014	(event.scanCode & 0xFF) << 16 \|
2015	(event.flags & 0xFF) << 24;
2016
2017	/* Windows sets here the extended bit when the Right Shift key is pressed,
2018	* which is totally wrong. Undo it. */
2019	if (event.vkCode == VK_RSHIFT)
2020	message.lParam &= ~0x1000000;
2021
2022	/* we suppose here that this hook is always called on the main GUI thread */
2023	long dummyResult;
2024	return winEvent (&message, &dummyResult);
2025	}
2026
2027	/**
2028	* Get Win32 messages before they are passed to Qt. This allows us to get
2029	* the keyboard events directly and bypass the harmful Qt translation. A
2030	* return value of @c true indicates to Qt that the event has been handled.
2031	*/
2032	bool VBoxConsoleView::winEvent (MSG aMsg, long /* aResult */)
2033	{
2034	if (!mAttached \|\| ! (
2035	aMsg->message == WM_KEYDOWN \|\| aMsg->message == WM_SYSKEYDOWN \|\|
2036	aMsg->message == WM_KEYUP \|\| aMsg->message == WM_SYSKEYUP
2037	))
2038	return false;
2039
2040	/* check for the special flag possibly set at the end of this function */
2041	if (aMsg->lParam & (0x1 << 25))
2042	{
2043	aMsg->lParam &= ~(0x1 << 25);
2044	return false;
2045	}
2046
2047	#if 0
2048	char buf [256];
2049	sprintf (buf, "WM_%04X: vk=%04X rep=%05d scan=%02X ext=%01d rzv=%01X ctx=%01d prev=%01d tran=%01d",
2050	aMsg->message, aMsg->wParam,
2051	(aMsg->lParam & 0xFFFF),
2052	((aMsg->lParam >> 16) & 0xFF),
2053	((aMsg->lParam >> 24) & 0x1),
2054	((aMsg->lParam >> 25) & 0xF),
2055	((aMsg->lParam >> 29) & 0x1),
2056	((aMsg->lParam >> 30) & 0x1),
2057	((aMsg->lParam >> 31) & 0x1));
2058	mMainWnd->statusBar()->message (buf);
2059	LogFlow (("%s\n", buf));
2060	#endif
2061
2062	int scan = (aMsg->lParam >> 16) & 0x7F;
2063	/* scancodes 0x80 and 0x00 are ignored */
2064	if (!scan)
2065	return true;
2066
2067	int vkey = aMsg->wParam;
2068
2069	/* When one of the SHIFT keys is held and one of the cursor movement
2070	* keys is pressed, Windows duplicates SHIFT press/release messages,
2071	* but with the virtual key code set to 0xFF. These virtual keys are also
2072	* sent in some other situations (Pause, PrtScn, etc.). Ignore such
2073	* messages. */
2074	if (vkey == 0xFF)
2075	return true;
2076
2077	int flags = 0;
2078	if (aMsg->lParam & 0x1000000)
2079	flags \|= KeyExtended;
2080	if (!(aMsg->lParam & 0x80000000))
2081	flags \|= KeyPressed;
2082
2083	switch (vkey)
2084	{
2085	case VK_SHIFT:
2086	case VK_CONTROL:
2087	case VK_MENU:
2088	{
2089	/* overcome stupid Win32 modifier key generalization */
2090	int keyscan = scan;
2091	if (flags & KeyExtended)
2092	keyscan \|= 0xE000;
2093	switch (keyscan)
2094	{
2095	case 0x002A: vkey = VK_LSHIFT; break;
2096	case 0x0036: vkey = VK_RSHIFT; break;
2097	case 0x001D: vkey = VK_LCONTROL; break;
2098	case 0xE01D: vkey = VK_RCONTROL; break;
2099	case 0x0038: vkey = VK_LMENU; break;
2100	case 0xE038: vkey = VK_RMENU; break;
2101	}
2102	break;
2103	}
2104	case VK_NUMLOCK:
2105	/* Win32 sets the extended bit for the NumLock key. Reset it. */
2106	flags &= ~KeyExtended;
2107	break;
2108	case VK_SNAPSHOT:
2109	flags \|= KeyPrint;
2110	break;
2111	case VK_PAUSE:
2112	flags \|= KeyPause;
2113	break;
2114	}
2115
2116	bool result = keyEvent (vkey, scan, flags);
2117	if (!result && mKbdCaptured)
2118	{
2119	/* keyEvent() returned that it didn't process the message, but since the
2120	* keyboard is captured, we don't want to pass it to Windows. We just want
2121	* to let Qt process the message (to handle non-alphanumeric <HOST>+key
2122	* shortcuts for example). So send it direcltly to the window with the
2123	* special flag in the reserved area of lParam (to avoid recursion). */
2124	::SendMessage (aMsg->hwnd, aMsg->message,
2125	aMsg->wParam, aMsg->lParam \| (0x1 << 25));
2126	return true;
2127	}
2128
2129	/* These special keys have to be handled by Windows as well to update the
2130	* internal modifier state and to enable/disable the keyboard LED */
2131	if (vkey == VK_NUMLOCK \|\| vkey == VK_CAPITAL \|\| vkey == VK_LSHIFT \|\| vkey == VK_RSHIFT)
2132	return false;
2133
2134	return result;
2135	}
2136
2137	#elif defined (Q_WS_PM)
2138
2139	/**
2140	* Get PM messages before they are passed to Qt. This allows us to get
2141	* the keyboard events directly and bypass the harmful Qt translation. A
2142	* return value of @c true indicates to Qt that the event has been handled.
2143	*/
2144	bool VBoxConsoleView::pmEvent (QMSG *aMsg)
2145	{
2146	if (!mAttached)
2147	return false;
2148
2149	if (aMsg->msg == UM_PREACCEL_CHAR)
2150	{
2151	/* we are inside the input hook */
2152
2153	/* let the message go through the normal system pipeline */
2154	if (!mKbdCaptured)
2155	return false;
2156	}
2157
2158	if (aMsg->msg != WM_CHAR &&
2159	aMsg->msg != UM_PREACCEL_CHAR)
2160	return false;
2161
2162	/* check for the special flag possibly set at the end of this function */
2163	if (SHORT2FROMMP (aMsg->mp2) & 0x8000)
2164	{
2165	aMsg->mp2 = MPFROM2SHORT (SHORT1FROMMP (aMsg->mp2),
2166	SHORT2FROMMP (aMsg->mp2) & ~0x8000);
2167	return false;
2168	}
2169
2170	#if 0
2171	{
2172	char buf [256];
2173	sprintf (buf, "*** %s: f=%04X rep=%03d scan=%02X ch=%04X vk=%04X",
2174	(aMsg->msg == WM_CHAR ? "WM_CHAR" : "UM_PREACCEL_CHAR"),
2175	SHORT1FROMMP (aMsg->mp1), CHAR3FROMMP (aMsg->mp1),
2176	CHAR4FROMMP (aMsg->mp1), SHORT1FROMMP (aMsg->mp2),
2177	SHORT2FROMMP (aMsg->mp2));
2178	mMainWnd->statusBar()->message (buf);
2179	LogFlow (("%s\n", buf));
2180	}
2181	#endif
2182
2183	USHORT ch = SHORT1FROMMP (aMsg->mp2);
2184	USHORT f = SHORT1FROMMP (aMsg->mp1);
2185
2186	int scan = (unsigned int) CHAR4FROMMP (aMsg->mp1);
2187	if (!scan \|\| scan > 0x7F)
2188	return true;
2189
2190	int vkey = QIHotKeyEdit::virtualKey (aMsg);
2191
2192	int flags = 0;
2193
2194	if ((ch & 0xFF) == 0xE0)
2195	{
2196	flags \|= KeyExtended;
2197	scan = ch >> 8;
2198	}
2199	else if (scan == 0x5C && (ch & 0xFF) == '/')
2200	{
2201	/* this is the '/' key on the keypad */
2202	scan = 0x35;
2203	flags \|= KeyExtended;
2204	}
2205	else
2206	{
2207	/* For some keys, the scan code passed in QMSG is a pseudo scan
2208	* code. We replace it with a real hardware scan code, according to
2209	* http://www.computer-engineering.org/ps2keyboard/scancodes1.html.
2210	* Also detect Pause and PrtScn and set flags. */
2211	switch (vkey)
2212	{
2213	case VK_ENTER: scan = 0x1C; flags \|= KeyExtended; break;
2214	case VK_CTRL: scan = 0x1D; flags \|= KeyExtended; break;
2215	case VK_ALTGRAF: scan = 0x38; flags \|= KeyExtended; break;
2216	case VK_LWIN: scan = 0x5B; flags \|= KeyExtended; break;
2217	case VK_RWIN: scan = 0x5C; flags \|= KeyExtended; break;
2218	case VK_WINMENU: scan = 0x5D; flags \|= KeyExtended; break;
2219	case VK_FORWARD: scan = 0x69; flags \|= KeyExtended; break;
2220	case VK_BACKWARD: scan = 0x6A; flags \|= KeyExtended; break;
2221	#if 0
2222	/// @todo this would send 0xE0 0x46 0xE0 0xC6. It's not fully
2223	// clear what is more correct
2224	case VK_BREAK: scan = 0x46; flags \|= KeyExtended; break;
2225	#else
2226	case VK_BREAK: scan = 0; flags \|= KeyPause; break;
2227	#endif
2228	case VK_PAUSE: scan = 0; flags \|= KeyPause; break;
2229	case VK_PRINTSCRN: scan = 0; flags \|= KeyPrint; break;
2230	default:;
2231	}
2232	}
2233
2234	if (!(f & KC_KEYUP))
2235	flags \|= KeyPressed;
2236
2237	bool result = keyEvent (vkey, scan, flags);
2238	if (!result && mKbdCaptured)
2239	{
2240	/* keyEvent() returned that it didn't process the message, but since the
2241	* keyboard is captured, we don't want to pass it to PM. We just want
2242	* to let Qt process the message (to handle non-alphanumeric <HOST>+key
2243	* shortcuts for example). So send it direcltly to the window with the
2244	* special flag in the reserved area of lParam (to avoid recursion). */
2245	::WinSendMsg (aMsg->hwnd, WM_CHAR,
2246	aMsg->mp1,
2247	MPFROM2SHORT (SHORT1FROMMP (aMsg->mp2),
2248	SHORT2FROMMP (aMsg->mp2) \| 0x8000));
2249	return true;
2250	}
2251	return result;
2252	}
2253
2254	#elif defined(Q_WS_X11)
2255
2256	/**
2257	* This function is a "predicate" for XCheckIfEvent(). It will check
2258	* the XEvent passed to it to see if it is a keypress event matching
2259	* the keyrelease event in @a pvArg.
2260	* @returns True if the event matches, False otherwise
2261	* @param pEvent the event to compare, taken from the event queue
2262	* @param pvArg the keyrelease event we would like to compare against
2263	*/
2264	static Bool VBoxConsoleViewCompEvent(Display , XEvent pEvent,
2265	XPointer pvArg)
2266	{
2267	XEvent pKeyEvent = (XEvent ) pvArg;
2268	if ((pEvent->type == XKeyPress) &&
2269	(pEvent->xkey.keycode == pKeyEvent->xkey.keycode))
2270	return True;
2271	else
2272	return False;
2273	}
2274
2275	/**
2276	* This routine gets X11 events before they are processed by Qt. This is
2277	* used for our platform specific keyboard implementation. A return value
2278	* of TRUE indicates that the event has been processed by us.
2279	*/
2280	bool VBoxConsoleView::x11Event (XEvent *event)
2281	{
2282	switch (event->type)
2283	{
2284	/* We have to handle XFocusOut right here as this event is not passed
2285	* to VBoxConsoleView::event(). Handling this event is important for
2286	* releasing the keyboard before the screen saver gets active.
2287	*
2288	* See public ticket #3894: Apparently this makes problems with newer
2289	* versions of Qt and this hack is probably not necessary anymore.
2290	* So disable it for Qt >= 4.5.0. */
2291	case XFocusOut:
2292	case XFocusIn:
2293	if (isRunning())
2294	{
2295	if (VBoxGlobal::qtRTVersion() < ((4 << 16) \| (5 << 8) \| 0))
2296	focusEvent (event->type == XFocusIn);
2297	}
2298	return false;
2299	case XKeyPress:
2300	case XKeyRelease:
2301	if (mAttached)
2302	break;
2303	/* else fall through */
2304	default:
2305	return false; /* pass the event to Qt */
2306	}
2307
2308	/* Translate the keycode to a PC scan code. */
2309	unsigned scan = handleXKeyEvent (event);
2310
2311	#if 0
2312	char buf [256];
2313	sprintf (buf, "pr=%d kc=%08X st=%08X extended=%s scan=%04X",
2314	event->type == XKeyPress ? 1 : 0, event->xkey.keycode,
2315	event->xkey.state, scan >> 8 ? "true" : "false", scan & 0x7F);
2316	mMainWnd->statusBar()->message (buf);
2317	LogFlow (("### %s\n", buf));
2318	#endif
2319
2320	// scancodes 0x00 (no valid translation) and 0x80 are ignored
2321	if (!scan & 0x7F)
2322	return true;
2323
2324	/* Fix for http://www.virtualbox.org/ticket/1296:
2325	* when X11 sends events for repeated keys, it always inserts an
2326	* XKeyRelease before the XKeyPress. */
2327	XEvent returnEvent;
2328	if ((event->type == XKeyRelease) &&
2329	(XCheckIfEvent(event->xkey.display, &returnEvent,
2330	VBoxConsoleViewCompEvent, (XPointer) event) == True)) {
2331	XPutBackEvent(event->xkey.display, &returnEvent);
2332	/* Discard it, don't pass it to Qt. */
2333	return true;
2334	}
2335
2336	KeySym ks = ::XKeycodeToKeysym (event->xkey.display, event->xkey.keycode, 0);
2337
2338	int flags = 0;
2339	if (scan >> 8)
2340	flags \|= KeyExtended;
2341	if (event->type == XKeyPress)
2342	flags \|= KeyPressed;
2343
2344	/* Remove the extended flag */
2345	scan &= 0x7F;
2346
2347	switch (ks)
2348	{
2349	case XK_Print:
2350	flags \|= KeyPrint;
2351	break;
2352	case XK_Pause:
2353	if (event->xkey.state & ControlMask) /* Break */
2354	{
2355	ks = XK_Break;
2356	flags \|= KeyExtended;
2357	scan = 0x46;
2358	}
2359	else
2360	flags \|= KeyPause;
2361	break;
2362	}
2363
2364	return keyEvent (ks, scan, flags);
2365	}
2366
2367	#elif defined (Q_WS_MAC)
2368
2369	/**
2370	* Invoked by VBoxConsoleView::darwinEventHandlerProc / VBoxConsoleView::macEventFilter when
2371	* it receives a raw keyboard event.
2372	*
2373	* @param pvCocoaEvent The Cocoa keyboard event. Can be NULL in some configs.
2374	* @param inEvent The keyboard event.
2375	*
2376	* @return true if the key was processed, false if it wasn't processed and should be passed on.
2377	*/
2378	bool VBoxConsoleView::darwinKeyboardEvent (const void *pvCocoaEvent, EventRef inEvent)
2379	{
2380	bool ret = false;
2381	UInt32 EventKind = ::GetEventKind (inEvent);
2382	if (EventKind != kEventRawKeyModifiersChanged)
2383	{
2384	/* convert keycode to set 1 scan code. */
2385	UInt32 keyCode = ~0U;
2386	::GetEventParameter (inEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof (keyCode), NULL, &keyCode);
2387	/* The usb keyboard driver translates these codes to different virtual
2388	* key codes depending of the keyboard type. There are ANSI, ISO, JIS
2389	* and unknown. For European keyboards (ISO) the key 0xa and 0x32 have
2390	* to be switched. Here we are doing this at runtime, cause the user
2391	* can have more than one keyboard (of different type), where he may
2392	* switch at will all the time. Default is the ANSI standard as defined
2393	* in g_aDarwinToSet1. */
2394	if ( (keyCode == 0xa \|\| keyCode == 0x32)
2395	&& KBGetLayoutType(LMGetKbdType()) == kKeyboardISO)
2396	keyCode = 0x3c - keyCode;
2397	unsigned scanCode = ::DarwinKeycodeToSet1Scancode (keyCode);
2398	if (scanCode)
2399	{
2400	/* calc flags. */
2401	int flags = 0;
2402	if (EventKind != kEventRawKeyUp)
2403	flags \|= KeyPressed;
2404	if (scanCode & VBOXKEY_EXTENDED)
2405	flags \|= KeyExtended;
2406	/** @todo KeyPause, KeyPrint. */
2407	scanCode &= VBOXKEY_SCANCODE_MASK;
2408
2409	/* get the unicode string (if present). */
2410	AssertCompileSize (wchar_t, 2);
2411	AssertCompileSize (UniChar, 2);
2412	ByteCount cbWritten = 0;
2413	wchar_t ucs[8];
2414	if (::GetEventParameter (inEvent, kEventParamKeyUnicodes, typeUnicodeText, NULL,
2415	sizeof (ucs), &cbWritten, &ucs[0]) != 0)
2416	cbWritten = 0;
2417	ucs[cbWritten / sizeof(wchar_t)] = 0; /* The api doesn't terminate it. */
2418
2419	ret = keyEvent (keyCode, scanCode, flags, ucs[0] ? ucs : NULL);
2420	}
2421	}
2422	else
2423	{
2424	/* May contain multiple modifier changes, kind of annoying. */
2425	UInt32 newMask = 0;
2426	::GetEventParameter (inEvent, kEventParamKeyModifiers, typeUInt32, NULL,
2427	sizeof (newMask), NULL, &newMask);
2428	newMask = ::DarwinAdjustModifierMask (newMask, pvCocoaEvent);
2429	UInt32 changed = newMask ^ mDarwinKeyModifiers;
2430	if (changed)
2431	{
2432	for (UInt32 bit = 0; bit < 32; bit++)
2433	{
2434	if (!(changed & (1 << bit)))
2435	continue;
2436	unsigned scanCode = ::DarwinModifierMaskToSet1Scancode (1 << bit);
2437	if (!scanCode)
2438	continue;
2439	unsigned keyCode = ::DarwinModifierMaskToDarwinKeycode (1 << bit);
2440	Assert (keyCode);
2441
2442	if (!(scanCode & VBOXKEY_LOCK))
2443	{
2444	unsigned flags = (newMask & (1 << bit)) ? KeyPressed : 0;
2445	if (scanCode & VBOXKEY_EXTENDED)
2446	flags \|= KeyExtended;
2447	scanCode &= VBOXKEY_SCANCODE_MASK;
2448	ret \|= keyEvent (keyCode, scanCode & 0xff, flags);
2449	}
2450	else
2451	{
2452	unsigned flags = 0;
2453	if (scanCode & VBOXKEY_EXTENDED)
2454	flags \|= KeyExtended;
2455	scanCode &= VBOXKEY_SCANCODE_MASK;
2456	keyEvent (keyCode, scanCode, flags \| KeyPressed);
2457	keyEvent (keyCode, scanCode, flags);
2458	}
2459	}
2460	}
2461
2462	mDarwinKeyModifiers = newMask;
2463
2464	/* Always return true here because we'll otherwise getting a Qt event
2465	we don't want and that will only cause the Pause warning to pop up. */
2466	ret = true;
2467	}
2468
2469	return ret;
2470	}
2471
2472
2473	/**
2474	* Installs or removes the keyboard event handler.
2475	*
2476	* @param fGrab True if we're to grab the events, false if we're not to.
2477	*/
2478	void VBoxConsoleView::darwinGrabKeyboardEvents (bool fGrab)
2479	{
2480	mKeyboardGrabbed = fGrab;
2481	if (fGrab)
2482	{
2483	/* Disable mouse and keyboard event compression/delaying to make sure
2484	we really get all of the events. */
2485	::CGSetLocalEventsSuppressionInterval (0.0);
2486	setMouseCoalescingEnabled (false);
2487
2488	/* Register the event callback/hook and grab the keyboard. */
2489	# ifdef QT_MAC_USE_COCOA
2490	::VBoxCocoaApplication_setCallback (UINT32_MAX, /** @todo fix mask */
2491	VBoxConsoleView::darwinEventHandlerProc, this);
2492
2493	# else /* QT_MAC_USE_COCOA */
2494	EventTypeSpec eventTypes[6];
2495	eventTypes[0].eventClass = kEventClassKeyboard;
2496	eventTypes[0].eventKind = kEventRawKeyDown;
2497	eventTypes[1].eventClass = kEventClassKeyboard;
2498	eventTypes[1].eventKind = kEventRawKeyUp;
2499	eventTypes[2].eventClass = kEventClassKeyboard;
2500	eventTypes[2].eventKind = kEventRawKeyRepeat;
2501	eventTypes[3].eventClass = kEventClassKeyboard;
2502	eventTypes[3].eventKind = kEventRawKeyModifiersChanged;
2503	/* For ignorning Command-H and Command-Q which aren't affected by the
2504	* global hotkey stuff (doesn't work well): */
2505	eventTypes[4].eventClass = kEventClassCommand;
2506	eventTypes[4].eventKind = kEventCommandProcess;
2507	eventTypes[5].eventClass = kEventClassCommand;
2508	eventTypes[5].eventKind = kEventCommandUpdateStatus;
2509
2510	EventHandlerUPP eventHandler = ::NewEventHandlerUPP (VBoxConsoleView::darwinEventHandlerProc);
2511
2512	mDarwinEventHandlerRef = NULL;
2513	::InstallApplicationEventHandler (eventHandler, RT_ELEMENTS (eventTypes), &eventTypes[0],
2514	this, &mDarwinEventHandlerRef);
2515	::DisposeEventHandlerUPP (eventHandler);
2516	# endif /* !QT_MAC_USE_COCOA */
2517
2518	::DarwinGrabKeyboard (false);
2519	}
2520	else
2521	{
2522	::DarwinReleaseKeyboard();
2523	# ifdef QT_MAC_USE_COCOA
2524	::VBoxCocoaApplication_unsetCallback (UINT32_MAX, /** @todo fix mask */
2525	VBoxConsoleView::darwinEventHandlerProc, this);
2526	# else /* !QT_MAC_USE_COCOA */
2527	if (mDarwinEventHandlerRef)
2528	{
2529	::RemoveEventHandler (mDarwinEventHandlerRef);
2530	mDarwinEventHandlerRef = NULL;
2531	}
2532	# endif /* !QT_MAC_USE_COCOA */
2533	}
2534	}
2535
2536	#endif // defined (Q_WS_MAC)
2537
2538	//
2539	// Private members
2540	/////////////////////////////////////////////////////////////////////////////
2541
2542	/**
2543	* Called on every focus change and also to forcibly capture/uncapture the
2544	* input in situations similar to gaining or losing focus.
2545	*
2546	* @param aHasFocus true if the window got focus and false otherwise.
2547	* @param aReleaseHostKey true to release the host key (used only when
2548	* @a aHasFocus is false.
2549	*/
2550	void VBoxConsoleView::focusEvent (bool aHasFocus,
2551	bool aReleaseHostKey /* = true */)
2552	{
2553	if (aHasFocus)
2554	{
2555	#ifdef RT_OS_WINDOWS
2556	if ( !mDisableAutoCapture && gs.autoCapture()
2557	&& GetAncestor (winId(), GA_ROOT) == GetForegroundWindow())
2558	#else
2559	if (!mDisableAutoCapture && gs.autoCapture())
2560	#endif /* RT_OS_WINDOWS */
2561	{
2562	captureKbd (true);
2563	/// @todo (dmik)
2564	// the below is for the mouse auto-capture. disabled for now. in order to
2565	// properly support it, we need to know when all mouse buttons are
2566	// released after we got focus, and grab the mouse only after then.
2567	// btw, the similar would be good the for keyboard auto-capture, too.
2568	// if (!(mMouseCanAbsolute && mMouseIntegration))
2569	// captureMouse (true);
2570	}
2571
2572	/* reset the single-time disable capture flag */
2573	if (mDisableAutoCapture)
2574	mDisableAutoCapture = false;
2575	}
2576	else
2577	{
2578	captureMouse (false);
2579	captureKbd (false, false);
2580	releaseAllPressedKeys (aReleaseHostKey);
2581	}
2582	}
2583
2584	/**
2585	* Synchronize the views of the host and the guest to the modifier keys.
2586	* This function will add up to 6 additional keycodes to codes.
2587	*
2588	* @param codes pointer to keycodes which are sent to the keyboard
2589	* @param count pointer to the keycodes counter
2590	*/
2591	void VBoxConsoleView::fixModifierState (LONG codes, uint count)
2592	{
2593	#if defined(Q_WS_X11)
2594
2595	Window wDummy1, wDummy2;
2596	int iDummy3, iDummy4, iDummy5, iDummy6;
2597	unsigned uMask;
2598	unsigned uKeyMaskNum = 0, uKeyMaskCaps = 0, uKeyMaskScroll = 0;
2599
2600	uKeyMaskCaps = LockMask;
2601	XModifierKeymap* map = XGetModifierMapping(QX11Info::display());
2602	KeyCode keyCodeNum = XKeysymToKeycode(QX11Info::display(), XK_Num_Lock);
2603	KeyCode keyCodeScroll = XKeysymToKeycode(QX11Info::display(), XK_Scroll_Lock);
2604
2605	for (int i = 0; i < 8; i++)
2606	{
2607	if ( keyCodeNum != NoSymbol
2608	&& map->modifiermap[map->max_keypermod * i] == keyCodeNum)
2609	uKeyMaskNum = 1 << i;
2610	else if ( keyCodeScroll != NoSymbol
2611	&& map->modifiermap[map->max_keypermod * i] == keyCodeScroll)
2612	uKeyMaskScroll = 1 << i;
2613	}
2614	XQueryPointer(QX11Info::display(), DefaultRootWindow(QX11Info::display()), &wDummy1, &wDummy2,
2615	&iDummy3, &iDummy4, &iDummy5, &iDummy6, &uMask);
2616	XFreeModifiermap(map);
2617
2618	if (muNumLockAdaptionCnt && (mNumLock ^ !!(uMask & uKeyMaskNum)))
2619	{
2620	muNumLockAdaptionCnt--;
2621	codes[(*count)++] = 0x45;
2622	codes[(*count)++] = 0x45 \| 0x80;
2623	}
2624	if (muCapsLockAdaptionCnt && (mCapsLock ^ !!(uMask & uKeyMaskCaps)))
2625	{
2626	muCapsLockAdaptionCnt--;
2627	codes[(*count)++] = 0x3a;
2628	codes[(*count)++] = 0x3a \| 0x80;
2629	/* Some keyboard layouts require shift to be pressed to break
2630	* capslock. For simplicity, only do this if shift is not
2631	* already held down. */
2632	if (mCapsLock && !(mPressedKeys [0x2a] & IsKeyPressed))
2633	{
2634	codes[(*count)++] = 0x2a;
2635	codes[(*count)++] = 0x2a \| 0x80;
2636	}
2637	}
2638
2639	#elif defined(Q_WS_WIN32)
2640
2641	if (muNumLockAdaptionCnt && (mNumLock ^ !!(GetKeyState(VK_NUMLOCK))))
2642	{
2643	muNumLockAdaptionCnt--;
2644	codes[(*count)++] = 0x45;
2645	codes[(*count)++] = 0x45 \| 0x80;
2646	}
2647	if (muCapsLockAdaptionCnt && (mCapsLock ^ !!(GetKeyState(VK_CAPITAL))))
2648	{
2649	muCapsLockAdaptionCnt--;
2650	codes[(*count)++] = 0x3a;
2651	codes[(*count)++] = 0x3a \| 0x80;
2652	/* Some keyboard layouts require shift to be pressed to break
2653	* capslock. For simplicity, only do this if shift is not
2654	* already held down. */
2655	if (mCapsLock && !(mPressedKeys [0x2a] & IsKeyPressed))
2656	{
2657	codes[(*count)++] = 0x2a;
2658	codes[(*count)++] = 0x2a \| 0x80;
2659	}
2660	}
2661
2662	#elif defined (Q_WS_MAC)
2663
2664	/* if (muNumLockAdaptionCnt) ... - NumLock isn't implemented by Mac OS X so ignore it. */
2665	if (muCapsLockAdaptionCnt && (mCapsLock ^ !!(::GetCurrentEventKeyModifiers() & alphaLock)))
2666	{
2667	muCapsLockAdaptionCnt--;
2668	codes[(*count)++] = 0x3a;
2669	codes[(*count)++] = 0x3a \| 0x80;
2670	/* Some keyboard layouts require shift to be pressed to break
2671	* capslock. For simplicity, only do this if shift is not
2672	* already held down. */
2673	if (mCapsLock && !(mPressedKeys [0x2a] & IsKeyPressed))
2674	{
2675	codes[(*count)++] = 0x2a;
2676	codes[(*count)++] = 0x2a \| 0x80;
2677	}
2678	}
2679
2680	#else
2681
2682	//#warning Adapt VBoxConsoleView::fixModifierState
2683
2684	#endif
2685
2686
2687	}
2688
2689	/**
2690	* Called on enter/exit seamless/fullscreen mode.
2691	*/
2692	void VBoxConsoleView::toggleFSMode (const QSize &aSize)
2693	{
2694	if (mAutoresizeGuest \|\|
2695	mMainWnd->isTrueSeamless() \|\|
2696	mMainWnd->isTrueFullscreen())
2697	{
2698	QSize newSize;
2699	if (aSize.isValid())
2700	{
2701	mNormalSize = aSize;
2702	newSize = maximumSize();
2703	}
2704	else
2705	newSize = mNormalSize;
2706	doResizeHint (newSize);
2707	}
2708
2709	/* Reactivate the console window to preserve the focus position.
2710	* Else focus will move to the mini-tool-bar. */
2711	activateWindow();
2712	}
2713
2714	/**
2715	* Get the current available desktop geometry for the console/framebuffer
2716	*
2717	* @returns the geometry. An empty rectangle means unrestricted.
2718	*/
2719	QRect VBoxConsoleView::desktopGeometry()
2720	{
2721	QRect rc;
2722	switch (mDesktopGeo)
2723	{
2724	case DesktopGeo_Fixed:
2725	case DesktopGeo_Automatic:
2726	rc = QRect (0, 0,
2727	RT_MAX (mDesktopGeometry.width(), mStoredConsoleSize.width()),
2728	RT_MAX (mDesktopGeometry.height(), mStoredConsoleSize.height()));
2729	break;
2730	case DesktopGeo_Any:
2731	rc = QRect (0, 0, 0, 0);
2732	break;
2733	default:
2734	AssertMsgFailed (("Bad geometry type %d\n", mDesktopGeo));
2735	}
2736	return rc;
2737	}
2738
2739	QRegion VBoxConsoleView::lastVisibleRegion() const
2740	{
2741	return mLastVisibleRegion;
2742	}
2743
2744	bool VBoxConsoleView::isAutoresizeGuestActive()
2745	{
2746	return mGuestSupportsGraphics && mAutoresizeGuest;
2747	}
2748
2749	/**
2750	* Called on every key press and release (while in focus).
2751	*
2752	* @param aKey virtual scan code (virtual key on Win32 and KeySym on X11)
2753	* @param aScan hardware scan code
2754	* @param aFlags flags, a combination of Key* constants
2755	* @param aUniKey Unicode translation of the key. Optional.
2756	*
2757	* @return true to consume the event and false to pass it to Qt
2758	*/
2759	bool VBoxConsoleView::keyEvent (int aKey, uint8_t aScan, int aFlags,
2760	wchar_t aUniKey/ = NULL*/)
2761	{
2762	#if 0
2763	{
2764	char buf [256];
2765	sprintf (buf, "aKey=%08X aScan=%02X aFlags=%08X",
2766	aKey, aScan, aFlags);
2767	mMainWnd->statusBar()->message (buf);
2768	}
2769	#endif
2770
2771	const bool isHostKey = aKey == gs.hostKey();
2772
2773	LONG buf [16];
2774	LONG *codes = buf;
2775	uint count = 0;
2776	uint8_t whatPressed = 0;
2777
2778	if (!isHostKey && !mIsHostkeyPressed)
2779	{
2780	if (aFlags & KeyPrint)
2781	{
2782	static LONG PrintMake[] = { 0xE0, 0x2A, 0xE0, 0x37 };
2783	static LONG PrintBreak[] = { 0xE0, 0xB7, 0xE0, 0xAA };
2784	if (aFlags & KeyPressed)
2785	{
2786	codes = PrintMake;
2787	count = SIZEOF_ARRAY (PrintMake);
2788	}
2789	else
2790	{
2791	codes = PrintBreak;
2792	count = SIZEOF_ARRAY (PrintBreak);
2793	}
2794	}
2795	else if (aFlags & KeyPause)
2796	{
2797	if (aFlags & KeyPressed)
2798	{
2799	static LONG Pause[] = { 0xE1, 0x1D, 0x45, 0xE1, 0x9D, 0xC5 };
2800	codes = Pause;
2801	count = SIZEOF_ARRAY (Pause);
2802	}
2803	else
2804	{
2805	/* Pause shall not produce a break code */
2806	return true;
2807	}
2808	}
2809	else
2810	{
2811	if (aFlags & KeyPressed)
2812	{
2813	/* Check if the guest has the same view on the modifier keys (NumLock,
2814	* CapsLock, ScrollLock) as the X server. If not, send KeyPress events
2815	* to synchronize the state. */
2816	fixModifierState (codes, &count);
2817	}
2818
2819	/* Check if it's C-A-D and GUI/PassCAD is not true */
2820	if (!mPassCAD &&
2821	aScan == 0x53 /* Del */ &&
2822	((mPressedKeys [0x38] & IsKeyPressed) /* Alt */ \|\|
2823	(mPressedKeys [0x38] & IsExtKeyPressed)) &&
2824	((mPressedKeys [0x1d] & IsKeyPressed) /* Ctrl */ \|\|
2825	(mPressedKeys [0x1d] & IsExtKeyPressed)))
2826	{
2827	/* Use the C-A-D combination as a last resort to get the
2828	* keyboard and mouse back to the host when the user forgets
2829	* the Host Key. Note that it's always possible to send C-A-D
2830	* to the guest using the Host+Del combination. BTW, it would
2831	* be preferrable to completely ignore C-A-D in guests, but
2832	* that's not possible because we cannot predict what other
2833	* keys will be pressed next when one of C, A, D is held. */
2834
2835	if (isRunning() && mKbdCaptured)
2836	{
2837	captureKbd (false);
2838	if (!(mMouseCanAbsolute && mMouseIntegration))
2839	captureMouse (false);
2840	}
2841
2842	return true;
2843	}
2844
2845	/* process the scancode and update the table of pressed keys */
2846	whatPressed = IsKeyPressed;
2847
2848	if (aFlags & KeyExtended)
2849	{
2850	codes [count++] = 0xE0;
2851	whatPressed = IsExtKeyPressed;
2852	}
2853
2854	if (aFlags & KeyPressed)
2855	{
2856	codes [count++] = aScan;
2857	mPressedKeys [aScan] \|= whatPressed;
2858	}
2859	else
2860	{
2861	/* if we haven't got this key's press message, we ignore its
2862	* release */
2863	if (!(mPressedKeys [aScan] & whatPressed))
2864	return true;
2865	codes [count++] = aScan \| 0x80;
2866	mPressedKeys [aScan] &= ~whatPressed;
2867	}
2868
2869	if (mKbdCaptured)
2870	mPressedKeys [aScan] \|= IsKbdCaptured;
2871	else
2872	mPressedKeys [aScan] &= ~IsKbdCaptured;
2873	}
2874	}
2875	else
2876	{
2877	/* currently this is used in winLowKeyboardEvent() only */
2878	hostkey_in_capture = mKbdCaptured;
2879	}
2880
2881	bool emitSignal = false;
2882	int hotkey = 0;
2883
2884	/* process the host key */
2885	if (aFlags & KeyPressed)
2886	{
2887	if (isHostKey)
2888	{
2889	if (!mIsHostkeyPressed)
2890	{
2891	mIsHostkeyPressed = mIsHostkeyAlone = true;
2892	if (isRunning())
2893	saveKeyStates();
2894	emitSignal = true;
2895	}
2896	}
2897	else
2898	{
2899	if (mIsHostkeyPressed)
2900	{
2901	if (mIsHostkeyAlone)
2902	{
2903	hotkey = aKey;
2904	mIsHostkeyAlone = false;
2905	}
2906	}
2907	}
2908	}
2909	else
2910	{
2911	if (isHostKey)
2912	{
2913	if (mIsHostkeyPressed)
2914	{
2915	mIsHostkeyPressed = false;
2916
2917	if (mIsHostkeyAlone)
2918	{
2919	if (isPaused())
2920	{
2921	vboxProblem().remindAboutPausedVMInput();
2922	}
2923	else
2924	if (isRunning())
2925	{
2926	bool captured = mKbdCaptured;
2927	bool ok = true;
2928	if (!captured)
2929	{
2930	/* temporarily disable auto capture that will take
2931	* place after this dialog is dismissed because
2932	* the capture state is to be defined by the
2933	* dialog result itself */
2934	mDisableAutoCapture = true;
2935	bool autoConfirmed = false;
2936	ok = vboxProblem().confirmInputCapture (&autoConfirmed);
2937	if (autoConfirmed)
2938	mDisableAutoCapture = false;
2939	/* otherwise, the disable flag will be reset in
2940	* the next console view's foucs in event (since
2941	* may happen asynchronously on some platforms,
2942	* after we return from this code) */
2943	}
2944
2945	if (ok)
2946	{
2947	captureKbd (!captured, false);
2948	if (!(mMouseCanAbsolute && mMouseIntegration))
2949	{
2950	#ifdef Q_WS_X11
2951	/* make sure that pending FocusOut events from the
2952	* previous message box are handled, otherwise the
2953	* mouse is immediately ungrabbed. */
2954	qApp->processEvents();
2955	#endif
2956	captureMouse (mKbdCaptured);
2957	}
2958	}
2959	}
2960	}
2961
2962	if (isRunning())
2963	sendChangedKeyStates();
2964
2965	emitSignal = true;
2966	}
2967	}
2968	else
2969	{
2970	if (mIsHostkeyPressed)
2971	mIsHostkeyAlone = false;
2972	}
2973	}
2974
2975	/* emit the keyboard state change signal */
2976	if (emitSignal)
2977	emitKeyboardStateChanged();
2978
2979	/* Process Host+<key> shortcuts. currently, <key> is limited to
2980	* alphanumeric chars. Other Host+<key> combinations are handled in
2981	* event(). */
2982	if (hotkey)
2983	{
2984	bool processed = false;
2985	#if defined (Q_WS_WIN32)
2986	NOREF(aUniKey);
2987	int n = GetKeyboardLayoutList (0, NULL);
2988	Assert (n);
2989	HKL *list = new HKL [n];
2990	GetKeyboardLayoutList (n, list);
2991	for (int i = 0; i < n && !processed; i++)
2992	{
2993	wchar_t ch;
2994	static BYTE keys [256] = {0};
2995	if (!ToUnicodeEx (hotkey, 0, keys, &ch, 1, 0, list [i]) == 1)
2996	ch = 0;
2997	if (ch)
2998	processed = processHotKey (QKeySequence (Qt::UNICODE_ACCEL +
2999	QChar (ch).toUpper().unicode()),
3000	mMainWnd->menuBar()->actions());
3001	}
3002	delete[] list;
3003	#elif defined (Q_WS_X11)
3004	NOREF(aUniKey);
3005	Display *display = QX11Info::display();
3006	int keysyms_per_keycode = getKeysymsPerKeycode();
3007	KeyCode kc = XKeysymToKeycode (display, aKey);
3008	// iterate over the first level (not shifted) keysyms in every group
3009	for (int i = 0; i < keysyms_per_keycode && !processed; i += 2)
3010	{
3011	KeySym ks = XKeycodeToKeysym (display, kc, i);
3012	char ch = 0;
3013	if (!XkbTranslateKeySym (display, &ks, 0, &ch, 1, NULL) == 1)
3014	ch = 0;
3015	if (ch)
3016	{
3017	QChar c = QString::fromLocal8Bit (&ch, 1) [0];
3018	processed = processHotKey (QKeySequence (Qt::UNICODE_ACCEL +
3019	c.toUpper().unicode()),
3020	mMainWnd->menuBar()->actions());
3021	}
3022	}
3023	#elif defined (Q_WS_MAC)
3024	if (aUniKey && aUniKey [0] && !aUniKey [1])
3025	processed = processHotKey (QKeySequence (Qt::UNICODE_ACCEL +
3026	QChar (aUniKey [0]).toUpper().unicode()),
3027	mMainWnd->menuBar()->actions());
3028
3029	/* Don't consider the hot key as pressed since the guest never saw
3030	* it. (probably a generic thing) */
3031	mPressedKeys [aScan] &= ~whatPressed;
3032	#endif
3033
3034	/* grab the key from Qt if processed, or pass it to Qt otherwise
3035	* in order to process non-alphanumeric keys in event(), after they are
3036	* converted to Qt virtual keys. */
3037	return processed;
3038	}
3039
3040	/* no more to do, if the host key is in action or the VM is paused */
3041	if (mIsHostkeyPressed \|\| isHostKey \|\| isPaused())
3042	{
3043	/* grab the key from Qt and from VM if it's a host key,
3044	* otherwise just pass it to Qt */
3045	return isHostKey;
3046	}
3047
3048	CKeyboard keyboard = mConsole.GetKeyboard();
3049	Assert (!keyboard.isNull());
3050
3051	#if defined (Q_WS_WIN32)
3052	/* send pending WM_PAINT events */
3053	::UpdateWindow (viewport()->winId());
3054	#endif
3055
3056	#if 0
3057	{
3058	char buf [256];
3059	sprintf (buf, "*** SCANS: ");
3060	for (uint i = 0; i < count; ++ i)
3061	sprintf (buf + strlen (buf), "%02X ", codes [i]);
3062	mMainWnd->statusBar()->message (buf);
3063	LogFlow (("%s\n", buf));
3064	}
3065	#endif
3066
3067	std::vector <LONG> scancodes(codes, &codes[count]);
3068	keyboard.PutScancodes (QVector<LONG>::fromStdVector(scancodes));
3069
3070	/* grab the key from Qt */
3071	return true;
3072	}
3073
3074	/**
3075	* Called on every mouse/wheel move and button press/release.
3076	*
3077	* @return true to consume the event and false to pass it to Qt
3078	*/
3079	bool VBoxConsoleView::mouseEvent (int aType, const QPoint &aPos, const QPoint &aGlobalPos,
3080	Qt::MouseButtons aButtons, Qt::KeyboardModifiers aModifiers,
3081	int aWheelDelta, Qt::Orientation aWheelDir)
3082	{
3083	#if 1
3084
3085	LogRel3(("%s: type=%03d x=%03d y=%03d btns=%08X wdelta=%03d wdir=%s\n",
3086	__PRETTY_FUNCTION__ , aType, aPos.x(), aPos.y(),
3087	(aButtons & Qt::LeftButton ? 1 : 0)
3088	\| (aButtons & Qt::RightButton ? 2 : 0)
3089	\| (aButtons & Qt::MidButton ? 4 : 0)
3090	\| (aButtons & Qt::XButton1 ? 8 : 0)
3091	\| (aButtons & Qt::XButton2 ? 16 : 0),
3092	aWheelDelta,
3093	aWheelDir == Qt::Horizontal ? "Horizontal"
3094	: aWheelDir == Qt::Vertical ? "Vertical" : "Unknown"));
3095	Q_UNUSED (aModifiers);
3096	#else
3097	Q_UNUSED (aModifiers);
3098	#endif
3099
3100	int state = 0;
3101	if (aButtons & Qt::LeftButton)
3102	state \|= KMouseButtonState_LeftButton;
3103	if (aButtons & Qt::RightButton)
3104	state \|= KMouseButtonState_RightButton;
3105	if (aButtons & Qt::MidButton)
3106	state \|= KMouseButtonState_MiddleButton;
3107	if (aButtons & Qt::XButton1)
3108	state \|= KMouseButtonState_XButton1;
3109	if (aButtons & Qt::XButton2)
3110	state \|= KMouseButtonState_XButton2;
3111
3112	#ifdef Q_WS_MAC
3113	/* Simulate the right click on
3114	* Host+Left Mouse */
3115	if (mIsHostkeyPressed &&
3116	mIsHostkeyAlone &&
3117	state == KMouseButtonState_LeftButton)
3118	state = KMouseButtonState_RightButton;
3119	#endif /* Q_WS_MAC */
3120
3121	int wheelVertical = 0;
3122	int wheelHorizontal = 0;
3123	if (aWheelDir == Qt::Vertical)
3124	{
3125	/* the absolute value of wheel delta is 120 units per every wheel
3126	* move; positive deltas correspond to counterclockwize rotations
3127	* (usually up), negative -- to clockwize (usually down). */
3128	wheelVertical = - (aWheelDelta / 120);
3129	}
3130	else if (aWheelDir == Qt::Horizontal)
3131	wheelHorizontal = aWheelDelta / 120;
3132
3133	if (mMouseCaptured)
3134	{
3135	#ifdef Q_WS_WIN32
3136	/* send pending WM_PAINT events */
3137	::UpdateWindow (viewport()->winId());
3138	#endif
3139
3140	CMouse mouse = mConsole.GetMouse();
3141	mouse.PutMouseEvent (aGlobalPos.x() - mLastPos.x(),
3142	aGlobalPos.y() - mLastPos.y(),
3143	wheelVertical, wheelHorizontal, state);
3144
3145	#if defined (Q_WS_MAC)
3146	/*
3147	* Keep the mouse from leaving the widget.
3148	*
3149	* This is a bit tricky to get right because if it escapes we won't necessarily
3150	* get mouse events any longer and can warp it back. So, we keep safety zone
3151	* of up to 300 pixels around the borders of the widget to prevent this from
3152	* happening. Also, the mouse is warped back to the center of the widget.
3153	*
3154	* (Note, aPos seems to be unreliable, it caused endless recursion here at one points...)
3155	* (Note, synergy and other remote clients might not like this cursor warping.)
3156	*/
3157	QRect rect = viewport()->visibleRegion().boundingRect();
3158	QPoint pw = viewport()->mapToGlobal (viewport()->pos());
3159	rect.translate (pw.x(), pw.y());
3160
3161	QRect dpRect = QApplication::desktop()->screenGeometry (viewport());
3162	if (rect.intersects (dpRect))
3163	rect = rect.intersect (dpRect);
3164
3165	int wsafe = rect.width() / 6;
3166	rect.setWidth (rect.width() - wsafe * 2);
3167	rect.setLeft (rect.left() + wsafe);
3168
3169	int hsafe = rect.height() / 6;
3170	rect.setWidth (rect.height() - hsafe * 2);
3171	rect.setTop (rect.top() + hsafe);
3172
3173	if (rect.contains (aGlobalPos, true))
3174	mLastPos = aGlobalPos;
3175	else
3176	{
3177	mLastPos = rect.center();
3178	QCursor::setPos (mLastPos);
3179	}
3180
3181	#else /* !Q_WS_MAC */
3182
3183	/* "jerk" the mouse by bringing it to the opposite side
3184	* to simulate the endless moving */
3185
3186	#ifdef Q_WS_WIN32
3187	int we = viewport()->width() - 1;
3188	int he = viewport()->height() - 1;
3189	QPoint p = aPos;
3190	if (aPos.x() == 0)
3191	p.setX (we - 1);
3192	else if (aPos.x() == we)
3193	p.setX (1);
3194	if (aPos.y() == 0 )
3195	p.setY (he - 1);
3196	else if (aPos.y() == he)
3197	p.setY (1);
3198
3199	if (p != aPos)
3200	{
3201	mLastPos = viewport()->mapToGlobal (p);
3202	QCursor::setPos (mLastPos);
3203	}
3204	else
3205	{
3206	mLastPos = aGlobalPos;
3207	}
3208	#else
3209	int we = QApplication::desktop()->width() - 1;
3210	int he = QApplication::desktop()->height() - 1;
3211	QPoint p = aGlobalPos;
3212	if (aGlobalPos.x() == 0)
3213	p.setX (we - 1);
3214	else if (aGlobalPos.x() == we)
3215	p.setX( 1 );
3216	if (aGlobalPos.y() == 0)
3217	p.setY (he - 1);
3218	else if (aGlobalPos.y() == he)
3219	p.setY (1);
3220
3221	if (p != aGlobalPos)
3222	{
3223	mLastPos = p;
3224	QCursor::setPos (mLastPos);
3225	}
3226	else
3227	{
3228	mLastPos = aGlobalPos;
3229	}
3230	#endif
3231	#endif /* !Q_WS_MAC */
3232	return true; /* stop further event handling */
3233	}
3234	else /* !mMouseCaptured */
3235	{
3236	if (mMainWnd->isTrueFullscreen())
3237	{
3238	if (mode != VBoxDefs::SDLMode)
3239	{
3240	/* try to automatically scroll the guest canvas if the
3241	* mouse is on the screen border */
3242	/// @todo (r=dmik) better use a timer for autoscroll
3243	QRect scrGeo = QApplication::desktop()->screenGeometry (this);
3244	int dx = 0, dy = 0;
3245	if (scrGeo.width() < contentsWidth())
3246	{
3247	if (scrGeo.left() == aGlobalPos.x()) dx = -1;
3248	if (scrGeo.right() == aGlobalPos.x()) dx = +1;
3249	}
3250	if (scrGeo.height() < contentsHeight())
3251	{
3252	if (scrGeo.top() == aGlobalPos.y()) dy = -1;
3253	if (scrGeo.bottom() == aGlobalPos.y()) dy = +1;
3254	}
3255	if (dx \|\| dy)
3256	scrollBy (dx, dy);
3257	}
3258	}
3259
3260	if (mMouseCanAbsolute && mMouseIntegration)
3261	{
3262	int cw = contentsWidth(), ch = contentsHeight();
3263	int vw = visibleWidth(), vh = visibleHeight();
3264
3265	if (mode != VBoxDefs::SDLMode)
3266	{
3267	/* try to automatically scroll the guest canvas if the
3268	* mouse goes outside its visible part */
3269
3270	int dx = 0;
3271	if (aPos.x() > vw) dx = aPos.x() - vw;
3272	else if (aPos.x() < 0) dx = aPos.x();
3273	int dy = 0;
3274	if (aPos.y() > vh) dy = aPos.y() - vh;
3275	else if (aPos.y() < 0) dy = aPos.y();
3276	if (dx != 0 \|\| dy != 0) scrollBy (dx, dy);
3277	}
3278
3279	QPoint cpnt = viewportToContents (aPos);
3280	if (cpnt.x() < 0) cpnt.setX (0);
3281	else if (cpnt.x() > cw - 1) cpnt.setX (cw - 1);
3282	if (cpnt.y() < 0) cpnt.setY (0);
3283	else if (cpnt.y() > ch - 1) cpnt.setY (ch - 1);
3284
3285	CMouse mouse = mConsole.GetMouse();
3286	mouse.PutMouseEventAbsolute (cpnt.x() + 1, cpnt.y() + 1,
3287	wheelVertical, wheelHorizontal,
3288	state);
3289	return true; /* stop further event handling */
3290	}
3291	else
3292	{
3293	if (hasFocus() &&
3294	(aType == QEvent::MouseButtonRelease &&
3295	aButtons == Qt::NoButton))
3296	{
3297	if (isPaused())
3298	{
3299	vboxProblem().remindAboutPausedVMInput();
3300	}
3301	else if (isRunning())
3302	{
3303	/* temporarily disable auto capture that will take
3304	* place after this dialog is dismissed because
3305	* the capture state is to be defined by the
3306	* dialog result itself */
3307	mDisableAutoCapture = true;
3308	bool autoConfirmed = false;
3309	bool ok = vboxProblem().confirmInputCapture (&autoConfirmed);
3310	if (autoConfirmed)
3311	mDisableAutoCapture = false;
3312	/* otherwise, the disable flag will be reset in
3313	* the next console view's foucs in event (since
3314	* may happen asynchronously on some platforms,
3315	* after we return from this code) */
3316
3317	if (ok)
3318	{
3319	#ifdef Q_WS_X11
3320	/* make sure that pending FocusOut events from the
3321	* previous message box are handled, otherwise the
3322	* mouse is immediately ungrabbed again */
3323	qApp->processEvents();
3324	#endif
3325	captureKbd (true);
3326	captureMouse (true);
3327	}
3328	}
3329	}
3330	}
3331	}
3332
3333	return false;
3334	}
3335
3336	void VBoxConsoleView::onStateChange (KMachineState state)
3337	{
3338	switch (state)
3339	{
3340	case KMachineState_Paused:
3341	case KMachineState_TeleportingPausedVM:
3342	{
3343	if ( mode != VBoxDefs::TimerMode
3344	&& mFrameBuf
3345	&& ( state != KMachineState_TeleportingPausedVM
3346	\|\| mLastState != KMachineState_Teleporting)
3347	)
3348	{
3349	/*
3350	* Take a screen snapshot. Note that TakeScreenShot() always
3351	* needs a 32bpp image
3352	*/
3353	QImage shot = QImage (mFrameBuf->width(), mFrameBuf->height(), QImage::Format_RGB32);
3354	CDisplay dsp = mConsole.GetDisplay();
3355	dsp.TakeScreenShot (0, shot.bits(), shot.width(), shot.height());
3356	/*
3357	* TakeScreenShot() may fail if, e.g. the Paused notification
3358	* was delivered after the machine execution was resumed. It's
3359	* not fatal.
3360	*/
3361	if (dsp.isOk())
3362	{
3363	dimImage (shot);
3364	mPausedShot = QPixmap::fromImage (shot);
3365	/* fully repaint to pick up mPausedShot */
3366	repaint();
3367	}
3368	}
3369	/* fall through */
3370	}
3371	case KMachineState_Stuck:
3372	{
3373	/* reuse the focus event handler to uncapture everything */
3374	if (hasFocus())
3375	focusEvent (false /* aHasFocus/, false / aReleaseHostKey */);
3376	break;
3377	}
3378	case KMachineState_Running:
3379	{
3380	if ( mLastState == KMachineState_Paused
3381	\|\| mLastState == KMachineState_TeleportingPausedVM
3382	)
3383	{
3384	if (mode != VBoxDefs::TimerMode && mFrameBuf)
3385	{
3386	/* reset the pixmap to free memory */
3387	mPausedShot = QPixmap ();
3388	/*
3389	* ask for full guest display update (it will also update
3390	* the viewport through IFramebuffer::NotifyUpdate)
3391	*/
3392	CDisplay dsp = mConsole.GetDisplay();
3393	dsp.InvalidateAndUpdate();
3394	}
3395	}
3396	/* reuse the focus event handler to capture input */
3397	if (hasFocus())
3398	focusEvent (true /* aHasFocus */);
3399	break;
3400	}
3401	default:
3402	break;
3403	}
3404
3405	mLastState = state;
3406	}
3407
3408	void VBoxConsoleView::doRefresh()
3409	{
3410	viewport()->repaint();
3411	}
3412
3413	void VBoxConsoleView::resizeEvent (QResizeEvent *)
3414	{
3415	updateSliders();
3416	#if defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA)
3417	QRect r = viewport()->geometry();
3418	// printf ("qt resize: %d %d %d %d\n", r.x(), r.y(), r.width(), r.height());
3419	PostBoundsChanged (r);
3420	#endif /* Q_WS_MAC */
3421	}
3422
3423	void VBoxConsoleView::moveEvent (QMoveEvent *)
3424	{
3425	#if defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA)
3426	QRect r = viewport()->geometry();
3427	// printf ("qt resize: %d %d %d %d\n", r.x(), r.y(), r.width(), r.height());
3428	PostBoundsChanged (r);
3429	#endif /* Q_WS_MAC */
3430	}
3431
3432	void VBoxConsoleView::paintEvent (QPaintEvent *pe)
3433	{
3434	if (mPausedShot.isNull())
3435	{
3436	/* delegate the paint function to the VBoxFrameBuffer interface */
3437	if (mFrameBuf)
3438	mFrameBuf->paintEvent (pe);
3439	#ifdef Q_WS_MAC
3440	/* Update the dock icon if we are in the running state */
3441	if (isRunning())
3442	updateDockIcon();
3443	#endif
3444	return;
3445	}
3446
3447	#ifdef VBOX_GUI_USE_QUARTZ2D
3448	if (mode == VBoxDefs::Quartz2DMode && mFrameBuf)
3449	{
3450	mFrameBuf->paintEvent (pe);
3451	updateDockIcon();
3452	}
3453	else
3454	#endif
3455	{
3456	/* we have a snapshot for the paused state */
3457	QRect r = pe->rect().intersect (viewport()->rect());
3458	/* We have to disable paint on screen if we are using the regular painter */
3459	bool paintOnScreen = viewport()->testAttribute (Qt::WA_PaintOnScreen);
3460	viewport()->setAttribute (Qt::WA_PaintOnScreen, false);
3461	QPainter pnt (viewport());
3462	pnt.drawPixmap (r.x(), r.y(), mPausedShot,
3463	r.x() + contentsX(), r.y() + contentsY(),
3464	r.width(), r.height());
3465	/* Restore the attribute to its previous state */
3466	viewport()->setAttribute (Qt::WA_PaintOnScreen, paintOnScreen);
3467	#ifdef Q_WS_MAC
3468	updateDockIcon();
3469	#endif
3470	}
3471
3472	}
3473
3474	/**
3475	* Captures the keyboard. When captured, no keyboard input reaches the host
3476	* system (including most system combinations like Alt-Tab).
3477	*
3478	* @param aCapture true to capture, false to uncapture.
3479	* @param aEmitSignal Whether to emit keyboardStateChanged() or not.
3480	*/
3481	void VBoxConsoleView::captureKbd (bool aCapture, bool aEmitSignal /* = true */)
3482	{
3483	AssertMsg (mAttached, ("Console must be attached"));
3484
3485	if (mKbdCaptured == aCapture)
3486	return;
3487
3488	/* On Win32, keyboard grabbing is ineffective, a low-level keyboard hook is
3489	* used instead. On X11, we use XGrabKey instead of XGrabKeyboard (called
3490	* by QWidget::grabKeyboard()) because the latter causes problems under
3491	* metacity 2.16 (in particular, due to a bug, a window cannot be moved
3492	* using the mouse if it is currently grabing the keyboard). On Mac OS X,
3493	* we use the Qt methods + disabling global hot keys + watching modifiers
3494	* (for right/left separation). */
3495	#if defined (Q_WS_WIN32)
3496	/**/
3497	#elif defined (Q_WS_X11)
3498	if (aCapture)
3499	XGrabKey (QX11Info::display(), AnyKey, AnyModifier,
3500	window()->winId(), False,
3501	GrabModeAsync, GrabModeAsync);
3502	else
3503	XUngrabKey (QX11Info::display(), AnyKey, AnyModifier,
3504	window()->winId());
3505	#elif defined (Q_WS_MAC)
3506	if (aCapture)
3507	{
3508	::DarwinDisableGlobalHotKeys (true);
3509	grabKeyboard();
3510	}
3511	else
3512	{
3513	::DarwinDisableGlobalHotKeys (false);
3514	releaseKeyboard();
3515	}
3516	#else
3517	if (aCapture)
3518	grabKeyboard();
3519	else
3520	releaseKeyboard();
3521	#endif
3522
3523	mKbdCaptured = aCapture;
3524
3525	if (aEmitSignal)
3526	emitKeyboardStateChanged();
3527	}
3528
3529	/**
3530	* Captures the host mouse pointer. When captured, the mouse pointer is
3531	* unavailable to the host applications.
3532	*
3533	* @param aCapture true to capture, false to uncapture.
3534	* @param aEmitSignal Whether to emit mouseStateChanged() or not.
3535	*/
3536	void VBoxConsoleView::captureMouse (bool aCapture, bool aEmitSignal /* = true */)
3537	{
3538	AssertMsg (mAttached, ("Console must be attached"));
3539
3540	if (mMouseCaptured == aCapture)
3541	return;
3542
3543	if (aCapture)
3544	{
3545	/* memorize the host position where the cursor was captured */
3546	mCapturedPos = QCursor::pos();
3547	#ifdef Q_WS_WIN32
3548	viewport()->setCursor (QCursor (Qt::BlankCursor));
3549	/* move the mouse to the center of the visible area */
3550	QCursor::setPos (mapToGlobal (visibleRegion().boundingRect().center()));
3551	mLastPos = QCursor::pos();
3552	#elif defined (Q_WS_MAC)
3553	/* move the mouse to the center of the visible area */
3554	mLastPos = mapToGlobal (visibleRegion().boundingRect().center());
3555	QCursor::setPos (mLastPos);
3556	/* grab all mouse events. */
3557	viewport()->grabMouse();
3558	#else
3559	viewport()->grabMouse();
3560	mLastPos = QCursor::pos();
3561	#endif
3562	}
3563	else
3564	{
3565	#ifndef Q_WS_WIN32
3566	viewport()->releaseMouse();
3567	#endif
3568	/* release mouse buttons */
3569	CMouse mouse = mConsole.GetMouse();
3570	mouse.PutMouseEvent (0, 0, 0, 0 /* Horizontal wheel */, 0);
3571	}
3572
3573	mMouseCaptured = aCapture;
3574
3575	updateMouseClipping();
3576
3577	if (aEmitSignal)
3578	emitMouseStateChanged();
3579	}
3580
3581	/**
3582	* Searches for a menu item with a given hot key (shortcut). If the item
3583	* is found, activates it and returns true. Otherwise returns false.
3584	*/
3585	bool VBoxConsoleView::processHotKey (const QKeySequence &aKey,
3586	const QList <QAction*> &aData)
3587	{
3588	foreach (QAction *pAction, aData)
3589	{
3590	if (QMenu *menu = pAction->menu())
3591	{
3592	/* Process recursively for each sub-menu */
3593	if (processHotKey (aKey, menu->actions()))
3594	return true;
3595	}
3596	else
3597	{
3598	QString hotkey = VBoxGlobal::extractKeyFromActionText (pAction->text());
3599	if (pAction->isEnabled() && !hotkey.isEmpty())
3600	{
3601	if (aKey.matches (QKeySequence (hotkey)) == QKeySequence::ExactMatch)
3602	{
3603	/* We asynchronously post a special event instead of calling
3604	* pAction->trigger() directly, to let key presses and
3605	* releases be processed correctly by Qt first.
3606	* Note: we assume that nobody will delete the menu item
3607	* corresponding to the key sequence, so that the pointer to
3608	* menu data posted along with the event will remain valid in
3609	* the event handler, at least until the main window is closed. */
3610	QApplication::postEvent (this, new ActivateMenuEvent (pAction));
3611	return true;
3612	}
3613	}
3614	}
3615	}
3616
3617	return false;
3618	}
3619
3620	/**
3621	* Send the KEY BREAK code to the VM for all currently pressed keys.
3622	*
3623	* @param aReleaseHostKey @c true to set the host key state to unpressed.
3624	*/
3625	void VBoxConsoleView::releaseAllPressedKeys (bool aReleaseHostKey /* = true*/)
3626	{
3627	AssertMsg (mAttached, ("Console must be attached"));
3628
3629	CKeyboard keyboard = mConsole.GetKeyboard();
3630	bool fSentRESEND = false;
3631
3632	/* send a dummy scan code (RESEND) to prevent the guest OS from recognizing
3633	* a single key click (for ex., Alt) and performing an unwanted action
3634	* (for ex., activating the menu) when we release all pressed keys below.
3635	* Note, that it's just a guess that sending RESEND will give the desired
3636	* effect :), but at least it works with NT and W2k guests. */
3637
3638	/// @todo Sending 0xFE is responsible for the warning
3639	//
3640	// ``atkbd.c: Spurious NAK on isa0060/serio0. Some program might
3641	// be trying access hardware directly''
3642	//
3643	// on Linux guests (#1944). It might also be responsible for #1949. Don't
3644	// send this command unless we really have to release any key modifier.
3645	// --frank
3646
3647	for (uint i = 0; i < SIZEOF_ARRAY (mPressedKeys); i++)
3648	{
3649	if (mPressedKeys [i] & IsKeyPressed)
3650	{
3651	if (!fSentRESEND)
3652	{
3653	keyboard.PutScancode (0xFE);
3654	fSentRESEND = true;
3655	}
3656	keyboard.PutScancode (i \| 0x80);
3657	}
3658	else if (mPressedKeys [i] & IsExtKeyPressed)
3659	{
3660	if (!fSentRESEND)
3661	{
3662	keyboard.PutScancode (0xFE);
3663	fSentRESEND = true;
3664	}
3665	QVector <LONG> codes (2);
3666	codes[0] = 0xE0;
3667	codes[1] = i \| 0x80;
3668	keyboard.PutScancodes (codes);
3669	}
3670	mPressedKeys [i] = 0;
3671	}
3672
3673	if (aReleaseHostKey)
3674	mIsHostkeyPressed = false;
3675
3676	#ifdef Q_WS_MAC
3677	/* clear most of the modifiers. */
3678	mDarwinKeyModifiers &=
3679	alphaLock \| kEventKeyModifierNumLockMask \|
3680	(aReleaseHostKey ? 0 : ::DarwinKeyCodeToDarwinModifierMask (gs.hostKey()));
3681	#endif
3682
3683	emitKeyboardStateChanged();
3684	}
3685
3686	void VBoxConsoleView::saveKeyStates()
3687	{
3688	::memcpy (mPressedKeysCopy, mPressedKeys, sizeof (mPressedKeys));
3689	}
3690
3691	void VBoxConsoleView::sendChangedKeyStates()
3692	{
3693	AssertMsg (mAttached, ("Console must be attached"));
3694
3695	QVector <LONG> codes (2);
3696	CKeyboard keyboard = mConsole.GetKeyboard();
3697	for (uint i = 0; i < SIZEOF_ARRAY (mPressedKeys); ++ i)
3698	{
3699	uint8_t os = mPressedKeysCopy [i];
3700	uint8_t ns = mPressedKeys [i];
3701	if ((os & IsKeyPressed) != (ns & IsKeyPressed))
3702	{
3703	codes [0] = i;
3704	if (!(ns & IsKeyPressed))
3705	codes[0] \|= 0x80;
3706	keyboard.PutScancode (codes[0]);
3707	}
3708	else if ((os & IsExtKeyPressed) != (ns & IsExtKeyPressed))
3709	{
3710	codes [0] = 0xE0;
3711	codes [1] = i;
3712	if (!(ns & IsExtKeyPressed))
3713	codes [1] \|= 0x80;
3714	keyboard.PutScancodes (codes);
3715	}
3716	}
3717	}
3718
3719	void VBoxConsoleView::updateMouseClipping()
3720	{
3721	AssertMsg (mAttached, ("Console must be attached"));
3722
3723	if (mMouseCaptured)
3724	{
3725	updateHostCursor();
3726	#ifdef Q_WS_WIN32
3727	QRect r = viewport()->rect();
3728	r.moveTopLeft (viewport()->mapToGlobal (QPoint (0, 0)));
3729	RECT rect = { r.left(), r.top(), r.right() + 1, r.bottom() + 1 };
3730	::ClipCursor (&rect);
3731	#endif
3732	}
3733	else
3734	{
3735	#ifdef Q_WS_WIN32
3736	::ClipCursor (NULL);
3737	#endif
3738	/* return the cursor to where it was when we captured it and show it */
3739	QCursor::setPos (mCapturedPos);
3740	updateHostCursor();
3741	}
3742	}
3743
3744	void VBoxConsoleView::setPointerShape (MousePointerChangeEvent *me)
3745	{
3746	if (me->shapeData() != NULL)
3747	{
3748	bool ok = false;
3749
3750	const uchar *srcAndMaskPtr = me->shapeData();
3751	uint andMaskSize = (me->width() + 7) / 8 * me->height();
3752	const uchar *srcShapePtr = me->shapeData() + ((andMaskSize + 3) & ~3);
3753	uint srcShapePtrScan = me->width() * 4;
3754
3755	#if defined (Q_WS_WIN)
3756
3757	BITMAPV5HEADER bi;
3758	HBITMAP hBitmap;
3759	void *lpBits;
3760
3761	::ZeroMemory (&bi, sizeof (BITMAPV5HEADER));
3762	bi.bV5Size = sizeof (BITMAPV5HEADER);
3763	bi.bV5Width = me->width();
3764	bi.bV5Height = - (LONG) me->height();
3765	bi.bV5Planes = 1;
3766	bi.bV5BitCount = 32;
3767	bi.bV5Compression = BI_BITFIELDS;
3768	// specifiy a supported 32 BPP alpha format for Windows XP
3769	bi.bV5RedMask = 0x00FF0000;
3770	bi.bV5GreenMask = 0x0000FF00;
3771	bi.bV5BlueMask = 0x000000FF;
3772	if (me->hasAlpha())
3773	bi.bV5AlphaMask = 0xFF000000;
3774	else
3775	bi.bV5AlphaMask = 0;
3776
3777	HDC hdc = GetDC (NULL);
3778
3779	// create the DIB section with an alpha channel
3780	hBitmap = CreateDIBSection (hdc, (BITMAPINFO *) &bi, DIB_RGB_COLORS,
3781	(void **) &lpBits, NULL, (DWORD) 0);
3782
3783	ReleaseDC (NULL, hdc);
3784
3785	HBITMAP hMonoBitmap = NULL;
3786	if (me->hasAlpha())
3787	{
3788	// create an empty mask bitmap
3789	hMonoBitmap = CreateBitmap (me->width(), me->height(), 1, 1, NULL);
3790	}
3791	else
3792	{
3793	/* Word aligned AND mask. Will be allocated and created if necessary. */
3794	uint8_t *pu8AndMaskWordAligned = NULL;
3795
3796	/* Width in bytes of the original AND mask scan line. */
3797	uint32_t cbAndMaskScan = (me->width() + 7) / 8;
3798
3799	if (cbAndMaskScan & 1)
3800	{
3801	/* Original AND mask is not word aligned. */
3802
3803	/* Allocate memory for aligned AND mask. */
3804	pu8AndMaskWordAligned = (uint8_t )RTMemTmpAllocZ ((cbAndMaskScan + 1) me->height());
3805
3806	Assert(pu8AndMaskWordAligned);
3807
3808	if (pu8AndMaskWordAligned)
3809	{
3810	/* According to MSDN the padding bits must be 0.
3811	* Compute the bit mask to set padding bits to 0 in the last byte of original AND mask.
3812	*/
3813	uint32_t u32PaddingBits = cbAndMaskScan * 8 - me->width();
3814	Assert(u32PaddingBits < 8);
3815	uint8_t u8LastBytesPaddingMask = (uint8_t)(0xFF << u32PaddingBits);
3816
3817	Log(("u8LastBytesPaddingMask = %02X, aligned w = %d, width = %d, cbAndMaskScan = %d\n",
3818	u8LastBytesPaddingMask, (cbAndMaskScan + 1) * 8, me->width(), cbAndMaskScan));
3819
3820	uint8_t src = (uint8_t )srcAndMaskPtr;
3821	uint8_t *dst = pu8AndMaskWordAligned;
3822
3823	unsigned i;
3824	for (i = 0; i < me->height(); i++)
3825	{
3826	memcpy (dst, src, cbAndMaskScan);
3827
3828	dst[cbAndMaskScan - 1] &= u8LastBytesPaddingMask;
3829
3830	src += cbAndMaskScan;
3831	dst += cbAndMaskScan + 1;
3832	}
3833	}
3834	}
3835
3836	/* create the AND mask bitmap */
3837	hMonoBitmap = ::CreateBitmap (me->width(), me->height(), 1, 1,
3838	pu8AndMaskWordAligned? pu8AndMaskWordAligned: srcAndMaskPtr);
3839
3840	if (pu8AndMaskWordAligned)
3841	{
3842	RTMemTmpFree (pu8AndMaskWordAligned);
3843	}
3844	}
3845
3846	Assert (hBitmap);
3847	Assert (hMonoBitmap);
3848	if (hBitmap && hMonoBitmap)
3849	{
3850	DWORD dstShapePtr = (DWORD ) lpBits;
3851
3852	for (uint y = 0; y < me->height(); y ++)
3853	{
3854	memcpy (dstShapePtr, srcShapePtr, srcShapePtrScan);
3855	srcShapePtr += srcShapePtrScan;
3856	dstShapePtr += me->width();
3857	}
3858
3859	ICONINFO ii;
3860	ii.fIcon = FALSE;
3861	ii.xHotspot = me->xHot();
3862	ii.yHotspot = me->yHot();
3863	ii.hbmMask = hMonoBitmap;
3864	ii.hbmColor = hBitmap;
3865
3866	HCURSOR hAlphaCursor = CreateIconIndirect (&ii);
3867	Assert (hAlphaCursor);
3868	if (hAlphaCursor)
3869	{
3870	mLastCursor = QCursor (hAlphaCursor);
3871	ok = true;
3872	if (mAlphaCursor)
3873	DestroyIcon (mAlphaCursor);
3874	mAlphaCursor = hAlphaCursor;
3875	}
3876	}
3877
3878	if (hMonoBitmap)
3879	DeleteObject (hMonoBitmap);
3880	if (hBitmap)
3881	DeleteObject (hBitmap);
3882
3883	#elif defined (Q_WS_X11) && !defined (VBOX_WITHOUT_XCURSOR)
3884
3885	XcursorImage *img = XcursorImageCreate (me->width(), me->height());
3886	Assert (img);
3887	if (img)
3888	{
3889	img->xhot = me->xHot();
3890	img->yhot = me->yHot();
3891
3892	XcursorPixel *dstShapePtr = img->pixels;
3893
3894	for (uint y = 0; y < me->height(); y ++)
3895	{
3896	memcpy (dstShapePtr, srcShapePtr, srcShapePtrScan);
3897
3898	if (!me->hasAlpha())
3899	{
3900	/* convert AND mask to the alpha channel */
3901	uchar byte = 0;
3902	for (uint x = 0; x < me->width(); x ++)
3903	{
3904	if (!(x % 8))
3905	byte = *(srcAndMaskPtr ++);
3906	else
3907	byte <<= 1;
3908
3909	if (byte & 0x80)
3910	{
3911	/* Linux doesn't support inverted pixels (XOR ops,
3912	* to be exact) in cursor shapes, so we detect such
3913	* pixels and always replace them with black ones to
3914	* make them visible at least over light colors */
3915	if (dstShapePtr [x] & 0x00FFFFFF)
3916	dstShapePtr [x] = 0xFF000000;
3917	else
3918	dstShapePtr [x] = 0x00000000;
3919	}
3920	else
3921	dstShapePtr [x] \|= 0xFF000000;
3922	}
3923	}
3924
3925	srcShapePtr += srcShapePtrScan;
3926	dstShapePtr += me->width();
3927	}
3928
3929	Cursor cur = XcursorImageLoadCursor (QX11Info::display(), img);
3930	Assert (cur);
3931	if (cur)
3932	{
3933	mLastCursor = QCursor (cur);
3934	ok = true;
3935	}
3936
3937	XcursorImageDestroy (img);
3938	}
3939
3940	#elif defined(Q_WS_MAC)
3941
3942	/* Create a ARGB image out of the shape data. */
3943	QImage image (me->width(), me->height(), QImage::Format_ARGB32);
3944	const uint8_t* pbSrcMask = static_cast<const uint8_t*> (srcAndMaskPtr);
3945	unsigned cbSrcMaskLine = RT_ALIGN (me->width(), 8) / 8;
3946	for (unsigned int y = 0; y < me->height(); ++y)
3947	{
3948	for (unsigned int x = 0; x < me->width(); ++x)
3949	{
3950	unsigned int color = ((unsigned int)srcShapePtr)[yme->width()+x];
3951	/* If the alpha channel isn't in the shape data, we have to
3952	* create them from the and-mask. This is a bit field where 1
3953	* represent transparency & 0 opaque respectively. */
3954	if (!me->hasAlpha())
3955	{
3956	if (!(pbSrcMask[x / 8] & (1 << (7 - (x % 8)))))
3957	color \|= 0xff000000;
3958	else
3959	{
3960	/* This isn't quite right, but it's the best we can do I
3961	* think... */
3962	if (color & 0x00ffffff)
3963	color = 0xff000000;
3964	else
3965	color = 0x00000000;
3966	}
3967	}
3968	image.setPixel (x, y, color);
3969	}
3970	/* Move one scanline forward. */
3971	pbSrcMask += cbSrcMaskLine;
3972	}
3973	/* Set the new cursor */
3974	QCursor cursor (QPixmap::fromImage (image),
3975	me->xHot(), me->yHot());
3976	mLastCursor = cursor;
3977	ok = true;
3978	NOREF (srcShapePtrScan);
3979
3980	#else
3981
3982	# warning "port me"
3983
3984	#endif
3985	if (!ok)
3986	mLastCursor = QCursor(); /* in practice this is equivalent to
3987	* unsetCursor() */
3988	mHideHostPointer = false;
3989	}
3990	else
3991	/* The visiblity flag is only interpreted if there is no shape */
3992	mHideHostPointer = !me->isVisible();
3993	updateHostCursor();
3994	}
3995
3996	inline QRgb qRgbIntensity (QRgb rgb, int mul, int div)
3997	{
3998	int r = qRed (rgb);
3999	int g = qGreen (rgb);
4000	int b = qBlue (rgb);
4001	return qRgb (mul * r / div, mul * g / div, mul * b / div);
4002	}
4003
4004	/* static */
4005	void VBoxConsoleView::dimImage (QImage &img)
4006	{
4007	for (int y = 0; y < img.height(); y ++) {
4008	if (y % 2) {
4009	if (img.depth() == 32) {
4010	for (int x = 0; x < img.width(); x ++) {
4011	int gray = qGray (img.pixel (x, y)) / 2;
4012	img.setPixel (x, y, qRgb (gray, gray, gray));
4013	// img.setPixel (x, y, qRgbIntensity (img.pixel (x, y), 1, 2));
4014	}
4015	} else {
4016	::memset (img.scanLine (y), 0, img.bytesPerLine());
4017	}
4018	} else {
4019	if (img.depth() == 32) {
4020	for (int x = 0; x < img.width(); x ++) {
4021	int gray = (2 * qGray (img.pixel (x, y))) / 3;
4022	img.setPixel (x, y, qRgb (gray, gray, gray));
4023	// img.setPixel (x, y, qRgbIntensity (img.pixel(x, y), 2, 3));
4024	}
4025	}
4026	}
4027	}
4028	}
4029
4030	void VBoxConsoleView::doResizeHint (const QSize &aToSize)
4031	{
4032	if (mAutoresizeGuest)
4033	{
4034	/* If this slot is invoked directly then use the passed size
4035	* otherwise get the available size for the guest display.
4036	* We assume here that the centralWidget() contains this view only
4037	* and gives it all available space. */
4038	QSize sz (aToSize.isValid() ? aToSize : mMainWnd->centralWidget()->size());
4039	if (!aToSize.isValid())
4040	sz -= QSize (frameWidth() * 2, frameWidth() * 2);
4041	/* Do not send out useless hints. */
4042	if ((sz.width() == mStoredConsoleSize.width()) &&
4043	(sz.height() == mStoredConsoleSize.height()))
4044	return;
4045	/* We only actually send the hint if
4046	* 1) the autoresize property is set to true and
4047	* 2) either an explicit new size was given (e.g. if the request
4048	* was triggered directly by a console resize event) or if no
4049	* explicit size was specified but a resize is flagged as being
4050	* needed (e.g. the autoresize was just enabled and the console
4051	* was resized while it was disabled). */
4052	if (mAutoresizeGuest &&
4053	(aToSize.isValid() \|\| mDoResize))
4054	{
4055	LogFlowFunc (("Will suggest %d x %d\n", sz.width(), sz.height()));
4056
4057	/* Remember the new size. */
4058	storeConsoleSize (sz.width(), sz.height());
4059
4060	mConsole.GetDisplay().SetVideoModeHint (sz.width(), sz.height(), 0, 0);
4061	}
4062	/* we have resized now... */
4063	mDoResize = false;
4064	}
4065	}
4066
4067
4068	/* If the desktop geometry is set automatically, this will update it. */
4069	void VBoxConsoleView::doResizeDesktop (int)
4070	{
4071	calculateDesktopGeometry();
4072	}
4073
4074	/**
4075	* Store the current size of the console (i.e. the viewport to the guest).
4076	* This has two purposes. One is to suppress unwanted resize events for
4077	* which the new size is the same as the stored size. The other is to expand
4078	* the maximum size to which we will let the guest resize itself. It makes
4079	* no sense to forbid guest resizes which are less than the current resolution
4080	* anyway.
4081	*
4082	* @param aWidth width of the resolution hint
4083	* @param aHeight height of the resolution hint
4084	*/
4085	void VBoxConsoleView::storeConsoleSize (int aWidth, int aHeight)
4086	{
4087	LogFlowThisFunc (("aWidth=%d, aHeight=%d\n", aWidth, aHeight));
4088	mStoredConsoleSize = QRect (0, 0, aWidth, aHeight);
4089	}
4090
4091	/**
4092	* Do initial setup of desktop geometry restrictions on the guest framebuffer.
4093	* These determine the maximum size the guest framebuffer can take on.
4094	*
4095	* @note a hint from the host will always override these restrictions.
4096	*
4097	* @param aGeo Fixed - the guest has a fixed maximum framebuffer size
4098	* Automatic - we calculate the maximum size ourselves. The
4099	* calculations will not actually be done until
4100	* @a calculateDesktopGeometry is called, since
4101	* we don't initially have the information needed.
4102	* Any - any size is allowed
4103	* @param aWidth The maximum width for the guest screen or zero for no change
4104	* (only used for fixed geometry)
4105	* @param aHeight The maximum height for the guest screen or zero for no change
4106	* (only used for fixed geometry)
4107	*/
4108	void VBoxConsoleView::setDesktopGeometry (DesktopGeo aGeo, int aWidth, int aHeight)
4109	{
4110	LogFlowThisFunc (("aGeo=%s, aWidth=%d, aHeight=%d\n",
4111	(aGeo == DesktopGeo_Fixed ? "Fixed" :
4112	aGeo == DesktopGeo_Automatic ? "Automatic" :
4113	aGeo == DesktopGeo_Any ? "Any" : "Invalid"),
4114	aWidth, aHeight));
4115	switch (aGeo)
4116	{
4117	case DesktopGeo_Fixed:
4118	mDesktopGeo = DesktopGeo_Fixed;
4119	if (aWidth != 0 && aHeight != 0)
4120	mDesktopGeometry = QRect (0, 0, aWidth, aHeight);
4121	else
4122	mDesktopGeometry = QRect (0, 0, 0, 0);
4123	storeConsoleSize (0, 0);
4124	break;
4125	case DesktopGeo_Automatic:
4126	mDesktopGeo = DesktopGeo_Automatic;
4127	mDesktopGeometry = QRect (0, 0, 0, 0);
4128	storeConsoleSize (0, 0);
4129	break;
4130	case DesktopGeo_Any:
4131	mDesktopGeo = DesktopGeo_Any;
4132	mDesktopGeometry = QRect (0, 0, 0, 0);
4133	break;
4134	default:
4135	AssertMsgFailed(("Invalid desktop geometry type %d\n", aGeo));
4136	mDesktopGeo = DesktopGeo_Invalid;
4137	}
4138	}
4139
4140
4141	/**
4142	* If we are in automatic mode, the geometry restrictions will be recalculated.
4143	* This is needed in particular on the first widget resize, as we can't
4144	* calculate them correctly before that.
4145	*
4146	* @note a hint from the host will always override these restrictions.
4147	* @note we can't do calculations on the fly when they are needed, because
4148	* they require querying the X server on X11 hosts and this must be done
4149	* from within the GUI thread, due to the single threadedness of Xlib.
4150	*/
4151	void VBoxConsoleView::calculateDesktopGeometry()
4152	{
4153	LogFlowThisFunc (("Entering\n"));
4154	/* This method should not get called until we have initially set up the */
4155	Assert ((mDesktopGeo != DesktopGeo_Invalid));
4156	/* If we are not doing automatic geometry calculation then there is
4157	* nothing to do. */
4158	if (DesktopGeo_Automatic == mDesktopGeo)
4159	{
4160	/* Available geometry of the desktop. If the desktop is a single
4161	* screen, this will exclude space taken up by desktop taskbars
4162	* and things, but this is unfortunately not true for the more
4163	* complex case of a desktop spanning multiple screens. */
4164	QRect desktop = availableGeometry();
4165	/* The area taken up by the console window on the desktop,
4166	* including window frame, title and menu bar and whatnot. */
4167	QRect frame = mMainWnd->frameGeometry();
4168	/* The area taken up by the console window, minus all
4169	* decorations. */
4170	QRect window = mMainWnd->centralWidget()->geometry();
4171	/* To work out how big we can make the console window while still
4172	* fitting on the desktop, we calculate desktop - frame + window.
4173	* This works because the difference between frame and window
4174	* (or at least its width and height) is a constant. */
4175	mDesktopGeometry =
4176	QRect (0, 0, desktop.width() - frame.width() + window.width(),
4177	desktop.height() - frame.height() + window.height());
4178	LogFlowThisFunc (("Setting %d, %d\n", mDesktopGeometry.width(),
4179	mDesktopGeometry.height()));
4180	}
4181	}
4182
4183	/**
4184	* Sets the minimum size restriction depending on the auto-resize feature
4185	* state and the current rendering mode.
4186	*
4187	* Currently, the restriction is set only in SDL mode and only when the
4188	* auto-resize feature is inactive. We need to do that because we cannot
4189	* correctly draw in a scrolled window in SDL mode.
4190	*
4191	* In all other modes, or when auto-resize is in force, this function does
4192	* nothing.
4193	*/
4194	void VBoxConsoleView::maybeRestrictMinimumSize()
4195	{
4196	if (mode == VBoxDefs::SDLMode)
4197	{
4198	if (!mGuestSupportsGraphics \|\| !mAutoresizeGuest)
4199	setMinimumSize (sizeHint());
4200	else
4201	setMinimumSize (0, 0);
4202	}
4203	}
4204
4205	QRect VBoxConsoleView::availableGeometry() const
4206	{
4207	return mMainWnd->isWindowFullScreen() ?
4208	QApplication::desktop()->screenGeometry(this) :
4209	QApplication::desktop()->availableGeometry(this);
4210	}
4211
4212	int VBoxConsoleView::contentsWidth() const
4213	{
4214	return mFrameBuf->width();
4215	}
4216
4217	int VBoxConsoleView::contentsHeight() const
4218	{
4219	return mFrameBuf->height();
4220	}
4221
4222	void VBoxConsoleView::updateSliders()
4223	{
4224	QSize p = viewport()->size();
4225	QSize m = maximumViewportSize();
4226
4227	QSize v = QSize (mFrameBuf->width(), mFrameBuf->height());
4228	/* no scroll bars needed */
4229	if (m.expandedTo(v) == m)
4230	p = m;
4231
4232	horizontalScrollBar()->setRange(0, v.width() - p.width());
4233	verticalScrollBar()->setRange(0, v.height() - p.height());
4234	horizontalScrollBar()->setPageStep(p.width());
4235	verticalScrollBar()->setPageStep(p.height());
4236	}
4237
4238	void VBoxConsoleView::requestToResize (const QSize &aSize)
4239	{
4240	mIgnoreFrameBufferResize = true;
4241	mNormalSize = aSize;
4242	}
4243
4244	#if defined(Q_WS_MAC)
4245
4246	void VBoxConsoleView::updateDockIcon()
4247	{
4248	if (mDockIconEnabled)
4249	{
4250	if (!mPausedShot.isNull())
4251	{
4252	CGImageRef pauseImg = ::darwinToCGImageRef (&mPausedShot);
4253	/* Use the pause image as background */
4254	mDockIconPreview->updateDockPreview (pauseImg);
4255	CGImageRelease (pauseImg);
4256	}
4257	else
4258	{
4259	# if defined (VBOX_GUI_USE_QUARTZ2D)
4260	if (mode == VBoxDefs::Quartz2DMode)
4261	{
4262	/* If the render mode is Quartz2D we could use the CGImageRef
4263	* of the framebuffer for the dock icon creation. This saves
4264	* some conversion time. */
4265	mDockIconPreview->updateDockPreview (static_cast <VBoxQuartz2DFrameBuffer *> (mFrameBuf)->imageRef());
4266	}
4267	else
4268	# endif
4269	/* In image mode we have to create the image ref out of the
4270	* framebuffer */
4271	mDockIconPreview->updateDockPreview (mFrameBuf);
4272	}
4273	}
4274	}
4275
4276	void VBoxConsoleView::updateDockOverlay()
4277	{
4278	/* Only to an update to the realtime preview if this is enabled by the user
4279	* & we are in an state where the framebuffer is likely valid. Otherwise to
4280	* the overlay stuff only. */
4281	if (mDockIconEnabled &&
4282	(mLastState == KMachineState_Running \|\|
4283	mLastState == KMachineState_Paused \|\|
4284	mLastState == KMachineState_Teleporting \|\|
4285	mLastState == KMachineState_LiveSnapshotting \|\|
4286	mLastState == KMachineState_Restoring \|\|
4287	mLastState == KMachineState_TeleportingPausedVM \|\|
4288	mLastState == KMachineState_TeleportingIn \|\|
4289	mLastState == KMachineState_Saving))
4290	updateDockIcon();
4291	else
4292	mDockIconPreview->updateDockOverlay();
4293	}
4294
4295	/**
4296	* Wrapper for SetMouseCoalescingEnabled().
4297	*
4298	* Called by eventFilter() and darwinGrabKeyboardEvents().
4299	*
4300	* @param aOn Switch it on (true) or off (false).
4301	*/
4302	void VBoxConsoleView::setMouseCoalescingEnabled (bool aOn)
4303	{
4304	/* Enable mouse event compression if we leave the VM view. This
4305	is necessary for having smooth resizing of the VM/other
4306	windows.
4307	Disable mouse event compression if we enter the VM view. So
4308	all mouse events are registered in the VM. Only do this if
4309	the keyboard/mouse is grabbed (this is when we have a valid
4310	event handler). */
4311	if (aOn \|\| mKeyboardGrabbed)
4312	::darwinSetMouseCoalescingEnabled (aOn);
4313	}
4314
4315	#endif /* Q_WS_MAC */
4316

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Frontends/VirtualBox/src/VBoxConsoleView.cpp@ 28215

Download in other formats: