MouseImpl.cpp@ 32817

Last change on this file since 32817 was 32817, checked in by vboxsync, 14 years ago
Main: some locking and readability clean-up of MouseImpl
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.0 KB

Line
1	/* $Id: MouseImpl.cpp 32817 2010-09-29 14:30:07Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2008 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
24	#include "AutoCaller.h"
25	#include "Logging.h"
26
27	#include <VBox/pdmdrv.h>
28
29	#include <iprt/asm.h>
30
31	#include <VBox/VMMDev.h>
32
33	/** @name Mouse device capabilities bitfield
34	* @{ */
35	enum
36	{
37	/** The mouse device can do relative reporting */
38	MOUSE_DEVCAP_RELATIVE = 1,
39	/** The mouse device can do absolute reporting */
40	MOUSE_DEVCAP_ABSOLUTE = 2
41	};
42	/** @} */
43
44	/**
45	* Mouse driver instance data.
46	*/
47	struct DRVMAINMOUSE
48	{
49	/** Pointer to the mouse object. */
50	Mouse *pMouse;
51	/** Pointer to the driver instance structure. */
52	PPDMDRVINS pDrvIns;
53	/** Pointer to the mouse port interface of the driver/device above us. */
54	PPDMIMOUSEPORT pUpPort;
55	/** Our mouse connector interface. */
56	PDMIMOUSECONNECTOR IConnector;
57	/** The capabilities of this device. */
58	uint32_t u32DevCaps;
59	};
60
61
62	// constructor / destructor
63	/////////////////////////////////////////////////////////////////////////////
64
65	Mouse::Mouse()
66	: mParent(NULL)
67	{
68	}
69
70	Mouse::~Mouse()
71	{
72	}
73
74
75	HRESULT Mouse::FinalConstruct()
76	{
77	RT_ZERO(mpDrv);
78	fVMMDevCanAbs = false;
79	fVMMDevNeedsHostCursor = false;
80	mLastAbsX = 0x8000;
81	mLastAbsY = 0x8000;
82	mLastButtons = 0;
83	return S_OK;
84	}
85
86	void Mouse::FinalRelease()
87	{
88	uninit();
89	}
90
91	// public methods only for internal purposes
92	/////////////////////////////////////////////////////////////////////////////
93
94	/**
95	* Initializes the mouse object.
96	*
97	* @returns COM result indicator
98	* @param parent handle of our parent object
99	*/
100	HRESULT Mouse::init (Console *parent)
101	{
102	LogFlowThisFunc(("\n"));
103
104	ComAssertRet(parent, E_INVALIDARG);
105
106	/* Enclose the state transition NotReady->InInit->Ready */
107	AutoInitSpan autoInitSpan(this);
108	AssertReturn(autoInitSpan.isOk(), E_FAIL);
109
110	unconst(mParent) = parent;
111
112	uHostCaps = 0;
113
114	/* Confirm a successful initialization */
115	autoInitSpan.setSucceeded();
116
117	return S_OK;
118	}
119
120	/**
121	* Uninitializes the instance and sets the ready flag to FALSE.
122	* Called either from FinalRelease() or by the parent when it gets destroyed.
123	*/
124	void Mouse::uninit()
125	{
126	LogFlowThisFunc(("\n"));
127
128	/* Enclose the state transition Ready->InUninit->NotReady */
129	AutoUninitSpan autoUninitSpan(this);
130	if (autoUninitSpan.uninitDone())
131	return;
132
133	for (unsigned i = 0; i < MOUSE_MAX_DEVICES; ++i)
134	{
135	if (mpDrv[i])
136	mpDrv[i]->pMouse = NULL;
137	mpDrv[i] = NULL;
138	}
139
140	#ifdef VBOXBFE_WITHOUT_COM
141	mParent = NULL;
142	#else
143	unconst(mParent) = NULL;
144	#endif
145	}
146
147
148	// IMouse properties
149	/////////////////////////////////////////////////////////////////////////////
150
151	HRESULT Mouse::getVMMDevMouseCaps(uint32_t *pfCaps)
152	{
153	AssertPtrReturn(pfCaps, E_POINTER);
154	/** @todo does getting the VMMDev and the VMMDevPort like this guarantee
155	* they won't go away while we are using them? */
156	VMMDev *pVMMDev = mParent->getVMMDev();
157	ComAssertRet(pVMMDev, E_FAIL);
158	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
159	ComAssertRet(pVMMDevPort, E_FAIL);
160
161	int rc = pVMMDevPort->pfnQueryMouseCapabilities(pVMMDevPort, pfCaps);
162	return RT_SUCCESS(rc) ? S_OK : E_FAIL;
163	}
164
165	HRESULT Mouse::setVMMDevMouseCaps(uint32_t fCaps)
166	{
167	VMMDev *pVMMDev = mParent->getVMMDev();
168	ComAssertRet(pVMMDev, E_FAIL);
169	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
170	ComAssertRet(pVMMDevPort, E_FAIL);
171
172	int rc = pVMMDevPort->pfnSetMouseCapabilities(pVMMDevPort, fCaps);
173	return RT_SUCCESS(rc) ? S_OK : E_FAIL;
174	}
175
176	/**
177	* Returns whether the current setup can accept absolute mouse
178	* events.
179	*
180	* @returns COM status code
181	* @param absoluteSupported address of result variable
182	*/
183	STDMETHODIMP Mouse::COMGETTER(AbsoluteSupported) (BOOL *absoluteSupported)
184	{
185	if (!absoluteSupported)
186	return E_POINTER;
187
188	AutoCaller autoCaller(this);
189	if (FAILED(autoCaller.rc())) return autoCaller.rc();
190
191	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
192	bool fAbs = false;
193
194	if (fVMMDevCanAbs)
195	fAbs = TRUE;
196
197	for (unsigned i = 0; i < MOUSE_MAX_DEVICES; ++i)
198	if (mpDrv[i] && (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_ABSOLUTE))
199	fAbs = TRUE;
200
201	*absoluteSupported = fAbs;
202	return S_OK;
203	}
204
205	/**
206	* Returns whether the current setup can accept relative mouse
207	* events.
208	*
209	* @returns COM status code
210	* @param relativeSupported address of result variable
211	*/
212	STDMETHODIMP Mouse::COMGETTER(RelativeSupported) (BOOL *relativeSupported)
213	{
214	if (!relativeSupported)
215	return E_POINTER;
216
217	AutoCaller autoCaller(this);
218	if (FAILED(autoCaller.rc())) return autoCaller.rc();
219
220	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
221	bool fRel = false;
222
223	for (unsigned i = 0; i < MOUSE_MAX_DEVICES; ++i)
224	if (mpDrv[i] && (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_RELATIVE))
225	fRel = TRUE;
226
227	*relativeSupported = fRel;
228	return S_OK;
229	}
230
231	/**
232	* Returns whether the guest can currently draw the mouse cursor itself.
233	*
234	* @returns COM status code
235	* @param pfNeedsHostCursor address of result variable
236	*/
237	STDMETHODIMP Mouse::COMGETTER(NeedsHostCursor) (BOOL *pfNeedsHostCursor)
238	{
239	if (!pfNeedsHostCursor)
240	return E_POINTER;
241
242	AutoCaller autoCaller(this);
243	if (FAILED(autoCaller.rc())) return autoCaller.rc();
244
245	*pfNeedsHostCursor = fVMMDevNeedsHostCursor;
246	return S_OK;
247	}
248
249	// IMouse methods
250	/////////////////////////////////////////////////////////////////////////////
251
252	static uint32_t mouseButtonsToPDM(LONG buttonState)
253	{
254	uint32_t fButtons = 0;
255	if (buttonState & MouseButtonState_LeftButton)
256	fButtons \|= PDMIMOUSEPORT_BUTTON_LEFT;
257	if (buttonState & MouseButtonState_RightButton)
258	fButtons \|= PDMIMOUSEPORT_BUTTON_RIGHT;
259	if (buttonState & MouseButtonState_MiddleButton)
260	fButtons \|= PDMIMOUSEPORT_BUTTON_MIDDLE;
261	if (buttonState & MouseButtonState_XButton1)
262	fButtons \|= PDMIMOUSEPORT_BUTTON_X1;
263	if (buttonState & MouseButtonState_XButton2)
264	fButtons \|= PDMIMOUSEPORT_BUTTON_X2;
265	return fButtons;
266	}
267
268
269	/**
270	* Send a relative event to the mouse device.
271	*
272	* @returns COM status code
273	*/
274	HRESULT Mouse::reportRelEventToMouseDev(int32_t dx, int32_t dy, int32_t dz,
275	int32_t dw, uint32_t fButtons)
276	{
277	if (dx \|\| dy \|\| dz \|\| dw \|\| fButtons != mLastButtons)
278	{
279	PPDMIMOUSEPORT pUpPort = NULL;
280	{
281	AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
282
283	for (unsigned i = 0; !pUpPort && i < MOUSE_MAX_DEVICES; ++i)
284	{
285	if (mpDrv[i] && (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_RELATIVE))
286	pUpPort = mpDrv[i]->pUpPort;
287	}
288	}
289	if (!pUpPort)
290	return S_OK;
291
292	int vrc = pUpPort->pfnPutEvent(pUpPort, dx, dy, dz, dw, fButtons);
293
294	if (RT_FAILURE(vrc))
295	return setError(VBOX_E_IPRT_ERROR,
296	tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
297	vrc);
298	mLastButtons = fButtons;
299	}
300	return S_OK;
301	}
302
303
304	/**
305	* Send an absolute position event to the mouse device.
306	*
307	* @returns COM status code
308	*/
309	HRESULT Mouse::reportAbsEventToMouseDev(uint32_t mouseXAbs, uint32_t mouseYAbs,
310	int32_t dz, int32_t dw, uint32_t fButtons)
311	{
312	if ( mouseXAbs != mLastAbsX \|\| mouseYAbs != mLastAbsY
313	\|\| dz \|\| dw \|\| fButtons != mLastButtons)
314	{
315	PPDMIMOUSEPORT pUpPort = NULL;
316	{
317	AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
318
319	for (unsigned i = 0; !pUpPort && i < MOUSE_MAX_DEVICES; ++i)
320	{
321	if (mpDrv[i] && (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_ABSOLUTE))
322	pUpPort = mpDrv[i]->pUpPort;
323	}
324	}
325	if (!pUpPort)
326	return S_OK;
327
328	int vrc = pUpPort->pfnPutEventAbs(pUpPort, mouseXAbs, mouseYAbs, dz,
329	dw, fButtons);
330	if (RT_FAILURE(vrc))
331	return setError(VBOX_E_IPRT_ERROR,
332	tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
333	vrc);
334	mLastButtons = fButtons;
335	}
336	return S_OK;
337	}
338
339
340	/**
341	* Send an absolute position event to the VMM device.
342	*
343	* @returns COM status code
344	*/
345	HRESULT Mouse::reportAbsEventToVMMDev(uint32_t mouseXAbs, uint32_t mouseYAbs)
346	{
347	VMMDev *pVMMDev = mParent->getVMMDev();
348	ComAssertRet(pVMMDev, E_FAIL);
349	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
350	ComAssertRet(pVMMDevPort, E_FAIL);
351
352	if (mouseXAbs != mLastAbsX \|\| mouseYAbs != mLastAbsY)
353	{
354	int vrc = pVMMDevPort->pfnSetAbsoluteMouse(pVMMDevPort,
355	mouseXAbs, mouseYAbs);
356	if (RT_FAILURE(vrc))
357	return setError(VBOX_E_IPRT_ERROR,
358	tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
359	vrc);
360	}
361	return S_OK;
362	}
363
364	HRESULT Mouse::reportAbsEvent(uint32_t mouseXAbs, uint32_t mouseYAbs,
365	int32_t dz, int32_t dw, uint32_t fButtons,
366	bool fUsesVMMDevEvent)
367	{
368	HRESULT rc;
369	/** If we are using the VMMDev to report absolute position but without
370	* VMMDev IRQ support then we need to send a small "jiggle" to the emulated
371	* relative mouse device to alert the guest to changes. */
372	LONG cJiggle = 0;
373
374	if (fVMMDevCanAbs)
375	{
376	/*
377	* Send the absolute mouse position to the VMM device.
378	*/
379	if (mouseXAbs != mLastAbsX \|\| mouseYAbs != mLastAbsY)
380	{
381	rc = reportAbsEventToVMMDev(mouseXAbs, mouseYAbs);
382	cJiggle = 1;
383	}
384	rc = reportRelEventToMouseDev(cJiggle, 0, dz, dw, fButtons);
385	}
386	else
387	rc = reportAbsEventToMouseDev(mouseXAbs, mouseYAbs, dz, dw, fButtons);
388
389	mLastAbsX = mouseXAbs;
390	mLastAbsY = mouseYAbs;
391	return rc;
392	}
393
394	/**
395	* Send a mouse event.
396	*
397	* @returns COM status code
398	* @param dx X movement
399	* @param dy Y movement
400	* @param dz Z movement
401	* @param buttonState The mouse button state
402	*/
403	STDMETHODIMP Mouse::PutMouseEvent(LONG dx, LONG dy, LONG dz, LONG dw, LONG buttonState)
404	{
405	HRESULT rc;
406	/** Do we need to send updated capabilities to the VMM device? */
407	bool fUpdateCaps = FALSE;
408	uint32_t fButtons;
409
410	AutoCaller autoCaller(this);
411	if (FAILED(autoCaller.rc())) return autoCaller.rc();
412
413	{
414	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
415
416	LogRel3(("%s: dx=%d, dy=%d, dz=%d, dw=%d\n", __PRETTY_FUNCTION__,
417	dx, dy, dz, dw));
418	/* Make sure that the guest knows that we are sending real movement
419	* events to the PS/2 device and not just dummy wake-up ones. */
420	if (uHostCaps & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE)
421	{
422	uHostCaps &= ~VMMDEV_MOUSE_HOST_CAN_ABSOLUTE;
423	fUpdateCaps = TRUE;
424	}
425
426	fButtons = mouseButtonsToPDM(buttonState);
427	}
428	if (fUpdateCaps)
429	setVMMDevMouseCaps(uHostCaps);
430	rc = reportRelEventToMouseDev(dx, dy, dz, dw, fButtons);
431
432	return rc;
433	}
434
435	/**
436	* Convert an (X, Y) value pair in screen co-ordinates (starting from 1) to a
437	* value from 0 to 0xffff.
438	*
439	* @returns COM status value
440	*/
441	HRESULT Mouse::convertDisplayRes(LONG x, LONG y, uint32_t pcX, uint32_t pcY)
442	{
443	AssertPtrReturn(pcX, E_POINTER);
444	AssertPtrReturn(pcY, E_POINTER);
445	Display *pDisplay = mParent->getDisplay();
446	ComAssertRet(pDisplay, E_FAIL);
447
448	ULONG displayWidth, displayHeight;
449	/* Takes the display lock */
450	HRESULT rc = pDisplay->GetScreenResolution (0, &displayWidth, &displayHeight,
451	NULL);
452	if (FAILED(rc))
453	return rc;
454
455	pcX = displayWidth ? ((x - 1) 0xFFFF) / displayWidth: 0;
456	pcY = displayHeight ? ((y - 1) 0xFFFF) / displayHeight: 0;
457	return S_OK;
458	}
459
460
461	/**
462	* Send an absolute mouse event to the VM. This requires either VirtualBox-
463	* specific drivers installed in the guest or absolute pointing device
464	* emulation.
465	*
466	* @returns COM status code
467	* @param x X position (pixel), starting from 1
468	* @param y Y position (pixel), starting from 1
469	* @param dz Z movement
470	* @param buttonState The mouse button state
471	*/
472	STDMETHODIMP Mouse::PutMouseEventAbsolute(LONG x, LONG y, LONG dz, LONG dw,
473	LONG buttonState)
474	{
475	AutoCaller autoCaller(this);
476	if (FAILED(autoCaller.rc())) return autoCaller.rc();
477
478	LogRel3(("%s: x=%d, y=%d, dz=%d, dw=%d, buttonState=0x%x\n",
479	__PRETTY_FUNCTION__, x, y, dz, dw, buttonState));
480
481	uint32_t mouseXAbs, mouseYAbs;
482	/** Do we need to send updated capabilities to the VMM device? */
483	bool fUpdateCaps = FALSE;
484
485	/** @todo the front end should do this conversion to avoid races */
486	/** @note Or maybe not... races are pretty inherent in everything done in
487	* this object and not really bad as far as I can see. */
488	HRESULT rc = convertDisplayRes(x, y, &mouseXAbs, &mouseYAbs);
489	if (FAILED(rc)) return rc;
490
491	/** @todo multi-monitor Windows guests expect this to be unbounded.
492	* Understand the issues involved and fix for the rest. */
493	/* if (mouseXAbs > 0xffff)
494	mouseXAbs = mLastAbsX;
495	if (mouseYAbs > 0xffff)
496	mouseYAbs = mLastAbsY; */
497
498	uint32_t mouseCaps;
499	rc = getVMMDevMouseCaps(&mouseCaps);
500	if (FAILED(rc)) return rc;
501	uint32_t fButtons = mouseButtonsToPDM(buttonState);
502
503	/* If we are doing old-style (IRQ-less) absolute reporting to the VMM
504	* device then make sure the guest is aware of it, so that it knows to
505	* ignore relative movement on the PS/2 device. */
506	{
507	AutoWriteLock aLock(this COMMA_LOCKVAL_SRC_POS);
508
509	/** @todo rename that capability to VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE */
510	if (fVMMDevCanAbs && !(uHostCaps & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE))
511	{
512	uHostCaps \|= VMMDEV_MOUSE_HOST_CAN_ABSOLUTE;
513	fUpdateCaps = TRUE;
514	}
515	}
516	if (fUpdateCaps)
517	setVMMDevMouseCaps(uHostCaps);
518
519	/** @todo rename that capability to VMMDEV_MOUSE_GUEST_USES_EVENT */
520	rc = reportAbsEvent(mouseXAbs, mouseYAbs, dz, dw, fButtons,
521	mouseCaps & VMMDEV_MOUSE_GUEST_USES_VMMDEV);
522
523	return rc;
524	}
525
526	// private methods
527	/////////////////////////////////////////////////////////////////////////////
528
529
530	void Mouse::sendMouseCapsNotifications(void)
531	{
532	bool fAbsDev = false;
533	bool fRelDev = false;
534	uint32_t u32MouseCaps;
535
536	{
537	AutoWriteLock aLock(this COMMA_LOCKVAL_SRC_POS);
538
539	for (unsigned i = 0; i < MOUSE_MAX_DEVICES; ++i)
540	if (mpDrv[i])
541	{
542	if (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_ABSOLUTE)
543	fAbsDev = true;
544	if (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_RELATIVE)
545	fRelDev = true;
546	}
547	if (fAbsDev && !(uHostCaps & VMMDEV_MOUSE_HOST_HAS_ABS_DEV))
548	uHostCaps \|= VMMDEV_MOUSE_HOST_HAS_ABS_DEV;
549	if (!fAbsDev && (uHostCaps & VMMDEV_MOUSE_HOST_HAS_ABS_DEV))
550	uHostCaps &= ~VMMDEV_MOUSE_HOST_HAS_ABS_DEV;
551	}
552	if (SUCCEEDED(getVMMDevMouseCaps(&u32MouseCaps)))
553	fVMMDevCanAbs = (u32MouseCaps & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
554	&& fRelDev;
555	else
556	fVMMDevCanAbs = false;
557	/** @todo this call takes the Console lock in order to update the cached
558	* callback data atomically. However I can't see any sign that the cached
559	* data is ever used again. */
560	mParent->onMouseCapabilityChange(fAbsDev \|\| fVMMDevCanAbs, fRelDev,
561	fVMMDevNeedsHostCursor);
562	/** @todo if this gets called during device initialisation we get an
563	* error due to VMMDev not being initialised yet. */
564	setVMMDevMouseCaps(uHostCaps);
565	}
566
567
568	/**
569	* @interface_method_impl{PDMIMOUSECONNECTOR,pfnReportModes}
570	*/
571	DECLCALLBACK(void) Mouse::mouseReportModes(PPDMIMOUSECONNECTOR pInterface, bool fRel, bool fAbs)
572	{
573	PDRVMAINMOUSE pDrv = RT_FROM_MEMBER(pInterface, DRVMAINMOUSE, IConnector);
574	if (fRel)
575	pDrv->u32DevCaps \|= MOUSE_DEVCAP_RELATIVE;
576	else
577	pDrv->u32DevCaps &= ~MOUSE_DEVCAP_RELATIVE;
578	if (fAbs)
579	pDrv->u32DevCaps \|= MOUSE_DEVCAP_ABSOLUTE;
580	else
581	pDrv->u32DevCaps &= ~MOUSE_DEVCAP_ABSOLUTE;
582
583	pDrv->pMouse->sendMouseCapsNotifications();
584	}
585
586
587	/**
588	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
589	*/
590	DECLCALLBACK(void ) Mouse::drvQueryInterface(PPDMIBASE pInterface, const char pszIID)
591	{
592	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
593	PDRVMAINMOUSE pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
594
595	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
596	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSECONNECTOR, &pDrv->IConnector);
597	return NULL;
598	}
599
600
601	/**
602	* Destruct a mouse driver instance.
603	*
604	* @returns VBox status.
605	* @param pDrvIns The driver instance data.
606	*/
607	DECLCALLBACK(void) Mouse::drvDestruct(PPDMDRVINS pDrvIns)
608	{
609	PDRVMAINMOUSE pData = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
610	LogFlow(("Mouse::drvDestruct: iInstance=%d\n", pDrvIns->iInstance));
611	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
612
613	if (pData->pMouse)
614	{
615	AutoWriteLock mouseLock(pData->pMouse COMMA_LOCKVAL_SRC_POS);
616	for (unsigned cDev = 0; cDev < MOUSE_MAX_DEVICES; ++cDev)
617	if (pData->pMouse->mpDrv[cDev] == pData)
618	{
619	pData->pMouse->mpDrv[cDev] = NULL;
620	break;
621	}
622	}
623	}
624
625
626	/**
627	* Construct a mouse driver instance.
628	*
629	* @copydoc FNPDMDRVCONSTRUCT
630	*/
631	DECLCALLBACK(int) Mouse::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
632	{
633	PDRVMAINMOUSE pData = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
634	LogFlow(("drvMainMouse_Construct: iInstance=%d\n", pDrvIns->iInstance));
635	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
636
637	/*
638	* Validate configuration.
639	*/
640	if (!CFGMR3AreValuesValid(pCfg, "Object\0"))
641	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
642	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
643	("Configuration error: Not possible to attach anything to this driver!\n"),
644	VERR_PDM_DRVINS_NO_ATTACH);
645
646	/*
647	* IBase.
648	*/
649	pDrvIns->IBase.pfnQueryInterface = Mouse::drvQueryInterface;
650
651	pData->IConnector.pfnReportModes = Mouse::mouseReportModes;
652
653	/*
654	* Get the IMousePort interface of the above driver/device.
655	*/
656	pData->pUpPort = (PPDMIMOUSEPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMIMOUSEPORT_IID);
657	if (!pData->pUpPort)
658	{
659	AssertMsgFailed(("Configuration error: No mouse port interface above!\n"));
660	return VERR_PDM_MISSING_INTERFACE_ABOVE;
661	}
662
663	/*
664	* Get the Mouse object pointer and update the mpDrv member.
665	*/
666	void *pv;
667	int rc = CFGMR3QueryPtr(pCfg, "Object", &pv);
668	if (RT_FAILURE(rc))
669	{
670	AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
671	return rc;
672	}
673	pData->pMouse = (Mouse )pv; /* @todo Check this cast! */
674	unsigned cDev;
675	{
676	AutoReadLock mouseLock(pData->pMouse COMMA_LOCKVAL_SRC_POS);
677
678	for (cDev = 0; cDev < MOUSE_MAX_DEVICES; ++cDev)
679	if (!pData->pMouse->mpDrv[cDev])
680	{
681	pData->pMouse->mpDrv[cDev] = pData;
682	break;
683	}
684	}
685	if (cDev == MOUSE_MAX_DEVICES)
686	return VERR_NO_MORE_HANDLES;
687
688	return VINF_SUCCESS;
689	}
690
691
692	/**
693	* Main mouse driver registration record.
694	*/
695	const PDMDRVREG Mouse::DrvReg =
696	{
697	/* u32Version */
698	PDM_DRVREG_VERSION,
699	/* szName */
700	"MainMouse",
701	/* szRCMod */
702	"",
703	/* szR0Mod */
704	"",
705	/* pszDescription */
706	"Main mouse driver (Main as in the API).",
707	/* fFlags */
708	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
709	/* fClass. */
710	PDM_DRVREG_CLASS_MOUSE,
711	/* cMaxInstances */
712	~0,
713	/* cbInstance */
714	sizeof(DRVMAINMOUSE),
715	/* pfnConstruct */
716	Mouse::drvConstruct,
717	/* pfnDestruct */
718	Mouse::drvDestruct,
719	/* pfnRelocate */
720	NULL,
721	/* pfnIOCtl */
722	NULL,
723	/* pfnPowerOn */
724	NULL,
725	/* pfnReset */
726	NULL,
727	/* pfnSuspend */
728	NULL,
729	/* pfnResume */
730	NULL,
731	/* pfnAttach */
732	NULL,
733	/* pfnDetach */
734	NULL,
735	/* pfnPowerOff */
736	NULL,
737	/* pfnSoftReset */
738	NULL,
739	/* u32EndVersion */
740	PDM_DRVREG_VERSION
741	};
742	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/MouseImpl.cpp@ 32817

Download in other formats: