xserver: Branch 'master' - 3 commits
Peter Hutterer
whot at kemper.freedesktop.org
Thu Jul 10 00:04:48 PDT 2008
Xi/xiproperty.c | 177 ++++++++++++++++++++++++++++++++++++++++-------------
dix/devices.c | 7 --
include/exevents.h | 72 +++++++++++++++++----
include/inputstr.h | 31 +++++----
4 files changed, 215 insertions(+), 72 deletions(-)
New commits:
commit e4054e5cb3d919dfc83021be3f2b9036d0e5a2be
Author: Peter Hutterer <peter.hutterer at who-t.net>
Date: Thu Jul 10 11:03:31 2008 +0930
Xi: pack the property stuff into a struct, make handlers a linked list.
We may need more than one handler to deal with a property (e.g. one in the
driver, one in the DIX), so get the handlers into a linked list and call them
one-by-one. This is of course slightly less entertaining than the hilarious
WRAP/UNWRAP game we play in other parts of the server.
XIRegisterPropertyHandler/XIUnregisterPropertyHandler are the interface
drivers/the DIX should use to attach themselves to the device.
XIDeleteAllDeviceProperties destroys everything, including the handlers.
diff --git a/Xi/xiproperty.c b/Xi/xiproperty.c
index 832a458..59bfe0f 100644
--- a/Xi/xiproperty.c
+++ b/Xi/xiproperty.c
@@ -39,33 +39,57 @@
#include "xiproperty.h"
+static long XIPropHandlerID = 1;
+
+/* Registers a new property handler on the given device and returns a unique
+ * identifier for this handler. This identifier is required to unregister the
+ * property handler again.
+ * @return The handler's identifier or 0 if an error occured.
+ */
+long
+XIRegisterPropertyHandler(DeviceIntPtr dev,
+ Bool (*SetProperty) (DeviceIntPtr dev,
+ Atom property,
+ XIPropertyValuePtr prop),
+ Bool (*GetProperty) (DeviceIntPtr dev,
+ Atom property))
+{
+ XIPropertyHandlerPtr new_handler;
+
+ new_handler = xcalloc(1, sizeof(XIPropertyHandler));
+ if (!new_handler)
+ return 0;
+
+ new_handler->id = XIPropHandlerID++;
+ new_handler->SetProperty = SetProperty;
+ new_handler->GetProperty = GetProperty;
+ new_handler->next = dev->properties.handlers;
+ dev->properties.handlers = new_handler;
+
+ return new_handler->id;
+}
+
void
-XIDeleteAllDeviceProperties (DeviceIntPtr device)
+XIUnRegisterPropertyHandler(DeviceIntPtr dev, long id)
{
- XIPropertyPtr prop, next;
- devicePropertyNotifyEvent event;
+ XIPropertyHandlerPtr curr, prev = NULL;
- for (prop = device->properties; prop; prop = next)
+ curr = dev->properties.handlers;
+ while(curr && curr->id != id)
{
- next = prop->next;
+ prev = curr;
+ curr = curr->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 (!curr)
+ return;
- if (prop->current.data)
- xfree(prop->current.data);
- if (prop->pending.data)
- xfree(prop->pending.data);
- xfree(prop);
- }
+ if (!prev) /* first one */
+ dev->properties.handlers = curr->next;
+ else
+ prev->next = curr->next;
+
+ xfree(curr);
}
static void
@@ -112,13 +136,53 @@ XIDestroyDeviceProperty (XIPropertyPtr prop)
xfree(prop);
}
+/* This function destroys all of the device's property-related stuff,
+ * including removing all device handlers.
+ * DO NOT CALL FROM THE DRIVER.
+ */
+void
+XIDeleteAllDeviceProperties (DeviceIntPtr device)
+{
+ XIPropertyPtr prop, next;
+ XIPropertyHandlerPtr curr_handler, next_handler;
+ devicePropertyNotifyEvent event;
+
+ for (prop = device->properties.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);
+
+ XIDestroyDeviceProperty(prop);
+ }
+
+ /* Now free all handlers */
+ curr_handler = device->properties.handlers;
+ while(curr_handler)
+ {
+ next_handler = curr_handler->next;
+ xfree(curr_handler);
+ curr_handler = next_handler;
+ }
+}
+
+
int
XIDeleteDeviceProperty (DeviceIntPtr device, Atom property, Bool fromClient)
{
XIPropertyPtr prop, *prev;
devicePropertyNotifyEvent event;
- for (prev = &device->properties; (prop = *prev); prev = &(prop->next))
+ for (prev = &device->properties.properties; (prop = *prev); prev = &(prop->next))
if (prop->propertyName == property)
break;
@@ -234,13 +298,20 @@ XIChangeDeviceProperty (DeviceIntPtr dev, Atom property, Atom type,
we're in a single thread after all
*/
if (pending && prop->is_pending)
- dev->pendingProperties = TRUE;
- if (pending && dev->SetProperty &&
- !dev->SetProperty(dev, prop->propertyName, &new_value))
+ dev->properties.pendingProperties = TRUE;
+ if (pending && dev->properties.handlers)
{
- if (new_value.data)
- xfree (new_value.data);
- return (BadValue);
+ XIPropertyHandlerPtr handler = dev->properties.handlers;
+ while(handler)
+ {
+ if (!handler->SetProperty(dev, prop->propertyName, &new_value))
+ {
+ if (new_value.data)
+ xfree (new_value.data);
+ return (BadValue);
+ }
+ handler = handler->next;
+ }
}
if (prop_value->data)
xfree (prop_value->data);
@@ -254,8 +325,8 @@ XIChangeDeviceProperty (DeviceIntPtr dev, Atom property, Atom type,
if (add)
{
- prop->next = dev->properties;
- dev->properties = prop;
+ prop->next = dev->properties.properties;
+ dev->properties.properties = prop;
}
@@ -280,7 +351,7 @@ XIQueryDeviceProperty (DeviceIntPtr dev, Atom property)
{
XIPropertyPtr prop;
- for (prop = dev->properties; prop; prop = prop->next)
+ for (prop = dev->properties.properties; prop; prop = prop->next)
if (prop->propertyName == property)
return prop;
return NULL;
@@ -297,8 +368,15 @@ XIGetDeviceProperty (DeviceIntPtr dev, Atom property, Bool pending)
return &prop->pending;
else {
/* If we can, try to update the property value first */
- if (dev->GetProperty)
- dev->GetProperty(dev, prop->propertyName);
+ if (dev->properties.handlers)
+ {
+ XIPropertyHandlerPtr handler = dev->properties.handlers;
+ while(handler)
+ {
+ handler->GetProperty(dev, prop->propertyName);
+ handler = handler->next;
+ }
+ }
return &prop->current;
}
}
@@ -353,8 +431,8 @@ XIConfigureDeviceProperty (DeviceIntPtr dev, Atom property,
prop->valid_values = new_values;
if (add) {
- prop->next = dev->properties;
- dev->properties = prop;
+ prop->next = dev->properties.properties;
+ dev->properties.properties = prop;
}
return Success;
@@ -377,7 +455,7 @@ ProcXListDeviceProperties (ClientPtr client)
if (rc != Success)
return rc;
- for (prop = dev->properties; prop; prop = prop->next)
+ for (prop = dev->properties.properties; prop; prop = prop->next)
numProps++;
if (numProps)
if(!(pAtoms = (Atom *)xalloc(numProps * sizeof(Atom))))
@@ -395,7 +473,7 @@ ProcXListDeviceProperties (ClientPtr client)
swapl (&rep.length, n);
}
temppAtoms = pAtoms;
- for (prop = dev->properties; prop; prop = prop->next)
+ for (prop = dev->properties.properties; prop; prop = prop->next)
*temppAtoms++ = prop->propertyName;
WriteReplyToClient(client, sizeof(xListDevicePropertiesReply), &rep);
@@ -589,7 +667,7 @@ ProcXGetDeviceProperty (ClientPtr client)
return(BadAtom);
}
- for (prev = &dev->properties; (prop = *prev); prev = &prop->next)
+ for (prev = &dev->properties.properties; (prop = *prev); prev = &prop->next)
if (prop->propertyName == stuff->property)
break;
diff --git a/dix/devices.c b/dix/devices.c
index df53613..6151421 100644
--- a/dix/devices.c
+++ b/dix/devices.c
@@ -175,10 +175,9 @@ AddInputDevice(ClientPtr client, DeviceProc deviceProc, Bool autoStart)
dev->last.numValuators = 0;
/* device properties */
- dev->properties = NULL;
- dev->SetProperty = NULL;
- dev->GetProperty = NULL;
- dev->pendingProperties = FALSE;
+ dev->properties.properties = NULL;
+ dev->properties.pendingProperties = FALSE;
+ dev->properties.handlers = NULL;
/* security creation/labeling check
*/
diff --git a/include/exevents.h b/include/exevents.h
index 48dfccf..b77a363 100644
--- a/include/exevents.h
+++ b/include/exevents.h
@@ -239,4 +239,18 @@ extern int XIConfigureDeviceProperty(
INT32* /* values */
);
+extern long XIRegisterPropertyHandler(
+ DeviceIntPtr dev,
+ Bool (*SetProperty) (DeviceIntPtr dev,
+ Atom property,
+ XIPropertyValuePtr prop),
+ Bool (*GetProperty) (DeviceIntPtr dev,
+ Atom property)
+);
+
+extern void XIUnRegisterPropertyHandler(
+ DeviceIntPtr dev,
+ long id
+);
+
#endif /* EXEVENTS_H */
diff --git a/include/inputstr.h b/include/inputstr.h
index 280774e..f3211a9 100644
--- a/include/inputstr.h
+++ b/include/inputstr.h
@@ -358,14 +358,22 @@ typedef struct _XIProperty
pending;
} XIPropertyRec;
+
+
typedef XIPropertyRec *XIPropertyPtr;
typedef XIPropertyValueRec *XIPropertyValuePtr;
-typedef Bool (*XISetDevicePropertyProcPtr) (DeviceIntPtr dev,
- Atom property,
- XIPropertyValuePtr prop);
-typedef Bool (*XIGetDevicePropertyProcPtr) (DeviceIntPtr dev,
- Atom property);
+
+typedef struct _XIPropertyHandler
+{
+ struct _XIPropertyHandler* next;
+ long id;
+ Bool (*SetProperty) (DeviceIntPtr dev,
+ Atom property,
+ XIPropertyValuePtr prop);
+ Bool (*GetProperty) (DeviceIntPtr dev,
+ Atom property);
+} XIPropertyHandler, *XIPropertyHandlerPtr;
/* states for devices */
@@ -465,11 +473,12 @@ typedef struct _DeviceIntRec {
int numValuators;
} last;
- /* Input device property handling */
- XIPropertyPtr properties;
- Bool pendingProperties;
- XISetDevicePropertyProcPtr SetProperty;
- XIGetDevicePropertyProcPtr GetProperty;
+ /* Input device property handling. */
+ struct {
+ XIPropertyPtr properties;
+ Bool pendingProperties;
+ XIPropertyHandlerPtr handlers; /* NULL-terminated */
+ } properties;
} DeviceIntRec;
typedef struct {
commit 2039c6ea43244339659323d05d96c14e41996c20
Author: Peter Hutterer <peter.hutterer at who-t.net>
Date: Mon Jul 7 22:10:17 2008 +0930
Xi: add support for input device properties.
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.
diff --git a/Xi/Makefile.am b/Xi/Makefile.am
index 2af1940..768f996 100644
--- a/Xi/Makefile.am
+++ b/Xi/Makefile.am
@@ -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
diff --git a/Xi/extinit.c b/Xi/extinit.c
index 613472a..7460d71 100644
--- a/Xi/extinit.c
+++ b/Xi/extinit.c
@@ -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 */
};
/*****************************************************************
diff --git a/Xi/xiproperty.c b/Xi/xiproperty.c
new file mode 100644
index 0000000..832a458
--- /dev/null
+++ b/Xi/xiproperty.c
@@ -0,0 +1,755 @@
+/*
+ * 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->fromClient = 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);
+}
+
+int
+XIDeleteDeviceProperty (DeviceIntPtr device, Atom property, Bool fromClient)
+{
+ XIPropertyPtr prop, *prev;
+ devicePropertyNotifyEvent event;
+
+ for (prev = &device->properties; (prop = *prev); prev = &(prop->next))
+ if (prop->propertyName == property)
+ break;
+
+ if (!prop->fromClient && fromClient)
+ return BadAtom;
+
+ 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);
+ }
+
+ return Success;
+}
+
+int
+XIChangeDeviceProperty (DeviceIntPtr dev, Atom property, Atom type,
+ int format, int mode, unsigned long len,
+ pointer value, Bool sendevent, Bool pending,
+ Bool fromClient)
+{
+ 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);
+ prop->fromClient = fromClient;
+ 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);
+
+ /* We must set pendingProperties TRUE before we commit to the driver,
+ we're in a single thread after all
+ */
+ if (pending && prop->is_pending)
+ dev->pendingProperties = TRUE;
+ 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 (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;
+ rep.fromClient = prop->fromClient;
+ 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, 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);
+ }
+
+
+ rc = XIDeleteDeviceProperty(dev, stuff->property, TRUE);
+ 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;
+}
+
diff --git a/Xi/xiproperty.h b/Xi/xiproperty.h
new file mode 100644
index 0000000..e31cdad
--- /dev/null
+++ b/Xi/xiproperty.h
@@ -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 */
diff --git a/dix/devices.c b/dix/devices.c
index 0a68c0e..df53613 100644
--- a/dix/devices.c
+++ b/dix/devices.c
@@ -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);
diff --git a/include/exevents.h b/include/exevents.h
index 664e236..48dfccf 100644
--- a/include/exevents.h
+++ b/include/exevents.h
@@ -188,10 +188,55 @@ extern int DeviceEventSuppressForWindow(
Mask /* mask */,
int /* maskndx */);
-void SendEventToAllWindows(
+extern void SendEventToAllWindows(
DeviceIntPtr /* dev */,
Mask /* mask */,
xEvent * /* ev */,
int /* count */);
+/* Input device properties */
+extern void XIDeleteAllDeviceProperties(
+ DeviceIntPtr /* device */
+);
+
+extern int XIDeleteDeviceProperty(
+ DeviceIntPtr /* device */,
+ Atom /* property */,
+ Bool /* fromClient */
+);
+
+extern int XIChangeDeviceProperty(
+ DeviceIntPtr /* dev */,
+ Atom /* property */,
+ Atom /* type */,
+ int /* format*/,
+ int /* mode*/,
+ unsigned long /* len*/,
+ pointer /* value*/,
+ Bool /* sendevent*/,
+ Bool /* pending*/,
+ Bool /* fromClient */
+ );
+
+extern XIPropertyPtr XIQueryDeviceProperty(
+ DeviceIntPtr /* dev */,
+ Atom /* property */
+);
+
+extern XIPropertyValuePtr XIGetDeviceProperty(
+ DeviceIntPtr /* dev */,
+ Atom /* property */,
+ Bool /* pending */
+);
+
+extern int XIConfigureDeviceProperty(
+ DeviceIntPtr /* dev */,
+ Atom /* property */,
+ Bool /* pending */,
+ Bool /* range */,
+ Bool /* immutable */,
+ int /* num_values */,
+ INT32* /* values */
+);
+
#endif /* EXEVENTS_H */
diff --git a/include/inputstr.h b/include/inputstr.h
index e5de6fc..280774e 100644
--- a/include/inputstr.h
+++ b/include/inputstr.h
@@ -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;
+ Bool fromClient; /* created by client or driver/server */
+ 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 {
commit 4ab01fe5db7fb330b1ec463aa49b77859527e597
Author: Peter Hutterer <peter.hutterer at who-t.net>
Date: Thu Jul 10 16:27:36 2008 +0930
Revert "Xi: add support for input device properties."
Note to self: don't mix up branches with half-finished cherrypicks.
This reverts commit 666838fcc8b71fdeae160844160187f345cbf4a6.
diff --git a/Xi/Makefile.am b/Xi/Makefile.am
index 768f996..2af1940 100644
--- a/Xi/Makefile.am
+++ b/Xi/Makefile.am
@@ -94,9 +94,7 @@ libXi_la_SOURCES = \
ungrdevk.h \
warpdevp.c \
warpdevp.h \
- xiproperty.c \
- xiproperty.h \
- xiselev.c \
- xiselev.h
+ xiselev.c \
+ xiselev.h
EXTRA_DIST = stubs.c
diff --git a/Xi/extinit.c b/Xi/extinit.c
index 7460d71..613472a 100644
--- a/Xi/extinit.c
+++ b/Xi/extinit.c
@@ -122,7 +122,6 @@ SOFTWARE.
#include "ungrdevk.h"
#include "warpdevp.h"
#include "xiselev.h"
-#include "xiproperty.c"
static Mask lastExtEventMask = 1;
@@ -218,13 +217,7 @@ static int (*ProcIVector[])(ClientPtr) = {
ProcXSetClientPointer, /* 42 */
ProcXGetClientPointer, /* 43 */
ProcXiSelectEvent, /* 44 */
- ProcXExtendedGrabDevice, /* 45 */
- ProcXListDeviceProperties, /* 46 */
- ProcXQueryDeviceProperty, /* 47 */
- ProcXConfigureDeviceProperty, /* 48 */
- ProcXChangeDeviceProperty, /* 49 */
- ProcXDeleteDeviceProperty, /* 50 */
- ProcXGetDeviceProperty /* 51 */
+ ProcXExtendedGrabDevice /* 45 */
};
/* For swapped clients */
@@ -274,13 +267,7 @@ static int (*SProcIVector[])(ClientPtr) = {
SProcXSetClientPointer, /* 42 */
SProcXGetClientPointer, /* 43 */
SProcXiSelectEvent, /* 44 */
- SProcXExtendedGrabDevice, /* 45 */
- SProcXListDeviceProperties, /* 46 */
- SProcXQueryDeviceProperty, /* 47 */
- SProcXConfigureDeviceProperty, /* 48 */
- SProcXChangeDeviceProperty, /* 49 */
- SProcXDeleteDeviceProperty, /* 50 */
- SProcXGetDeviceProperty /* 51 */
+ SProcXExtendedGrabDevice /* 45 */
};
/*****************************************************************
diff --git a/Xi/xiproperty.c b/Xi/xiproperty.c
deleted file mode 100644
index a02c565..0000000
--- a/Xi/xiproperty.c
+++ /dev/null
@@ -1,742 +0,0 @@
-/*
- * 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;
-}
-
diff --git a/Xi/xiproperty.h b/Xi/xiproperty.h
deleted file mode 100644
index e31cdad..0000000
--- a/Xi/xiproperty.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * 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 */
diff --git a/dix/devices.c b/dix/devices.c
index df53613..0a68c0e 100644
--- a/dix/devices.c
+++ b/dix/devices.c
@@ -83,7 +83,6 @@ SOFTWARE.
#include "exglobals.h"
#include "exevents.h"
#include "listdev.h" /* for CopySwapXXXClass */
-#include "xiproperty.h"
/** @file
* This file handles input device-related stuff.
@@ -174,12 +173,6 @@ 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)) {
@@ -777,8 +770,6 @@ CloseDevice(DeviceIntPtr dev)
if (!dev)
return;
- XIDeleteAllDeviceProperties(dev);
-
if (dev->inited)
(void)(*dev->deviceProc)(dev, DEVICE_CLOSE);
diff --git a/include/exevents.h b/include/exevents.h
index 46fe5ef..664e236 100644
--- a/include/exevents.h
+++ b/include/exevents.h
@@ -194,19 +194,4 @@ 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 */
diff --git a/include/inputstr.h b/include/inputstr.h
index de1aa79..e5de6fc 100644
--- a/include/inputstr.h
+++ b/include/inputstr.h
@@ -335,38 +335,6 @@ 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
@@ -379,9 +347,8 @@ typedef Bool (*XIGetDevicePropertyProcPtr) (DeviceIntPtr dev,
#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;
@@ -464,12 +431,6 @@ 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 {
More information about the xorg-commit
mailing list