frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

input: remove OpenInputDevice and CloseInputDevice DDX hooks. 

In theory, these hooks were to be used for DDX-specific device enablement.
None of the DDXs however did anything here. Now we call DEVICE_INIT on all
devices when they are added, so the xfree86 DDX as the only one with real
code didn't do anything here.

kdrive checked for device validity but that's already handled in
ProcXOpenDevice.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
Reviewed-by: Adam Jackson <ajax@redhat.com>
Reviewed-by: Daniel Stone <daniel@fooishbar.org>
This commit is contained in:
Peter Hutterer 2010-07-30 14:21:14 +10:00
parent a46d2bb344
commit cb672a461c
8 changed files with 0 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Xi/closedev.c
View File

@ -162,6 +162,5 @@ ProcXCloseDevice(ClientPtr client)
DeleteEventsFromChildren(d, p1, client);
}
CloseInputDevice(d, client);
return Success;
}

1
Xi/opendev.c
View File

@ -115,7 +115,6 @@ ProcXOpenDevice(ClientPtr client)
if (IsMaster(dev))
return BadDevice;
OpenInputDevice(dev, client, &status);
if (status != Success)
return status;

46
Xi/stubs.c
View File

@ -66,24 +66,6 @@ SOFTWARE.
#include "XIstubs.h"
#include "xace.h"
/***********************************************************************
*
* Caller: ProcXCloseDevice
*
* Take care of implementation-dependent details of closing a device.
* Some implementations may actually close the device, others may just
* remove this clients interest in that device.
*
* The default implementation is to do nothing (assume all input devices
* are initialized during X server initialization and kept open).
*
*/
void
CloseInputDevice(DeviceIntPtr d, ClientPtr client)
{
}
/***********************************************************************
*
* Caller: ProcXListInputDevices
@ -127,34 +109,6 @@ AddOtherInputDevices(void)
}
/***********************************************************************
*
* Caller: ProcXOpenDevice
*
* This is the implementation-dependent routine to open an input device.
* Some implementations open all input devices when the server is first
* initialized, and never close them. Other implementations open only
* the X pointer and keyboard devices during server initialization,
* and only open other input devices when some client makes an
* XOpenDevice request. This entry point is for the latter type of
* implementation.
*
* If the physical device is not already open, do it here. In this case,
* you need to keep track of the fact that one or more clients has the
* device open, and physically close it when the last client that has
* it open does an XCloseDevice.
*
* The default implementation is to do nothing (assume all input devices
* are opened during X server initialization and kept open).
*
*/
void
OpenInputDevice(DeviceIntPtr dev, ClientPtr client, int *status)
{
*status = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixUseAccess);
}
/****************************************************************************
*
* Caller: ProcXSetDeviceMode

12
hw/dmx/input/dmxxinput.c
View File

@ -51,23 +51,11 @@
#include "dmxinputinit.h"
#include "exevents.h"
/** Close the input device. This is not required by the XINPUT model
* that DMX uses. */
void CloseInputDevice (DeviceIntPtr d, ClientPtr client)
{
}
/** This is not required by the XINPUT model that DMX uses. */
void AddOtherInputDevices(void)
{
}
/** Open an input device. This is not required by the XINPUT model that
* DMX uses. */
void OpenInputDevice (DeviceIntPtr dev, ClientPtr client, int *status)
{
}
/** Set device mode to \a mode. This is not implemented. */
int SetDeviceMode(ClientPtr client, DeviceIntPtr dev, int mode)
{

17
hw/kdrive/src/kinput.c
View File

@ -2176,23 +2176,6 @@ ProcessInputEvents (void)
KdCheckLock ();
}
/* FIXME use XSECURITY to work out whether the client should be allowed to
* open and close. */
void
OpenInputDevice(DeviceIntPtr pDev, ClientPtr client, int *status)
{
if (!pDev)
*status = BadDevice;
else
*status = Success;
}
void
CloseInputDevice(DeviceIntPtr pDev, ClientPtr client)
{
return;
}
/* We initialise all input devices at startup. */
void
AddOtherInputDevices(void)

41
hw/xfree86/common/xf86Xinput.c
View File

@ -327,47 +327,6 @@ xf86ActivateDevice(InputInfoPtr pInfo)
return dev;
}
/***********************************************************************
*
* Caller: ProcXOpenDevice
*
* This is the implementation-dependent routine to open an input device.
* Some implementations open all input devices when the server is first
* initialized, and never close them. Other implementations open only
* the X pointer and keyboard devices during server initialization,
* and only open other input devices when some client makes an
* XOpenDevice request. This entry point is for the latter type of
* implementation.
*
* If the physical device is not already open, do it here. In this case,
* you need to keep track of the fact that one or more clients has the
* device open, and physically close it when the last client that has
* it open does an XCloseDevice.
*
* The default implementation is to do nothing (assume all input devices
* are opened during X server initialization and kept open).
*
***********************************************************************
*/
void
OpenInputDevice(DeviceIntPtr dev,
ClientPtr client,
int *status)
{
if (!dev->inited)
ActivateDevice(dev, TRUE);
*status = Success;
}
void
CloseInputDevice(DeviceIntPtr dev,
ClientPtr client)
{
}
/****************************************************************************
*
* Caller: ProcXSetDeviceMode

28
hw/xquartz/darwinXinput.c
View File

@ -125,34 +125,6 @@ AddOtherInputDevices(void)
DEBUG_LOG("AddOtherInputDevices\n");
}
/***********************************************************************
*
* Caller: ProcXOpenDevice
*
* This is the implementation-dependent routine to open an input device.
* Some implementations open all input devices when the server is first
* initialized, and never close them. Other implementations open only
* the X pointer and keyboard devices during server initialization,
* and only open other input devices when some client makes an
* XOpenDevice request. This entry point is for the latter type of
* implementation.
*
* If the physical device is not already open, do it here. In this case,
* you need to keep track of the fact that one or more clients has the
* device open, and physically close it when the last client that has
* it open does an XCloseDevice.
*
* The default implementation is to do nothing (assume all input devices
* are opened during X server initialization and kept open).
*
*/
void
OpenInputDevice(DeviceIntPtr dev, ClientPtr client, int *status)
{
DEBUG_LOG("OpenInputDevice(%p, %p, %p)\n", dev, client, status);
}
/****************************************************************************
*
* Caller: ProcXSetDeviceMode

11
include/XIstubs.h
View File

@ -26,20 +26,9 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef XI_STUBS_H
#define XI_STUBS_H 1
extern _X_EXPORT void
CloseInputDevice (
DeviceIntPtr /* d */,
ClientPtr /* client */);
extern _X_EXPORT void
AddOtherInputDevices (void);
extern _X_EXPORT void
OpenInputDevice (
DeviceIntPtr /* dev */,
ClientPtr /* client */,
int * /* status */);
extern _X_EXPORT int
SetDeviceMode (
ClientPtr /* client */,