MouseImpl.cpp@ 55747

Last change on this file since 55747 was 54495, checked in by vboxsync, 10 years ago
Main/Display and Mouse: input mapping fix for when VMMDev is not in use.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 38.4 KB

Line
1	/* $Id: MouseImpl.cpp 54495 2015-02-25 13:47:58Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2014 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#include <iprt/cpp/utils.h>
19
20	#include "MouseImpl.h"
21	#include "DisplayImpl.h"
22	#include "VMMDev.h"
23	#include "MousePointerShapeWrap.h"
24
25	#include "AutoCaller.h"
26	#include "Logging.h"
27
28	#include <VBox/vmm/pdmdrv.h>
29	#include <VBox/VMMDev.h>
30
31	#include <iprt/asm.h>
32
33	class ATL_NO_VTABLE MousePointerShape:
34	public MousePointerShapeWrap
35	{
36	public:
37
38	DECLARE_EMPTY_CTOR_DTOR(MousePointerShape)
39
40	HRESULT FinalConstruct();
41	void FinalRelease();
42
43	/* Public initializer/uninitializer for internal purposes only. */
44	HRESULT init(ComObjPtr<Mouse> pMouse,
45	bool fVisible, bool fAlpha,
46	uint32_t hotX, uint32_t hotY,
47	uint32_t width, uint32_t height,
48	const uint8_t *pu8Shape, uint32_t cbShape);
49	void uninit();
50
51	private:
52	// wrapped IMousePointerShape properties
53	virtual HRESULT getVisible(BOOL *aVisible);
54	virtual HRESULT getAlpha(BOOL *aAlpha);
55	virtual HRESULT getHotX(ULONG *aHotX);
56	virtual HRESULT getHotY(ULONG *aHotY);
57	virtual HRESULT getWidth(ULONG *aWidth);
58	virtual HRESULT getHeight(ULONG *aHeight);
59	virtual HRESULT getShape(std::vector<BYTE> &aShape);
60
61	struct Data
62	{
63	ComObjPtr<Mouse> pMouse;
64	bool fVisible;
65	bool fAlpha;
66	uint32_t hotX;
67	uint32_t hotY;
68	uint32_t width;
69	uint32_t height;
70	std::vector<BYTE> shape;
71	};
72
73	Data m;
74	};
75
76	/*
77	* MousePointerShape implementation.
78	*/
79	DEFINE_EMPTY_CTOR_DTOR(MousePointerShape)
80
81	HRESULT MousePointerShape::FinalConstruct()
82	{
83	return BaseFinalConstruct();
84	}
85
86	void MousePointerShape::FinalRelease()
87	{
88	uninit();
89
90	BaseFinalRelease();
91	}
92
93	HRESULT MousePointerShape::init(ComObjPtr<Mouse> pMouse,
94	bool fVisible, bool fAlpha,
95	uint32_t hotX, uint32_t hotY,
96	uint32_t width, uint32_t height,
97	const uint8_t *pu8Shape, uint32_t cbShape)
98	{
99	LogFlowThisFunc(("v %d, a %d, h %d,%d, %dx%d, cb %d\n",
100	fVisible, fAlpha, hotX, hotY, width, height, cbShape));
101
102	/* Enclose the state transition NotReady->InInit->Ready */
103	AutoInitSpan autoInitSpan(this);
104	AssertReturn(autoInitSpan.isOk(), E_FAIL);
105
106	m.pMouse = pMouse;
107	m.fVisible = fVisible;
108	m.fAlpha = fAlpha;
109	m.hotX = hotX;
110	m.hotY = hotY;
111	m.width = width;
112	m.height = height;
113	m.shape.resize(cbShape);
114	if (cbShape)
115	{
116	memcpy(&m.shape.front(), pu8Shape, cbShape);
117	}
118
119	/* Confirm a successful initialization */
120	autoInitSpan.setSucceeded();
121
122	return S_OK;
123	}
124
125	void MousePointerShape::uninit()
126	{
127	LogFlowThisFunc(("\n"));
128
129	/* Enclose the state transition Ready->InUninit->NotReady */
130	AutoUninitSpan autoUninitSpan(this);
131	if (autoUninitSpan.uninitDone())
132	return;
133
134	m.pMouse.setNull();
135	}
136
137	HRESULT MousePointerShape::getVisible(BOOL *aVisible)
138	{
139	*aVisible = m.fVisible;
140	return S_OK;
141	}
142
143	HRESULT MousePointerShape::getAlpha(BOOL *aAlpha)
144	{
145	*aAlpha = m.fAlpha;
146	return S_OK;
147	}
148
149	HRESULT MousePointerShape::getHotX(ULONG *aHotX)
150	{
151	*aHotX = m.hotX;
152	return S_OK;
153	}
154
155	HRESULT MousePointerShape::getHotY(ULONG *aHotY)
156	{
157	*aHotY = m.hotY;
158	return S_OK;
159	}
160
161	HRESULT MousePointerShape::getWidth(ULONG *aWidth)
162	{
163	*aWidth = m.width;
164	return S_OK;
165	}
166
167	HRESULT MousePointerShape::getHeight(ULONG *aHeight)
168	{
169	*aHeight = m.height;
170	return S_OK;
171	}
172
173	HRESULT MousePointerShape::getShape(std::vector<BYTE> &aShape)
174	{
175	aShape.resize(m.shape.size());
176	memcpy(&aShape.front(), &m.shape.front(), aShape.size());
177	return S_OK;
178	}
179
180
181	/** @name Mouse device capabilities bitfield
182	* @{ */
183	enum
184	{
185	/** The mouse device can do relative reporting */
186	MOUSE_DEVCAP_RELATIVE = 1,
187	/** The mouse device can do absolute reporting */
188	MOUSE_DEVCAP_ABSOLUTE = 2,
189	/** The mouse device can do absolute reporting */
190	MOUSE_DEVCAP_MULTI_TOUCH = 4
191	};
192	/** @} */
193
194
195	/**
196	* Mouse driver instance data.
197	*/
198	struct DRVMAINMOUSE
199	{
200	/** Pointer to the mouse object. */
201	Mouse *pMouse;
202	/** Pointer to the driver instance structure. */
203	PPDMDRVINS pDrvIns;
204	/** Pointer to the mouse port interface of the driver/device above us. */
205	PPDMIMOUSEPORT pUpPort;
206	/** Our mouse connector interface. */
207	PDMIMOUSECONNECTOR IConnector;
208	/** The capabilities of this device. */
209	uint32_t u32DevCaps;
210	};
211
212
213	// constructor / destructor
214	/////////////////////////////////////////////////////////////////////////////
215
216	Mouse::Mouse()
217	: mParent(NULL)
218	{
219	}
220
221	Mouse::~Mouse()
222	{
223	}
224
225
226	HRESULT Mouse::FinalConstruct()
227	{
228	RT_ZERO(mpDrv);
229	RT_ZERO(mPointerData);
230	mcLastX = 0x8000;
231	mcLastY = 0x8000;
232	mfLastButtons = 0;
233	mfVMMDevGuestCaps = 0;
234	return BaseFinalConstruct();
235	}
236
237	void Mouse::FinalRelease()
238	{
239	uninit();
240	BaseFinalRelease();
241	}
242
243	// public methods only for internal purposes
244	/////////////////////////////////////////////////////////////////////////////
245
246	/**
247	* Initializes the mouse object.
248	*
249	* @returns COM result indicator
250	* @param parent handle of our parent object
251	*/
252	HRESULT Mouse::init (ConsoleMouseInterface *parent)
253	{
254	LogFlowThisFunc(("\n"));
255
256	ComAssertRet(parent, E_INVALIDARG);
257
258	/* Enclose the state transition NotReady->InInit->Ready */
259	AutoInitSpan autoInitSpan(this);
260	AssertReturn(autoInitSpan.isOk(), E_FAIL);
261
262	unconst(mParent) = parent;
263
264	unconst(mEventSource).createObject();
265	HRESULT rc = mEventSource->init();
266	AssertComRCReturnRC(rc);
267	mMouseEvent.init(mEventSource, VBoxEventType_OnGuestMouse,
268	0, 0, 0, 0, 0, 0);
269
270	/* Confirm a successful initialization */
271	autoInitSpan.setSucceeded();
272
273	return S_OK;
274	}
275
276	/**
277	* Uninitializes the instance and sets the ready flag to FALSE.
278	* Called either from FinalRelease() or by the parent when it gets destroyed.
279	*/
280	void Mouse::uninit()
281	{
282	LogFlowThisFunc(("\n"));
283
284	/* Enclose the state transition Ready->InUninit->NotReady */
285	AutoUninitSpan autoUninitSpan(this);
286	if (autoUninitSpan.uninitDone())
287	return;
288
289	for (unsigned i = 0; i < MOUSE_MAX_DEVICES; ++i)
290	{
291	if (mpDrv[i])
292	mpDrv[i]->pMouse = NULL;
293	mpDrv[i] = NULL;
294	}
295
296	mPointerShape.setNull();
297
298	RTMemFree(mPointerData.pu8Shape);
299	mPointerData.pu8Shape = NULL;
300	mPointerData.cbShape = 0;
301
302	mMouseEvent.uninit();
303	unconst(mEventSource).setNull();
304	unconst(mParent) = NULL;
305	}
306
307	void Mouse::updateMousePointerShape(bool fVisible, bool fAlpha,
308	uint32_t hotX, uint32_t hotY,
309	uint32_t width, uint32_t height,
310	const uint8_t *pu8Shape, uint32_t cbShape)
311	{
312	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
313
314	RTMemFree(mPointerData.pu8Shape);
315	mPointerData.pu8Shape = NULL;
316	mPointerData.cbShape = 0;
317
318	mPointerData.fVisible = fVisible;
319	mPointerData.fAlpha = fAlpha;
320	mPointerData.hotX = hotX;
321	mPointerData.hotY = hotY;
322	mPointerData.width = width;
323	mPointerData.height = height;
324	if (cbShape)
325	{
326	mPointerData.pu8Shape = (uint8_t *)RTMemDup(pu8Shape, cbShape);
327	if (mPointerData.pu8Shape)
328	{
329	mPointerData.cbShape = cbShape;
330	}
331	}
332
333	mPointerShape.setNull();
334	}
335
336	// IMouse properties
337	/////////////////////////////////////////////////////////////////////////////
338
339	/** Report the front-end's mouse handling capabilities to the VMM device and
340	* thus to the guest.
341	* @note all calls out of this object are made with no locks held! */
342	HRESULT Mouse::i_updateVMMDevMouseCaps(uint32_t fCapsAdded,
343	uint32_t fCapsRemoved)
344	{
345	VMMDevMouseInterface *pVMMDev = mParent->i_getVMMDevMouseInterface();
346	if (!pVMMDev)
347	return E_FAIL; /* No assertion, as the front-ends can send events
348	* at all sorts of inconvenient times. */
349	DisplayMouseInterface *pDisplay = mParent->i_getDisplayMouseInterface();
350	if (pDisplay == NULL)
351	return E_FAIL;
352	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
353	if (!pVMMDevPort)
354	return E_FAIL; /* same here */
355
356	int rc = pVMMDevPort->pfnUpdateMouseCapabilities(pVMMDevPort, fCapsAdded,
357	fCapsRemoved);
358	if (RT_FAILURE(rc))
359	return E_FAIL;
360	return pDisplay->i_reportHostCursorCapabilities(fCapsAdded, fCapsRemoved);
361	}
362
363	/**
364	* Returns whether the currently active device portfolio can accept absolute
365	* mouse events.
366	*
367	* @returns COM status code
368	* @param absoluteSupported address of result variable
369	*/
370	HRESULT Mouse::getAbsoluteSupported(BOOL *aAbsoluteSupported)
371	{
372	*aAbsoluteSupported = i_supportsAbs();
373	return S_OK;
374	}
375
376	/**
377	* Returns whether the currently active device portfolio can accept relative
378	* mouse events.
379	*
380	* @returns COM status code
381	* @param relativeSupported address of result variable
382	*/
383	HRESULT Mouse::getRelativeSupported(BOOL *aRelativeSupported)
384	{
385	*aRelativeSupported = i_supportsRel();
386	return S_OK;
387	}
388
389	/**
390	* Returns whether the currently active device portfolio can accept multi-touch
391	* mouse events.
392	*
393	* @returns COM status code
394	* @param multiTouchSupported address of result variable
395	*/
396	HRESULT Mouse::getMultiTouchSupported(BOOL *aMultiTouchSupported)
397	{
398	*aMultiTouchSupported = i_supportsMT();
399	return S_OK;
400	}
401
402	/**
403	* Returns whether the guest can currently switch to drawing the mouse cursor
404	* itself if it is asked to by the front-end.
405	*
406	* @returns COM status code
407	* @param pfNeedsHostCursor address of result variable
408	*/
409	HRESULT Mouse::getNeedsHostCursor(BOOL *aNeedsHostCursor)
410	{
411	*aNeedsHostCursor = i_guestNeedsHostCursor();
412	return S_OK;
413	}
414
415	HRESULT Mouse::getPointerShape(ComPtr<IMousePointerShape> &aPointerShape)
416	{
417	HRESULT hr = S_OK;
418
419	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
420
421	if (mPointerShape.isNull())
422	{
423	ComObjPtr<MousePointerShape> obj;
424	hr = obj.createObject();
425	if (SUCCEEDED(hr))
426	{
427	hr = obj->init(this, mPointerData.fVisible, mPointerData.fAlpha,
428	mPointerData.hotX, mPointerData.hotY,
429	mPointerData.width, mPointerData.height,
430	mPointerData.pu8Shape, mPointerData.cbShape);
431	}
432
433	if (SUCCEEDED(hr))
434	{
435	mPointerShape = obj;
436	}
437	}
438
439	if (SUCCEEDED(hr))
440	{
441	aPointerShape = mPointerShape;
442	}
443
444	return hr;
445	}
446
447	// IMouse methods
448	/////////////////////////////////////////////////////////////////////////////
449
450	/** Converts a bitfield containing information about mouse buttons currently
451	* held down from the format used by the front-end to the format used by PDM
452	* and the emulated pointing devices. */
453	static uint32_t i_mouseButtonsToPDM(LONG buttonState)
454	{
455	uint32_t fButtons = 0;
456	if (buttonState & MouseButtonState_LeftButton)
457	fButtons \|= PDMIMOUSEPORT_BUTTON_LEFT;
458	if (buttonState & MouseButtonState_RightButton)
459	fButtons \|= PDMIMOUSEPORT_BUTTON_RIGHT;
460	if (buttonState & MouseButtonState_MiddleButton)
461	fButtons \|= PDMIMOUSEPORT_BUTTON_MIDDLE;
462	if (buttonState & MouseButtonState_XButton1)
463	fButtons \|= PDMIMOUSEPORT_BUTTON_X1;
464	if (buttonState & MouseButtonState_XButton2)
465	fButtons \|= PDMIMOUSEPORT_BUTTON_X2;
466	return fButtons;
467	}
468
469	HRESULT Mouse::getEventSource(ComPtr<IEventSource> &aEventSource)
470	{
471	// no need to lock - lifetime constant
472	mEventSource.queryInterfaceTo(aEventSource.asOutParam());
473	return S_OK;
474	}
475
476	/**
477	* Send a relative pointer event to the relative device we deem most
478	* appropriate.
479	*
480	* @returns COM status code
481	*/
482	HRESULT Mouse::i_reportRelEventToMouseDev(int32_t dx, int32_t dy, int32_t dz,
483	int32_t dw, uint32_t fButtons)
484	{
485	if (dx \|\| dy \|\| dz \|\| dw \|\| fButtons != mfLastButtons)
486	{
487	PPDMIMOUSEPORT pUpPort = NULL;
488	{
489	AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
490
491	for (unsigned i = 0; !pUpPort && i < MOUSE_MAX_DEVICES; ++i)
492	{
493	if (mpDrv[i] && (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_RELATIVE))
494	pUpPort = mpDrv[i]->pUpPort;
495	}
496	}
497	if (!pUpPort)
498	return S_OK;
499
500	int vrc = pUpPort->pfnPutEvent(pUpPort, dx, dy, dz, dw, fButtons);
501
502	if (RT_FAILURE(vrc))
503	return setError(VBOX_E_IPRT_ERROR,
504	tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
505	vrc);
506	mfLastButtons = fButtons;
507	}
508	return S_OK;
509	}
510
511
512	/**
513	* Send an absolute pointer event to the emulated absolute device we deem most
514	* appropriate.
515	*
516	* @returns COM status code
517	*/
518	HRESULT Mouse::i_reportAbsEventToMouseDev(int32_t x, int32_t y,
519	int32_t dz, int32_t dw, uint32_t fButtons)
520	{
521	if ( x < VMMDEV_MOUSE_RANGE_MIN
522	\|\| x > VMMDEV_MOUSE_RANGE_MAX)
523	return S_OK;
524	if ( y < VMMDEV_MOUSE_RANGE_MIN
525	\|\| y > VMMDEV_MOUSE_RANGE_MAX)
526	return S_OK;
527	if ( x != mcLastX \|\| y != mcLastY
528	\|\| dz \|\| dw \|\| fButtons != mfLastButtons)
529	{
530	PPDMIMOUSEPORT pUpPort = NULL;
531	{
532	AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
533
534	for (unsigned i = 0; !pUpPort && i < MOUSE_MAX_DEVICES; ++i)
535	{
536	if (mpDrv[i] && (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_ABSOLUTE))
537	pUpPort = mpDrv[i]->pUpPort;
538	}
539	}
540	if (!pUpPort)
541	return S_OK;
542
543	int vrc = pUpPort->pfnPutEventAbs(pUpPort, x, y, dz,
544	dw, fButtons);
545	if (RT_FAILURE(vrc))
546	return setError(VBOX_E_IPRT_ERROR,
547	tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
548	vrc);
549	mfLastButtons = fButtons;
550
551	}
552	return S_OK;
553	}
554
555	HRESULT Mouse::i_reportMultiTouchEventToDevice(uint8_t cContacts,
556	const uint64_t *pau64Contacts,
557	uint32_t u32ScanTime)
558	{
559	HRESULT hrc = S_OK;
560
561	PPDMIMOUSEPORT pUpPort = NULL;
562	{
563	AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
564
565	unsigned i;
566	for (i = 0; i < MOUSE_MAX_DEVICES; ++i)
567	{
568	if ( mpDrv[i]
569	&& (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_MULTI_TOUCH))
570	{
571	pUpPort = mpDrv[i]->pUpPort;
572	break;
573	}
574	}
575	}
576
577	if (pUpPort)
578	{
579	int vrc = pUpPort->pfnPutEventMultiTouch(pUpPort, cContacts, pau64Contacts, u32ScanTime);
580	if (RT_FAILURE(vrc))
581	hrc = setError(VBOX_E_IPRT_ERROR,
582	tr("Could not send the multi-touch event to the virtual device (%Rrc)"),
583	vrc);
584	}
585	else
586	{
587	hrc = E_UNEXPECTED;
588	}
589
590	return hrc;
591	}
592
593
594	/**
595	* Send an absolute position event to the VMM device.
596	* @note all calls out of this object are made with no locks held!
597	*
598	* @returns COM status code
599	*/
600	HRESULT Mouse::i_reportAbsEventToVMMDev(int32_t x, int32_t y)
601	{
602	VMMDevMouseInterface *pVMMDev = mParent->i_getVMMDevMouseInterface();
603	ComAssertRet(pVMMDev, E_FAIL);
604	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
605	ComAssertRet(pVMMDevPort, E_FAIL);
606
607	if (x != mcLastX \|\| y != mcLastY)
608	{
609	int vrc = pVMMDevPort->pfnSetAbsoluteMouse(pVMMDevPort,
610	x, y);
611	if (RT_FAILURE(vrc))
612	return setError(VBOX_E_IPRT_ERROR,
613	tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
614	vrc);
615	}
616	return S_OK;
617	}
618
619
620	/**
621	* Send an absolute pointer event to a pointing device (the VMM device if
622	* possible or whatever emulated absolute device seems best to us if not).
623	*
624	* @returns COM status code
625	*/
626	HRESULT Mouse::i_reportAbsEventToInputDevices(int32_t x, int32_t y, int32_t dz, int32_t dw, uint32_t fButtons,
627	bool fUsesVMMDevEvent)
628	{
629	HRESULT rc;
630	/** If we are using the VMMDev to report absolute position but without
631	* VMMDev IRQ support then we need to send a small "jiggle" to the emulated
632	* relative mouse device to alert the guest to changes. */
633	LONG cJiggle = 0;
634
635	if (i_vmmdevCanAbs())
636	{
637	/*
638	* Send the absolute mouse position to the VMM device.
639	*/
640	if (x != mcLastX \|\| y != mcLastY)
641	{
642	rc = i_reportAbsEventToVMMDev(x, y);
643	cJiggle = !fUsesVMMDevEvent;
644	}
645	rc = i_reportRelEventToMouseDev(cJiggle, 0, dz, dw, fButtons);
646	}
647	else
648	rc = i_reportAbsEventToMouseDev(x, y, dz, dw, fButtons);
649
650	mcLastX = x;
651	mcLastY = y;
652	return rc;
653	}
654
655
656	/**
657	* Send an absolute position event to the display device.
658	* @note all calls out of this object are made with no locks held!
659	* @param x Cursor X position in pixels relative to the first screen, where
660	* (1, 1) is the upper left corner.
661	* @param y Cursor Y position in pixels relative to the first screen, where
662	* (1, 1) is the upper left corner.
663	*/
664	HRESULT Mouse::i_reportAbsEventToDisplayDevice(int32_t x, int32_t y)
665	{
666	DisplayMouseInterface *pDisplay = mParent->i_getDisplayMouseInterface();
667	ComAssertRet(pDisplay, E_FAIL);
668
669	if (x != mcLastX \|\| y != mcLastY)
670	{
671	pDisplay->i_reportHostCursorPosition(x - 1, y - 1);
672	}
673	return S_OK;
674	}
675
676
677	void Mouse::i_fireMouseEvent(bool fAbsolute, LONG x, LONG y, LONG dz, LONG dw,
678	LONG fButtons)
679	{
680	/* If mouse button is pressed, we generate new event, to avoid reusable events coalescing and thus
681	dropping key press events */
682	GuestMouseEventMode_T mode;
683	if (fAbsolute)
684	mode = GuestMouseEventMode_Absolute;
685	else
686	mode = GuestMouseEventMode_Relative;
687
688	if (fButtons != 0)
689	{
690	VBoxEventDesc evDesc;
691	evDesc.init(mEventSource, VBoxEventType_OnGuestMouse, mode, x, y,
692	dz, dw, fButtons);
693	evDesc.fire(0);
694	}
695	else
696	{
697	mMouseEvent.reinit(VBoxEventType_OnGuestMouse, mode, x, y, dz, dw,
698	fButtons);
699	mMouseEvent.fire(0);
700	}
701	}
702
703	void Mouse::i_fireMultiTouchEvent(uint8_t cContacts,
704	const LONG64 *paContacts,
705	uint32_t u32ScanTime)
706	{
707	com::SafeArray<SHORT> xPositions(cContacts);
708	com::SafeArray<SHORT> yPositions(cContacts);
709	com::SafeArray<USHORT> contactIds(cContacts);
710	com::SafeArray<USHORT> contactFlags(cContacts);
711
712	uint8_t i;
713	for (i = 0; i < cContacts; i++)
714	{
715	uint32_t u32Lo = RT_LO_U32(paContacts[i]);
716	uint32_t u32Hi = RT_HI_U32(paContacts[i]);
717	xPositions[i] = (int16_t)u32Lo;
718	yPositions[i] = (int16_t)(u32Lo >> 16);
719	contactIds[i] = RT_BYTE1(u32Hi);
720	contactFlags[i] = RT_BYTE2(u32Hi);
721	}
722
723	VBoxEventDesc evDesc;
724	evDesc.init(mEventSource, VBoxEventType_OnGuestMultiTouch,
725	cContacts, ComSafeArrayAsInParam(xPositions), ComSafeArrayAsInParam(yPositions),
726	ComSafeArrayAsInParam(contactIds), ComSafeArrayAsInParam(contactFlags), u32ScanTime);
727	evDesc.fire(0);
728	}
729
730	/**
731	* Send a relative mouse event to the guest.
732	* @note the VMMDev capability change is so that the guest knows we are sending
733	* real events over the PS/2 device and not dummy events to signal the
734	* arrival of new absolute pointer data
735	*
736	* @returns COM status code
737	* @param dx X movement
738	* @param dy Y movement
739	* @param dz Z movement
740	* @param fButtons The mouse button state
741	*/
742	HRESULT Mouse::putMouseEvent(LONG dx, LONG dy, LONG dz, LONG dw,
743	LONG aButtonState)
744	{
745	HRESULT rc;
746	uint32_t fButtonsAdj;
747
748	LogRel3(("%s: dx=%d, dy=%d, dz=%d, dw=%d\n", __PRETTY_FUNCTION__,
749	dx, dy, dz, dw));
750
751	fButtonsAdj = i_mouseButtonsToPDM(aButtonState);
752	/* Make sure that the guest knows that we are sending real movement
753	* events to the PS/2 device and not just dummy wake-up ones. */
754	i_updateVMMDevMouseCaps(0, VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE);
755	rc = i_reportRelEventToMouseDev(dx, dy, dz, dw, fButtonsAdj);
756
757	i_fireMouseEvent(false, dx, dy, dz, dw, aButtonState);
758
759	return rc;
760	}
761
762	/**
763	* Convert an (X, Y) value pair in screen co-ordinates (starting from 1) to a
764	* value from VMMDEV_MOUSE_RANGE_MIN to VMMDEV_MOUSE_RANGE_MAX. Sets the
765	* optional validity value to false if the pair is not on an active screen and
766	* to true otherwise.
767	* @note since guests with recent versions of X.Org use a different method
768	* to everyone else to map the valuator value to a screen pixel (they
769	* multiply by the screen dimension, do a floating point divide by
770	* the valuator maximum and round the result, while everyone else
771	* does truncating integer operations) we adjust the value we send
772	* so that it maps to the right pixel both when the result is rounded
773	* and when it is truncated.
774	*
775	* @returns COM status value
776	*/
777	HRESULT Mouse::i_convertDisplayRes(LONG x, LONG y, int32_t pxAdj, int32_t pyAdj,
778	bool *pfValid)
779	{
780	AssertPtrReturn(pxAdj, E_POINTER);
781	AssertPtrReturn(pyAdj, E_POINTER);
782	AssertPtrNullReturn(pfValid, E_POINTER);
783	DisplayMouseInterface *pDisplay = mParent->i_getDisplayMouseInterface();
784	ComAssertRet(pDisplay, E_FAIL);
785	/** The amount to add to the result (multiplied by the screen width/height)
786	* to compensate for differences in guest methods for mapping back to
787	* pixels */
788	enum { ADJUST_RANGE = - 3 * VMMDEV_MOUSE_RANGE / 4 };
789
790	if (pfValid)
791	*pfValid = true;
792	if (!(mfVMMDevGuestCaps & VMMDEV_MOUSE_NEW_PROTOCOL) && !pDisplay->i_isInputMappingSet())
793	{
794	ULONG displayWidth, displayHeight;
795	ULONG ulDummy;
796	LONG lDummy;
797	/* Takes the display lock */
798	HRESULT rc = pDisplay->i_getScreenResolution(0, &displayWidth,
799	&displayHeight, &ulDummy, &lDummy, &lDummy);
800	if (FAILED(rc))
801	return rc;
802
803	pxAdj = displayWidth ? (x VMMDEV_MOUSE_RANGE + ADJUST_RANGE)
804	/ (LONG) displayWidth: 0;
805	pyAdj = displayHeight ? (y VMMDEV_MOUSE_RANGE + ADJUST_RANGE)
806	/ (LONG) displayHeight: 0;
807	}
808	else
809	{
810	int32_t x1, y1, x2, y2;
811	/* Takes the display lock */
812	pDisplay->i_getFramebufferDimensions(&x1, &y1, &x2, &y2);
813	pxAdj = x1 < x2 ? ((x - x1) VMMDEV_MOUSE_RANGE + ADJUST_RANGE)
814	/ (x2 - x1) : 0;
815	pyAdj = y1 < y2 ? ((y - y1) VMMDEV_MOUSE_RANGE + ADJUST_RANGE)
816	/ (y2 - y1) : 0;
817	if ( *pxAdj < VMMDEV_MOUSE_RANGE_MIN
818	\|\| *pxAdj > VMMDEV_MOUSE_RANGE_MAX
819	\|\| *pyAdj < VMMDEV_MOUSE_RANGE_MIN
820	\|\| *pyAdj > VMMDEV_MOUSE_RANGE_MAX)
821	if (pfValid)
822	*pfValid = false;
823	}
824	return S_OK;
825	}
826
827
828	/**
829	* Send an absolute mouse event to the VM. This requires either VirtualBox-
830	* specific drivers installed in the guest or absolute pointing device
831	* emulation.
832	* @note the VMMDev capability change is so that the guest knows we are sending
833	* dummy events over the PS/2 device to signal the arrival of new
834	* absolute pointer data, and not pointer real movement data
835	* @note all calls out of this object are made with no locks held!
836	*
837	* @returns COM status code
838	* @param x X position (pixel), starting from 1
839	* @param y Y position (pixel), starting from 1
840	* @param dz Z movement
841	* @param fButtons The mouse button state
842	*/
843	HRESULT Mouse::putMouseEventAbsolute(LONG x, LONG y, LONG dz, LONG dw,
844	LONG aButtonState)
845	{
846	LogRel3(("%s: x=%d, y=%d, dz=%d, dw=%d, fButtons=0x%x\n",
847	__PRETTY_FUNCTION__, x, y, dz, dw, aButtonState));
848
849	int32_t xAdj, yAdj;
850	uint32_t fButtonsAdj;
851	bool fValid;
852
853	/** @todo the front end should do this conversion to avoid races */
854	/** @note Or maybe not... races are pretty inherent in everything done in
855	* this object and not really bad as far as I can see. */
856	HRESULT rc = i_convertDisplayRes(x, y, &xAdj, &yAdj, &fValid);
857	if (FAILED(rc)) return rc;
858
859	fButtonsAdj = i_mouseButtonsToPDM(aButtonState);
860	/* If we are doing old-style (IRQ-less) absolute reporting to the VMM
861	* device then make sure the guest is aware of it, so that it knows to
862	* ignore relative movement on the PS/2 device. */
863	i_updateVMMDevMouseCaps(VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE, 0);
864	if (fValid)
865	{
866	rc = i_reportAbsEventToInputDevices(xAdj, yAdj, dz, dw, fButtonsAdj,
867	RT_BOOL(mfVMMDevGuestCaps & VMMDEV_MOUSE_NEW_PROTOCOL));
868	if (FAILED(rc)) return rc;
869
870	i_fireMouseEvent(true, x, y, dz, dw, aButtonState);
871	}
872	rc = i_reportAbsEventToDisplayDevice(x, y);
873
874	return rc;
875	}
876
877	/**
878	* Send a multi-touch event. This requires multi-touch pointing device emulation.
879	* @note all calls out of this object are made with no locks held!
880	*
881	* @returns COM status code.
882	* @param aCount Number of contacts.
883	* @param aContacts Information about each contact.
884	* @param aScanTime Timestamp.
885	*/
886	HRESULT Mouse::putEventMultiTouch(LONG aCount,
887	const std::vector<LONG64> &aContacts,
888	ULONG aScanTime)
889	{
890	LogRel3(("%s: aCount %d(actual %d), aScanTime %u\n",
891	__FUNCTION__, aCount, aContacts.size(), aScanTime));
892
893	HRESULT rc = S_OK;
894
895	if ((LONG)aContacts.size() >= aCount)
896	{
897	const LONG64 *paContacts = aCount > 0? &aContacts.front(): NULL;
898
899	rc = i_putEventMultiTouch(aCount, paContacts, aScanTime);
900	}
901	else
902	{
903	rc = E_INVALIDARG;
904	}
905
906	return rc;
907	}
908
909	/**
910	* Send a multi-touch event. Version for scripting languages.
911	*
912	* @returns COM status code.
913	* @param aCount Number of contacts.
914	* @param aContacts Information about each contact.
915	* @param aScanTime Timestamp.
916	*/
917	HRESULT Mouse::putEventMultiTouchString(LONG aCount,
918	const com::Utf8Str &aContacts,
919	ULONG aScanTime)
920	{
921	/** @todo implement: convert the string to LONG64 array and call putEventMultiTouch. */
922	NOREF(aCount);
923	NOREF(aContacts);
924	NOREF(aScanTime);
925	return E_NOTIMPL;
926	}
927
928
929	// private methods
930	/////////////////////////////////////////////////////////////////////////////
931
932	/* Used by PutEventMultiTouch and PutEventMultiTouchString. */
933	HRESULT Mouse::i_putEventMultiTouch(LONG aCount,
934	const LONG64 *paContacts,
935	ULONG aScanTime)
936	{
937	if (aCount >= 256)
938	{
939	return E_INVALIDARG;
940	}
941
942	DisplayMouseInterface *pDisplay = mParent->i_getDisplayMouseInterface();
943	ComAssertRet(pDisplay, E_FAIL);
944
945	/* Touch events are mapped to the primary monitor, because the emulated USB
946	* touchscreen device is associated with one (normally the primary) screen in the guest.
947	*/
948	ULONG uScreenId = 0;
949
950	ULONG cWidth = 0;
951	ULONG cHeight = 0;
952	ULONG cBPP = 0;
953	LONG xOrigin = 0;
954	LONG yOrigin = 0;
955	HRESULT rc = pDisplay->i_getScreenResolution(uScreenId, &cWidth, &cHeight, &cBPP, &xOrigin, &yOrigin);
956	NOREF(cBPP);
957	ComAssertComRCRetRC(rc);
958
959	uint64_t* pau64Contacts = NULL;
960	uint8_t cContacts = 0;
961
962	/* Deliver 0 contacts too, touch device may use this to reset the state. */
963	if (aCount > 0)
964	{
965	/* Create a copy with converted coords. */
966	pau64Contacts = (uint64_t )RTMemTmpAlloc(aCount sizeof(uint64_t));
967	if (pau64Contacts)
968	{
969	int32_t x1 = xOrigin;
970	int32_t y1 = yOrigin;
971	int32_t x2 = x1 + cWidth;
972	int32_t y2 = y1 + cHeight;
973
974	LogRel3(("%s: screen [%d] %d,%d %d,%d\n",
975	__FUNCTION__, uScreenId, x1, y1, x2, y2));
976
977	LONG i;
978	for (i = 0; i < aCount; i++)
979	{
980	uint32_t u32Lo = RT_LO_U32(paContacts[i]);
981	uint32_t u32Hi = RT_HI_U32(paContacts[i]);
982	int32_t x = (int16_t)u32Lo;
983	int32_t y = (int16_t)(u32Lo >> 16);
984	uint8_t contactId = RT_BYTE1(u32Hi);
985	bool fInContact = (RT_BYTE2(u32Hi) & 0x1) != 0;
986	bool fInRange = (RT_BYTE2(u32Hi) & 0x2) != 0;
987
988	LogRel3(("%s: [%d] %d,%d id %d, inContact %d, inRange %d\n",
989	__FUNCTION__, i, x, y, contactId, fInContact, fInRange));
990
991	/* x1,y1 are inclusive and x2,y2 are exclusive,
992	* while x,y start from 1 and are inclusive.
993	*/
994	if (x <= x1 \|\| x > x2 \|\| y <= y1 \|\| y > y2)
995	{
996	/* Out of range. Skip the contact. */
997	continue;
998	}
999
1000	int32_t xAdj = x1 < x2? ((x - 1 - x1) * VMMDEV_MOUSE_RANGE) / (x2 - x1) : 0;
1001	int32_t yAdj = y1 < y2? ((y - 1 - y1) * VMMDEV_MOUSE_RANGE) / (y2 - y1) : 0;
1002
1003	bool fValid = ( xAdj >= VMMDEV_MOUSE_RANGE_MIN
1004	&& xAdj <= VMMDEV_MOUSE_RANGE_MAX
1005	&& yAdj >= VMMDEV_MOUSE_RANGE_MIN
1006	&& yAdj <= VMMDEV_MOUSE_RANGE_MAX);
1007
1008	if (fValid)
1009	{
1010	uint8_t fu8 = (fInContact? 0x01: 0x00)
1011	\| (fInRange? 0x02: 0x00);
1012	pau64Contacts[cContacts] = RT_MAKE_U64_FROM_U16((uint16_t)xAdj,
1013	(uint16_t)yAdj,
1014	RT_MAKE_U16(contactId, fu8),
1015	0);
1016	cContacts++;
1017	}
1018	}
1019	}
1020	else
1021	{
1022	rc = E_OUTOFMEMORY;
1023	}
1024	}
1025
1026	if (SUCCEEDED(rc))
1027	{
1028	rc = i_reportMultiTouchEventToDevice(cContacts, cContacts? pau64Contacts: NULL, (uint32_t)aScanTime);
1029
1030	/* Send the original contact information. */
1031	i_fireMultiTouchEvent(cContacts, cContacts? paContacts: NULL, (uint32_t)aScanTime);
1032	}
1033
1034	RTMemTmpFree(pau64Contacts);
1035
1036	return rc;
1037	}
1038
1039
1040	/** Does the guest currently rely on the host to draw the mouse cursor or
1041	* can it switch to doing it itself in software? */
1042	bool Mouse::i_guestNeedsHostCursor(void)
1043	{
1044	return RT_BOOL(mfVMMDevGuestCaps & VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
1045	}
1046
1047
1048	/** Check what sort of reporting can be done using the devices currently
1049	* enabled. Does not consider the VMM device. */
1050	void Mouse::i_getDeviceCaps(bool pfAbs, bool pfRel, bool *pfMT)
1051	{
1052	bool fAbsDev = false;
1053	bool fRelDev = false;
1054	bool fMTDev = false;
1055
1056	AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
1057
1058	for (unsigned i = 0; i < MOUSE_MAX_DEVICES; ++i)
1059	if (mpDrv[i])
1060	{
1061	if (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_ABSOLUTE)
1062	fAbsDev = true;
1063	if (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_RELATIVE)
1064	fRelDev = true;
1065	if (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_MULTI_TOUCH)
1066	fMTDev = true;
1067	}
1068	if (pfAbs)
1069	*pfAbs = fAbsDev;
1070	if (pfRel)
1071	*pfRel = fRelDev;
1072	if (pfMT)
1073	*pfMT = fMTDev;
1074	}
1075
1076
1077	/** Does the VMM device currently support absolute reporting? */
1078	bool Mouse::i_vmmdevCanAbs(void)
1079	{
1080	bool fRelDev;
1081
1082	i_getDeviceCaps(NULL, &fRelDev, NULL);
1083	return (mfVMMDevGuestCaps & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
1084	&& fRelDev;
1085	}
1086
1087
1088	/** Does the VMM device currently support absolute reporting? */
1089	bool Mouse::i_deviceCanAbs(void)
1090	{
1091	bool fAbsDev;
1092
1093	i_getDeviceCaps(&fAbsDev, NULL, NULL);
1094	return fAbsDev;
1095	}
1096
1097
1098	/** Can we currently send relative events to the guest? */
1099	bool Mouse::i_supportsRel(void)
1100	{
1101	bool fRelDev;
1102
1103	i_getDeviceCaps(NULL, &fRelDev, NULL);
1104	return fRelDev;
1105	}
1106
1107
1108	/** Can we currently send absolute events to the guest? */
1109	bool Mouse::i_supportsAbs(void)
1110	{
1111	bool fAbsDev;
1112
1113	i_getDeviceCaps(&fAbsDev, NULL, NULL);
1114	return fAbsDev \|\| i_vmmdevCanAbs();
1115	}
1116
1117
1118	/** Can we currently send absolute events to the guest? */
1119	bool Mouse::i_supportsMT(void)
1120	{
1121	bool fMTDev;
1122
1123	i_getDeviceCaps(NULL, NULL, &fMTDev);
1124	return fMTDev;
1125	}
1126
1127
1128	/** Check what sort of reporting can be done using the devices currently
1129	* enabled (including the VMM device) and notify the guest and the front-end.
1130	*/
1131	void Mouse::i_sendMouseCapsNotifications(void)
1132	{
1133	bool fRelDev, fMTDev, fCanAbs, fNeedsHostCursor;
1134
1135	{
1136	AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
1137
1138	i_getDeviceCaps(NULL, &fRelDev, &fMTDev);
1139	fCanAbs = i_supportsAbs();
1140	fNeedsHostCursor = i_guestNeedsHostCursor();
1141	}
1142	mParent->i_onMouseCapabilityChange(fCanAbs, fRelDev, fMTDev, fNeedsHostCursor);
1143	}
1144
1145
1146	/**
1147	* @interface_method_impl{PDMIMOUSECONNECTOR,pfnReportModes}
1148	* A virtual device is notifying us about its current state and capabilities
1149	*/
1150	DECLCALLBACK(void) Mouse::i_mouseReportModes(PPDMIMOUSECONNECTOR pInterface, bool fRel, bool fAbs, bool fMT)
1151	{
1152	PDRVMAINMOUSE pDrv = RT_FROM_MEMBER(pInterface, DRVMAINMOUSE, IConnector);
1153	if (fRel)
1154	pDrv->u32DevCaps \|= MOUSE_DEVCAP_RELATIVE;
1155	else
1156	pDrv->u32DevCaps &= ~MOUSE_DEVCAP_RELATIVE;
1157	if (fAbs)
1158	pDrv->u32DevCaps \|= MOUSE_DEVCAP_ABSOLUTE;
1159	else
1160	pDrv->u32DevCaps &= ~MOUSE_DEVCAP_ABSOLUTE;
1161	if (fMT)
1162	pDrv->u32DevCaps \|= MOUSE_DEVCAP_MULTI_TOUCH;
1163	else
1164	pDrv->u32DevCaps &= ~MOUSE_DEVCAP_MULTI_TOUCH;
1165
1166	pDrv->pMouse->i_sendMouseCapsNotifications();
1167	}
1168
1169
1170	/**
1171	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
1172	*/
1173	DECLCALLBACK(void ) Mouse::i_drvQueryInterface(PPDMIBASE pInterface, const char pszIID)
1174	{
1175	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1176	PDRVMAINMOUSE pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
1177
1178	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
1179	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSECONNECTOR, &pDrv->IConnector);
1180	return NULL;
1181	}
1182
1183
1184	/**
1185	* Destruct a mouse driver instance.
1186	*
1187	* @returns VBox status.
1188	* @param pDrvIns The driver instance data.
1189	*/
1190	DECLCALLBACK(void) Mouse::i_drvDestruct(PPDMDRVINS pDrvIns)
1191	{
1192	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
1193	PDRVMAINMOUSE pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
1194	LogFlow(("Mouse::drvDestruct: iInstance=%d\n", pDrvIns->iInstance));
1195
1196	if (pThis->pMouse)
1197	{
1198	AutoWriteLock mouseLock(pThis->pMouse COMMA_LOCKVAL_SRC_POS);
1199	for (unsigned cDev = 0; cDev < MOUSE_MAX_DEVICES; ++cDev)
1200	if (pThis->pMouse->mpDrv[cDev] == pThis)
1201	{
1202	pThis->pMouse->mpDrv[cDev] = NULL;
1203	break;
1204	}
1205	}
1206	}
1207
1208
1209	/**
1210	* Construct a mouse driver instance.
1211	*
1212	* @copydoc FNPDMDRVCONSTRUCT
1213	*/
1214	DECLCALLBACK(int) Mouse::i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1215	{
1216	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1217	PDRVMAINMOUSE pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
1218	LogFlow(("drvMainMouse_Construct: iInstance=%d\n", pDrvIns->iInstance));
1219
1220	/*
1221	* Validate configuration.
1222	*/
1223	if (!CFGMR3AreValuesValid(pCfg, "Object\0"))
1224	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
1225	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
1226	("Configuration error: Not possible to attach anything to this driver!\n"),
1227	VERR_PDM_DRVINS_NO_ATTACH);
1228
1229	/*
1230	* IBase.
1231	*/
1232	pDrvIns->IBase.pfnQueryInterface = Mouse::i_drvQueryInterface;
1233
1234	pThis->IConnector.pfnReportModes = Mouse::i_mouseReportModes;
1235
1236	/*
1237	* Get the IMousePort interface of the above driver/device.
1238	*/
1239	pThis->pUpPort = (PPDMIMOUSEPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMIMOUSEPORT_IID);
1240	if (!pThis->pUpPort)
1241	{
1242	AssertMsgFailed(("Configuration error: No mouse port interface above!\n"));
1243	return VERR_PDM_MISSING_INTERFACE_ABOVE;
1244	}
1245
1246	/*
1247	* Get the Mouse object pointer and update the mpDrv member.
1248	*/
1249	void *pv;
1250	int rc = CFGMR3QueryPtr(pCfg, "Object", &pv);
1251	if (RT_FAILURE(rc))
1252	{
1253	AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
1254	return rc;
1255	}
1256	pThis->pMouse = (Mouse )pv; /* @todo Check this cast! */
1257	unsigned cDev;
1258	{
1259	AutoReadLock mouseLock(pThis->pMouse COMMA_LOCKVAL_SRC_POS);
1260
1261	for (cDev = 0; cDev < MOUSE_MAX_DEVICES; ++cDev)
1262	if (!pThis->pMouse->mpDrv[cDev])
1263	{
1264	pThis->pMouse->mpDrv[cDev] = pThis;
1265	break;
1266	}
1267	}
1268	if (cDev == MOUSE_MAX_DEVICES)
1269	return VERR_NO_MORE_HANDLES;
1270
1271	return VINF_SUCCESS;
1272	}
1273
1274
1275	/**
1276	* Main mouse driver registration record.
1277	*/
1278	const PDMDRVREG Mouse::DrvReg =
1279	{
1280	/* u32Version */
1281	PDM_DRVREG_VERSION,
1282	/* szName */
1283	"MainMouse",
1284	/* szRCMod */
1285	"",
1286	/* szR0Mod */
1287	"",
1288	/* pszDescription */
1289	"Main mouse driver (Main as in the API).",
1290	/* fFlags */
1291	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1292	/* fClass. */
1293	PDM_DRVREG_CLASS_MOUSE,
1294	/* cMaxInstances */
1295	~0U,
1296	/* cbInstance */
1297	sizeof(DRVMAINMOUSE),
1298	/* pfnConstruct */
1299	Mouse::i_drvConstruct,
1300	/* pfnDestruct */
1301	Mouse::i_drvDestruct,
1302	/* pfnRelocate */
1303	NULL,
1304	/* pfnIOCtl */
1305	NULL,
1306	/* pfnPowerOn */
1307	NULL,
1308	/* pfnReset */
1309	NULL,
1310	/* pfnSuspend */
1311	NULL,
1312	/* pfnResume */
1313	NULL,
1314	/* pfnAttach */
1315	NULL,
1316	/* pfnDetach */
1317	NULL,
1318	/* pfnPowerOff */
1319	NULL,
1320	/* pfnSoftReset */
1321	NULL,
1322	/* u32EndVersion */
1323	PDM_DRVREG_VERSION
1324	};
1325	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/src-client/MouseImpl.cpp@ 55747

Download in other formats: