andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Xi: add support for input device properties.

Browse Source 
Basically just copied from randr properties, with minor changes only.
Each device supports arbitrary properties that can be modified by clients.
Modifications to the properties are passed to the driver (if applicable) and
can then affect the configuration of the device.

Note that device properties are limited to a specific device. A property set
on a slave device does not migrate to the master.
This commit is contained in:
Peter Hutterer 2008-07-07 22:10:17 +09:30
parent acce270935
commit 666838fcc8
7 changed files with 868 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Xi/Makefile.am
View File

@ -94,7 +94,9 @@ libXi_la_SOURCES = \
ungrdevk.h \
warpdevp.c \
warpdevp.h \
xiselev.c \
xiselev.h
xiproperty.c \
xiproperty.h \
xiselev.c \
xiselev.h
EXTRA_DIST = stubs.c

17
Xi/extinit.c
View File

@ -122,6 +122,7 @@ SOFTWARE.
#include "ungrdevk.h"
#include "warpdevp.h"
#include "xiselev.h"
#include "xiproperty.c"
static Mask lastExtEventMask = 1;
@ -217,7 +218,13 @@ static int (*ProcIVector[])(ClientPtr) = {
ProcXSetClientPointer, /* 42 */
ProcXGetClientPointer, /* 43 */
ProcXiSelectEvent, /* 44 */
ProcXExtendedGrabDevice /* 45 */
ProcXExtendedGrabDevice, /* 45 */
ProcXListDeviceProperties, /* 46 */
ProcXQueryDeviceProperty, /* 47 */
ProcXConfigureDeviceProperty, /* 48 */
ProcXChangeDeviceProperty, /* 49 */
ProcXDeleteDeviceProperty, /* 50 */
ProcXGetDeviceProperty /* 51 */
};
/* For swapped clients */
@ -267,7 +274,13 @@ static int (*SProcIVector[])(ClientPtr) = {
SProcXSetClientPointer, /* 42 */
SProcXGetClientPointer, /* 43 */
SProcXiSelectEvent, /* 44 */
SProcXExtendedGrabDevice /* 45 */
SProcXExtendedGrabDevice, /* 45 */
SProcXListDeviceProperties, /* 46 */
SProcXQueryDeviceProperty, /* 47 */
SProcXConfigureDeviceProperty, /* 48 */
SProcXChangeDeviceProperty, /* 49 */
SProcXDeleteDeviceProperty, /* 50 */
SProcXGetDeviceProperty /* 51 */
};
/*****************************************************************

742
Xi/xiproperty.c Normal file
View File

@ -0,0 +1,742 @@
/*
* Copyright © 2006 Keith Packard
* Copyright © 2008 Peter Hutterer
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WAXIANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WAXIANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
*/
/* This code is a modified version of randr/rrproperty.c */
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include "dix.h"
#include "inputstr.h"
#include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h>
#include "exglobals.h"
#include "exevents.h"
#include "swaprep.h"
#include "xiproperty.h"
void
XIDeleteAllDeviceProperties (DeviceIntPtr device)
{
XIPropertyPtr prop, next;
devicePropertyNotifyEvent event;
for (prop = device->properties; prop; prop = next)
{
next = prop->next;
event.type = GenericEvent;
event.extension = IReqCode;
event.evtype = XI_DevicePropertyNotify;
event.length = 0;
event.deviceid = device->id;
event.state = PropertyDelete;
event.atom = prop->propertyName;
event.time = currentTime.milliseconds;
SendEventToAllWindows(device, XI_DevicePropertyNotifyMask,
(xEvent*)&event, 1);
if (prop->current.data)
xfree(prop->current.data);
if (prop->pending.data)
xfree(prop->pending.data);
xfree(prop);
}
}
static void
XIInitDevicePropertyValue (XIPropertyValuePtr property_value)
{
property_value->type = None;
property_value->format = 0;
property_value->size = 0;
property_value->data = NULL;
}
static XIPropertyPtr
XICreateDeviceProperty (Atom property)
{
XIPropertyPtr prop;
prop = (XIPropertyPtr)xalloc(sizeof(XIPropertyRec));
if (!prop)
return NULL;
prop->next = NULL;
prop->propertyName = property;
prop->is_pending = FALSE;
prop->range = FALSE;
prop->immutable = FALSE;
prop->num_valid = 0;
prop->valid_values = NULL;
XIInitDevicePropertyValue (&prop->current);
XIInitDevicePropertyValue (&prop->pending);
return prop;
}
static void
XIDestroyDeviceProperty (XIPropertyPtr prop)
{
if (prop->valid_values)
xfree (prop->valid_values);
if (prop->current.data)
xfree(prop->current.data);
if (prop->pending.data)
xfree(prop->pending.data);
xfree(prop);
}
void
XIDeleteDeviceProperty (DeviceIntPtr device, Atom property)
{
XIPropertyPtr prop, *prev;
devicePropertyNotifyEvent event;
for (prev = &device->properties; (prop = *prev); prev = &(prop->next))
if (prop->propertyName == property)
break;
if (prop)
{
*prev = prop->next;
event.type = GenericEvent;
event.extension = IReqCode;
event.length = 0;
event.evtype = XI_DevicePropertyNotify;
event.deviceid = device->id;
event.state = PropertyDelete;
event.atom = prop->propertyName;
event.time = currentTime.milliseconds;
SendEventToAllWindows(device, XI_DevicePropertyNotifyMask,
(xEvent*)&event, 1);
XIDestroyDeviceProperty (prop);
}
}
int
XIChangeDeviceProperty (DeviceIntPtr dev, Atom property, Atom type,
int format, int mode, unsigned long len,
pointer value, Bool sendevent, Bool pending)
{
XIPropertyPtr prop;
devicePropertyNotifyEvent event;
int size_in_bytes;
int total_size;
unsigned long total_len;
XIPropertyValuePtr prop_value;
XIPropertyValueRec new_value;
Bool add = FALSE;
size_in_bytes = format >> 3;
/* first see if property already exists */
prop = XIQueryDeviceProperty (dev, property);
if (!prop) /* just add to list */
{
prop = XICreateDeviceProperty (property);
if (!prop)
return(BadAlloc);
add = TRUE;
mode = PropModeReplace;
}
if (pending && prop->is_pending)
prop_value = &prop->pending;
else
prop_value = &prop->current;
/* To append or prepend to a property the request format and type
must match those of the already defined property. The
existing format and type are irrelevant when using the mode
"PropModeReplace" since they will be written over. */
if ((format != prop_value->format) && (mode != PropModeReplace))
return(BadMatch);
if ((prop_value->type != type) && (mode != PropModeReplace))
return(BadMatch);
new_value = *prop_value;
if (mode == PropModeReplace)
total_len = len;
else
total_len = prop_value->size + len;
if (mode == PropModeReplace || len > 0)
{
pointer new_data = NULL, old_data = NULL;
total_size = total_len * size_in_bytes;
new_value.data = (pointer)xalloc (total_size);
if (!new_value.data && total_size)
{
if (add)
XIDestroyDeviceProperty (prop);
return BadAlloc;
}
new_value.size = len;
new_value.type = type;
new_value.format = format;
switch (mode) {
case PropModeReplace:
new_data = new_value.data;
old_data = NULL;
break;
case PropModeAppend:
new_data = (pointer) (((char *) new_value.data) +
(prop_value->size * size_in_bytes));
old_data = new_value.data;
break;
case PropModePrepend:
new_data = new_value.data;
old_data = (pointer) (((char *) new_value.data) +
(prop_value->size * size_in_bytes));
break;
}
if (new_data)
memcpy ((char *) new_data, (char *) value, len * size_in_bytes);
if (old_data)
memcpy ((char *) old_data, (char *) prop_value->data,
prop_value->size * size_in_bytes);
if (pending && dev->SetProperty &&
!dev->SetProperty(dev, prop->propertyName, &new_value))
{
if (new_value.data)
xfree (new_value.data);
return (BadValue);
}
if (prop_value->data)
xfree (prop_value->data);
*prop_value = new_value;
}
else if (len == 0)
{
/* do nothing */
}
if (add)
{
prop->next = dev->properties;
dev->properties = prop;
}
if (pending && prop->is_pending)
dev->pendingProperties = TRUE;
if (sendevent)
{
event.type = GenericEvent;
event.extension = IReqCode;
event.length = 0;
event.evtype = XI_DevicePropertyNotify;
event.deviceid = dev->id;
event.state = PropertyNewValue;
event.atom = prop->propertyName;
event.time = currentTime.milliseconds;
SendEventToAllWindows(dev, XI_DevicePropertyNotifyMask,
(xEvent*)&event, 1);
}
return(Success);
}
XIPropertyPtr
XIQueryDeviceProperty (DeviceIntPtr dev, Atom property)
{
XIPropertyPtr prop;
for (prop = dev->properties; prop; prop = prop->next)
if (prop->propertyName == property)
return prop;
return NULL;
}
XIPropertyValuePtr
XIGetDeviceProperty (DeviceIntPtr dev, Atom property, Bool pending)
{
XIPropertyPtr prop = XIQueryDeviceProperty (dev, property);
if (!prop)
return NULL;
if (pending && prop->is_pending)
return &prop->pending;
else {
/* If we can, try to update the property value first */
if (dev->GetProperty)
dev->GetProperty(dev, prop->propertyName);
return &prop->current;
}
}
int
XIConfigureDeviceProperty (DeviceIntPtr dev, Atom property,
Bool pending, Bool range, Bool immutable,
int num_values, INT32 *values)
{
XIPropertyPtr prop = XIQueryDeviceProperty (dev, property);
Bool add = FALSE;
INT32 *new_values;
if (!prop)
{
prop = XICreateDeviceProperty (property);
if (!prop)
return(BadAlloc);
add = TRUE;
} else if (prop->immutable && !immutable)
return(BadAccess);
/*
* ranges must have even number of values
*/
if (range && (num_values & 1))
return BadMatch;
new_values = xalloc (num_values * sizeof (INT32));
if (!new_values && num_values)
return BadAlloc;
if (num_values)
memcpy (new_values, values, num_values * sizeof (INT32));
/*
* Property moving from pending to non-pending
* loses any pending values
*/
if (prop->is_pending && !pending)
{
if (prop->pending.data)
xfree (prop->pending.data);
XIInitDevicePropertyValue (&prop->pending);
}
prop->is_pending = pending;
prop->range = range;
prop->immutable = immutable;
prop->num_valid = num_values;
if (prop->valid_values)
xfree (prop->valid_values);
prop->valid_values = new_values;
if (add) {
prop->next = dev->properties;
dev->properties = prop;
}
return Success;
}
int
ProcXListDeviceProperties (ClientPtr client)
{
Atom *pAtoms = NULL, *temppAtoms;
xListDevicePropertiesReply rep;
int numProps = 0;
DeviceIntPtr dev;
XIPropertyPtr prop;
int rc = Success;
REQUEST(xListDevicePropertiesReq);
REQUEST_SIZE_MATCH(xListDevicePropertiesReq);
rc = dixLookupDevice (&dev, stuff->deviceid, client, DixReadAccess);
if (rc != Success)
return rc;
for (prop = dev->properties; prop; prop = prop->next)
numProps++;
if (numProps)
if(!(pAtoms = (Atom *)xalloc(numProps * sizeof(Atom))))
return(BadAlloc);
rep.repType = X_Reply;
rep.RepType = X_ListDeviceProperties;
rep.length = (numProps * sizeof(Atom)) >> 2;
rep.sequenceNumber = client->sequence;
rep.nAtoms = numProps;
if (client->swapped)
{
int n;
swaps (&rep.sequenceNumber, n);
swapl (&rep.length, n);
}
temppAtoms = pAtoms;
for (prop = dev->properties; prop; prop = prop->next)
*temppAtoms++ = prop->propertyName;
WriteReplyToClient(client, sizeof(xListDevicePropertiesReply), &rep);
if (numProps)
{
client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;
WriteSwappedDataToClient(client, numProps * sizeof(Atom), pAtoms);
xfree(pAtoms);
}
return rc;
}
int
ProcXQueryDeviceProperty (ClientPtr client)
{
REQUEST(xQueryDevicePropertyReq);
xQueryDevicePropertyReply rep;
DeviceIntPtr dev;
XIPropertyPtr prop;
int rc;
REQUEST_SIZE_MATCH(xQueryDevicePropertyReq);
rc = dixLookupDevice (&dev, stuff->deviceid, client, DixReadAccess);
if (rc != Success)
return rc;
prop = XIQueryDeviceProperty (dev, stuff->property);
if (!prop)
return BadName;
rep.repType = X_Reply;
rep.length = prop->num_valid;
rep.sequenceNumber = client->sequence;
rep.pending = prop->is_pending;
rep.range = prop->range;
rep.immutable = prop->immutable;
if (client->swapped)
{
int n;
swaps (&rep.sequenceNumber, n);
swapl (&rep.length, n);
}
WriteReplyToClient (client, sizeof (xQueryDevicePropertyReply), &rep);
if (prop->num_valid)
{
client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;
WriteSwappedDataToClient(client, prop->num_valid * sizeof(INT32),
prop->valid_values);
}
return(client->noClientException);
}
int
ProcXConfigureDeviceProperty (ClientPtr client)
{
REQUEST(xConfigureDevicePropertyReq);
DeviceIntPtr dev;
int num_valid;
int rc;
REQUEST_AT_LEAST_SIZE(xConfigureDevicePropertyReq);
rc = dixLookupDevice (&dev, stuff->deviceid, client, DixReadAccess);
if (rc != Success)
return rc;
num_valid = stuff->length - (sizeof (xConfigureDevicePropertyReq) >> 2);
return XIConfigureDeviceProperty (dev, stuff->property,
stuff->pending, stuff->range,
FALSE, num_valid,
(INT32 *) (stuff + 1));
}
int
ProcXChangeDeviceProperty (ClientPtr client)
{
REQUEST(xChangeDevicePropertyReq);
DeviceIntPtr dev;
char format, mode;
unsigned long len;
int sizeInBytes;
int totalSize;
int rc;
REQUEST_AT_LEAST_SIZE(xChangeDevicePropertyReq);
UpdateCurrentTime();
format = stuff->format;
mode = stuff->mode;
if ((mode != PropModeReplace) && (mode != PropModeAppend) &&
(mode != PropModePrepend))
{
client->errorValue = mode;
return BadValue;
}
if ((format != 8) && (format != 16) && (format != 32))
{
client->errorValue = format;
return BadValue;
}
len = stuff->nUnits;
if (len > ((0xffffffff - sizeof(xChangePropertyReq)) >> 2))
return BadLength;
sizeInBytes = format>>3;
totalSize = len * sizeInBytes;
REQUEST_FIXED_SIZE(xChangeDevicePropertyReq, totalSize);
rc = dixLookupDevice (&dev, stuff->deviceid, client, DixWriteAccess);
if (rc != Success)
return rc;
if (!ValidAtom(stuff->property))
{
client->errorValue = stuff->property;
return(BadAtom);
}
if (!ValidAtom(stuff->type))
{
client->errorValue = stuff->type;
return(BadAtom);
}
rc = XIChangeDeviceProperty(dev, stuff->property,
stuff->type, (int)format,
(int)mode, len, (pointer)&stuff[1], TRUE, TRUE);
return rc;
}
int
ProcXDeleteDeviceProperty (ClientPtr client)
{
REQUEST(xDeleteDevicePropertyReq);
DeviceIntPtr dev;
int rc;
REQUEST_SIZE_MATCH(xDeleteDevicePropertyReq);
UpdateCurrentTime();
rc = dixLookupDevice (&dev, stuff->deviceid, client, DixWriteAccess);
if (rc != Success)
return rc;
if (!ValidAtom(stuff->property))
{
client->errorValue = stuff->property;
return (BadAtom);
}
XIDeleteDeviceProperty(dev, stuff->property);
return rc;
}
int
ProcXGetDeviceProperty (ClientPtr client)
{
REQUEST(xGetDevicePropertyReq);
XIPropertyPtr prop, *prev;
XIPropertyValuePtr prop_value;
unsigned long n, len, ind;
DeviceIntPtr dev;
xGetDevicePropertyReply reply;
int rc;
REQUEST_SIZE_MATCH(xGetDevicePropertyReq);
if (stuff->delete)
UpdateCurrentTime();
rc = dixLookupDevice (&dev, stuff->deviceid, client,
stuff->delete ? DixWriteAccess :
DixReadAccess);
if (rc != Success)
return rc;
if (!ValidAtom(stuff->property))
{
client->errorValue = stuff->property;
return(BadAtom);
}
if ((stuff->delete != xTrue) && (stuff->delete != xFalse))
{
client->errorValue = stuff->delete;
return(BadValue);
}
if ((stuff->type != AnyPropertyType) && !ValidAtom(stuff->type))
{
client->errorValue = stuff->type;
return(BadAtom);
}
for (prev = &dev->properties; (prop = *prev); prev = &prop->next)
if (prop->propertyName == stuff->property)
break;
reply.repType = X_Reply;
reply.RepType = X_GetDeviceProperty;
reply.sequenceNumber = client->sequence;
if (!prop)
{
reply.nItems = 0;
reply.length = 0;
reply.bytesAfter = 0;
reply.propertyType = None;
reply.format = 0;
WriteReplyToClient(client, sizeof(xGetDevicePropertyReply), &reply);
return(client->noClientException);
}
if (prop->immutable && stuff->delete)
return BadAccess;
prop_value = XIGetDeviceProperty(dev, stuff->property, stuff->pending);
if (!prop_value)
return BadAtom;
/* If the request type and actual type don't match. Return the
property information, but not the data. */
if (((stuff->type != prop_value->type) &&
(stuff->type != AnyPropertyType))
)
{
reply.bytesAfter = prop_value->size;
reply.format = prop_value->format;
reply.length = 0;
reply.nItems = 0;
reply.propertyType = prop_value->type;
WriteReplyToClient(client, sizeof(xGetDevicePropertyReply), &reply);
return(client->noClientException);
}
/*
* Return type, format, value to client
*/
n = (prop_value->format/8) * prop_value->size; /* size (bytes) of prop */
ind = stuff->longOffset << 2;
/* If longOffset is invalid such that it causes "len" to
be negative, it's a value error. */
if (n < ind)
{
client->errorValue = stuff->longOffset;
return BadValue;
}
len = min(n - ind, 4 * stuff->longLength);
reply.bytesAfter = n - (ind + len);
reply.format = prop_value->format;
reply.length = (len + 3) >> 2;
if (prop_value->format)
reply.nItems = len / (prop_value->format / 8);
else
reply.nItems = 0;
reply.propertyType = prop_value->type;
if (stuff->delete && (reply.bytesAfter == 0))
{
devicePropertyNotifyEvent event;
event.type = GenericEvent;
event.extension = IReqCode;
event.length = 0;
event.evtype = XI_DevicePropertyNotify;
event.deviceid = dev->id;
event.state = PropertyDelete;
event.atom = prop->propertyName;
event.time = currentTime.milliseconds;
SendEventToAllWindows(dev, XI_DevicePropertyNotifyMask,
(xEvent*)&event, 1);
}
WriteReplyToClient(client, sizeof(xGenericReply), &reply);
if (len)
{
switch (reply.format) {
case 32: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap32Write; break;
case 16: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write; break;
default: client->pSwapReplyFunc = (ReplySwapPtr)WriteToClient; break;
}
WriteSwappedDataToClient(client, len,
(char *)prop_value->data + ind);
}
if (stuff->delete && (reply.bytesAfter == 0))
{ /* delete the Property */
*prev = prop->next;
XIDestroyDeviceProperty (prop);
}
return(client->noClientException);
}
int
SProcXListDeviceProperties (ClientPtr client)
{
REQUEST(xListDevicePropertiesReq);
REQUEST_SIZE_MATCH(xListDevicePropertiesReq);
(void) stuff;
return BadImplementation;
}
int
SProcXQueryDeviceProperty (ClientPtr client)
{
REQUEST(xQueryDevicePropertyReq);
REQUEST_SIZE_MATCH(xQueryDevicePropertyReq);
(void) stuff;
return BadImplementation;
}
int
SProcXConfigureDeviceProperty (ClientPtr client)
{
REQUEST(xConfigureDevicePropertyReq);
REQUEST_SIZE_MATCH(xConfigureDevicePropertyReq);
(void) stuff;
return BadImplementation;
}
int
SProcXChangeDeviceProperty (ClientPtr client)
{
REQUEST(xChangeDevicePropertyReq);
REQUEST_SIZE_MATCH(xChangeDevicePropertyReq);
(void) stuff;
return BadImplementation;
}
int
SProcXDeleteDeviceProperty (ClientPtr client)
{
REQUEST(xDeleteDevicePropertyReq);
REQUEST_SIZE_MATCH(xDeleteDevicePropertyReq);
(void) stuff;
return BadImplementation;
}
int
SProcXGetDeviceProperty (ClientPtr client)
{
REQUEST(xGetDevicePropertyReq);
REQUEST_SIZE_MATCH(xGetDevicePropertyReq);
(void) stuff;
return BadImplementation;
}

