Common subdirectories: oldsrc-20140904-1824/.deps and src/.deps
Common subdirectories: oldsrc-20140904-1824/.libs and src/.libs
Common subdirectories: oldsrc-20140904-1824/man and src/man
diff -u -U 7 -x '*.py*' oldsrc-20140904-1824/xinput.c src/xinput.c
--- oldsrc-20140904-1824/xinput.c	2014-09-04 18:25:54.117849514 +0200
+++ src/xinput.c	2014-09-04 21:50:34.425806088 +0200
@@ -1524,32 +1524,134 @@
 xcb_input_get_device_dont_propagate_list_reply (xcb_connection_t                                   *c  /**< */,
                                                 xcb_input_get_device_dont_propagate_list_cookie_t   cookie  /**< */,
                                                 xcb_generic_error_t                               **e  /**< */)
 {
     return (xcb_input_get_device_dont_propagate_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
 }
 
+int
+xcb_input_device_time_coord_sizeof (const void  *_buffer  /**< */,
+                                    uint8_t      num_axes  /**< */)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_padding_offset = 0;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_device_time_coord_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+    /* axisvalues */
+    xcb_block_len += num_axes * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -( xcb_block_len + xcb_padding_offset ) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int32_t *
+xcb_input_device_time_coord_axisvalues (const xcb_input_device_time_coord_t *R  /**< */)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_input_device_time_coord_axisvalues_length (const xcb_input_device_time_coord_t *R  /**< */,
+                                               uint8_t num_axes /**< */)
+{
+    return num_axes;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_time_coord_axisvalues_end (const xcb_input_device_time_coord_t *R  /**< */,
+                                            uint8_t num_axes /**< */)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (num_axes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
 void
 xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i  /**< */)
 {
+    xcb_input_device_time_coord_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_device_time_coord_t *)(((char *)R) + xcb_input_device_time_coord_sizeof(R, i->num_axes));
+    i->index = (char *) child.data - (char *) i->data;
     --i->rem;
-    ++i->data;
-    i->index += sizeof(xcb_input_device_time_coord_t);
+    i->data = (xcb_input_device_time_coord_t *) child.data;
 }
 
 xcb_generic_iterator_t
 xcb_input_device_time_coord_end (xcb_input_device_time_coord_iterator_t i  /**< */)
 {
     xcb_generic_iterator_t ret;
-    ret.data = i.data + i.rem;
-    ret.index = i.index + ((char *) ret.data - (char *) i.data);
-    ret.rem = 0;
+    while(i.rem > 0)
+        xcb_input_device_time_coord_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
     return ret;
 }
 
+int
+xcb_input_get_device_motion_events_sizeof (const void  *_buffer  /**< */)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_padding_offset = 0;
+    const xcb_input_get_device_motion_events_reply_t *_aux = (xcb_input_get_device_motion_events_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_get_device_motion_events_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+    /* events */
+    for(i=0; i<_aux->num_events; i++) {
+        xcb_tmp_len = xcb_input_device_time_coord_sizeof(xcb_tmp, _aux->num_axes);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_device_time_coord_t);
+    /* insert padding */
+    xcb_pad = -( xcb_block_len + xcb_padding_offset ) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
 xcb_input_get_device_motion_events_cookie_t
 xcb_input_get_device_motion_events (xcb_connection_t *c  /**< */,
                                     xcb_timestamp_t   start  /**< */,
                                     xcb_timestamp_t   stop  /**< */,
                                     uint8_t           device_id  /**< */)
 {
     static const xcb_protocol_request_t xcb_req = {
@@ -1604,14 +1706,31 @@
     xcb_parts[3].iov_base = 0;
     xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
 
     xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
     return xcb_ret;
 }
 
+int
+xcb_input_get_device_motion_events_events_length (const xcb_input_get_device_motion_events_reply_t *R  /**< */)
+{
+    return R->num_events;
+}
+
+xcb_input_device_time_coord_iterator_t
+xcb_input_get_device_motion_events_events_iterator (const xcb_input_get_device_motion_events_reply_t *R  /**< */)
+{
+    xcb_input_device_time_coord_iterator_t i;
+    i.data = (xcb_input_device_time_coord_t *) (R + 1);
+    i.rem = R->num_events;
+    i.index = (char *) i.data - (char *) R;
+    i.num_axes = R->num_axes;
+    return i;
+}
+
 xcb_input_get_device_motion_events_reply_t *
 xcb_input_get_device_motion_events_reply (xcb_connection_t                             *c  /**< */,
                                           xcb_input_get_device_motion_events_cookie_t   cookie  /**< */,
                                           xcb_generic_error_t                         **e  /**< */)
 {
     return (xcb_input_get_device_motion_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
 }
diff -u -U 7 -x '*.py*' oldsrc-20140904-1824/xinput.h src/xinput.h
--- oldsrc-20140904-1824/xinput.h	2014-09-04 18:25:54.193849514 +0200
+++ src/xinput.h	2014-09-04 21:50:34.417806088 +0200
@@ -462,14 +462,15 @@
 /**
  * @brief xcb_input_device_time_coord_iterator_t
  **/
 typedef struct xcb_input_device_time_coord_iterator_t {
     xcb_input_device_time_coord_t *data; /**<  */
     int                            rem; /**<  */
     int                            index; /**<  */
+    uint8_t                        num_axes; /**<  */
 } xcb_input_device_time_coord_iterator_t;
 
 /**
  * @brief xcb_input_get_device_motion_events_cookie_t
  **/
 typedef struct xcb_input_get_device_motion_events_cookie_t {
     unsigned int sequence; /**<  */
@@ -4710,14 +4711,29 @@
  * The returned value must be freed by the caller using free().
  */
 xcb_input_get_device_dont_propagate_list_reply_t *
 xcb_input_get_device_dont_propagate_list_reply (xcb_connection_t                                   *c  /**< */,
                                                 xcb_input_get_device_dont_propagate_list_cookie_t   cookie  /**< */,
                                                 xcb_generic_error_t                               **e  /**< */);
 
+int
+xcb_input_device_time_coord_sizeof (const void  *_buffer  /**< */,
+                                    uint8_t      num_axes  /**< */);
+
+int32_t *
+xcb_input_device_time_coord_axisvalues (const xcb_input_device_time_coord_t *R  /**< */);
+
+int
+xcb_input_device_time_coord_axisvalues_length (const xcb_input_device_time_coord_t *R  /**< */,
+                                               uint8_t num_axes /**< */);
+
+xcb_generic_iterator_t
+xcb_input_device_time_coord_axisvalues_end (const xcb_input_device_time_coord_t *R  /**< */,
+                                            uint8_t num_axes /**< */);
+
 /**
  * Get the next element of the iterator
  * @param i Pointer to a xcb_input_device_time_coord_iterator_t
  *
  * Get the next element in the iterator. The member rem is
  * decreased by one. The member data points to the next
  * element. The member index is increased by sizeof(xcb_input_device_time_coord_t)
@@ -4733,14 +4749,17 @@
  * Set the current element in the iterator to the last element.
  * The member rem is set to 0. The member data points to the
  * last element.
  */
 xcb_generic_iterator_t
 xcb_input_device_time_coord_end (xcb_input_device_time_coord_iterator_t i  /**< */);
 
+int
+xcb_input_get_device_motion_events_sizeof (const void  *_buffer  /**< */);
+
 /**
  *
  * @param c The connection
  * @return A cookie
  *
  * Delivers a request to the X server.
  *
@@ -4764,14 +4783,20 @@
  */
 xcb_input_get_device_motion_events_cookie_t
 xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c  /**< */,
                                               xcb_timestamp_t   start  /**< */,
                                               xcb_timestamp_t   stop  /**< */,
                                               uint8_t           device_id  /**< */);
 
+int
+xcb_input_get_device_motion_events_events_length (const xcb_input_get_device_motion_events_reply_t *R  /**< */);
+
+xcb_input_device_time_coord_iterator_t
+xcb_input_get_device_motion_events_events_iterator (const xcb_input_get_device_motion_events_reply_t *R  /**< */);
+
 /**
  * Return the reply
  * @param c      The connection
  * @param cookie The cookie
  * @param e      The xcb_generic_error_t supplied
  *
  * Returns the reply of the request asked by
Binary files oldsrc-20140904-1824/xinput.o and src/xinput.o differ