43
Xi/xiproperty.h Normal file
View File

@ -0,0 +1,43 @@
/*
* Copyright © 2008 Peter Hutterer
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Author: Peter Hutterer
*/
#ifndef XIPROPERTY_C
#define XIPROPERTY_C
int ProcXListDeviceProperties (ClientPtr client);
int ProcXQueryDeviceProperty (ClientPtr client);
int ProcXConfigureDeviceProperty (ClientPtr client);
int ProcXChangeDeviceProperty (ClientPtr client);
int ProcXDeleteDeviceProperty (ClientPtr client);
int ProcXGetDeviceProperty (ClientPtr client);
int SProcXListDeviceProperties (ClientPtr client);
int SProcXQueryDeviceProperty (ClientPtr client);
int SProcXConfigureDeviceProperty (ClientPtr client);
int SProcXChangeDeviceProperty (ClientPtr client);
int SProcXDeleteDeviceProperty (ClientPtr client);
int SProcXGetDeviceProperty (ClientPtr client);
#endif /* XIPROPERTY_C */

9
dix/devices.c
View File

@ -83,6 +83,7 @@ SOFTWARE.
#include "exglobals.h"
#include "exevents.h"
#include "listdev.h" /* for CopySwapXXXClass */
#include "xiproperty.h"
/** @file
* This file handles input device-related stuff.
@ -173,6 +174,12 @@ AddInputDevice(ClientPtr client, DeviceProc deviceProc, Bool autoStart)
memset(dev->last.valuators, 0, sizeof(dev->last.valuators));
dev->last.numValuators = 0;
/* device properties */
dev->properties = NULL;
dev->SetProperty = NULL;
dev->GetProperty = NULL;
dev->pendingProperties = FALSE;
/* security creation/labeling check
*/
if (XaceHook(XACE_DEVICE_ACCESS, client, dev, DixCreateAccess)) {
@ -770,6 +777,8 @@ CloseDevice(DeviceIntPtr dev)
if (!dev)
return;
XIDeleteAllDeviceProperties(dev);
if (dev->inited)
(void)(*dev->deviceProc)(dev, DEVICE_CLOSE);

15
include/exevents.h
View File

@ -194,4 +194,19 @@ void SendEventToAllWindows(
xEvent * /* ev */,
int /* count */);
/* Input device properties */
void XIDeleteAllDeviceProperties (DeviceIntPtr device);
void XIDeleteDeviceProperty (DeviceIntPtr Device, Atom property);
int XIChangeDeviceProperty (DeviceIntPtr dev, Atom property, Atom type,
int format, int mode, unsigned long len,
pointer value, Bool sendevent, Bool pending);
XIPropertyPtr XIQueryDeviceProperty (DeviceIntPtr dev, Atom property);
XIPropertyValuePtr XIGetDeviceProperty (DeviceIntPtr dev, Atom property,
Bool pending);
int XIConfigureDeviceProperty (DeviceIntPtr dev, Atom property,
Bool pending, Bool range, Bool immutable,
int num_values, INT32 *values);
#endif /* EXEVENTS_H */

41
include/inputstr.h
View File

@ -335,6 +335,38 @@ typedef struct {
} SpriteRec, *SpritePtr;
/* Device properties */
typedef struct _XIPropertyValue
{
Atom type; /* ignored by server */
short format; /* format of data for swapping - 8,16,32 */
long size; /* size of data in (format/8) bytes */
pointer data; /* private to client */
} XIPropertyValueRec;
typedef struct _XIProperty
{
struct _XIProperty *next;
Atom propertyName;
Bool is_pending;
Bool range;
Bool immutable;
int num_valid;
INT32 *valid_values;
XIPropertyValueRec current,
pending;
} XIPropertyRec;
typedef XIPropertyRec *XIPropertyPtr;
typedef XIPropertyValueRec *XIPropertyValuePtr;
typedef Bool (*XISetDevicePropertyProcPtr) (DeviceIntPtr dev,
Atom property,
XIPropertyValuePtr prop);
typedef Bool (*XIGetDevicePropertyProcPtr) (DeviceIntPtr dev,
Atom property);
/* states for devices */
#define NOT_GRABBED 0
@ -347,8 +379,9 @@ typedef struct {
#define FROZEN_WITH_EVENT 6
#define THAW_OTHERS 7
typedef struct _GrabInfoRec {
TimeStamp grabTime;
TimeStamp grabTime;
Bool fromPassiveGrab; /* true if from passive grab */
Bool implicitGrab; /* implicit from ButtonPress */
GrabRec activeGrab;
@ -431,6 +464,12 @@ typedef struct _DeviceIntRec {
int valuators[MAX_VALUATORS];
int numValuators;
} last;
/* Input device property handling */
XIPropertyPtr properties;
Bool pendingProperties;
XISetDevicePropertyProcPtr SetProperty;
XIGetDevicePropertyProcPtr GetProperty;
} DeviceIntRec;
typedef struct {