diff --git a/dist/libxcb/ChangeLog b/dist/libxcb/ChangeLog new file mode 100644 index 000000000..1b3ad5ee4 --- /dev/null +++ b/dist/libxcb/ChangeLog @@ -0,0 +1,7043 @@ +commit d34785a34f28fa6a00f8ce00d87e3132ff0f6467 +Author: Uli Schlachter +Date: Sat May 14 10:36:54 2016 +0200 + + Release libxcb 1.12 + + Signed-off-by: Uli Schlachter + +commit b11fca06f75b26b94e3f1d3e3c3954d365f80759 +Author: Uli Schlachter +Date: Sat May 14 10:33:54 2016 +0200 + + Bump xcb-proto requirement to 1.12 + + This is needed due to various changes that were done to the XML schema. + + Signed-off-by: Uli Schlachter + +commit 095353ff1a4f611922dfc4c98b0c4bd55d9f6d4f +Author: Mark Kettenis +Date: Sat Jan 23 17:29:32 2016 +0100 + + Increase unix socket send buffer to at least 64KB + + Some systems (e.g. OpenBSD) have a rather small default socket send buffer + size of 4KB. The result is that sending requests with a largish payload + requires serveral writev(2) system calls. Make sure the socket send buffer + is at least 64KB such that we're likely to succeed with a single system + call for most requests. A similar change was made to the xtrans code + some time ago. + + Signed-off-by: Mark Kettenis + Reviewed-by: Matthieu Herrb + +commit b3516102b4469df99db39e0e354deae496867f35 +Author: Christian Linhart +Date: Mon Jan 18 06:56:39 2016 +0100 + + do not serialize pads by default anymore + + Pads should not be serialized/deserialized to maintain + ABI compatibility when adding explicit align pads. + + Therefore this pad switches off serialization of pads + unless it is enforced by serialize=true in the xml-definition + of that pad + + Signed-off-by: Christian Linhart + +commit c03388ff9e253b86e4b41fb77034ca6007fe47e9 +Author: Jaya Tiwari +Date: Wed Nov 11 01:02:09 2015 +0100 + + calculate lengthless list + + Some rework done by Christian Linhart + + Signed-off-by: Jaya Tiwari + Signed-off-by: Christian Linhart + +commit 775825756714eb6b8467e099cda73a03b782ea0e +Author: Christian Linhart +Date: Tue Nov 10 12:53:04 2015 +0100 + + Fix handling of align-pads in end-iterators + + If a list is preceded by an align-pad, then + accessor for the end-iterator returned a wrong + value. + + Reason: the length of the align-iterator was added + to a pointer of list-member type. Therefore, the length + was multiplied by the size of the list-member type, + due to C pointer arithmetic rules. + + This has looked like the following, e.g., in + xcb_randr_get_crtc_transform_pending_params_end: + + i.data = ((xcb_render_fixed_t *) prev.data) + ((-prev.index) & (4 - 1)) + (R->pending_nparams); + + This bug was introduced with the following commit: + http://cgit.freedesktop.org/xcb/libxcb/commit/?id=4033d39d4da21842bb1396a419dfc299591c3b1f + + The fix handles this by casting to char* before adding the align, + and then casting the result to the member type. + + Signed-off-by: Christian Linhart + +commit 32a2189183696e942b002efcbca823a416fe5f6a +Author: Christian Linhart +Date: Sun Nov 1 18:35:35 2015 +0100 + + set the align-offset as provided by proto + + instead of using the lower bits of the pointer address. + This fixes a bug reported by Peter Hutterer in off-list communication + back in June 2015. + + This requires the alignment-checker patches in xcb/proto. + + Signed-off-by: Christian Linhart + +commit 6e0378ebbf5f842992e37c93ad60b960427849ac +Author: Adam Jackson +Date: Mon Sep 21 15:27:52 2015 -0400 + + Bump version to 1.11.90 + + We've released 1.11.1 and new libX11 wants that or better. git master + will suffice, so bump the version number ahead of 1.11 branch. + + Signed-off-by: Adam Jackson + +commit 4033d39d4da21842bb1396a419dfc299591c3b1f +Author: Christian Linhart +Date: Fri Sep 19 13:44:38 2014 +0200 + + make lists after align-pads work + + Handle align-pads when generating an end-function + in the same way as handling them when generating + an accessor or iterator function. + + Signed-off-by: Christian Linhart + +commit b15c96f9507119e5d38a61d92b4dbcd479ea2099 +Author: Christian Linhart +Date: Thu Jun 11 18:58:38 2015 +0200 + + make support for server side stuff optional + + and make it disabled by default with an EXPERIMENTAL warning + + reason: this feature is unfinished and we want to have flexibility for + ABI/API changes, while still being able to make a release soon + + Signed-off-by: Christian Linhart + +commit c5d923d8ff4a9b9fc1aef1c6c6918bab15098d34 +Author: Jon TURNEY +Date: Tue Mar 17 17:49:14 2015 +0000 + + Link with winsock library for socket functions on MinGW + + Signed-off-by: Jon TURNEY + +commit 5b40681c887192307f3ae147d2158870aa79c05f +Author: Uli Schlachter +Date: Fri Jun 12 15:13:05 2015 +0200 + + Fix a thread hang with xcb_wait_for_special_event() + + Consider the following: + + - Two threads are calling xcb_wait_for_special_event() and xcb_wait_for_reply() + concurrently. + - The thread doing xcb_wait_for_reply() wins the race and poll()s the socket for + readability. + - The other thread will be put to sleep on the special_event_cond of the special + event (this is done in _xcb_conn_wait() via the argument + xcb_wait_for_special_event() gives it). + - The first thread gets its reply, but does not yet receive any special event. + + In this case, the first thread will return to its caller. On its way out, it + will call _xcb_in_wake_up_next_reader(), but that function cannot wake up + anything since so far it did not handle xcb_wait_for_special_event(). + + Thus, the first thread stays blocked on the condition variable and no thread + tries to read from the socket. + + A test case demonstrating this problem is available at the bug report. + + Fix this similar to how we handle this with xcb_wait_for_reply(): + + The function wait_for_reply() adds an entry into a linked list of threads that + wait for a reply. Via this list, _xcb_in_wake_up_next_reader() can wake up this + thread so that it can call _xcb_conn_wait() again and then poll()s the socket. + + Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=84252 + Signed-off-by: Uli Schlachter + Tested-by: Michel Dänzer + +commit f85661c3bca97faa72431df92a3867be39a74e23 +Author: Michel Dänzer +Date: Mon Jun 1 11:04:18 2015 +0900 + + Call _xcb_wake_up_next_reader from xcb_wait_for_special_event + + All functions calling _xcb_conn_wait() must make sure that waiting + readers are woken up when we read a reply or event that they are waiting + for. xcb_wait_for_special_event() did not do so. This adds the missing + call to_xcb_in_wake_up_next_reader(). + + Fixes deadlock when waiting for a special event and concurrently + processing the display connection queue in another thread. + + Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=84252 + Tested-by: Thomas Daede + Tested-by: Clément Guérin + Reviewed-by: Uli Schlachter + Signed-off-by: Michel Dänzer + Signed-off-by: Uli Schlachter + +commit 8584c0e09573a29d8ba7050e3d5afd925b4d8d80 +Author: Uli Schlachter +Date: Thu May 14 09:44:05 2015 +0200 + + send_fds(): Handle too many outstanding FDs to send + + Before this patch, the following code caused an endless loop in send_fds(), + because the queue of FDs to send was eventually full, but _xcb_out_flush_to() + didn't make any progress, since there was no request to send: + + while (1) { xcb_send_fd(conn, dup(some_fd)); } + + Fix this by sending a sync when flushing didn't make any progress. That way we + actually have something to send and can attach the pending FDs. + + Because send_fds() can now send requests, the code in + xcb_send_request_with_fds64() has to be changed. It has to call send_fds() + before it establishes a good sequence number for the request it wants to send. + + Signed-off-by: Uli Schlachter + +commit 658fb4a5f0050db68fdf092936afe596412ef5f7 +Author: Uli Schlachter +Date: Wed Apr 22 09:26:05 2015 +0200 + + Code generator: Use xcb_send_request_with_fds() + + Signed-off-by: Uli Schlachter + +commit b15aa6bd4efde784e546d168bb23b8a8e816e85b +Author: Uli Schlachter +Date: Wed Apr 22 09:23:47 2015 +0200 + + Add xcb_send_request_with_fds() and *_with_fds64() + + Doing xcb_send_fd(), xcb_send_request() is racy. If two threads do this at the + same time, they could mix up their file descriptors. This commit makes it + possibly to fix this race by providing a single function which does everything + that is needed. + + Signed-off-by: Uli Schlachter + +commit cc04cfb41bece6ec239f57d83822286b507f4482 +Author: Uli Schlachter +Date: Mon May 18 21:40:34 2015 +0200 + + send_fds(): Make sure no other thread interrupts us + + Two threads trying to send fds at the same time could interfere. To guarantee a + correct ordering, we have to use correct locking. The code in send_fds() missed + one case: If there was another thread already writing requests, we slept on the + "done with writing" condition variable (c->out.cond). This would allow other + threads to re-acquire the iolock before us and could cause fds to be sent out of + order. + + To fix this, at the beginning of send_fds() we now make sure that no other + thread is already writing requests. This is what prepare_socket_request() does. + Additionally, it gets the socket back in case xcb_take_socket() was called, + which is a good thing, too, since fds are only sent with corresponding requests. + +commit 25f9e7e45a7652b35b71c7941beef774a39f0d86 +Author: Uli Schlachter +Date: Wed Apr 22 09:20:38 2015 +0200 + + xcb_send_fd(): Always close fds + + The API docs for xcb_send_fd() says "After this function returns, the file + descriptor given is owned by xcb and will be closed eventually". + + Let the implementation live up to its documentation. We now also close fds if fd + passing is unavailable (!HAVE_SENDMSG) and when the connection is in an error + state. + + (This also does sneak in some preparatory functions for follow-up commits and + thus does things in a more complicated way than really necessary.) + + Signed-off-by: Uli Schlachter + +commit bbdf1d133f7bd979c6ff3bf44ec3d0c2d2b9dbfe +Author: Ran Benita +Date: Wed Mar 18 12:27:32 2015 +0200 + + c_client.py: don't generate useless empty /** < */ comments + + (This does not change doxygen's output or warnings). + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit ff6cb3913b64a4aa29cb5e65168ea49d77195296 +Author: Ran Benita +Date: Wed Mar 18 12:27:31 2015 +0200 + + c_client.py: use pattern matching with enumerate() + + Signed-off-by: Ran Benita + +commit cb621341a62e6d2233db3e337611f6fdd4f675a6 +Author: Christian Linhart +Date: Wed Apr 29 09:11:37 2015 +0200 + + expose 64-bit sequence numbers for XLib + + While XCB uses 64-bit sequence number internally, it only exposes + "unsigned int" so that, on 32-bit architecture, Xlib based applications + may see their sequence number wrap which causes the connection to the X + server to be lost. + + Expose 64-bit sequence number from XCB API so that Xlib and others can + use it even on 32-bit environment. + + This implies the following API addition: + + xcb_send_request64() + xcb_discard_reply64() + xcb_wait_for_reply64() + xcb_poll_for_reply64() + + Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=71338 + + Reviewed-by: Uli Schlachter + Signed-off-by: Christian Linhart + Signed-off-by: Olivier Fourdan + +commit c49aa985941112be05599032b9bb45b2652301ce +Author: Alan Coopersmith +Date: Wed Apr 29 23:23:05 2015 -0700 + + Escape \n to display properly in xcb-requests man page + + In nroff, \n is a macro that "Interpolates number register x" (where x + is the character following the \n sequence), thus the man page currently + prints 0 instead of \n" in several lines, leading to output such as: + + printf("The _NET_WM_NAME atom has ID %u0, reply-⁠>atom); + + It needs to be escaped here, as \\n, as is done in other examples in + this man page already. + + https://bugs.freedesktop.org/show_bug.cgi?id=90231 + + Reported-by: Stefan Merettig + Signed-off-by: Alan Coopersmith + +commit a90be9955d2c5a635f791d44db1154633b9d3322 +Author: Ran Benita +Date: Sun Oct 12 21:58:20 2014 +0300 + + c_client.py: make condition easier to follow in _c_complex() + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit f9f925107e37e0c9a0ed8220ee3a23f584e3b2ec +Author: Ran Benita +Date: Sun Oct 12 21:58:14 2014 +0300 + + c_client.py: don't add /* */ before references to 'S' + + The name can be understood from the type of S already. + + For examples, look for 'S->' in xkb.c or xinput.c. + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + Reviewed-by: Rémi Cardona + +commit 17f9bda6c291a8b9ccc98b22c241b64880b80621 +Author: Ran Benita +Date: Sun Oct 12 21:58:19 2014 +0300 + + c_client.py: remove duplicated `cookie_type` argument for requests + + It is implied already inside the function by the `void` argument. + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit c65005e9d0ce60524d2e883c13c027a5f1f7914c +Author: Ran Benita +Date: Sun Oct 12 21:58:18 2014 +0300 + + c_client.py: spell out keyword arguments in c_request() for clarity + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 6872e925828e615e2c1d4a0bbcc6be6a32fa4e7a +Author: Ran Benita +Date: Sun Oct 12 21:58:17 2014 +0300 + + c_client.py: simplify _c_reply_has_fds() + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 8bf8b62316a3066b61243d797d22c2100fd173f5 +Author: Ran Benita +Date: Sun Oct 12 21:58:16 2014 +0300 + + c_client.py: remove commented debug statements + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit ec435aebd6ed0523de2d341e6aff5ae66f230b10 +Author: Ran Benita +Date: Sun Oct 12 21:58:15 2014 +0300 + + c_client.py: use C99 initializers instead of comments + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 89498d1d450d0e6e476f6b24908ecae857863386 +Author: Ran Benita +Date: Sun Oct 12 21:58:11 2014 +0300 + + c_client.py: remove end-of-function comments + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 2871d4b1b8736044ba50df2f7dacfcc65d820fa9 +Author: Ran Benita +Date: Sun Oct 12 21:58:10 2014 +0300 + + c_client.py: no need to compare bools to True/False + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 30976e5255a25117d17d4d8162e29b84913953cd +Author: Ran Benita +Date: Sun Oct 12 21:58:09 2014 +0300 + + c_client.py: use "foo".join() instead of reduce + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 0ab52cbcc630ff8ddfa6f6b245c6b3071867b291 +Author: Ran Benita +Date: Sun Oct 12 21:58:08 2014 +0300 + + c_client.py: fix indentation + + (Also remove unnecessary parens around the condition). + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 80341d5df3e30e2cfc3066d05256af9e513e4500 +Author: Ran Benita +Date: Sun Oct 12 21:58:07 2014 +0300 + + c_client.py: use comprehensions instead of map/filter + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 86ea6645d9e388112670cf88da1fe3b350953789 +Author: Ran Benita +Date: Sun Oct 12 21:58:06 2014 +0300 + + c_client.py: use print as a function for python3 compatibility + + This works for all python>=2.6, which is what configure requires. + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 70d32ce7d8ef3ce9490d9a51b189829c8bcdb5c4 +Author: Ran Benita +Date: Sun Oct 12 21:58:05 2014 +0300 + + c_client.py: fix pyflakes errors + + c_client.py:2: 'from xml.etree.cElementTree import *' used; unable to detect undefined names + c_client.py:3: 'basename' imported but unused + c_client.py:9: 'time' imported but unused + c_client.py:1437: local variable 'list_obj' is assigned to but never used + c_client.py:1745: local variable 'varfield' is assigned to but never used + c_client.py:2050: local variable 'length' is assigned to but never used + c_client.py:2416: local variable 'R_obj' is assigned to but never used + c_client.py:2441: local variable 'S_obj' is assigned to but never used + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 12d23b934f189607ad77667834205dfcf89a41f0 +Author: Ran Benita +Date: Sun Oct 12 21:58:04 2014 +0300 + + c_client.py: simplify maximum expression + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit 1b37d6ad3a37a9d0201e3b2caee6cd53b7b4b3dc +Author: Ran Benita +Date: Sun Oct 12 21:58:03 2014 +0300 + + c_client.py: remove unneeded call to get_serialize_params() + + The results are not used, and the function doesn't have side effects. + + Signed-off-by: Ran Benita + Reviewed-by: Christian Linhart + +commit e3ec1f74637237ce500dfd0ca59f2e422da4e019 +Author: Jaya Tiwari +Date: Thu Jan 22 12:16:33 2015 -0500 + + Adding accessors for requests + + Added accessor functions for requests the same way they were added for + structs,events and replies. + Lists for replies have accessor functions now. + + Signed-off-by: Jaya Tiwari + Reviewed-by: Christian Linhart + + Comment from the Reviewer Christian Linhart: + I have tested your patch after fixing the issues with the patch-format. + It looks good: + * only adds new functions, and does not modify existing functions. + Therefore it is API and ABI compatible. + + * adds accessors for varsized-stuff in requests. + This is needed for server-side XCB and may be useful for implementing X11-protocol proxies. + +commit 5353c0216e091b64d01a43e6580e6d69b2ac16c7 +Merge: bbca7b8 c6f3fb2 +Author: Christian Linhart +Date: Tue Feb 10 10:13:04 2015 +0100 + + Merge http://git.demorecorder.com/git/free-sw/xcb/libxcb + branch 'ParametrizedStruct-V7' + +commit c6f3fb2529a6211221e8254f58c85fd67c1d8844 +Author: Christian Linhart +Date: Mon Nov 3 09:57:59 2014 +0100 + + generator: support parametrized structs + + Parametrized structs contain paramref expressions which + refer to the value of a field defined in the context + where the struct is used. + + Implementing the parametrized structs turned out + to be somewhat easier than previously thought + because the generator already had some support for type-parametrization + because this is needed when case or bitcase refers to fields outside + of the switch. + + So I decided to go with the flow and to implement the solution + which best fits the current implementation. + + I did the following: + * I provided a way to specify fieldref with an explicitely given type: + This resulted in . + That can be added later, if needed. + ( Wont be too complicated ) + + * So this is pretty much like the proposal from Ran Benita. + + changes for V2 of this patch, according to suggestions from Ran Benita: + * replace map with list comprehension + because map returns an iterator instead of a list from Python 3 on, + so it cannot be added to a list anymore. + + * removed "self" parameter of function additional_params_to_str + and accessed the variable additional_params from the outer + function directly. + + changes for V2 of this patch: + * adapt to revision 2 of patchset ListInputDevices + * style fixes for similar things that Ran Benita has found in my previous patches + + Message-ID: <54574397.4060000@DemoRecorder.com> + Patch-Thread-Subject: [Xcb] parametrized structs implemented + Patch-Set: ParametrizedStruct + Patch-Number: libxcb 1/1 + Patch-Version: V3 + Signed-off-by: Christian Linhart + +commit 912cd97a6dd019e9e7ecf09c82c4577dd2ad7529 +Author: Christian Linhart +Date: Mon Nov 3 09:58:08 2014 +0100 + + generator: support listelement-ref + + Support for listelement-ref needs the following three changes + (in the order as they appear in the patch): + + * making the current list-element accessible with the variable + xcb_listelement which is a pointer to the list-element + + * supporting lists of simple-type for sumof with a nested expression + + * using the variable for resolving a listelement-ref expression + + Changes for V2 of this patch: + - adapt to removal of patch "libxcb 2/6" from patchset "ListInputDevices". + + Changes for V3 of this patch: + - adapt to V2 of patch "libxcb 5/6" from patchset "ListInputDevices" + + Changes for V4 of this patch: + - adapt to revision 2 of the patchset "ListInputDevices" + + Message-ID: <545743A0.50907@DemoRecorder.com> + Patch-Thread-Subject: [Xcb] support popcount of a list and associated xml changes + Patch-Set: PopcountList + Patch-Number: libxcb 4/4 + Patch-Version: V4 + Signed-off-by: Christian Linhart + +commit 422458b66380e4103c4937f0e2e8bb93e31f273a +Author: Christian Linhart +Date: Thu Sep 4 17:50:50 2014 +0200 + + generator: _c_accessor_get_length: remove buggy special case + + The function _c_accessor_get_length had a special case handling + for intermixed var and fixed size fields. + + However: + * The implementation of that special case was buggy: + It tried to call a python-dict as a function which causes + Python to abort the program with a stacktrace and error message. + So this code was never used. + + * The case it tried to handle is handeled elsewhere in the + meantime: in _c_helper_absolute_name by previous patches + made by me. + + Message-ID: <1409845851-38950-3-git-send-email-chris@demorecorder.com> + Patch-Thread-Subject: [Xcb] support popcount of a list and associated xml changes + Patch-Set: PopcountList + Patch-Number: libxcb 3/4 + Patch-Version: V1 + Signed-off-by: Christian Linhart + +commit b1e4a3bbd8194d12d7fcd9705fcbbe0deb59bcba +Author: Christian Linhart +Date: Thu Sep 4 17:50:49 2014 +0200 + + generator: generate accessors for events, too + + Accessors are generally needed for var-sized fields + and fields after var-sized fields. + + Generic events can have ver-sized fields. + Therefore they need accessors. + + Message-ID: <1409845851-38950-2-git-send-email-chris@demorecorder.com> + Patch-Thread-Subject: [Xcb] support popcount of a list and associated xml changes + Patch-Set: PopcountList + Patch-Number: libxcb 2/4 + Patch-Version: V1 + Signed-off-by: Christian Linhart + +commit 6234225b4be862c5882bf547d066c5a3885906dd +Author: Christian Linhart +Date: Thu Sep 4 17:50:48 2014 +0200 + + generator: no type-setup for eventcopies anymore + + _c_type_setup is not called for eventcopies anymore: + Reasons: + * the type-setup of an eventcopy would overwrite members of the original + event object such as c_type, ... + * it is needed for the next patch, i.e., generating accessors: + type_setup would create sizeof-etc funtions which called + undefined accessor functions. + + Sizeof-functions are generated for compatibility: + Reason: + * Type-setup of eventcopies has previously generated + sizeof-functions for eventcopies. + So, we still need to generate these functions. + These new sizeof-functions simply call the sizeof-function + of the defining event of the eventcopy. + + Message-ID: <1409845851-38950-1-git-send-email-chris@demorecorder.com> + Patch-Thread-Subject: [Xcb] support popcount of a list and associated xml changes + Patch-Set: PopcountList + Patch-Number: libxcb 1/4 + Patch-Version: V1 + Signed-off-by: Christian Linhart + +commit 18ff453edd42712ea4d1e7218bbe8829f9f4caba +Author: Christian Linhart +Date: Sun Nov 2 13:46:58 2014 +0100 + + _c_helper_fieldaccess_expr: remove handling for empty sep + + The loop-variable "sep" is never empty in function + "_c_helper_fieldaccess_expr", after a fix elsewhere. + Therefore I removed the handling of the case of "sep" being empty. + + Thanks to Ran Benita for the hint that this can be removed. + + Signed-off-by: Christian Linhart + Reviewed-by: Ran Benita + + Message-ID: <545627C2.3050608@DemoRecorder.com> + Patch-Thread-Subject: [Xcb] [PATCHSET] ListInputDevices revision 2 + Patch-Set: ListInputDevices + Patch-Number: libxcb 9/9 + Patch-Version: V1 + +commit d905b886185fd8e0d9d7f70e0d112cb58ab86f98 +Author: Christian Linhart +Date: Sun Nov 2 13:46:50 2014 +0100 + + function _c_helper_fieldaccess_expr: improve description + + Signed-off-by: Christian Linhart + Reviewed-by: Ran Benita + + Message-ID: <545627BA.1000909@DemoRecorder.com> + Patch-Thread-Subject: [Xcb] [PATCHSET] ListInputDevices revision 2 + Patch-Set: ListInputDevices + Patch-Number: libxcb 8/9 + Patch-Version: V1 + +commit 17f6e04493c93014beaf3a704c8cc4d050cb13bf +Author: Christian Linhart +Date: Sun Nov 2 13:46:38 2014 +0100 + + rename _c_helper_absolute_name to _c_helper_fieldaccess_expr + + The function _c_helper_absolute_name was named in + a misleading way. + It computes a C-expression for accessing a field of an xcb-type. + + Therefore the name _c_helper_fieldaccess_expr is more appropriate. + + Note: Patch 6 of this series has been removed during the review process. + + Signed-off-by: Christian Linhart + Reviewed-by: Ran Benita + + Message-ID: <545627AE.2040200@DemoRecorder.com> + Patch-Thread-Subject: [Xcb] [PATCHSET] ListInputDevices revision 2 + Patch-Set: ListInputDevices + Patch-Number: libxcb 7/9 + Patch-Version: V1 + +commit 51a0d57acc6ec0c9487d2dbc2dda806f05c49884 +Author: Christian Linhart +Date: Sun Nov 2 13:46:16 2014 +0100 + + generator: sumof with nested expression + + Support sumof with a nested expression. + The nested expression is computed for every list-element + and the result of the computation is added to the sum. + + This way, sumof can be applied to a list of structs, + and, e.g., compute the sum of a specific field of that struct. + + example: + + + + + + + + + len + + + + bar + + + + + generated tmpvar: + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const xcb_input_sumof_test_element_t* xcb_pre_tmp_4; /* sumof list ptr */ + + generated code: + /* mylist2 */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_sumof_test_field_access_mylist_1(_aux); + for ( xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += xcb_pre_tmp_4->bar; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(uint16_t); + + changes for V2 of this patch: + * explicitely set the member access operator in the prefix-tuple + passed to function _c_helper_field_mapping. + This enables us to simplify function "_c_helper_absolute_name" + (which will be renamed "_c_helper_fieldaccess_expr" soon) + + V3: Changed style and formatting according to suggestions from Ran Benita + + Signed-off-by: Christian Linhart + Reviewed-by: Ran Benita + + Message-ID: <54562798.8040500@DemoRecorder.com> + Patch-Thread-Subject: [Xcb] [PATCHSET] ListInputDevices revision 2 + Patch-Set: ListInputDevices + Patch-Number: libxcb 5/9 + Patch-Version: V3 + +commit 4a915c0dbadf326ea61349e29a0029d29f4bd339 +Author: Christian Linhart +Date: Sun Nov 2 13:45:40 2014 +0100 + + generator: sumof: support any type, generate explicit code + + A sumof-expression now generates explicit code ( for-loop etc ) + instead of calling xcb_sumof. + + This way, it supports any type which can be added. + Previously, only uint_8 was supported. + + Here's an example and the generated code: + + xml: + + + + len + + + + + + + declaration of tempvars at the start of enclosing function: + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint16_t* xcb_pre_tmp_4; /* sumof list ptr */ + + code: + /* mylist2 */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_sumof_test_mylist_1(_aux); + for ( xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += *xcb_pre_tmp_4; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(uint8_t); + + This patch is also a preparation for sumof which can access + fields of lists of struct, etc. + + V2: Changed style and formatting according to suggestions from Ran Benita + + Signed-off-by: Christian Linhart + Reviewed-by: Ran Benita + + Message-ID: <54562774.8030306@DemoRecorder.com> + Patch-Thread-Subject: [Xcb] [PATCHSET] ListInputDevices revision 2 + Patch-Set: ListInputDevices + Patch-Number: libxcb 4/9 + Patch-Version: V2 + +commit fda1fb4ed47a705744677a0074d83464af7aa4eb +Author: Christian Linhart +Date: Sun Nov 2 13:45:29 2014 +0100 + + generator: expressions can generate pre-code + + This patch provides a mechanism for generating + preparatory code for expressions. + + This is e.g. necessary when an expression needs computations + which cannot be done in a C-Expression, like for-loops. + + This will be used for sumof expressions but may be useful + elsewhere. + + Note: Patch 2 of this series has been removed during the review process. + + V2: adapt to changes in previous patches + + V3: some style and formatting changes according to suggestions from Ran Benita. + + Signed-off-by: Christian Linhart + Reviewed-by: Ran Benita + + Message-ID: <54562769.3090405@DemoRecorder.com> + Patch-Thread-Subject: [Xcb] [PATCHSET] ListInputDevices revision 2 + Patch-Set: ListInputDevices + Patch-Number: libxcb 3/9 + Patch-Version: V3 + +commit 265d38882cffce597367cc8bb2160b9e2482a80f +Author: Christian Linhart +Date: Sun Nov 2 13:45:12 2014 +0100 + + generator: fix absname for fields with only accessor function + + Fix _c_helper_absolute_name for fields which cannot be accessed + as a struct/union member but which can be accessed by an + accessor function. + + The fix generates calls to the accessor function in these cases. + + Example: + + + + len + + + + + + + The sumof-expression ( ) refers to mylist1 + which is only acessible by an accessor function. + + Previously, sumof was only used inside bitcases, + where such lists are accessible by members of the + deserialized parent struct. + (there is a difference between deserialization of switches + and structs.) + + V2 of this patch: + * replaced "!= None" with "is not None" because that's more pythonic. + (according to suggestion from Ran Benita) + + V3 of this patch: simplification: + * fixed the recursion in _c_type_setup + so that _c_helper_absolute_name does not need check + a gazillion things as a workaround anymore. + + * simplified _c_helper_absolute_name + - remove unneeded check for empty string before + append of last_sep to prefix_str + + - removed those if-conditions which are not + needed anymore after fixing the recursion + in _c_type_setup. + + - extract functionality for checking whether a field + needs an accessor ( and which type of accessor ) + in functions. + (also extracted from _c_accessors) + + - rearrange the condition branches and actions for + more readability. + + V3 generates exactly the same *.c and *.h files as V2. + + V4 of this patch: + * improve formatting as per suggestions of Ran + + Signed-off-by: Christian Linhart + Reviewed-by: Ran Benita + + Message-ID: <54562758.5090107@DemoRecorder.com> + Patch-Thread-Subject: [Xcb] [PATCHSET] ListInputDevices revision 2 + Patch-Set: ListInputDevices + Patch-Number: libxcb 1/9 + Patch-Version: V4 + +commit bbca7b82f803fa13fd30a2891ec06f2a213a28c2 +Merge: 382d306 fdb291b +Author: Peter Harris +Date: Thu Oct 30 11:51:57 2014 -0400 + + Merge branch 'NestedStructTypenames-V5' of http://infra-srv1.demorecorder.com/git/free-sw/xcb/libxcb + +commit fdb291b414a7afc2c2326124b8ca11d6846cd7b9 +Author: Christian Linhart +Date: Wed Sep 3 10:10:49 2014 +0200 + + no typename for nested structs + + Nested structs which are generated for named case and bitcase + do not get a typename anymore, i.e., they are anonymous structs. + + Reasons for this change: + * Prior typenames have caused nameclashes + * Prior typenames introduced names in the global namespace which + did not start with the xcb prefix. + + This change is safe with respect to API compatibility because: + I have searched for instances of named bitcases and there's only one place + where they are used, and that's in xkb.xml: reply GetKbdByName. + ( no need to search for because it was introduced after the last release ) + + The reply GetKbdByName is broken in its current form in the xkb.xml anyways, + so it is most probably not used anywhere. + + So, my conclusion is that we can safely omit named types for nested structs. + No need for an attribute. + + Message-ID: <1409731849-51897-1-git-send-email-chris@demorecorder.com> + Patch-Thread-Subject: Re: [Xcb] names of nested structs of named bitcase/case are prone to nameclashes. Solution? + Patch-Set: NestedStructTypenames + Patch-Number: libxcb 1/1 + Patch-Version: V1 + Signed-off-by: Christian Linhart + Reviewed-By: Ran Benita + +commit a7c75be5b1e2da32f7ce2c255972178e7d4b7598 +Author: Christian Linhart +Date: Tue Sep 9 23:26:40 2014 +0200 + + generator: fix align-pads for switches which start at unaligned pos + + Fix the alignment computation inside switches which start at + an unaligned pos. + This affects both explicit and implicit align pads. + + The alignment offset is derived from the lowest 3 bits of + the pointer to the protocol-data at the start of the switch. + This is sufficient for correcting all alignments up to 8-byte alignment. + As far as I know there is no bigger alignment than 8-byte for the + X-protocol. + + Example: + struct InputState, where the switch starts after two 1-byte fields, + which is a 2 byte offset for 4-byte and 8-byte alignment. + + The previous problem can be demonstrated when adding a + at the end of case "key". + + (Or when finding a testcase which reports the case "valuator" not + at the last position of the QueryDeviceState-reply. + I didn't find such a testcase, so I have used the pad align + as described above.) + + V2: patch modified in order to fix bugs which I found when working on the + next issue: + * xcb_padding_offset has to be set 0 when xcb_block_len is set 0 + * xcb_padding_offset cannot be "const" therefore + * for unpack and unserialize, the padding_offset must computed + from _buffer instead of from the aux_var. + + V3: patch revised according to suggestion by Ran Benita: + * only create and use xcb_padding_offset for switch + + Message-ID: <1410298000-24734-1-git-send-email-chris@demorecorder.com> + Patch-Thread-Subject: [Xcb] xinput:QueryDeviceState: full-support: generator and xml-changes + Patch-Set: QueryDeviceState + Patch-Number: libxcb 4/4 + Patch-Version: V3 + Signed-off-by: Christian Linhart + Reviewed-By: Ran Benita + +commit 277ea629def6728c9d826ff88e95b31c3e25915f +Author: Christian Linhart +Date: Thu Aug 21 22:35:55 2014 +0200 + + generator: support lists of structs which contain a switch + + This essentially requires to have a correct sizeof-function + for the struct. + This in turn requires a sizeof-function for the switch, too. + + Making a sizeof-function for the switch is triggered by + replacing "elif" by "if" in the first change of this patch. + This way, c_need_sizeof is also set to True for switches if appropriate. + + The _c_serialize_helper_switch_field function has to support + the context "sizeof": + This is done in the second change of this patch + + The third change of this patch fixes an alignment error: + It does not make sense to base the padding on the struct-type + which is generated for switch because this struct does not + represent the protocol. Rather it is the output of deserialization. + ( The implicit padding for var-sized fields has other issues, IMHO, + but I am not touching these now...) + + The effect on the generated code for the current xml-files + is as follows: + * several additional sizeof-functions are generated + * the fix of the alignment error only changes one place + in the XKB-extension for the GetKbdByName-reply. + This is no problem because that reply in its current form + is broken/unfinished anyways. + + Note: + This patch also fixes a problem in the generator when + a fixed-size list is the last field of a case or bitcase. + + Message-ID: <1408653356-21191-2-git-send-email-chris@demorecorder.com> + Patch-Thread-Subject: [Xcb] xinput:QueryDeviceState: full-support: generator and xml-changes + Patch-Set: QueryDeviceState + Patch-Number: libxcb 2/3 + Patch-Version: V1 + Signed-off-by: Christian Linhart + Reviewed-By: Ran Benita + +commit 382d306d6c44a9ece5551c210a932773b5cb94a5 +Author: Emil Velikov +Date: Fri Sep 5 01:46:40 2014 +0100 + + Move internal/private dependencies to Requires.private + + Program using the xcb sub-modules has indirect compile and runtime + dependency of core xcb. To ensure this out we currently list xcb in + the Requires field of the pkg-config files. While this provides all + the required dependencies for successful compilation this causes + over-linking and hides potential linking miss-use against the xcb modules. + + By moving to Requires.private we retain the compilation and runtime + compatibility and avoids any runtime problems. + + Cc: Keith Packard + Cc: Alan Coopersmith + References: http://people.freedesktop.org/~dbn/pkg-config-guide.html#faq + References: https://wiki.mageia.org/en/Overlinking_issues_in_packaging + References: http://err.no/personal/blog/2008/Mar/25 + Signed-off-by: Emil Velikov + Reviewed-by: Julien Cristau + Signed-off-by: Uli Schlachter + +commit d74d066949dbbbbbcb03bf7764e63f4347f99974 +Author: Christian Linhart +Date: Sat Sep 6 20:06:15 2014 +0200 + + generator: support fixed size lists in var-sized structs + + V2: patch revised according to suggestions from Ran Benita: + * removed blanks before an after parentheses of function-calls or tuples + * replaced if by elif in "if field.type.is_list". ( this fixes old code ) + + Message-ID: <540B4D17.1080908@DemoRecorder.com> + Patch-Thread-Subject: [Xcb] xinput:QueryDeviceState: full-support: generator and xml-changes + Patch-Set: QueryDeviceState + Patch-Number: libxcb 1/3 + Patch-Version: V2 + Signed-off-by: Christian Linhart + Reviewed-By: Ran Benita + +commit b0e6c2de09c7474868dd7185674fa113a5c2e0aa +Author: Uli Schlachter +Date: Mon Aug 18 10:38:48 2014 +0200 + + xcb_get_setup(): Never return NULL + + The documentation doesn't mention it and it's unlikely that a lot of code out + there handles this case correctly. So, instead of returning NULL, let + xcb_get_setup() return a pointer to a static, invalid, all-zero setup + information structure. + + Signed-off-by: Uli Schlachter + +commit c4e40f646b8da4fd112ea54a612c880be5e942a8 +Author: Uli Schlachter +Date: Mon Aug 18 10:38:41 2014 +0200 + + Make some functions also work on error connections + + There is no technical reason why xcb_get_setup() and xcb_get_file_descriptor() + shouldn't work on non-static error connections. They cannot be used for many + useful things, but at least they work. + + This works around bugs in lots of programs out there which assume that + xcb_get_setup() does not return NULL and which just happily dereference the + results. Since xcb_connect() never returns NULL, it's a bit weird that + xcb_get_setup() can do so. xcb_get_file_descriptor() is just modified since this + can be done here equally easily and because the fd isn't closed until the final + xcb_disconnect() on the error connection. + + Non-static error connections are connections which entered an error state after + xcb_connect() succeeded. If something goes wrong in establishing a connection, + xcb_connect() will return a static error connection which doesn't have the + fields used here. + + Signed-off-by: Uli Schlachter + +commit 355d4d6ab9f5c12c2ee4a91e8cf6eb4a2854d73c +Author: Christian Linhart +Date: Tue Aug 19 15:57:34 2014 +0200 + + support switch case in the generator + + The implementation is rather simple: + When a is used instead of a + then operator "==" is used instead of "&" in the if-condition. + + So it creates a series of "if" statements + (instead of a switch-case statement in C ) + + In practice this does not matter because a good + optimizing compiler will create the same code + as for a switch-case. + + With this simple implementation we get additional + flexibility in the following forms: + * a case value may appear in multiple case branches. + for example: + case C1 will be selected by values 1, 4, or 5 + case C2 will be selected by values 3, 4, or 7 + + * mixing of bitcase and case is possible + (this will usually make no sense but there may + be protocol specs where this is needed) + + details of the impl: + * replaced "is_bitcase" with "is_case_or_bitcase" in all places + so that cases are treated like bitcases. + + * In function "_c_serialize_helper_switch": write operator "==" + instead of operator "&" if it is a case. + +commit 966fba6ba4838949d0727dfa45eeb9392d1f85d9 +Author: Daniel Martin +Date: Tue Jul 29 22:48:44 2014 +0200 + + Disable Xevie and Xprint by default + + Both extensions have been dropped from the X-Server in 2008: + http://cgit.freedesktop.org/xorg/xserver/commit/?id=1c8bd31 + http://cgit.freedesktop.org/xorg/xserver/commit/?id=f4036f6 + + Don't build them by default. + + Reviewed-by: Julien Cristau + Signed-off-by: Daniel Martin + Signed-off-by: Uli Schlachter + +commit a5e90ae6a1543a681d95b831dc5c44e9c6e78610 +Author: Gaetan Nadon +Date: Wed Mar 26 15:40:57 2014 -0400 + + help text: do not report the insanly long list of Warning flags. + + Originally there was just one. Now that XCB has been integrated with X and + uses the same compiler flags, it is a different story. + + Used CFLAGS: + CPPFLAGS............: + CFLAGS..............: -g -O2 + Warning CFLAGS......: -Wall -Wpointer-arith AND SO ON FOR 8 lines... + + It completely defaces the otherwise excellent output. + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + Signed-off-by: Uli Schlachter + +commit 529e3bfc2088dcd35e68a0a8394d0e9bff7c978b +Author: Gaetan Nadon +Date: Wed Mar 26 15:40:56 2014 -0400 + + Add ChangeLog and INSTALL using xorg macros + + Same as all other X modules. The one in libxcb git is removed. + + Those files are created during 'make dist' + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + Signed-off-by: Uli Schlachter + +commit 74f552c1b39eb6a1ab64451477a492a2b22d9d7a +Author: Gaetan Nadon +Date: Wed Mar 26 15:24:46 2014 -0400 + + sendmsg: remove --enable-sendfds as it is superceeded by --enable-dri3 + + DRI3 requires sendmsg support which is auto-detected. A builder can enable + or disable dri3 feature. If sendmsg function is not available, dri3 cannot + be enabled. + + This reverts af8067cbf4856 which was done at a time where --enable-dri3 + had not been added yet. + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + Signed-off-by: Uli Schlachter + +commit 23f57ac8bf0812bbc851ec9a815e50a640b97db5 +Author: Gaetan Nadon +Date: Wed Mar 26 15:24:45 2014 -0400 + + config: issue an error if DRI3 is requested, but sendfds is not available + + When a user issues the --enable-dri3 option and sendfds is not available + on the system, the configuration will abort with an error message. + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + Signed-off-by: Uli Schlachter + +commit 7f07b57be587a2ebe0cadceba3fe67ed4a1e79db +Author: Gaetan Nadon +Date: Wed Mar 26 15:24:44 2014 -0400 + + config: default option for enable-dri3 is not implemented + + The first symptom is the help text: + + --enable-dri3 Build XCB DRI3 Extension (default: "$sendfds") + + The implementation variable $sendfds leaked into the user interface. + Testing the various user inputs: + DRI3 is enabled PASS + --enable-dri3 DRI3 is enabled PASS + --enable-dri3=yes DRI3 is enabled PASS + --enable-dri3=no DRI3 is disabled PASS + --disable-dri3 DRI3 is disabled PASS + --enable-dri3=$sendfds DRI3 is disabled FAIL + + This patch implements the usual idiom for features that are enabled by + default if the various conditions are met (sendfds is available). + New help text: + + --enable-dri3 Build XCB DRI3 Extension (default: auto) + + With the additional user input: + + --enable-dri3=auto + + which is equivalent to providing no input at all. + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + Signed-off-by: Uli Schlachter + +commit d1e8ec96fca4862f37ec9f0e9407bb989c4c161a +Author: Uli Schlachter +Date: Fri Aug 1 15:56:52 2014 +0200 + + Release libxcb 1.11 + +commit c5c6cfa4d2a27d0f9e139a1856d866433b6046bc +Author: Uli Schlachter +Date: Fri Aug 1 16:03:24 2014 +0200 + + Bump xcb-proto requirement to 1.11 + + This is needed for the new direct_imports field that we need from xcb-proto. + + Signed-off-by: Uli Schlachter + +commit 70ea5da64b34336bb0916f6c325545cb50746159 +Author: Alexander Mezin +Date: Sun Jun 29 17:33:48 2014 +0700 + + xcb.h: add 'struct' before xcb_setup_t, xcb_query_extension_reply_t + + These structs are typedef'ed in xproto.h, so in xcb.h these types + (without 'struct') are actually undefined. + + GCC reports this as error when building precompiled header. + + Signed-off-by: Alexander Mezin + Reviewed-by: Peter Harris + +commit 7e6af51b4e984f661fe4f21596cab5cb8ee15ea0 +Author: Ran Benita +Date: Tue Feb 25 14:11:35 2014 +0200 + + c_client.py: remove more trailing space from generated files + + Signed-off-by: Ran Benita + Reviewed-by: Josh Triplett + Reviewed-by: Daniel Martin + +commit 8221d249b77131b338e3b35ce2229193f129e514 +Author: Ran Benita +Date: Sun Feb 23 22:55:21 2014 +0200 + + c_client.py: remove trailing whitespace from generated files + + Signed-off-by: Ran Benita + Reviewed-by: Daniel Martin + +commit e3c728ee3d9a2fd7478d5f57830c3483b774a16e +Author: Ran Benita +Date: Sun Feb 23 22:55:20 2014 +0200 + + c_client.py: remove useless generated comments + + They are bloated, don't add anything over the signature, in some cases + duplicate the doxygen comments, and are not integrated with the + tags in any way. Remove them and cut the generated LOC by half. + + Signed-off-by: Ran Benita + Reviewed-by: Daniel Martin + +commit cae2e398563841c5b814596fd1f1c64354dcac71 +Author: Ran Benita +Date: Sun Feb 23 22:55:19 2014 +0200 + + c_client.py: make the man page output deterministic + + Some parts of the man pages (SEE ALSO and ERRORS) are generated by + iterating a Python dict. But the iteration order in a dict is random, + so each build the output is ordered differently. Avoid that by iterating + in sorted order. + + Signed-off-by: Ran Benita + Reviewed-by: Daniel Martin + +commit bfbf83b1d8113ac398b57c2738706792946d1c03 +Author: Ran Benita +Date: Sun Feb 23 22:55:18 2014 +0200 + + c_client.py: prefix all monkey-patched fields with c_ + + The script adds many fields to the objects coming from xcbgen. To + distinguish them, a c_ prefix is used, but for some it was missing. + + Signed-off-by: Ran Benita + Reviewed-by: Daniel Martin + +commit 285d566a5c11c6edd3665beb42312e24bde77d16 +Author: Ran Benita +Date: Sun Feb 23 22:55:17 2014 +0200 + + c_client.py: remove trailing whitespace + + These are extra annoying in python code. + + Signed-off-by: Ran Benita + Reviewed-by: Daniel Martin + +commit 285838cfe41c212a2453d903497757d2392fd0ce +Author: Ran Benita +Date: Sun Feb 23 22:55:16 2014 +0200 + + c_client.py: remove useless 'today' variable + + Signed-off-by: Ran Benita + Reviewed-by: Daniel Martin + +commit 49a61c8b459ab19c7f39e653bbb0d0339ea8f00f +Author: Alan Coopersmith +Date: Fri Jul 11 20:41:15 2014 -0700 + + Fix typos & awkward wording in tutorial + + Signed-off-by: Alan Coopersmith + +commit 125135452a554e89e49448e2c1ee6658324e1095 +Author: Michael Haubenwallner +Date: Fri Jun 13 16:18:34 2014 +0200 + + bug#79986: include system headers early + + AIX does redefine 'events' to 'reqevents' eventually. + To not have this cause compilation errors, need to include the local + header files after any system header file. + + Reviewed-by: Alan Coopersmith + Signed-off-by: Alan Coopersmith + +commit bc5a1047548b578624cfbc44ca192cde7664ed78 +Author: Alan Coopersmith +Date: Fri Jun 13 21:26:21 2014 -0700 + + Document failure modes of xcb_connect*() functions + + Documentation was previously unclear that these always return a non-NULL + pointer, and that callers need to check it for error values, instead of + checking for a NULL return value. + + Triggered by having to dig through code to answer a user's question on + the #xcb irc channel, since neither of us found it covered in the docs. + + Signed-off-by: Alan Coopersmith + Reviewed-by: Uli Schlachter + +commit 72e45969ff71204cee2dde3502841736cfd41c8a +Author: Daniel Martin +Date: Mon Jun 9 17:55:04 2014 +0200 + + Handle between lists + + Without this patch we end up with invalid C code if we've a + between two variadic lists. Check for such a condition + and take the alignment pad into account. + + Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=79808 + + Signed-off-by: Daniel Martin + Signed-off-by: Peter Harris + +commit d978a4f69b30b630f28d07f1003cf290284d24d8 +Author: Jeremy Huddleston Sequoia +Date: Sat Apr 5 20:54:59 2014 -0700 + + xcb_open: Improve abstraction for launchd secure sockets + + This changes away from hard-coding the /tmp/launch-* path to now + supporting a generic [.] format for + $DISPLAY. + + Signed-off-by: Jeremy Huddleston Sequoia + +commit 29e419c5840a1eeda3336a0802686ee723dcaab3 +Author: Jeremy Huddleston Sequoia +Date: Sat Apr 5 21:09:42 2014 -0700 + + xcb_open: Minor code cleanup for better readability + + Signed-off-by: Jeremy Huddleston Sequoia + Reviewed-by: Uli Schlachter + +commit be0fe56c3bcad5124dcc6c47a2fad01acd16f71a +Author: Keith Packard +Date: Mon Dec 23 21:15:20 2013 -0800 + + Ensure xcb owns socket and no other threads are writing before send_request + + send_request may only write to out.queue if no other thread is busy + writing to the network (as that thread may be writing from out.queue). + + send_request may only allocate request sequence numbers if XCB owns + the socket. + + Therefore, send_request must make sure that both conditions are true + when it holds iolock, which can only be done by looping until both + conditions are true without having dropped the lock waiting for the + second condition. + + We choose to get the socket back from Xlib first as get_socket_back + has a complicated test and checking for other threads writing is a + simple in-lined check. + + This also changes the sequence number checks (64k requests with no + reply, 4M request wrapping) to ensure that both conditions are true + before queueing the request. + + Signed-off-by: Keith Packard + Reviewed-by: Uli Schlachter + +commit e2813e1cde893f384fa620ff3c13493beebabe0c +Author: Keith Packard +Date: Wed Feb 12 14:15:46 2014 -0800 + + Update .pc file Requires lines to express full dependencies + + Some xcb libraries depend on others; make these dependencies explicit + in the .pc files that are installed. + + This change was generated automatically by running 'check-pc-requires -fix' + + Signed-off-by: Keith Packard + Signed-off-by: Uli Schlachter + +commit 32de4c4213a49c61127c6957ea05fef3e5355291 +Author: Keith Packard +Date: Wed Feb 12 14:15:45 2014 -0800 + + Validate .pc file Requires lines + + This walks through the .pc.in files and makes sure all of the Requires + lines express sufficient dependency information. + + Signed-off-by: Keith Packard + Signed-off-by: Uli Schlachter + +commit 1f6cd9f1fcd3c07d323b678292c9cb00ae1f7504 +Author: Keith Packard +Date: Wed Feb 12 14:15:44 2014 -0800 + + Only #include directly referenced module header files + + This avoids having the nested header files also included at the top + level, which is more efficient. + + Signed-off-by: Keith Packard + Signed-off-by: Uli Schlachter + +commit cb686b576739deea00180c54697c8b62b8419ae0 +Author: Uli Schlachter +Date: Tue Feb 25 15:50:50 2014 +0100 + + Add doxygen documentation to functions in xcbext.h + + Signed-off-by: Uli Schlachter + Reviewed-by: Josh Triplett + +commit 2fb14e5883f2ea2f01d248674cfcc26ccb704753 +Author: Uli Schlachter +Date: Tue Dec 31 15:18:01 2013 +0100 + + Make xcb_disconnect(NULL) safe + + Code can be simplified if the deallocation functions can always be called in + cleanup code. So if you have some code that does several things that can go + wrong, one of which is xcb_connect(), after this change, the xcb_connection_t* + variable can be initialized to NULL and xcb_disconnect() can always be called on + the connection object. + + References: http://lists.freedesktop.org/archives/xcb/2013-September/008659.html + + Signed-off-by: Uli Schlachter + Reviewed-by: Julien Cristau + +commit 4dcbfd77b78ca6b016ce815af26235501f6cd75a +Author: Uli Schlachter +Date: Tue Dec 31 15:05:36 2013 +0100 + + xcb_disconnect(): Fix leak with error connections + + There are two kind of error connections in XCB. First, if something goes wrong + while the connection is being set up, _xcb_conn_ret_error() is used to return a + static connection in an error state. If something goes wrong later, + _xcb_conn_shutdown() is used to set c->has_error. + + This is important, because the static object that _xcb_conn_ret_error() returns + must not be freed, while the dynamically allocated objects that go through + _xcb_conn_shutdown() must obviously be properly deallocated. + + This used to work correctly, but in 769acff0da8, xcb_disconnect() was made to + ignore all connections in an error state completely. Fix this by only ignoring + the few static error connections that we have. + + This was tested with the following hack: + + xcb_connection_t *c = xcb_connect(NULL, NULL); + close(xcb_get_file_descriptor(c)); + xcb_discard_reply(c, xcb_get_input_focus(c).sequence); + xcb_flush(c); + xcb_disconnect(c); + + Valgrind confirms that xcb has a memory leak before this patch that this patch + indeed fixes. + + Signed-off-by: Uli Schlachter + Reviewed-by: Julien Cristau + +commit d84dd752ef571491b015443fefedca53c7f81282 +Author: Uli Schlachter +Date: Mon Sep 9 13:04:11 2013 +0200 + + Remove tabs and trailing whitespaces + + Signed-off-by: Uli Schlachter + +commit 4ffa6f83b92763eb901c7ddb7c20775e24d507ca +Author: Ran Benita +Date: Sat Jan 18 17:10:53 2014 +0200 + + Add comments about how _xcb_conn_ret_error() works + + If xcb_connect() fails, it doesn't return NULL. Instead, it always + returns an xcb_connection_t*, and the user should check for errors with + the xcb_connection_has_error() function. What this function does is + check if conn->has_error contains a non-zero error code, and returns it. + + If an error did occur, xcb doesn't actually return a full + xcb_connection_t though, it just returns (xcb_connection_t *) + error_code. Since the 'has_error' field is the first, it is still + possible to check conn->has_error. + + That last trick was not immediately obvious to me, so add some guiding + comments. This also ensures no one obliviously rearranges the struct. + + Signed-off-by: Ran Benita + Signed-off-by: Uli Schlachter + +commit d7eb0bdf3b5b11ee9f40ee5e73df8fc0bdfa59f3 +Author: Gaetan Nadon +Date: Tue Jan 7 14:02:21 2014 -0500 + + generated man pages: use xorg footer and no hard coded extension + + The section number is no longer hard-coded + The left footer is now "X Version 11". + The center footer is the package name with the version, "libxcb 1.9" + The three values above are provided through xorg-macros. They are passed-in + to the python c_client code. + + Example of footer (last line, above dotted line) + + [...] + AUTHOR + Generated from xproto.xml. Contact xcb@lists.freedesktop.org for cor‐ + rections and improvements. + + X Version 11 libxcb 1.9 xcb_send_event(3) + + ------------------------------------------------------------------------------ + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit e4061b8f00d301a51d4c9eef4a07f1e87592fe85 +Author: Gaetan Nadon +Date: Tue Jan 7 14:02:16 2014 -0500 + + generated man pages: build without hard coded extension + + The automake MAN primary requires a hard coded extension to build + man pages. Let's avoid that as the extension number may vary by platform. + Take advantage of the fact that the man directory only contains man pages. + Wildcards are not supported by Automake but it happens to work + sufficiently well here. + + Normally xorg build man pages by converting a source .man file to a + target file with the extension number. That would be too many files + in this case. + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit 3cdd524cadc4352ebd9e17b1f73134bec1838b40 +Author: Gaetan Nadon +Date: Tue Jan 7 14:02:05 2014 -0500 + + man: build static man pages using xorg patterns + + The section number is no longer hard-coded, supplied by xorg-macros. + The left footer is now "X Version 11". + The center footer is the package name with the version, "libxcb 1.9" + The man directory is a sibbling to the doc directory. One can build + or clean the man pages without disturbing the library code. + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit c056adcd92daa06f4825d5c85a40e140a3e85b42 +Author: Gaetan Nadon +Date: Thu Jan 9 14:32:18 2014 -0500 + + autoconf: replace all tabs with spaces + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit 412928f113c8a5e5b30c03a294a42b0b1cf5f5d7 +Author: Gaetan Nadon +Date: Tue Jan 7 14:00:44 2014 -0500 + + autoconf: use default xorg configuration for doxygen documentation + + No content or form changes for the xcb manual or tutorial. + Only the configuration user visible bits change. + + Xcb will now have the same configuration options as the 30 other + xorg modules. + + Xorg classifies documentation as "user", "developer" or "specifications". + The xcb manual falls under the "developer" category. Developers docs + are never installed under $prefix. + + A builder can selectively turn on/off any or all of the categories. He can + also selectively turn on/off any of the many tools used to generate + documentation such as doxygen, xmlto, etc... Each tool has an environment + variable defined such as DOXYGEN. + + Other features are available, the user interface and the functionality + is the same on all modules. + + --with-doxygen=FILE is replaced with DOXYGEN env variable + --disable-build-docs is replaced with --disable-devel-docs + + The new interface displayed with ./configure --help: + + --enable-devel-docs Enable building the developer documentation + (default: yes) + --with-doxygen Use doxygen to regenerate documentation (default: + auto) + DOXYGEN Path to doxygen command + DOT Path to the dot graphics utility + + The dot tool checking has been added to util-macros in version 1.18. + + Refer to the table of existing docs in xorg. + XCB will be added for the doxygen generated API manual. + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit 9ba6aa759e937e60b231b209b1293a40ad6c7a8a +Author: Gaetan Nadon +Date: Tue Jan 7 14:00:43 2014 -0500 + + autoconf: fix warning by replacing deprecated AC_HELP_STRING + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit 942eabaae3600e7277aa09a179ef10c9a06de62f +Author: Gaetan Nadon +Date: Tue Jan 7 14:00:42 2014 -0500 + + autoconf: require libtool minimum level 2.2 + + This is the updated minimum level as referenced in: + http://www.x.org/wiki/Building_the_X_Window_System/#index2h3 + + Libtool version 2 has been used for several years now. There should be + no surprises. + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit 517cb0e888eca4030b4bd00c316619db925032ea +Author: Gaetan Nadon +Date: Tue Jan 7 14:00:41 2014 -0500 + + autoconf: comment and layout the initialization section + + No functional changes. Trying to make it clearer. + + Reviewed-by: Alan Coopersmith + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit 0a17b61a8971d3c4600a5c19fa7d753e7196abfb +Author: Gaetan Nadon +Date: Tue Jan 7 14:00:40 2014 -0500 + + autoconf: AC_INIT: add bug url + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit 414b1037c5a9770270022e62aa66fe7a4021a96b +Author: Gaetan Nadon +Date: Tue Jan 7 14:00:39 2014 -0500 + + autoconf: use the warning variables from xorg + + The BASE_CFLAGS variable contains only warnings, just like the XCB + version of CWARNFLAGS. This will result in no changes in the binaries + produced. Xorg was missing -fd for SUNCC so it has been added to util-macros + v 1.18. + + Do not get confused with the xorg deprecated CWARNFLAGS variable which + contains an option that is not a warning, -fno-strict-aliasing. This + option, should it be needed, can be added using the XORG_TESTSET_CFLAG + macro. + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit c4f2c70bc37a592406b7693562c7513f2f99b34d +Author: Gaetan Nadon +Date: Tue Jan 7 14:00:38 2014 -0500 + + autoconf: use XORG_DEFAULT_OPTIONS + + XCB has been part of X.Org for a while now. This patch will harmonize the XCB + configuration, using xorg-macros series of macros. It is already used in the + XCB utils packages and is needed to build xcb-proto. + + The XORG_DEFAULT_OPTIONS already includes the statement for the silent + rules. + + The AC_PROG_CC statement is removed so as not to override AC_PROG_CC_C99 + in XORG_DEFAULT_OPTIONS. The effective change is that xcb now uses c99 as + requested. + + Reviewed-by: Josh Triplett + Signed-off-by: Gaetan Nadon + +commit e7263931aff3e3450dc938ad465a7577f943549f +Author: Peter Harris +Date: Tue Jan 14 14:50:55 2014 -0500 + + Support + + Reviewed-By: Ran Benita + Signed-off-by: Peter Harris + +commit 3b72a2c9d1d656c74c691a45689e1d637f669e3a +Author: Kenneth Graunke +Date: Fri Jan 3 15:08:33 2014 -0800 + + Force XCB event structures with 64-bit extended fields to be packed. + + With the advent of the Present extension, some events (such as + PresentCompleteNotify) now use native 64-bit types on the wire. + + For XGE events, we insert an extra "uint32_t full_sequence" field + immediately after the first 32 bytes of data. Normally, this causes + the subsequent fields to be shifted over by 4 bytes, and the structure + to grow in size by 4 bytes. Everything works fine. + + However, if event contains 64-bit extended fields, this may result in + the compiler adding an extra 4 bytes of padding so that those fields + remain aligned on 64-bit boundaries. This causes the structure to grow + by 8 bytes, not 4. Unfortunately, XCB doesn't realize this, and + always believes that the length only increased by 4. read_packet() + then fails to malloc enough memory to hold the event, and the event + processing code uses the wrong offsets. + + To fix this, mark any event structures containing 64-bit extended + fields with __attribute__((__packed__)). + + v2: Use any(...) instead of True in (...), as suggested by + Daniel Martin. + + v3 (Alan Coopersmith): Fix build with Solaris Studio 12.3 by moving the + attribute to after the structure definition. + + Signed-off-by: Kenneth Graunke + Reviewed-by: Keith Packard [v1] + Reviewed-by: Josh Triplett [v1] + Reviewed-by: Daniel Martin + Signed-off-by: Alan Coopersmith + +commit 010872f611a044ced4e96b18a7514796b2a443df +Author: Uli Schlachter +Date: Sun Dec 22 15:59:24 2013 +0100 + + Release libxcb 1.10 + + Signed-off-by: Uli Schlachter + +commit f653464554469b5767f1c99abced25a76bace047 +Author: Julien Cristau +Date: Sat Dec 14 06:16:37 2013 +0100 + + Add NEWS for 1.10 + + Signed-off-by: Julien Cristau + +commit 9c2a6dc20c64ce93e0acd2fceec6d3cab8fc9134 +Author: Uli Schlachter +Date: Fri Nov 15 22:33:12 2013 +0100 + + Add NEWS entries for releases 1.9.1 to 1.9.3 + + libxcb 1.9.1 was released from a branch and thus its NEWS entries never made it + into the master branch. The other releases didn't update NEWS. + + Signed-off-by: Uli Schlachter + Signed-off-by: Julien Cristau + +commit ea4406a8e0193cad8effe569e7835f8b67894e54 +Author: Julien Cristau +Date: Sat Dec 14 05:54:20 2013 +0100 + + Bump xcb-proto requirement to 1.10 + + Makes sure we generate the new generic event struct. + + Signed-off-by: Julien Cristau + +commit a1299eb2a210b5788a2b827b82a3d825caa1f201 +Author: PHO +Date: Tue Dec 3 12:43:04 2013 +0900 + + Test the value of msg_controllen for platforms whose CMSG_FIRSTHDR() does not test it for us + + As RFC 2292 points out, some platforms (e.g. Darwin 9.8.0) provide + CMSG_FIRSTHDR(msg) which just returns msg.msg_control without first + checking if msg.msg_controllen is non-zero. We need a workaround for + such platforms not to let _xcb_in_read() segfault. + + https://bugs.freedesktop.org/show_bug.cgi?id=72253 + + Signed-off-by: Julien Cristau + +commit b30b11ac49d934541312b03c41d1ab83047a59f4 +Author: Uli Schlachter +Date: Mon Nov 18 20:28:08 2013 +0100 + + Increment the "current" version info for sync, xinput and xkb + + Sync: Due to commit e6a246e50e62cbcba3 "sync: Change value list param of + CreateAlarm and ChangeAlarm into switch", various symbols disappeared, + for example xcb_sync_{change,create}_alarm_sizeof. + + xinput: This extension was updated from version 1.4 to 2.3. This means + that lots of new things are generated. However, this change is + backwards-compatible and thus age gets set to 1. + + xkb: In commit 37d0f55392d6 "xkb: Work around alignment problems in + GetNames and GetMap replies", some padding fields were introduced into + structures for which an _unpack() function is generated. This changed + the size of the struct and caused offsets into this struct to change. + + https://bugs.freedesktop.org/show_bug.cgi?id=71507 + + Signed-off-by: Uli Schlachter + Signed-off-by: Julien Cristau + +commit ce5395eb4611341ba7c243ed524d023a616f73bb +Author: Uli Schlachter +Date: Mon Nov 18 20:30:18 2013 +0100 + + Revert "Remove xcb_ge_event_t from xcb.h" + + This reverts commit f4d5b84800f960831e4fbb3ad9848bbb701020be. + + The version of this struct that the code generator produces breaks the API, + because it gives the fields different (albeit better) names. Thus, we need to + restore the old version of this struct. + + Additionally to the revert, this struct is documented as being deprecated. The + replacement was added to xcb-proto. + + Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=71502 + Signed-off-by: Uli Schlachter + Signed-off-by: Julien Cristau + +commit 18f0afab3f0de68114fe185e89d8b25a8c072a2c +Author: Daniel Martin +Date: Fri Nov 22 23:27:28 2013 +0100 + + c_client.py: Fix _sizeof() functions + + Currently, it is not possible to correctly iterate over the replies of + some requests. For example, the list of XIDeviceInfo returned by + the XIQueryDevice request from xinput2 is read as garbage starting from + the second entry. + + The culprits are the _sizeof() used by the iterators. In the above case: + + int + xcb_input_xi_device_info_sizeof (const void *_buffer /**< */) + { + char *xcb_tmp = (char *)_buffer; + [...] + unsigned int xcb_block_len = 0; + [...] + + xcb_block_len += sizeof(xcb_input_xi_device_info_t); + xcb_tmp += xcb_block_len; + /* name */ + xcb_block_len += (((_aux->name_len + 3) / 4) * 4) * sizeof(char); + xcb_tmp += xcb_block_len; + [...] + } + + The problem here is that `xcb_block_len` is not zero'd right above the + `/* name */` comment, causing `xcb_tmp` to be incremented by + `sizeof(xcb_input_xi_device_info_t)` twice. The returned size is too + large. + + https://bugs.freedesktop.org/show_bug.cgi?id=68387 + + Tested-by: Ran Benita + Reviewed-by: Ran Benita + Reviewed-by: Daniel Martin + Signed-off-by: Ran Benita + Signed-off-by: Julien Cristau + +commit 5d1dbb468bb0f834eaa8adea6daf6729808ca429 +Author: Uli Schlachter +Date: Mon Nov 18 19:49:41 2013 +0100 + + Revert "fix deadlock with xcb_take_socket/return_socket v3" + + This reverts commit 9ae84ad187e2ba440c40f44b8eb21c82c2fdbf12. + + After this patch was merged, there were complaints about it not being a good + idea. Revert this for now until we can agree on this. + + References: http://lists.freedesktop.org/archives/xcb/2013-June/008340.html + Signed-off-by: Uli Schlachter + + Conflicts: + src/xcbint.h + +commit c7c5b710f2cc0782412c9e159986c96b52aa0d02 +Author: Mark Kettenis +Date: Mon Nov 11 23:11:56 2013 +0100 + + Fix alignment issues in FD passing code + + A char array on the stack is not guaranteed to have more than byte alignment. + This means that casting it to a 'struct cmsghdr' and accessing its members + may result in unaligned access. This will generate SIGBUS on struct + alignment architectures like OpenBSD/sparc64. The canonical solution is to + use a union to force proper alignment. + + Signed-off-by: Mark Kettenis + Reviewed-by: Matthieu Herrb + Signed-off-by: Uli Schlachter + +commit e8663a935890ff366f49e356211049dfd0d9756a +Author: Alan Coopersmith +Date: Thu Nov 7 20:23:27 2013 -0800 + + Check if we need to define _XOPEN_SOURCE for struct msghdr.msg_control + + Required to expose the structure members in Solaris headers, since it + was an XPG4/UNIX95 addition to the Solaris ABI. + + Signed-off-by: Alan Coopersmith + +commit af8067cbf48561f1e2d43e153292e68e0376a8f9 +Author: Keith Packard +Date: Thu Nov 7 17:36:01 2013 -0800 + + Add configure option to enable or disable fd passing with sendmsg + + --disable-sendfds or --enable-sendfds + + By default, configure auto-detects based on whether your system + supports sendmsg at all. + + Signed-off-by: Keith Packard + Reviewed-by: Alan Coopersmith + Signed-off-by: Alan Coopersmith + +commit 83f28ef8655acff746eab64eabe2e31f8cf0c892 +Author: Keith Packard +Date: Thu Nov 7 17:28:45 2013 -0800 + + Switch to using the CMSG_* macros for FD passing + + Use these instead of computing the values directly so that it might + work on BSD or other non-Linux systems + + Signed-off-by: Keith Packard + Reviewed-by: Alan Coopersmith + Signed-off-by: Alan Coopersmith + +commit cca607409068ad0948e7283fb8d0465cabc51686 +Author: Keith Packard +Date: Thu Jul 11 16:01:02 2013 -0700 + + Add Present extension + + Signed-off-by: Keith Packard + Reviewed-By: Uli Schlachter + +commit 7a9373078e69b2cb2753570f91e5c31062ba25f8 +Author: Keith Packard +Date: Tue Apr 9 21:35:52 2013 -0700 + + Add DRI3 library + + Signed-off-by: Keith Packard + Reviewed-By: Uli Schlachter + +commit 93d733e85ded5e92292d36fc7025f0c8ff7b1167 +Author: Keith Packard +Date: Thu Nov 7 05:20:06 2013 -0800 + + Require xcb proto version 1.9 + + Signed-off-by: Keith Packard + +commit 79019541e7c56ddfc3828b7bf96e6e5d3cf81c56 +Author: Keith Packard +Date: Fri Apr 12 20:15:41 2013 -0700 + + Add event queue splitting + + This allows apps to peel off certain XGE events into separate queues + for custom handling. Designed to support the Present extension + + Signed-off-by: Keith Packard + Reviewed-By: Uli Schlachter + +commit 7983bf0fbdc2725403f9db6154d0f5bc944040e5 +Author: Keith Packard +Date: Fri Jan 18 01:29:40 2013 -0800 + + Add support for receiving fds in replies + + Requests signal which replies will have fds, and the replies report + how many fds they expect in byte 1. + + Signed-off-by: Keith Packard + Reviewed-By: Uli Schlachter + +commit 7b53fb0f9bddae77b3ab8823743db57faee4e99b +Author: Keith Packard +Date: Mon Jan 14 11:23:00 2013 -0800 + + Add xcb_send_fd API + + This uses sendmsg to transmit file descriptors from the application to + the X server + + Signed-off-by: Keith Packard + Reviewed-By: Uli Schlachter + +commit 98c227a2222fb5c7ca7e8101b1ed2bc096a33048 +Author: Keith Packard +Date: Fri Jan 18 01:28:56 2013 -0800 + + -pendantic is too pendantic + + Many system headers have warnings when compiled with this flag. + + Signed-off-by: Keith Packard + Reviewed-By: Uli Schlachter + +commit d04a4a03a90f2721d507287938c90f1755d9da0e +Author: Keith Packard +Date: Fri Jul 12 10:32:03 2013 -0700 + + Make protocol C files depend on protocol XML files + + When new XML files get installed, make sure the C files are regenerated + + Signed-off-by: Keith Packard + Reviewed-By: Uli Schlachter + +commit f4d5b84800f960831e4fbb3ad9848bbb701020be +Author: Keith Packard +Date: Wed Nov 6 19:33:53 2013 -0800 + + Remove xcb_ge_event_t from xcb.h + + xcb proto now publishes this structure from an XML description + + Signed-off-by: Keith Packard + +commit e4e0c6eec861f4c69da12060dc8dbe7a63fa5eb6 +Author: Daphne Pfister +Date: Sat Sep 14 17:36:22 2013 -0400 + + Use /usr/spool/sockets/X11/ on HP-UX for UNIX sockets (#69118). + +commit f1405d9fe4a6ddcae24585ba254389a4c4f4c8c9 +Author: Daphne Pfister +Date: Sun Sep 8 16:25:11 2013 -0400 + + Fix poll() if POLLIN == ROLLRDNORM|POLLRDBAND + + It seems like POLLIN is specified as equivalent to POLLRDNORM | POLLRDBAND. Some + systems (e.g. QNX and HP-UX) take this literaly and have POLLIN defined as the + above bit combination. Other systems (e.g. Linux) have POLLIN as just a single + bit. + + This means that if no out-of-band data is available (which should never be the + case), the result of poll() will not fulfil (fd.revents & POLLIN) == POLLIN on + QNX, because the POLLRDBAND bit is not set. + + In other words, even though poll() signaled that the fd is readable, xcb would + not read from the file descriptor. + + Fix this by checking if any bits from POLLIN are set in the result of poll(), + instead of all of them. + + (This change was independently done by seanb@qnx.com as well) + + Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=38001 + Acked-by: Julien Cristau + Signed-off-by: Uli Schlachter + +commit ac47e0ecdb46aa91b191a59364437a8f65947467 +Author: Uli Schlachter +Date: Sun Sep 8 22:16:39 2013 +0200 + + Fix documentation of xcb_poll_for_event() + + In commit 8eba8690adac2, the API documentation for xcb_poll_for_event() was + fixed to remove an argument that was previously removed in commit 34168ab549. + + However, that commit only removed the first line of the documentation, leaving + behind a spurious half-sentence. That commit happened seven years ago and now + finally someone noticed... + + Thanks to Benjamin Herr for reporting this on IRC. + + v2: Thanks again to Benjamin Herr for noticing that my commit message blamed the + wrong commit. + + Signed-off-by: Uli Schlachter + +commit c52f2891b43ae77008f63700982f800371458f4d +Author: Daniel Martin +Date: Sun Aug 11 13:25:18 2013 +0200 + + tests: Add files to .gitignore + + Add check_all.log, check_all.trs and test-suite.log to tests/.gitignore. + + Signed-off-by: Daniel Martin + +commit a8d11c36edf5c49b718664dd7206f36be150f694 +Author: Daniel Martin +Date: Thu Jul 25 11:09:26 2013 +0200 + + Sort gitignore, adjust pattern for config.h + + Don't ignore the files config.h and config.h.in, adjust the pattern to + ignore config.h*. This matches an additional config.h.in~ too. + + Signed-off-by: Daniel Martin + Reviewed-by: Alan Coopersmith + Reviewed-by: Uli Schlachter + Tested-By: Ran Benita + +commit cbe54c97b3f0e4d40e0ee18796f8077cb4a6c16a +Author: Daniel Martin +Date: Thu Jul 25 10:56:30 2013 +0200 + + Use m4 directory + + - Follow the suggestion by libtoolize: + "Consider adding `AC_CONFIG_MACRO_DIR([m4])' to configure.ac and + rerunning libtoolize, to keep the correct libtool macros in-tree. + Consider adding `-I m4' to ACLOCAL_AMFLAGS in Makefile.am." + and add the macro and define. + + - Create the m4 directory and move acinclude.m4 as xcb.m4 there. + + - Ignore the m4 files libtoolize copies into the m4 directory + (m4/l*.m4). + + Signed-off-by: Daniel Martin + Reviewed-by: Alan Coopersmith + Reviewed-by: Uli Schlachter + Tested-By: Ran Benita + +commit 6746ab1549d34a146c8383ed5acdabf0d48c1889 +Author: Daniel Martin +Date: Wed Jul 24 14:13:41 2013 +0200 + + Use build-aux as autom4te cache directory + + Remove the generated directory ./autom4te.cache by reusing ./build-aux + as cache directory. + + Signed-off-by: Daniel Martin + Reviewed-by: Alan Coopersmith + Reviewed-by: Uli Schlachter + Tested-By: Ran Benita + +commit b6d8c8fe61f25e4eb7b43d3d9b1de81a1f0638a3 +Author: Daniel Martin +Date: Wed Jul 24 14:08:38 2013 +0200 + + Set AC_CONFIG_AUX_DIR to build-aux + + Do not clutter the project directory with generated/copied auxiliary + files, save them in ./build-aux. + + Signed-off-by: Daniel Martin + Reviewed-by: Alan Coopersmith + Reviewed-by: Uli Schlachter + Tested-By: Ran Benita + +commit e3b34ad346efcaf0fd28b95e68d99388276802bc +Author: Daniel Martin +Date: Wed Jul 24 19:22:44 2013 +0200 + + Remove second AC_PREREQ, require version 2.60 + + Remove a second AC_PREREQ and bump the required autoconf version to + 2.60. + + Version 2.59c was a testing release, published in April 2006. Version + 2.60 was the stable release afterwards, released in June 2006. + + Signed-off-by: Daniel Martin + Reviewed-by: Alan Coopersmith + Reviewed-by: Uli Schlachter + Tested-By: Ran Benita + +commit 50fb3a6312dd0b6b613fc886ffd6827952d1e286 +Author: Daniel Martin +Date: Wed Jul 24 12:51:04 2013 +0200 + + Initialize automake earlier (bugfix for #66413) + + This fixes: + https://bugs.freedesktop.org/show_bug.cgi?id=66413 + Bug 66413 - libxcb 1.9.1: Fails to build on Arch Linux: \ + /home//install-sh: No such file or directory + + Without that patch the search path for `install-sh` will become $HOME + and the `install` target will fail, when DESTDIR doesn't exist in + advance. (occured with automake 1.14 and autoconf 2.69) + + Initial patch by: Alain Kalker + Signed-off-by: Daniel Martin + Reviewed-by: Alan Coopersmith + Reviewed-by: Uli Schlachter + Tested-By: Ran Benita + +commit dd01db570c34dd3e2e0f5d07b8d40c837fa51057 +Author: Daniel Martin +Date: Mon Dec 31 11:57:49 2012 +0100 + + Make xsltproc optional + + Fix Bug 23863 - xcb still checks for xsltproc: + https://bugs.freedesktop.org/show_bug.cgi?id=23863 + + xsltproc is used to generate the optional html page for `check` results, + only. So, it's not a hard build dependency. + + Additionally, use yes/no instead of true/false in the HTML_CHECK_RESULT + variable for consistent output after a configure run. + + Signed-off-by: Daniel Martin + Reviewed-by: Josh Triplett + +commit 0289348f2c4ed3b1b286c51df19d82c6787c2b36 +Author: Daniel Martin +Date: Fri Dec 28 23:25:16 2012 +0100 + + c_client.py: Do not create pointers in unions + + Do not create pointers in unions for fields of variadic length. + + Signed-off-by: Daniel Martin + Reviewed-by: Ran Benita + +commit b9efd2a09a45616f6238e4da49b8f2127b6ec6d9 +Author: Daniel Martin +Date: Wed Jan 9 12:52:15 2013 +0100 + + c_client.py: Always initialize xcb_align_to + + to get rid of: + warning: 'xcb_align_to' may be used uninitialized in this function + + Signed-off-by: Daniel Martin + Reviewed-by: Peter Harris + +commit 5648ddd2b97068f549268284129a438a6845e14c +Author: Alan Coopersmith +Date: Sat Aug 3 20:25:23 2013 -0700 + + Define _xcb_map_new with explicit void arg list instead of empty one + + Fixes Solaris Studio compiler warning: + "xcb_list.c", line 50: warning: old style function definition + + and gcc warning: + xcb_list.c: In function '_xcb_map_new': + xcb_list.c:50:11: warning: old-style function definition [-Wold-style-definition] + + Signed-off-by: Alan Coopersmith + Reviewed-by: Josh Triplett + +commit cb51f271b26c6abc76d415553f202bc5139273ca +Author: Alan Coopersmith +Date: Sat Aug 3 20:22:25 2013 -0700 + + Enable warnings for pre-C89 style definitions for gcc & Solaris Studio + + Signed-off-by: Alan Coopersmith + Reviewed-by: Josh Triplett + +commit bc6a4f557ff4e497acdafdcebb006e5a7b4c5b11 +Author: Michael Stapelberg +Date: Mon Aug 5 22:14:18 2013 +0200 + + Build xcb-xkb by default + + There have not been any big issues with xcb-xkb recently. + + Also, Wayland is using xcb-xkb actively, making distributions compile + libxcb with xkb support anyway, so let’s reflect reality :). + + Reviewed-by: Jamey Sharp + Signed-off-by: Daniel Martin + +commit 45619dc71e9411a526d7c69595cf615b1b1206cf +Author: Daniel Martin +Date: Sat Jun 8 11:20:39 2013 +0200 + + c_client.py: Inject full_sequence into GE events + + The generic event structure xcb_ge_event_t has the full_sequence field + at the 32byte boundary. That's why we've to inject this field into GE + events while generating the structure for them. Otherwise we would read + garbage (the internal full_sequence) when accessing normal event fields + there. + + Signed-off-by: Daniel Martin + Reviewed-by: Keith Packard + Signed-off-by: Peter Harris + +commit a1e67b141a57d39cbcaff1a703d6fc0da1fbb56d +Author: Alan Coopersmith +Date: Mon Jul 8 17:54:35 2013 -0700 + + Fix "indention" typos in xcb-examples.3 man page + + Signed-off-by: Alan Coopersmith + +commit 8b6bb1a71977116d382f45eef803aedd3e313d37 +Author: Marc Deslauriers +Date: Wed Jun 5 16:38:00 2013 -0400 + + Update Makefile.am for newer automake + + Debian Bug #710344 + + Reviewed-by: Daniel Martin + +commit 9ae84ad187e2ba440c40f44b8eb21c82c2fdbf12 +Author: Christian König +Date: Wed May 15 11:21:36 2013 +0200 + + fix deadlock with xcb_take_socket/return_socket v3 + + To prevent different threads from stealing the socket from each other the + caller of "xcb_take_socket" must hold a lock that is also acquired in + "return_socket". Unfortunately xcb tries to prevent calling return_socket + from multiple threads and this can lead to a deadlock situation. + + A simple example: + - X11 has taken the socket + - Thread A has locked the display. + - Thread B does xcb_no_operation() and thus ends up in libX11's return_socket(), + waiting for the display lock. + - Thread A calls e.g. xcb_no_operation(), too, ends up in return_socket() and + because socket_moving == 1, ends up waiting for thread B + => Deadlock + + This patch allows calling return_socket from different threads at the same time + an so resolves the deadlock situation. + + Partially fixes: https://bugs.freedesktop.org/show_bug.cgi?id=20708 + + v2: fixes additional pthread_cond_wait dependencies, + rework comments and patch description + + v3: separate pthread_cond_wait dependencies and unrelated whitespace + change into their own patch, use unsigned for socket_seq + + Signed-off-by: Christian König + Signed-off-by: Uli Schlachter + +commit 1b33867fa996034deb50819ae54640be501f8d20 +Author: Alan Coopersmith +Date: Wed May 1 17:59:31 2013 -0700 + + integer overflow in read_packet() [CVE-2013-2064] + + Ensure that when calculating the size of the incoming response from the + Xserver, we don't overflow the integer used in the calculations when we + multiply the int32_t length by 4 and add it to the default response size. + + Signed-off-by: Alan Coopersmith + +commit e602b653c191e18cbb63db6526aac77c368ed70b +Author: Daniel Martin +Date: Mon May 13 23:33:04 2013 +0200 + + c_client.py: Handle multiple expr. in a bitcase + + Adopt a change from xcbgen. With that modification the expression in a + bitcase became a list of expressions to support multiple in a + . + + Signed-off-by: Daniel Martin + Signed-off-by: Peter Harris + +commit 6b6044cb8aacdf1b637da7b5dda392f9ff41ed39 +Author: Christian König +Date: Wed May 15 11:21:35 2013 +0200 + + whitespace fix in xcb_take_socket + + Signed-off-by: Christian König + Signed-off-by: Jamey Sharp + +commit 0dd8f8d26a758bc385e79d9239bf6ef2e3d7bf13 +Author: Colin Walters +Date: Wed Jan 4 17:37:06 2012 -0500 + + autogen.sh: Implement GNOME Build API + + http://people.gnome.org/~walters/docs/build-api.txt + + Signed-off-by: Adam Jackson + +commit 76a2166de9c80b35f987fdc3f3a228bafa0de94e +Author: Chí-Thanh Christopher Nguyễn +Date: Thu Oct 11 01:14:12 2012 +0200 + + c_client.py: Fix python-3 invalid except statement + + Replace except statement with a PEP-3110 compliant one. This fixes a regression + introduced by c3deeaf714630531d693a6a902b8dabf791858b1 + https://bugs.freedesktop.org/show_bug.cgi?id=55690 + + Reviewed-by: Peter Harris + Signed-off-by: Uli Schlachter + +commit 9db4517c87f56bb0ac82b647a08db30850ee2b04 +Author: Chí-Thanh Christopher Nguyễn +Date: Thu Oct 11 01:14:11 2012 +0200 + + c-client.py: Fix python-3 AttributeError: 'dict' object has no attribute 'iteritems' + + This fixes a regression introduced by ea71d7d7e3f5d8189b80747678e9ca9a417b1d37 + https://bugs.freedesktop.org/show_bug.cgi?id=55690 + + Reviewed-by: Peter Harris + Signed-off-by: Uli Schlachter + +commit 4ffe54f69049e6792a35a287fd9ff83abbd4fd8d +Author: Uli Schlachter +Date: Fri Oct 5 14:53:37 2012 +0200 + + Release libxcb 1.9 + + Signed-off-by: Uli Schlachter + +commit 4f52f884f42b72087f3323f2bab204223664a488 +Author: Uli Schlachter +Date: Fri Oct 5 11:23:26 2012 +0200 + + Include static man pages in "make dist" + + This was found by distcheck. It tried to install src/man/xcb-examples.3 and + src/man/xcb-requests.3, but those files weren't in the distribution. + + Fix this by explicitly telling automake to distribute those files. + + Signed-off-by: Uli Schlachter + +commit 23911a707b8845bff52cd7853fc5d59fb0823cef +Author: Uli Schlachter +Date: Mon Sep 24 22:07:51 2012 +0200 + + Fix a multi-thread deadlock + + This fixes a deadlock which was seen in-the-wild with wine. + + It could happen that two threads tried to read from the socket at the same time + and one of the thread got stuck inside of poll()/select(). + + The fix works by making sure that the writing thread doesn't steal the reading + thread's reply. + + Debugged-by: Erich Hoover + Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=54671 + Signed-off-by: Uli Schlachter + +commit c16cc5467eb0af7c5cdee16e6efaee54eb53bba6 +Author: Uli Schlachter +Date: Mon Sep 24 22:07:30 2012 +0200 + + Add a .gitignore for src/man/ + + Signed-off-by: Uli Schlachter + +commit 08cc068ead7b8e678cdb119b38ada5261d5cc3ea +Author: Peter Harris +Date: Thu Aug 16 11:59:14 2012 -0400 + + Allow xcb_send_request with >MAX_IOV iovecs + + This allows an application to do a scatter/gather operation on a large + image buffer to avoid the extra memcpy. + + Use autoconf to use UIO_MAXIOV where IOV_MAX is not available (and the + POSIX minimum of 16 where neither are available). + + Reviewed-by: Uli Schlachter + Signed-off-by: Peter Harris + +commit ff53285ae3f604e9f2cc5f4837255220459b5e44 +Author: Alan Coopersmith +Date: Sat Aug 25 13:53:37 2012 -0700 + + Return connection failure if display string specifies non-existent screen + + Matches the behaviour of Xlib - if you set DISPLAY to :0.1 but only have + one screen, closes connection and returns error. + + This introduces a new connection error code: + XCB_CONN_CLOSED_INVALID_SCREEN + + Signed-off-by: Jeremy Huddleston Sequoia + Signed-off-by: Alan Coopersmith + Reviewed-by: Jeremy Huddleston Sequoia + Reviewed-by: Josh Triplett + +commit 90889794ad882a6847bcffe52c4cc5dfd168f1f4 +Author: Alan Coopersmith +Date: Fri Aug 24 23:35:41 2012 -0700 + + Add AC_USE_SYSTEM_EXTENSIONS to allow use of more system functionality + + Copied from libX11 configure.ac + + Signed-off-by: Alan Coopersmith + +commit b52790e8ed4bb077eabdeca803935d2910558acc +Author: Alan Coopersmith +Date: Fri Aug 24 23:32:32 2012 -0700 + + Always include "config.h" at the start of all C source files. + + Allows configure to set defines such as _POSIX_SOURCE in config.h + that affect functions exposed by system headers and get consistent + results across all the source files. + + Signed-off-by: Alan Coopersmith + +commit ed93a6a2a8e23f12380709de6e04b2d833df7e71 +Author: Alan Coopersmith +Date: Sat Aug 25 12:33:35 2012 -0700 + + Fix "sppported" typo in doxygen comment for XCB_CONN_CLOSED_EXT_NOTSUPPORTED + + Signed-off-by: Alan Coopersmith + +commit c3deeaf714630531d693a6a902b8dabf791858b1 +Author: Colin Walters +Date: Mon Aug 13 15:32:31 2012 -0400 + + c_client: Fix parallel-make issue creating 'man' directory + + With make -j, it was possible to hit a race condition in the code to + make the 'man' directory. + + Signed-off-by: Julien Danjou + +commit 5f8f2ba1c4f9ac74c8f301dcca8566e296e37995 +Author: Jeremy Huddleston +Date: Sat Apr 21 22:42:51 2012 -0700 + + xcb_connect: launchd: Don't fall back on tcp if $DISPLAY is a path to a launchd socket + + Signed-off-by: Jeremy Huddleston + +commit 71a295082e07ff20d4c4cc97feed03b94cceb251 +Author: Julien Danjou +Date: Tue Mar 27 12:10:59 2012 +0200 + + Move static man to man + + Signed-off-by: Julien Danjou + +commit df217bf7c930d4433c991d86f857ecf63cc2d25a +Author: Julien Danjou +Date: Tue Mar 27 12:10:15 2012 +0200 + + Do not list manpages, use a wildcard + + Signed-off-by: Julien Danjou + +commit a4417b1611f0bf02b81b54be90ef3353010da10a +Author: Julien Danjou +Date: Tue Mar 27 12:06:54 2012 +0200 + + Split manpage list in two (static/built) + + Signed-off-by: Julien Danjou + +commit cc7fab2d5e912629d4a2a6adfb7666dc2ba45db2 +Author: Julien Danjou +Date: Mon Mar 26 18:29:35 2012 +0200 + + Allow undocumented code to be built + + Signed-off-by: Julien Danjou + +commit ea71d7d7e3f5d8189b80747678e9ca9a417b1d37 +Author: Michael Stapelberg +Date: Sun Nov 27 10:38:26 2011 +0000 + + c_client.py: generate manpages + + Signed-off-by: Julien Danjou + +commit 57a62e99b1241d5a0e6cf0b72f52090862a9c07d +Author: Julien Danjou +Date: Fri Mar 9 15:38:56 2012 +0100 + + Release libxcb 1.8.1 + + Signed-off-by: Julien Danjou + +commit 236f914ea7205f5f74e87fcc1b06d87bd0789a7a +Author: Uli Schlachter +Date: Thu Mar 1 20:26:39 2012 +0100 + + Fix a busy loop on BSD and Mac OS + + On FreeBSD MSG_WAITALL on a non-blocking socket fails immediately if less bytes + than were asked for are available. This is different than the behavior on linux + where as many bytes as are available are returned in this case. Other OS + apparently follow the FreeBSD behavior. + + _xcb_in_read() is used to fill xcb's read buffer, thus this function will call + recv() with a big length argument (xcb's read buffer is by default 16 KiB + large). That many bytes are highly unlikely to be available in the kernel + buffer. + + This means that _xcb_in_read() always failed on FreeBSD. Since the socket was + still signaled as readable by poll(), this bug even resulted in a busy loop. + + The same issue is present in read_block(), but here it is slightly different. + read_block() is called when we read the first few bytes of an event or a reply, + so that we already know its length. This means that we should be able to use + MSG_WAITALL here, because we know how many bytes there have to be. + + However, that function could busy loop, too, when only the first few bytes of + the packet were sent while the rest is stuck somewhere on the way to us. Thus, + MSG_WAITALL should be removed here, too. + + Thanks to Christoph Egger from Debian for noticing the problem, doing all the + necessary debugging and figuring out what the problem was! This patch is 99% + from debian. Thanks for all the work. + + This bug was introduced in commit 2dcf8b025be88a25d4333abdc28d425b88238d96. + + This commit also reverts commit 9061ee45b8dbe5431c23e3f628089d703ccad0b1. + + Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=45776 + + Signed-off-by: Uli Schlachter + Reviewed-by: Josh Triplett + +commit 9061ee45b8dbe5431c23e3f628089d703ccad0b1 +Author: Jeremy Huddleston +Date: Thu Mar 8 00:50:13 2012 -0800 + + darwin: Use read(2) rather than recv(2) + + 2dcf8b025be88a25d4333abdc28d425b88238d96 was causing some regressions on + darwin, so go back to using read(2) there until I have time to investigate + further. + + Signed-off-by: Jeremy Huddleston + +commit 7d235c62f0d5bd0df1236cc52141c10c5d272a18 +Author: Julien Cristau +Date: Sun Feb 19 13:43:54 2012 +0100 + + Fallback to TCP if no protocol is specified and the UNIX connection fails + + Signed-off-by: Julien Cristau + Signed-off-by: Jamey Sharp + +commit f7bd139616d228b20eeb2c96b85e4093606c93fc +Author: Arnaud Fontaine +Date: Wed Jan 25 17:18:20 2012 +0900 + + Add xkb_internals and xkb_issues to EXTRA_DIST. + +commit 68d30adde982f1be33a934707fa105c0db6f7f8f +Author: Jon TURNEY +Date: Tue Jan 17 20:59:56 2012 +0000 + + Update use of error_connection under WIN32 to _xcb_conn_ret_error() + + Unfortunately, commit 31b57676 adding WSACleanup/WSAShutdown on Win32 adds a new use + of error_connection, which was removed in commit 769acff0, applied 5 minutes earlier. + + src/xcb_util.c: In function 'xcb_connect_to_display_with_auth_info': + src/xcb_util.c:433:39: error: 'error_connection' undeclared (first use in this function) + + Signed-off-by: Jon TURNEY + Reviewed-by: Arvind Umrao + Signed-off-by: Uli Schlachter + +commit 87b7bf875e0105924ae306e90ca79512d6c0cf47 +Author: Jon TURNEY +Date: Wed Jan 18 14:11:07 2012 +0000 + + Fix build of xcb_auth.c with XDMCP on WIN32 + + Fix a redefinition problem which shows up when building for _WIN32 and + libXdmcp is installed, so HASXDMAUTH is enabled + + It seems this is a special place in xcb as it uses other X11 library headers here + + If HASXDMAUTH is defined, include the wrapped windows.h before any header which + includes it unwrapped, to avoid conflicts with types defined in X headers + + We need to include config.h and check HASXDMAUTH to avoid an unconditional dependency + on x11proto headers + + In file included from install/include/X11/Xdmcp.h:19:0, + from git/xcb/libxcb/src/xcb_auth.c:52: + install/include/X11/Xmd.h:120:14: error: conflicting types for 'INT32' + /usr/i686-pc-mingw32/sys-root/mingw/include/basetsd.h:54:13: note: previous declaration of 'INT32' was here + install/include/X11/Xmd.h:143:15: error: conflicting types for 'BOOL' + /usr/i686-pc-mingw32/sys-root/mingw/include/windef.h:234:17: note: previous declaration of 'BOOL' was here + + Signed-off-by: Jon TURNEY + Reviewed-by: Jeremy Huddleston + +commit 6db1a2686f0f073438d36f5fa0f97b787842b0f2 +Author: Jeremy Huddleston +Date: Tue Jan 17 23:55:23 2012 -0800 + + Revert "Fix include order with Xdmcp on WIN32" + + This reverts commit 0e9246def562be97cc816f824f702233a826ec56. + + This change caused build failures because was never + included under any circumstance. This is because the check for + HASXDMAUTH was moved before the inclusion of config.h (via xcbint.h) + which defined it. + + Found-by: Tinderbox + Signed-off-by: Jeremy Huddleston + Reviewed-by: Jon TURNEY + +commit da1d15082baab844a3b9b2d5cc48620af0b806ec +Author: Julien Danjou +Date: Thu Jan 12 10:25:07 2012 +0100 + + Bump xcb-proto requirement + + We are now unable to build xcb-proto before 1.7. + + Signed-off-by: Julien Danjou + +commit b95b33e8c04c90c2240df19acea0c841d6e3450b +Author: Julien Danjou +Date: Wed Jan 11 18:27:38 2012 +0100 + + Release libxcb 1.8 + + Signed-off-by: Julien Danjou + +commit 31b57676e8d7ab6048dbfb145187833fac5e478c +Author: Ryan Pavlik +Date: Wed Jan 11 18:06:50 2012 +0100 + + Use WSAStartup()/WSACleanup() on WIN32 + + The alternative is to use these in every WIN32 application which uses xcb. Doing + it this way should be safe, as, according to MSDN, "There must be a call to + WSACleanup for each successful call to WSAStartup. Only the final WSACleanup + function call performs the actual cleanup. The preceding calls simply decrement + an internal reference count" + + (We should probably also include ws2_32 in Libs.private for libxcb, as anything + which links with libxcb will also need that, but there seems to be some pkg-config + issues to resolve first...) + + v2: Check for errors so WSAStartup()/WSACleanup() uses are balanced + v3: Use same indentation style as surrounding code + + Reviewed-by: Peter Harris + Signed-off-by: Julien Danjou + +commit 0e9246def562be97cc816f824f702233a826ec56 +Author: Ryan Pavlik +Date: Thu Jan 5 20:57:53 2012 +0000 + + Fix include order with Xdmcp on WIN32 + + Fix a redefinition problem due to include order which shows up when + building for _WIN32 and libXdmcp is installed, so HASXDMAUTH is enabled + + Signed-off-by: Jon TURNEY + Reviewed-by: Peter Harris + Signed-off-by: Julien Danjou + +commit 4aa7a2c849a9536febb2dc7773e06c12a69c5213 +Author: Jon TURNEY +Date: Thu Jan 5 20:57:52 2012 +0000 + + Fix WIN32 compilation after commit 163c47bdc0d32785d831e4c93fea9ab7e023446b + + WIN32 does not have arpa/inet.h, so do not try to include it unless _WIN32 is + not defined + + Signed-off-by: Jon TURNEY + Reviewed-by: Peter Harris + Signed-off-by: Julien Danjou + +commit 769acff0da8b9859ebdf052dce80045465c7598c +Author: Arvind Umrao +Date: Fri Nov 4 15:42:05 2011 +0530 + + Added more error states and removed global error_connection + + Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=41443 + Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=42304 + + I have added more xcb connection error states at xcb.h header. + Also I have removed global error_connection variable, and added + an interface that returns connection error state. + + TBD: + I will segregate errors states in a separate header file and try to + provide more precise error states, in future. Also I will give patch + for libX11, in that patch xcb_connection_t::has_error will be passed + to default io handler of libX11. This value can then be used for + displaying error messages. + + Reviewed-by: Rami Ylimäki + Reviewed-by: Uli Schlachter + Signed-off-by: Arvind Umrao + +commit 9b4d6f30a339e2d18ebaea98149da81aba453216 +Author: Keith Packard +Date: Thu Dec 1 10:28:51 2011 +0000 + + Make xcb_take_socket keep flushing until idle + + _xcb_out_flush_to will drop the iolock in pthread_cond_wait allowing + other threads to queue new requests. When this happened, + there would be requests queued for the socket after _xcb_out_flush_to + returned, and xcb_take_socket would throw an assert. + + Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=29875 + Signed-off-by: Keith Packard + Signed-off-by: Julien Danjou + +commit 5ceeaaa4294201b3f613c07f9ec610c0e5f673c7 +Author: Uli Schlachter +Date: Thu Aug 25 14:18:16 2011 +0200 + + Fix a dead-lock due to xcb_poll_for_reply + + Imagine two threads: + + Thread#1: for(;;) { xcb_get_input_focus_reply(c, xcb_get_input_focus(c), 0); } + + Thread#2: for(;;) { xcb_poll_for_event(c); } + + Since xcb_poll_for_event() calls _xcb_in_read() directly without synchronizing + with any other readers, this causes two threads to end up calling recv() at the + same time. We now have a race because any of these two threads could get read + the GetInputFocus reply. + + If thread#2 reads this reply, it will be put in the appropriate queue and + thread#1 will still be stuck in recv(), although its reply was already received. + If no other reply or event causes this thread to wake up, the process deadlocks. + + To fix this, we have to make sure that there is only ever one thread reading + from the connection. The obvious solution is to check in poll_for_next_event() + if another thread is already reading (in which case c->in.reading != 0) and not + to read from the wire in this case. + + This solution is actually correct if we assume that the other thread is blocked + in poll() which means there isn't any data which can be read. Since we already + checked that there is no event in the queue this means that + poll_for_next_event() didn't find any event to return. + + There might be a small race here where the other thread already determined that + there is data to read, but it still has to wait for c->iolock. However, this + means that the next poll_for_next_event() will be able to read the event, so + this shouldn't cause any problems. + + Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=40372 + + Signed-off-by: Uli Schlachter + Signed-off-by: Peter Harris + +commit b12038e9ae5343c4176f11d68c963c752bc35c03 +Author: Jamey Sharp +Date: Wed Aug 24 08:52:02 2011 -0700 + + Keep ALIGNOF definition out of the public namespace. + + Uli's patch is an excellent solution; I just want to keep the new + ALIGNOF macro hidden from XCB's users, as they don't need it to call + XCB. + + Signed-off-by: Jamey Sharp + +commit 163c47bdc0d32785d831e4c93fea9ab7e023446b +Author: Markus Duft +Date: Wed Aug 24 10:49:06 2011 -0400 + + Support pre-IPv6 systems (without getaddrinfo) + + Some of these systems (eg. Interix on XP) are still in use. + + Reviewed-by: Josh Triplett + Signed-off-by: Peter Harris + +commit aa02096b8e7f94ad3c998a8d5af54963ee860b13 +Author: Uli Schlachter +Date: Wed Aug 24 12:47:16 2011 +0200 + + Compute alignment correctly + + The code previously assumed that everything has to be aligned to a 4 byte + boundary. This assumption is wrong as e.g. the STR struct from xproto shows. + + Instead, each type has to be aligned to its natural alignment. So a char doesn't + need any alignment, a INT16 gets aligned to a 2-byte-boundary and a INT32 gets + the old 4 byte alignment. + + I'm not 100% sure that this commit is correct, but some quick tests with awesome + and cairo-xcb went well. + + This commit causes lots of dead assignments to xcb_align_to since only the last + field's alignment is actually used, but this simplified this patch a lot. + + Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=34037 + + Signed-off-by: Uli Schlachter + Signed-off-by: Peter Harris + +commit 4f25ee16443b29e1a25bd26a724e1e0a577e21ff +Author: Michael Stapelberg +Date: Thu Aug 18 21:38:28 2011 +0200 + + Drop AI_ADDRCONFIG when resolving TCP addresses + + When a system is completely offline (no interface has an IP address but 'lo'), + xcb could not connect to localhost via TCP, e.g. connections with + DISPLAY=127.0.0.1:0 fail. + + AI_ADDRCONFIG will only return IPv4 addresses if the system has an IPv4 + address configured (likewise for IPv6). This also takes place when + resolving localhost (or 127.0.0.0/8 or ::1). Also, as per RFC 3493, + loopback addresses are not considered as valid addresses when + determining whether to return IPv4 or IPv6 addresses. + + As per mailing-list discussion on the xcb list started with message + 20110813215405.5818a0c1@x200, the AI_ADDRCONFIG flag is there for historical + reasons: + + In the old days, the "default on-link" assumption in IPv6 made the flag vey + much indispensable for dual-stack hosts on IPv4-only networks. Without it, + there would be long timeouts trying non-existent IPv6 connectivity. Nowadays, + this assumption has been flagged as historic bad practice by IETF, and hosts + should have been updated to not make it anymore. + + Then AI_ADDRCONFIG became mostly cosmetic: it avoids phony "Protocol family + not supported" or "Host unreachable" errors while trying to connect to a dual- + stack mode from a host with no support for source address selection. + + Nowadays, on up-to-date systems, this flag is completely useless. Then again, + I understood only the very latest MacOS release is "up-to-date" with this + definition. + +commit 662ad589c5d6f03757ae57a926d3800bfb528b30 +Author: James Jones +Date: Wed May 11 23:22:22 2011 -0700 + + Insert, not append explicit xcbgen dir python path + + If a the path to the xcb python generate libs is + explicitly specified to c_client.py, insert it in + the python path list just after the local dir entry, + rather than appending it to the existing paths. + This keeps a global/distro install of xcb from + overriding a local build of the xcb proto files. + + Signed-off-by: James Jones + Signed-off-by: Jamey Sharp + +commit 294c9f455c3534d836b010dacd2e7aa62a7dde9d +Author: David Coles +Date: Fri Apr 8 17:47:05 2011 -0700 + + Add support for building with Python 3 + + Python 3 introduces some language changes that cause issues when running + c_client.py. This also breaks compatibility with Python 2.5 since it does not + support the "as" statement in try/except blocks and does not have reduce() in + the functools package. + + The main changes are: + * try/except blocks require `except ... as ...:` to resolve syntactical ambiguity + * map() and filter() return iterators rather than lists in Python 3 + * reduce() is now in functools package (and not built-in in Python 3) + * Dictionaries don't have a has_key() method in Python 3 + * None and int types can't be directly compared in Python 3 + * print() is a statement in Python 3 + + See http://diveintopython3.org/porting-code-to-python-3-with-2to3.html and + PEP-3110 for details. + + Verified on Python 2.6.5 and 3.1.3. + + Signed-off-by: David Coles + Signed-off-by: Julien Danjou + +commit e300ee4920bf4618f58618f3063b362f811154c1 +Author: Jamey Sharp +Date: Tue Apr 12 13:09:23 2011 -0700 + + Revert "Introduce xcb_wait_for_event_until, for consuming responses in wire-order." + + This function was intended to allow libX11 to fix a multi-threaded hang, + but the corresponding libX11 patch caused single-threaded apps to spin + sometimes. Since I've retracted that patch, this patch has no users and + shouldn't go into a release unless/until that changes. + + This reverts commit 2415c11dec5e5adb0c17f98aa52fbb371a4f8f23. + + Conflicts: + + src/xcb.h + src/xcb_in.c + + Signed-off-by: Jamey Sharp + +commit 527df3c84bd71113cedc7f55089c02d1c099ecad +Author: Rami Ylimäki +Date: Tue Mar 22 14:33:23 2011 +0200 + + Introduce a variant of xcb_poll_for_event for examining event queue. + + In some circumstances using xcb_poll_for_event is suboptimal because + it checks the connection for new events. This may lead to a lot of + failed nonblocking read system calls. + + Signed-off-by: Rami Ylimäki + Signed-off-by: Jamey Sharp + +commit b64cd0df884e7901ff13def0272df74962035920 +Author: Alan Coopersmith +Date: Mon Apr 4 21:36:47 2011 -0700 + + If protocol is "unix", use a Unix domain socket, not TCP + + Fixes fallback to local connections from Xlib's XOpenDisplay(), which + will try with protocol "unix" if a hostname is specified and tcp fails + (as it usually will now that most OS'es ship with -nolisten tcp enabled). + + Also fixes explicitly specifying DISPLAY as "unix/foo:0", which Xlib + previously accepted for Unix domain sockets. + + Signed-off-by: Alan Coopersmith + +commit b027922ebf1931885e00629c20e26f14f184998d +Author: Alan Coopersmith +Date: Mon Apr 4 21:28:00 2011 -0700 + + Make launchd code in xcb_util.c match surrounding code indent levels + + Signed-off-by: Alan Coopersmith + +commit 82b1f3919a82a730f6b2f952d4090fe15702694e +Author: Carlos Garnacho +Date: Tue Oct 5 18:03:22 2010 +0200 + + Handle XGE events with the "send event" flag + + This patch is necessary so xcb reads the payload after the message + for GenericEvents with the 0x80 flag turned on. + + Signed-off-by: Carlos Garnacho + Signed-off-by: Jamey Sharp + +commit 42c4adeff4a6aedfba30e22f71800c1b73942923 +Author: Alan Coopersmith +Date: Mon Apr 4 20:20:16 2011 -0700 + + Add #include to xcb_conn.c + + Solves compiler warning on Solaris: + "xcb_conn.c", line 304: warning: implicit function declaration: shutdown + + Also provides system definition of SHUT_RDWR on Solaris 11. + + Signed-off-by: Alan Coopersmith + Reviewed-by: Jamey Sharp + +commit 4b502dd696cf7f59a961bcf71c9255ae28f0765a +Author: Alan Coopersmith +Date: Mon Apr 4 20:12:56 2011 -0700 + + Remove unused DECnet code + + "unifdef -UDNETCONN src/xcb_util.c" plus re-indenting code that was + formerly in the else clause after a DECnet check. + + DECnet support has been removed from most of the X.Org code base for + several years, and it appears DNETCONN was never defined in XCB. + + Signed-off-by: Alan Coopersmith + Reviewed-by: Jamey Sharp + +commit 7131d5d0706f2b63caad13c815e893627872114c +Author: Alan Coopersmith +Date: Mon Apr 4 16:32:45 2011 -0700 + + Use special path to sockets when running under Solaris Trusted Extensions + + Solaris Trusted Extensions puts the endpoints for the X server's Unix + domain sockets in a special directory shared from the global zone to + each of the labeled zones, since each labeled zone has a separate /tmp. + + Signed-off-by: Alan Coopersmith + Reviewed-by: Peter Harris + +commit 70976d87f18d15c2ccc28eb7728e4822d3849e0d +Author: Rami Ylimäki +Date: Wed Mar 23 17:47:50 2011 +0200 + + Prevent theoretical double free and leak on get_peer_sock_name. + + Variable new_sockname will leak and sockname will be double freed if + both of the cases shown below are true. + + 1. realloc succeeds and doesn't return the original pointer + 2. calling socket_func fails + + Signed-off-by: Rami Ylimäki + Signed-off-by: Erkki Seppälä + Reviewed-by: Arnaud Fontaine + Signed-off-by: Peter Harris + +commit 3678159e4ed64502f9ce218a63c8d069649f2215 +Author: Jamey Sharp +Date: Sat Mar 19 20:04:55 2011 -0700 + + Delete the old c-client.xsl. + + It hasn't been used since libxcb 1.1.90.1, released in 2008. + + Signed-off-by: Jamey Sharp + +commit 2415c11dec5e5adb0c17f98aa52fbb371a4f8f23 +Author: Jamey Sharp +Date: Fri Mar 18 20:56:07 2011 -0700 + + Introduce xcb_wait_for_event_until, for consuming responses in wire-order. + + Signed-off-by: Jamey Sharp + Reviewed-by: Josh Triplett + +commit 29a974f212aae9eeff4fde99f110cee08f0312f3 +Author: Jamey Sharp +Date: Fri Mar 18 17:36:32 2011 -0700 + + Dequeue readers that can't receive any new responses. + + Signed-off-by: Jamey Sharp + Reviewed-by: Josh Triplett + +commit 131e867fca5cda94e634af69214ad54e066ac871 +Author: Jamey Sharp +Date: Fri Mar 18 15:37:34 2011 -0700 + + Factor reader_list management out of wait_for_reply. + + Later patches will insert reader_list entries from other entry points. + + Signed-off-by: Jamey Sharp + Reviewed-by: Josh Triplett + +commit 1469e879655b20351530059538a7b89612028ae2 +Author: Jamey Sharp +Date: Fri Mar 18 18:18:41 2011 -0700 + + Enable AM_SILENT_RULES on automake 1.11 or newer. + + This incantation is supposed to be a no-op on earlier automake versions. + + Signed-off-by: Jamey Sharp + Reviewed-by: Josh Triplett + +commit 6310475e23eac6917db54f1425e20d8434bee679 +Author: Rami Ylimäki +Date: Wed Oct 13 17:48:13 2010 +0300 + + Prevent reply waiters from being blocked. + + It's possible to call xcb_wait_for_reply more than once for a single + request. In this case we are nice and let reply waiters continue so + that they can notice that the reply is not available + anymore. Otherwise an event waiter could just signal the reply waiter + that got its reply to continue but leave a waiter for an earlier reply + blocked. + + Below is an example sequence for reproducing this problem. + + thread #1 (XNextEvent) + - waits for events + thread #2 (XSync) + - executes request #2 + - waits for reply #2 + thread #1 + - reads reply #2 + - signals waiter of reply #2 to continue + - waits for events + thread #2 + - handles reply #2 + thread #3 (XCloseDisplay) + - executes request #3 + - waits for reply #2 + thread #1 + - reads reply #3 + - nobody is waiting for reply #3 so don't signal + - wait for events + + Of course it may be questionable to wait for a reply twice, but XCB + should be smart enough to let clients continue if they choose to do + so. + + Signed-off-by: Rami Ylimäki + Signed-off-by: Jamey Sharp + +commit 29ab5aeb9b1b1daf7f0659b134a4cfe9f42ca71a +Author: Jamey Sharp +Date: Sun Mar 13 09:41:10 2011 -0700 + + Include XKB in ./configure's summary output. + + Signed-off-by: Jamey Sharp + +commit 2edfd5c375bf980b484b7cfbfc1f4fb751621859 +Merge: ed37b08 8c3325f +Author: Jamey Sharp +Date: Sun Mar 13 09:18:24 2011 -0700 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb/libxcb + + Apparently I forgot to push these months ago. + +commit 8c3325f8bbdb1e8975bdb01525a52d6b0f80cfa3 +Author: Jeremy Huddleston +Date: Fri Mar 4 12:41:55 2011 -0800 + + darwin: Don't use poll() when expected to run on darwin10 and prior + + Signed-off-by: Jeremy Huddleston + +commit c2e023646298da05e212056fbc6b329e4dd9a100 +Author: Peter Harris +Date: Thu Dec 23 13:32:17 2010 -0500 + + Don't try to sizeof(void) + + sizeof(void) is a gcc extension, and not portable. + + Xorg Bugzilla 31959 + http://bugs.freedesktop.org/show_bug.cgi?id=31959 + http://lists.freedesktop.org/archives/xcb/2010-May/006039.html + + Signed-off-by: Peter Harris + Tested-by: Cyril Brulebois + +commit 9efced72a3cb8072fa60fbed4f04d61cde412494 +Author: Vincent Torri +Date: Sun Nov 28 14:02:40 2010 +0100 + + fix Windows build and installation + +commit 3c5813697169a33ecfd6ac0ab5641dec654f6612 +Merge: 69b78ce b672d15 +Author: Peter Harris +Date: Thu Dec 23 13:04:40 2010 -0500 + + Merge branch 'master' of git://anongit.freedesktop.org/~peterh/libxcb + +commit 69b78ced1a7bcdca538c0720fde9cf3e6f70d040 +Author: Jeetu Golani +Date: Sun Dec 12 16:48:41 2010 -0500 + + Don't validate FD_SETSIZE on Win32 + + Windows' file handles have never been small or consecutive, so Windows' + select has always been implemented the same way as everyone else's poll. + + On Windows, FD_SETSIZE is the size of the poll array, not the maximum + SOCKET number. + + Signed-off-by: Peter Harris + +commit 8ecd754b168a0352783bf1ba0f0887f7ff479ee8 +Author: Uli Schlachter +Date: Wed Nov 17 20:26:11 2010 +0100 + + xcb_take_socket: Document sequence wrap requirements + + If lots of requests are send without one causing a reply, xcb can get confused + about the current sequence number of a reply. Document the requirements of an + external socket owner to avoid this problem. + + The return_socket callback for xcb_take_socket() originally was supposed to + return the last sequence number used, but the version committed to libxcb never + actually had this signature. This fixes the function's documentation not to + mention this non-existent return value. + + Signed-off-by: Uli Schlachter + Signed-off-by: Julien Danjou + +commit 5755582444ad0ba79e661ab3173cc38e9e588d83 +Author: Nick Bowler +Date: Wed Nov 10 20:49:41 2010 -0500 + + xcb_auth: Fix memory leak in _xcb_get_auth_info. + + If the initial get_peer_sock_name(getpeername ...) succeeds, the + pointer to allocated memory is overwritten by the later call to + get_peer_sock_name(getsockname ...). Fix that up by freeing + the allocated memory before overwriting the pointer. + + Signed-off-by: Nick Bowler + Signed-off-by: Julien Danjou + +commit ed37b087519ecb9e74412e4df8f8a217ab6d12a9 +Author: Jamey Sharp +Date: Sat Oct 9 17:13:45 2010 -0700 + + xcb_in: Use 64-bit sequence numbers internally everywhere. + + Widen sequence numbers on entry to those public APIs that still take + 32-bit sequence numbers. + + Signed-off-by: Jamey Sharp + +commit 6c8b539c2a2e53bf3deb0e749a941ab52b7e8834 +Author: Jamey Sharp +Date: Sat Oct 9 13:19:05 2010 -0700 + + xcb_discard_reply: Simplify by re-using poll_for_reply helper. + + If you discard a sequence number that has multiple responses already + read, this will do more allocations than necessary. But nobody cares + about ListFontsWithInfo. + + Signed-off-by: Jamey Sharp + +commit 3a74b5e7a1aab0619b7e34d90d2b8b2b1e386129 +Author: Jamey Sharp +Date: Sat Oct 9 12:32:05 2010 -0700 + + xcb_request_check: Hold the I/O lock while deciding to sync. + + Signed-off-by: Jamey Sharp + +commit ee1bc1d28a1bda0526db90139edc1304d2ef3d7c +Author: Jamey Sharp +Date: Sat Oct 9 04:08:18 2010 -0700 + + xcb_send_request: Send all requests using a common internal send_request. + + This simplifies the critical section of xcb_send_request and fixes a + couple of subtle bugs: + + - It's possible for xcb_send_request to need to issue two sync requests + before it can issue the real request. Previously, we counted sequence + numbers as if both were issued, but only one went out on the wire. + + - The test for whether to sync at 32-bit sequence number wrap has been + incorrect since we switched to 64-bit sequence numbers internally. + + This change means that if the output queue was already full and the + current request is bigger than the output queue, XCB will do one more + write syscall than it did before. But syncs are rare and small requests + are the norm, so this shouldn't be a measurable difference. + + Signed-off-by: Jamey Sharp + +commit b672d1514c88e119f3aaeded8c8a488cad36db52 +Author: Peter Harris +Date: Wed Sep 22 23:15:38 2010 -0400 + + Fix _unserialize of reply headers + + This cleans up a number of warnings, and passes the sequence number + through correctly. + + Signed-off-by: Peter Harris + +commit 29cca33b9001961fa2c33bb9d9fe4a9983913fce +Author: Peter Harris +Date: Wed Sep 22 22:32:34 2010 -0400 + + Clean up a couple of warnings in xprint + + Signed-off-by: Peter Harris + +commit 8c1d2021ca611c1452a8d2ff2a705569e4ebd056 +Author: Peter Harris +Date: Wed Sep 22 21:16:51 2010 -0400 + + Make *_unserialize safe to use on buffers in-place + + By calling memmove instead of memcpy, and walking the buffer backward + from the end, *_unserialize is safe to use in-place. + + Signed-off-by: Peter Harris + +commit 28a71c6567d08272dc9c1c2b32f0529f11f62b9e +Author: Peter Harris +Date: Fri Sep 10 15:51:56 2010 -0400 + + Fix memory leak in _sizeof implemented with _unserialize + + Signed-off-by: Peter Harris + +commit a22909c0f513fe28347c56be65a345831c3ce744 +Author: Peter Harris +Date: Wed Sep 8 15:57:00 2010 -0400 + + Don't emit out-of-module sizeof definitions + + Signed-off-by: Peter Harris + +commit 1c4717de367fe3bf1cf56bd8ef2bd30586bed023 +Author: Josh Triplett +Date: Sun Sep 19 20:38:06 2010 +0200 + + Allow disconnecting connections that are in error state. + + In support of this, consolidate the two static error_connection + definitions into one so we don't try to free the static out-of-memory + error_connection. + + Commit by Josh Triplett and Jamey Sharp. + + Signed-off-by: Josh Triplett + Signed-off-by: Jamey Sharp + +commit 03bcccb132249142ba908a075e0bd5075fc20d97 +Author: Peter Harris +Date: Fri Sep 10 15:53:13 2010 -0400 + + Add xkb.* to gitignore + + Signed-off-by: Peter Harris + +commit 28d39258008fcc8ced84dc6c1dd2644e2c908c87 +Merge: f0565e8 5e8a7ad +Author: Peter Harris +Date: Wed Sep 8 14:41:52 2010 -0400 + + Merge branch 'gsoc2010' of git://anongit.freedesktop.org/~chr/libxcb + +commit f0565e8f06aadf760a9065a97b8cf5ab9cbd18de +Author: Jamey Sharp +Date: Sat Sep 4 10:17:21 2010 -0700 + + _xcb_conn_wait: Shut down the connection on unexpected poll() events. + + If a client calls close(2) on the connection's file descriptor and then + flushes writes, libxcb causes a hang in the client. + + Any flush eventually calls _xcb_out_send() with has the following loop: + while(ret && *count) + ret = _xcb_conn_wait(c, &c->out.cond, vector, count); + + _xcb_conn_wait(), if built with USE_POLL, gets the POLLNVAL error. It only + checks for POLLIN and POLLOUT though, ignoring the error. Return value is 1, + count is unmodified, leaving us with an endless loop and a client hang. + + XTS testcase Xlib3/XConnectionNumber triggers this bug. It creates a display + connection, closes its file descriptor, tries to send a no-op, and then expects + an error. + http://cgit.freedesktop.org/xorg/test/xts/tree/xts5/Xlib3/XConnectionNumber.m + + If poll returned POLLHUP or POLLERR, we might see the same result. + + If poll returns any event we didn't ask for, this patch causes + _xcb_conn_shutdown() to be invoked and an error returned. This matches the + behaviour if select(2) is used instead of poll(2): select(2) returns -1 and + EBADF for an already closed file descriptor. + + I believe this fix both is safe and will handle any similar error. POSIX says + that the only bits poll is permitted to set in revents are those bits that were + set in events, plus POLLHUP, POLLERR, and POLLNVAL. So if we see any flags we + didn't ask for then something has gone wrong. + + Patch inspired by earlier proposals from Peter Hutterer and Aaron + Plattner--thanks! + + Reported-by: Peter Hutterer + Reported-by: Aaron Plattner + Signed-off-by: Jamey Sharp + Reviewed-by: Aaron Plattner + Reviewed-by: Peter Hutterer + Tested-by: Aaron Plattner + Cc: Peter Hutterer + Cc: Dan Nicholson + Signed-off-by: Peter Harris + +commit 20da10490f8dac75ec9fe1df28cb9e862e171be5 +Merge: 7f5cfcc 2dcf8b0 +Author: Peter Harris +Date: Tue Aug 31 18:33:36 2010 -0400 + + Merge branch 'master' of git://github.com/topcat/xcb-win32 + + Conflicts: + src/xcb_conn.c + src/xcb_util.c + + Signed-off-by: Peter Harris + +commit 7f5cfcc2fd0168d505504cc088bfdcba5c71f0ea +Author: Aaron Plattner +Date: Tue Aug 17 08:04:41 2010 -0700 + + xcb_disconnect: call shutdown() to force a disconnect + + Fixes the X Test Suite's XCloseDisplay-6 test, which has this (admittedly + ridiculous) behavior: + + 1. Create a window w. + 2. Open two display connections, dpy1, and dpy2. + 3. Grab the server using dpy1. + 4. Fork. + 5 (child). XSetProperty on w using dpy2. + 5 (parent). Verify that no event was recieved on dpy1. + 6 (parent). XCloseDisplay(dpy1). + 6 (child). Verify that an event was received on dpy2. + + It was failing because at step 6 (child), the server had not actually ungrabbed + yet because the file descriptor for dpy1 was still open in the child process. + + Shutting down the socket during XCloseDisplay matches the behavior of non-XCB + Xlib, which calls shutdown() from _X11TransSocketDisconnect. + + Thanks to Julien Cristau for noticing this. + + Signed-off-by: Aaron Plattner + Reviewed-by: Julien Cristau + Signed-off-by: Peter Harris + +commit 2040f10a4efa95092bc9409c5b20347989b5f0a2 +Author: Jamey Sharp +Date: Tue Aug 24 09:17:38 2010 -0700 + + xcb_request_check: Sync even if an event was read for this sequence. + + This fixes the test case I have so far for Havoc's report that + xcb_request_check hangs. + + Rationale: Since we have a void cookie, request_expected can't have been + set equal to this sequence number when the request was sent; it can only + have become equal due to the arrival of an event or error. If it became + equal due to an event then we still need to sync. If it became equal due + to an error, then request_completed will have been updated, which means + we correctly won't sync. + + Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=29599 + + However, Havoc reports that he can still reproduce the problem, so we + may be revisiting this later. + + Reported-by: Havoc Pennington + Signed-off-by: Jamey Sharp + +commit 5e8a7ade2dc8aeeeb8013785ca3f24c6057ae443 +Author: Christoph Reimann +Date: Mon Aug 16 20:24:40 2010 +0200 + + small fix to get rid of some compiler warnings + also added very basic documentation for xkb + +commit b89f634ff9b321f21874cd45e398d661a6ff726e +Author: Christoph Reimann +Date: Mon Aug 16 18:22:42 2010 +0200 + + small fix in the xkb pkg file + +commit 22e1013131984a217e9bddeac3a6a4183e35f0c1 +Author: Christoph Reimann +Date: Mon Aug 16 18:19:16 2010 +0200 + + added accessors for special cases + major bugfixes include: rewrite of prefix related functions, merge of serialize/unserialize/... generators, extended field name resolution + +commit 35f901a0f2bc3f5bb30dc6ff9d791679c9e84c05 +Author: Julien Danjou +Date: Fri Aug 13 13:46:37 2010 +0200 + + Release libxcb 1.7 + + Signed-off-by: Julien Danjou + +commit fe0e32b5fa3923fae97210e974c0f96a085116cb +Author: Christoph Reimann +Date: Sun Aug 8 21:25:13 2010 +0200 + + special case 'intermixed variable and fixed size fields': fixed reply side, needs testing + +commit 77b594f9583ea0247ff27130316d8e045da7f921 +Author: Christoph Reimann +Date: Thu Aug 5 15:55:28 2010 +0200 + + renamed most _unserialize() functions to _sizeof() and fixed _unserialize() for the special case of intermixed variable and fixed size fields + +commit dd1a4dbe20d6b5fd33aeb65e662bb2ca18665518 +Author: Eamon Walsh +Date: Thu Aug 5 00:48:08 2010 -0400 + + Tutorial uses wrong function. + + https://bugs.freedesktop.org/show_bug.cgi?id=29392 + + Signed-off-by: Eamon Walsh + +commit b187f029d6bb693f0294bad5261ec486b140f185 +Author: Christoph Reimann +Date: Mon Aug 2 23:30:42 2010 +0200 + + attempt to fix special case: variable fields followed by fixed size fields + +commit a700eeb502b5fe902e4c93cc707100ec868ce946 +Author: Christoph Reimann +Date: Sun Aug 1 23:40:20 2010 +0200 + + bug fixes for all kinds of 'special cases' + +commit 1c590d5a86ae854e53f388e40c952e92f11d59e6 +Author: Christoph Reimann +Date: Thu Jul 22 16:41:15 2010 +0200 + + partial rewrite of serialize helper functions completed; + _serialize() & _unserialize() have been tested for switch derived from valueparam + +commit 566ae9baee20fb6147b94b89a26796087461bae8 +Author: Christoph Reimann +Date: Tue Jul 20 22:46:37 2010 +0200 + + preliminary handling of further special cases in unserialize + first attempts to unify serialize and unserialize + +commit 4e665e1580ece7bc9505f3a2f657959669ffcd05 +Author: Christoph Reimann +Date: Thu Jul 15 18:43:43 2010 +0200 + + added generating code for _serialize() in case of variable sized structs (largely untested) + +commit d0031456097f009bdb82fb979924e71ca38c539b +Author: Christoph Reimann +Date: Tue Jul 13 20:08:51 2010 +0200 + + xkb: added pkg config file + +commit 86704124b1fd62c30441ace1f3f8e2c316801c53 +Author: Christoph Reimann +Date: Tue Jul 13 20:06:08 2010 +0200 + + new and still preliminary functions for switch; feautures include + - API compatibility with valueparam + - request _aux() auxiliary functions + - _serialize() and _unserialize() auxiliary functions + - new data type that allows mixing of fixed and variable size members + +commit 80322d11636dd638902660d80481080d2fad40fe +Author: Christoph Reimann +Date: Tue Jul 13 19:59:23 2010 +0200 + + xkb: updated configure.ac/Makefile.am + +commit 8c2707773b3621fb8bbda9021d23944f5be34aab +Author: Christoph Reimann +Date: Tue Jul 13 19:56:44 2010 +0200 + + added xcb_sumof() with restriction to uint8_t + +commit 496efb7624d14b4ca0391f44926edc448cbd605e +Author: Jamey Sharp +Date: Tue Jul 13 07:01:06 2010 -0700 + + _xcb_conn_wait: Fix whitespace. + + Signed-off-by: Jamey Sharp + +commit 74057c7eb6836353960ce3849703ce20e45089bc +Author: Jeremy Huddleston +Date: Mon Jul 12 16:53:53 2010 -0700 + + AC_CHECK_PROG(LAUNCHD, [launchd], [yes], [no], [$PATH$PATH_SEPARATOR/sbin]) + + launchd: Explicitly search /sbin + + Previously, launchd wasn't found if /sbin wasn't in the user's PATH. + https://bugs.freedesktop.org/show_bug.cgi?id=29028 + + Signed-off-by: Jeremy Huddleston + +commit 75ff427d41fc10d00b780c965c289fc02c81aaac +Author: Vincent Torri +Date: Sun Jun 20 20:50:06 2010 -0700 + + configure.ac: Report which extensions are being built. + + I was surprised to see that xinput was not installed. Looking at + configure.ac, it seems that it is disabled by default. Maybe configure + should output the status of the different extensions. + +commit de3cdad87a341c238c544425f4dd574b19c58ae3 +Author: Pauli Nieminen +Date: Fri Jun 11 16:30:47 2010 +0300 + + xcb_connect_to_display_with_auth_info: Fix memory leak + + protocol and host are allocated in _xcb_parse_display but ownership of + them is passed to the caller. They have to be freed in + xcb_connect_to_display_with_auth_info. + + Signed-off-by: Pauli Nieminen + Signed-off-by: Peter Harris + +commit 18718d483e0982c779a61c71176fb0e64f850015 +Author: Pauli Nieminen +Date: Fri Jun 11 16:30:46 2010 +0300 + + _xcb_parse_display: Fix error path + + xcb_parse_display claims that there is no side effects when failing. + That requires _xcb_parse_display to free the memory in failure case. + + Signed-off-by: Pauli Nieminen + Signed-off-by: Peter Harris + +commit 3f79628becbd3b0eff1aef804902eb739fac4403 +Author: Jeremy Huddleston +Date: Wed May 12 19:53:45 2010 -0700 + + xcb_open: Improve protocol/host parsing + + Support scenarios where host is not set and protocol is. eg: + + DISPLAY=tcp/:0 + + as well as the "inet" and "inet6" alias for "tcp" for compatability + with Xlib + + Signed-off-by: Jeremy Huddleston + Reviewed-by: Jamey Sharp + +commit e4b746ac13e89b99abd80b3d1fa2a16796da3b6d +Author: Marcin Kościelnicki +Date: Thu May 13 21:05:57 2010 +0000 + + Add ~ operator support in code generator + + Reviewed-by: Julien Cristau + Signed-off-by: Julien Danjou + +commit 5e86cb05666c448de2f61c23ae94e94ef4b38d64 +Author: Arnaud Fontaine +Date: Fri Apr 30 18:49:18 2010 +0100 + + Fix GCC error on undeclared variable when not using abstract socket + + This is a regression found by tinderbox in previous commit: + + xcb_util.c: In function '_xcb_open': + xcb_util.c:213: error: 'fd' undeclared (first use in this function) + +commit a546d00091de0ab16374dec55e8e2fa87d6bbebf +Author: Arnaud Fontaine +Date: Fri Apr 30 14:47:16 2010 +0200 + + Get rid of PATH_MAX and MAXPATHLEN + + There could be no upper limit on the length of a path according + to POSIX, therefore these macros may not be defined at all on + some systems (such as GNU Hurd). + + Signed-off-by: Arnaud Fontaine + Reviewed-by: Peter Harris + +commit d06857217328c2283a8956788d72646fc67216fb +Author: Jeremy Huddleston +Date: Fri Apr 23 21:57:26 2010 -0700 + + Use limits.h instead of syslimits.h + + Regression found by tinderbox in 89b3485dadef47a30264a5bf150b96522183376b + + xcb_util.c:31:27: error: sys/syslimits.h: No such file or directory + xcb_util.c: In function '_xcb_open': + xcb_util.c:148: error: 'PATH_MAX' undeclared (first use in this function) + + Signed-off-by: Jeremy Huddleston + +commit 89b3485dadef47a30264a5bf150b96522183376b +Author: Jeremy Huddleston +Date: Fri Apr 23 17:29:25 2010 -0700 + + Reworked launchd support to work better with _xcb_parse_display + + Fixes: http://xquartz.macosforge.org/trac/ticket/390 + + Signed-off-by: Jeremy Huddleston + +commit 2dcf8b025be88a25d4333abdc28d425b88238d96 +Author: Jeetu Golani +Date: Fri Apr 23 00:47:16 2010 +0530 + + Replaced read() in read_block and _xcb_in_read() with recv for all + platforms. MSG_WAITALL is undefined in MinGW so it's been explicitly + defined in xcb_in.c + +commit 56962e42a509dc4d0d9541e46b93689dac61c4fd +Author: Jeetu Golani +Date: Thu Apr 22 23:23:27 2010 +0530 + + Set errno=0 in read_block. On Win32 there is no errno and this makes the + do..while loop execute only once. Also set the return value to -1 in + _xcb_open if control reaches the end - if all goes well it shouldn't + reach there. + +commit b0525e242368fffbc77ebb45293f34e80847e65a +Author: Jamey Sharp +Date: Sat Apr 17 17:59:11 2010 -0700 + + Always wake up readers after writing. + + Since writers must make sure they read as well, threads may have gone to + sleep waiting for the opportunity to read. The writer must wake up one + of those readers or the application can hang. + + Signed-off-by: Jamey Sharp + Reviewed-by: Josh Triplett + +commit eff3851ba80c42b5b3ba240f7e9049d7b0fac6f0 +Author: Jamey Sharp +Date: Sun Mar 28 10:31:55 2010 -0700 + + Fix strict-aliasing warning when getting generic event length. + + xcb_ge_event_t has its length field in the same place that + xcb_generic_reply_t does, so there's no need to cast the generic reply. + + Signed-off-by: Jamey Sharp + Cc: Peter Hutterer + Reviewed-by: Julien Danjou + +commit 6dd8228a137d280ce24cec604a419129d8ed0e8e +Author: Jamey Sharp +Date: Fri Feb 12 12:25:05 2010 -0800 + + Delete a useless level of indirection from _xcb_out_send's parameters. + + _xcb_out_send needs _xcb_conn_wait to store back its progress so it can + be reinvoked to pick up where it left off---but then _xcb_out_send + guarantees that it leaves either an empty output vector or a shut-down + connection, so *its* callers never care how much progress was made. + + Signed-off-by: Jamey Sharp + Reviewed-by: Josh Triplett + +commit a63fbc9d6c484e5ad7a5e9d56f81b8e1a2f38a82 +Author: Julien Danjou +Date: Fri Apr 9 16:57:51 2010 +0200 + + Release libxcb 1.6 + +commit a1d9aa6e07a297f4108b4ad787336f74c86a3312 +Author: Rémi Denis-Courmont +Date: Fri Mar 26 23:12:47 2010 +0200 + + Fail if fd is too big and poll() is not available + + Depending on the process file limit, a file descriptor can be larger + than the capacity of fd_set. There is no portable way to create a + large enough fd_set at run-time. So we just fail if the file descriptor + number is too high and poll() is not available. + + Reviewed-by: Jamey Sharp + Signed-off-by: Julien Danjou + +commit 0e0c80e749eccf121e55c1e855c48d03b54f33ef +Author: Jeetu Golani +Date: Wed Mar 31 22:00:04 2010 +0530 + + xcb_in.c #ifndef _WIN32 inside of #if USE_POLL redundant and removed + +commit e8009194c9f5a6995c4a9b03a7a49d5bc09e96fc +Author: Jeetu Golani +Date: Wed Mar 31 09:50:51 2010 +0530 + + restablished inclusion of fcntl.h and netinet/tcp.h in xcb_util.c -- without these the code no longer compiled on *ix + +commit d302f1e9b158d0a51936c28e5dc66251d90d1d56 +Author: Jeetu Golani +Date: Mon Mar 29 22:37:33 2010 +0530 + + changes in xcb_windefs.h - the flag _XCB_WINDEFS_H replaces WINDEFS_H + +commit 36c9a985aaee655c118c9f7b8425d3ac9ce0f840 +Author: Jeetu Golani +Date: Mon Mar 29 22:31:49 2010 +0530 + + windefs.h is now called xcb_windefs.h - changed all includes to reflect that.Replaced one instance ofWIN32 with _WIN32 in each xcb_in.c and xcb_conn.c + +commit bce72f63d2dfb61661f81e305ad3a7db0334403c +Author: Jeetu Golani +Date: Fri Mar 26 09:40:09 2010 +0530 + + Win32 code for xcb-1.5 + +commit d18d03d6f37ec220805855d840950716e22354e4 +Author: Samuel Thibault +Date: Fri Mar 12 23:51:32 2010 +0100 + + Fix authentication on hpux and Hurd + + libxcb's 010e5661 (Fix XDM-AUTHORIZATION-1 (bug #14202)) mistakenly + inverted a few lines of code, making local socket authentication fail on + hpux and Hurd: when getpeername fails, sockname needs to be initialized + by getsockname before its address family can be checked. + + Signed-off-by: Samuel Thibault + Signed-off-by: Julien Danjou + +commit 53a9834e4cdd11aba8c1cc49347f09a958107de8 +Author: Rémi Denis-Courmont +Date: Sat Feb 13 12:23:51 2010 +0200 + + Open the X11 socket with close-on-exec flag + + This saves the X11 connection from leaking into children processes. + On Linux, this is fully thread-safe using SOCK_CLOEXEC. On other + systems, there is a small race condition. + + Signed-off-by: Julien Danjou + +commit 367882fa32489ebafcd9afc04fbf732b02ceb33a +Author: Peter Harris +Date: Tue Feb 9 16:27:22 2010 -0500 + + Support xcb_discard_reply + + This function is useful for dynamic language garbage collectors. Frequently + a GC cycle may run before you want to block wainting for a reply. + + This function is also marginally useful for libxcb apps that issue + speculative requests (eg. xlsclients). + + Reviewed-by: Jamey Sharp + Tested-by: Eamon Walsh + Signed-off-by: Peter Harris + +commit be7e528eae62ddee14fa50f2c0e9036bafbc9f81 +Author: Rémi Denis-Courmont +Date: Thu Jan 7 18:08:35 2010 +0200 + + xcb_connect_to_fd: fix descriptor leak on memory error path + + Signed-off-by: Julien Danjou + +commit c7a57043da1717c18703a38772555fea6aa811bf +Author: Jeremy Huddleston +Date: Fri Dec 11 17:24:43 2009 -0800 + + configure.ac: Fix a typo on the last commit. + + Signed-off-by: Jeremy Huddleston + +commit 58c96da9283d3c2f65c818bd952f611ec4e4dad0 +Author: Jeremy Huddleston +Date: Fri Dec 11 17:15:16 2009 -0800 + + darwin: xnu doesn't support poll on ttys on the master side. + + + + Signed-off-by: Jeremy Huddleston + +commit 1e746fd89ae93965183c759b969ff9f4d5dbc9d8 +Author: Jim Ingram +Date: Mon Dec 7 14:41:18 2009 -0600 + + Tutorial code fix + + Accessed elements of names[] after freeing them in the first example. + + Signed-off-by: Julien Danjou + +commit a470579ba29c8f39e77668558a08bb173297711f +Author: Rémi Cardona +Date: Fri Dec 4 22:06:20 2009 +0100 + + DRI2 extension requires xcb-proto 1.6 or newer + + Signed-off-by: Rémi Cardona + Signed-off-by: Julien Danjou + +commit 6e875a82a8a1a324067970a5f9d7442585ee0eef +Author: Julien Danjou +Date: Thu Dec 3 11:34:18 2009 +0100 + + build: simplify extension building + + Signed-off-by: Julien Danjou + +commit 48217ac986d77eba40f3af4df597a734f4fd3690 +Author: Julien Danjou +Date: Thu Dec 3 10:08:59 2009 +0100 + + Release libxcb 1.5 + + Signed-off-by: Julien Danjou + +commit 1cf2a87def76f4646fe05e282b45605d572f2513 +Author: Adam Jackson +Date: Wed Dec 2 14:31:56 2009 -0500 + + setsockopt(SO_KEEPALIVE) on TCP display connections. + + This matches xtrans behaviour in SocketINETConnect, and makes it so apps + don't hang forever if their display dies. + + Signed-off-by: Adam Jackson + +commit e82c34c2f7ac3fbb23ab14cbee8df2dd9178f5a4 +Author: Eric Anholt +Date: Thu Oct 15 13:13:47 2009 -0700 + + Add DRI2 support. (v2) + + v2: Build fix from jcristau. + +commit a27c77ccae059fb64e0506648b81677858d3b05b +Author: Eric Anholt +Date: Thu Oct 15 13:14:49 2009 -0700 + + Fix typo in the tutorial. + +commit 17af34b4a438a80d3dcad93bb5254366791a488f +Author: Paulo R. Zanoni +Date: Fri Sep 18 15:05:46 2009 -0300 + + Don't build docs if 'dot' is not found Signed-off-by: Paulo R. Zanoni + +commit 29207e2943ad56fb8b4d2b7f07b1530cb1d7d9be +Author: Julien Cristau +Date: Mon Aug 31 17:51:36 2009 +0200 + + Fix check dependency + + Bugzilla #21992 + + make -j check fails because the check-local rule gets executed before + the tests actually ran, so CheckLog*.xml doesn't exist. + + Signed-off-by: Julien Danjou + +commit ff2e2e35bcac1d835c9eecf9ac8b3072005989a5 +Author: Yaakov Selkowitz +Date: Sat Jun 6 15:52:20 2009 +0100 + + Cygwin build fix: Add -no-undefined to libtool flags + + -no-undefined is needed to tell libtool a shared library can be built + on platforms which require all references to be statisfied at link time. + + Signed-off-by: Jon TURNEY + Signed-off-by: Julien Danjou + +commit 96ff5fb635bc333e80ebce6cc03008a1b9992ff6 +Author: Arnaud Fontaine +Date: Wed Jul 15 16:15:02 2009 +0100 + + Release libxcb 1.4 + +commit f4c2794bf5990a0b2f6168f2b22b60b15e08ac44 +Author: Arnaud Fontaine +Date: Wed Jul 15 16:03:56 2009 +0100 + + Add majorCode, minorCode and resourceID fields to X generic error + +commit e06955ed66cb499ada52b8add6709edd38d70054 +Author: Jamey Sharp +Date: Mon Jul 6 13:14:35 2009 -0700 + + Fix precedence bug: wrong length for big-requests preceded by sync. + + Also replace excessively clever use of bitwise OR with equivalent + addition. + + Reported-by: Geoffrey Li + Signed-off-by: Jamey Sharp + Signed-off-by: Josh Triplett + +commit 9e191c722a0be4b5f3d993165055a71f85c21882 +Author: Julien Cristau +Date: Fri May 29 14:41:59 2009 +0200 + + Fix libxcb-randr version info + + The SONAME shouldn't have been bumped in 1.3, only new symbols were + added. + + Signed-off-by: Julien Danjou + +commit f44dc519c5b324335d05f6e7fb31b78062a8c5f5 +Author: Julien Danjou +Date: Fri May 29 08:26:05 2009 +0200 + + Release libxcb 1.3 + +commit ee89850e68205a7f8961ace0839b5be86040dade +Author: elupus +Date: Tue May 26 16:14:48 2009 +0200 + + Disable Nagle on TCP socket + + Signed-off-by: Julien Danjou + +commit 62fe187e2d617eb0feb1ca03d8b4a64db9dd952b +Author: Bob Ham +Date: Mon May 25 12:20:23 2009 +0200 + + Store xcbproto version libxcb was compiled with + + Signed-off-by: Julien Danjou + +commit efbe96ee0ab0c5511035eee99f8fe7b38d5f65fa +Author: Julien Danjou +Date: Sat May 9 17:39:34 2009 +0200 + + depends on recent xcb-proto and bump version of randr + + Signed-off-by: Julien Danjou + +commit 010e566126625c56bdf9989085bacf731520ff87 +Author: Bart Massey +Date: Tue Apr 21 08:39:52 2009 +0200 + + Fix XDM-AUTHORIZATION-1 (bug #14202) + + With this patch, we know use correctly the socket address or peer + address for authentication purpose. + + Signed-off-by: Julien Danjou + +commit ca978a9dae621126075712f9e2c29591208570bc +Author: Julien Danjou +Date: Tue Apr 7 14:22:57 2009 +0200 + + util: remove useless strlen calls from decnet opening + + Signed-off-by: Julien Danjou + +commit cc191431412d8764c645a51b0f106c0dfe652213 +Author: Julien Danjou +Date: Tue Apr 7 14:18:40 2009 +0200 + + util: merge common code for xcb_connect + + Many code was duplicated between xcb_connect_to_display_with_auth_info + and xcb_connect(). We merge both, since the difference is just about the + xcb_auth_info_t pointer being supplied, or not. + + Signed-off-by: Julien Danjou + +commit 8797e053b2b2ee989f47490c7687b9a2fbdb0021 +Author: Julien Danjou +Date: Tue Apr 7 13:37:40 2009 +0200 + + util: open_abstract gets filelen as parameters + + That saves us from a couple of strlen() calls. + + Signed-off-by: Julien Danjou + +commit f0b29819749b769e5a8d313bf1bab80d6513208b +Author: Julien Danjou +Date: Tue Apr 7 11:55:30 2009 +0200 + + auth: use snprintf() return value + + That save us from a strlen(). + + Signed-off-by: Julien Danjou + +commit 9f24c91f91dd68a52e46191b686283b0df38d2f5 +Author: Julien Danjou +Date: Tue Apr 7 11:49:13 2009 +0200 + + auth: precompute authnameslen + + Signed-off-by: Julien Danjou + +commit 2a4f1cf3801080276694f5026d35220b65201038 +Author: Jeremy Huddleston +Date: Thu Apr 9 05:12:02 2009 -0700 + + darwin: Don't use poll() on versions of darwin before darwin10 + +commit 6e2e87d0bbdff87f127986a0666445160d52e6a5 +Author: Samuel Thibault +Date: Mon Apr 6 03:31:23 2009 +0200 + + Local socket connections do not work on hurd-i386 + + Local socket connections currently do not work on hurd-i386 because + xcb_auth calls getpeername() on the client socket, but hurd-i386 does + not implement anything in that case (I actually wonder what reasonable + value could be returned). In such case the xcb code does not actually + need the peer name anyway. + + Signed-off-by: Julien Danjou + +commit f916062edf0e04cd4e0a78f6975892f59fae3b60 +Author: Michael Ost +Date: Mon Mar 30 11:09:32 2009 +0200 + + use poll() instead of select() when available + + Signed-off-by: Julien Danjou + +commit beccb0be15f5699c942a0af33307d9e4bf797e2a +Author: Bart Massey +Date: Tue Mar 24 16:24:04 2009 -0700 + + kludgily hand-merged xid fixes + + Signed-off-by: Bart Massey + Signed-off-by: Julien Danjou + +commit 1e9c0f1012b6d349f92ea7246194b8667d27f849 +Author: Julien Danjou +Date: Mon Mar 16 10:26:02 2009 +0100 + + Fix do_append() arguments + + Signed-off-by: Julien Danjou + +commit fcb433db80315a44154248a9229c9cfcbab63f04 +Author: Julien Danjou +Date: Sun Mar 15 10:18:50 2009 +0100 + + Copy full IPv4 mapping (Bug #20665) + + Signed-off-by: Julien Danjou + +commit eaa71eac02c6a862ab23e8afcce12d9f38590338 +Author: Peter Harris +Date: Fri Mar 13 15:24:55 2009 -0400 + + Avoid name collisions between xidtype and enum. + + These changes are necessary to build with latest xcb/proto. + + Signed-off-by: Peter Harris + +commit e986d1ee5a126dc38113125075a1e986235ba7c7 +Author: Peter Harris +Date: Fri Mar 13 15:25:30 2009 -0400 + + Revert "Don't use enums in generated C code" + + This commit broke xcb/util. + + This reverts commit 9984b72888108a038d6b3f7dee374d17e26ef9e2. + + Signed-off-by: Peter Harris + +commit 9984b72888108a038d6b3f7dee374d17e26ef9e2 +Author: Peter Harris +Date: Wed Feb 25 18:48:50 2009 -0500 + + Don't use enums in generated C code - use integer constants instead. + + Signed-off-by: Peter Harris + +commit b08e1535cf0716fc917eaa1f5d5f6d1960bf1e3c +Author: Julien Danjou +Date: Tue Feb 17 13:37:29 2009 +0100 + + Release libxcb 1.2 + + Signed-off-by: Julien Danjou + +commit 2e65188f91800d7e6a8d74fa077b46f8f67b6893 +Author: Julien Danjou +Date: Mon Feb 16 11:44:20 2009 +0100 + + Stop providing autogenerated files in tarball + + Signed-off-by: Julien Danjou + +commit 37f5ce3ef46c8af38ec0103b9d960615a0a1e058 +Author: Julien Danjou +Date: Thu Dec 11 11:17:13 2008 +0100 + + Release libxcb 1.1.93 + + Signed-off-by: Julien Danjou + +commit f896ae8c53e99f39b347f9f0ac2b4a8cc12cad6f +Author: Jeremy Huddleston +Date: Sun Nov 23 17:25:21 2008 -0800 + + Shutup compiler warning about unused variable... + +commit d79621b25ba6784135b1a3aa51e9561fcf72fe7f +Author: Jeremy Huddleston +Date: Sun Nov 23 17:23:17 2008 -0800 + + Apple: Apple launchd cleanup + Added --with-launchd option instead of just using __APPLE__ + Fixed opening launchd fd when displayname=NULL + +commit 9b79ae49f709707e99b8487b01f9d3f102754bd3 +Author: Jeremy Huddleston +Date: Sat Nov 8 14:41:23 2008 -0800 + + Apple: Enable support for launchd DISPLAY socket + +commit 43b612a5e99ccdfb787a11b2b7c3179fc242edf3 +Author: Peter Harris +Date: Wed Nov 12 14:45:04 2008 -0500 + + Treat XIDs the same as other cardinal values. + + This fixes a bug where c_client.py wasn't generating *_end functions, + but expected them to exist in order to find the subsequent list's start. + + Signed-off-by: Peter Harris + +commit 902cade8ec9e7eb5d29f6f6d61cac0470c300aec +Author: Julien Danjou +Date: Tue Nov 4 10:19:14 2008 +0100 + + Release libxcb 1.1.92 + + Signed-off-by: Julien Danjou + +commit fa452cc9b2bb69fa0603dfd97e00e540b6b52840 +Author: Josh Triplett +Date: Sun Mar 16 23:16:31 2008 -0700 + + Support handing off socket write permission to external code. + + Libraries like Xlib, some XCB language bindings, and potentially others + have a common problem: they want to share the X connection with XCB. This + requires coordination of request sequence numbers. Previously, XCB had an + Xlib-specific lock, and allowed Xlib to block XCB from making requests. + Now we've replaced that lock with a handoff mechanism, xcb_take_socket, + allowing external code to ask XCB for permission to take over the write + side of the socket and send raw data with xcb_writev. The caller of + xcb_take_socket must supply a callback which XCB can call when it wants + the write side of the socket back to make a request. This callback + synchronizes with the external socket owner, flushes any output queues if + appropriate, and then returns the sequence number of the last request sent + over the socket. + + Commit by Josh Triplett and Jamey Sharp. + Handoff mechanism inspired by Keith Packard. + +commit baff35a04b0e8d21821850a405a550d86a8aeb6f +Author: Jamey Sharp +Date: Wed May 21 14:44:16 2008 -0700 + + Track 64-bit sequence numbers internally. + + External APIs that used 32-bit sequence numbers continue to do so. + + Commit by Josh Triplett and Jamey Sharp. + +commit 96e55444b9b9500420f9132a1ace720100a26398 +Author: Jamey Sharp +Date: Fri Mar 14 20:18:52 2008 -0700 + + Use sequence number ranges in pending replies + + This allows optimizing adjacent pending replies with the same flags, and + will help support default flags for a range of future requests. + + Commit by Josh Triplett and Jamey Sharp. + +commit 059ca642c76639fee958dc6054070de85e257e98 +Author: Jamey Sharp +Date: Fri Mar 14 12:08:58 2008 -0700 + + Inline _xcb_lock_io, _xcb_unlock_io, and _xcb_wait_io. + + These functions are once again a single pthread call, so just make that + call directly. + +commit d989656cde2ee7a4a66b2065209ef389495f3452 +Author: Jamey Sharp +Date: Fri Mar 14 12:08:32 2008 -0700 + + Remove libxcb-xlib and xcbxlib.h. + +commit dcbef23d730b95ef7dc9ef524a4c3fc0017b63d2 +Author: Julien Danjou +Date: Tue Oct 14 23:39:07 2008 +0200 + + build: fix configure.ac AC_DEFINE + + Rather use AC_DEFINE_UNQUOTED and only once. + + Signed-off-by: Julien Danjou + +commit cebd482a20fcc2b2dae0683c38e917a3740638a6 +Author: Julien Danjou +Date: Fri Sep 26 15:26:42 2008 +0200 + + allow compile-time setting for XCB queue buffer size + + Signed-off-by: Julien Danjou + +commit 625ed596cae6dd8175aeb6cb6f26784928042f22 +Author: Josh Triplett +Date: Wed Oct 8 16:04:25 2008 -0700 + + Remove duplicate XCB_EXTENSION calls for Composite extension + +commit db332dcda989b5b021dc220c102666f695c772cf +Author: Henning Sten +Date: Sat Sep 20 13:08:58 2008 +0200 + + fix tiny memory leak in read_packet (leak only happens when malloc returns NULL so it's very rare) + + Signed-off-by: Julien Danjou + +commit 9afadd2aef8af89a4f4ab70baeae0b848904c367 +Author: Carsten Meier +Date: Tue Sep 9 12:11:37 2008 +0200 + + Added generation of extern "C" for compatibility with C++ + + The auto-generated header files now include an extern "C" + declaration for compatibility with C++. + + Signed-off-by: Julien Danjou + +commit 25e59ccc0dc8baf344145d6d739229e8120330db +Author: Julien Cristau +Date: Tue Sep 9 04:42:36 2008 +0100 + + Add support for the abstract socket namespace under Linux + + Based on same in Xtrans. + + Signed-off-by: Julien Danjou + +commit f3f8738436d09f7e590b76e22a7a2cc4b16abd1d +Author: Julien Cristau +Date: Tue Sep 9 04:42:35 2008 +0100 + + Fix some fd leaks in _xcb_open_*() + + Signed-off-by: Julien Danjou + +commit d6d44e1bf09cca8aefbf4ce9875d7f794bf19fb1 +Author: Bart Massey +Date: Wed Sep 3 13:52:58 2008 -0700 + + fixed overly aggressive warning about fixed field following variable + +commit 7e0674e76186ee4491a089350511fc0d22fb3af3 +Author: Bart Massey +Date: Sun Aug 31 00:42:23 2008 -0700 + + added small fix to support trailing fixed fields; also warning for non-pad fixed fields + +commit 2d04a1e6cedcdc832e2db3c65ababc3aff904ec4 +Author: Vincent Torri +Date: Sun Aug 31 10:33:31 2008 +0200 + + factorize m4 macros and add one to set X extensions + + Signed-off-by: Julien Danjou + +commit bcf662c1b433b296060c66ae1656fcb5c6e697ef +Author: Julien Danjou +Date: Thu Aug 28 14:35:54 2008 +0200 + + Initialize all fields of addrinfo + + Signed-off-by: Julien Danjou + +commit baf31b1bf20b49ec00d0f64bb7cc9c788a28c088 +Author: Julien Danjou +Date: Thu Aug 28 13:51:38 2008 +0200 + + Use ifdef instead of if for defined value + + Signed-off-by: Julien Danjou + +commit 38d5de3a5573b2e89e97d04a809a3dd38a0fe8a7 +Author: Julien Danjou +Date: Wed Aug 27 13:56:28 2008 +0200 + + Set namelen unsigned + + Signed-off-by: Julien Danjou + +commit 9c9c09b376fe1ddcedd03c52cfc0b06867d998c9 +Author: Julien Danjou +Date: Wed Aug 27 13:56:26 2008 +0200 + + Rename index to idx to avoid shadowing + + Signed-off-by: Julien Danjou + +commit c5b2e53abf0b113d4cc4105127cf848ee450aa98 +Author: Julien Danjou +Date: Wed Aug 27 13:56:25 2008 +0200 + + Use a signed size in read_block() + + Signed-off-by: Julien Danjou + +commit 1bbdba52116f127bed3ce812a00240b4009bbf22 +Author: Julien Danjou +Date: Wed Aug 27 13:56:24 2008 +0200 + + Use unsigned to compare and rename sync + + - i must be unsigned to be compare in the loop + - sync shadow global sync() function + + Signed-off-by: Julien Danjou + +commit 6438584285de72858f97be891e16a125d13471d8 +Author: Julien Danjou +Date: Wed Aug 27 13:56:23 2008 +0200 + + Fix htonl() arg & convert sizeof() to signed + + Signed-off-by: Julien Danjou + +commit 1ead02e88eb9f37757eeb1cc8c762fc48d6d08ee +Author: Julien Danjou +Date: Wed Aug 27 13:56:22 2008 +0200 + + initialize global_id to 0 + + Signed-off-by: Julien Danjou + +commit f209d0ef7ad57a395c01ca09ecf48117a648e39c +Author: Peter Hutterer +Date: Thu Jul 17 13:57:41 2008 +0930 + + Bump to 1.1.91. + +commit cdc347938702dddbacb5af5c24988e9152b5447c +Author: Julien Cristau +Date: Wed Jul 16 23:25:04 2008 +0930 + + Make EXTHEADERS, EXTSOURCES, EXTENSION_XML unconditional of configure flags. + + yay, make distcheck works now even when some extensions are disabled. + + Acked-by: Peter Hutterer + +commit a9d15a08451c76a9250642c9f662f296196f60a0 +Author: Petr Salinger +Date: Mon Jul 7 17:57:37 2008 +0200 + + fix FreeBSD support + + The GNU/kFreeBSD (and BSDs in general) have a different + layout of struct sockaddr, sockaddr_in, sockaddr_un ... + + The first member do not have to be "sa_family", + they also have "sa_len" field. + + Signed-off-by: Julien Danjou + +commit ee78071902e93ce22a3170f0937c158fd16894d8 +Author: Peter Hutterer +Date: Wed May 28 17:41:35 2008 +0930 + + Bump to 1.1.90. + +commit 424ad131b7d97d6196181c31677655e6d52b41df +Author: Josh Triplett +Date: Wed May 28 12:26:13 2008 -0700 + + Fix variable declaration formatting + +commit 6532c715c3805128b9976ab208f1426f691056a2 +Author: Peter Hutterer +Date: Tue May 15 16:28:19 2007 +0930 + + Add xcb_ge_event_t and handling for long events. + + GenericEvent can be more than 32 bytes long. Ensure that the required data is + pulled off the wire and tack it onto the event. + + Due to the structure of the xcb_generic_event_t, the data is appended AFTER + the full_sequence field. + +commit b08a5909daf589d5e06c17c55d044f39c1d3479a +Author: Oswald Buddenhagen +Date: Thu May 1 16:17:55 2008 -0400 + + Fix libxcb/src compile with srcdir != builddir. + +commit 4a405feba8cde8490d847a57b7e833176e18b90f +Author: Eamon Walsh +Date: Wed Apr 23 20:26:28 2008 -0400 + + Replace a stray c-client.xsl in the libxcb SOURCES. Fixes make distcheck. + +commit 40566c36d543edc2118cbb358e0303d9e8862892 +Author: Eamon Walsh +Date: Wed Apr 23 20:25:57 2008 -0400 + + Use the python install path from xcb-xproto.pc to locate the xcbgen package. + +commit b3832bcc46d85110fdb2b553df6249a831cfe0fa +Author: Jeremy Kolb +Date: Sun Apr 20 16:26:51 2008 -0400 + + Add mention of PYTHONPATH if xcbgen cannot be found. + +commit 5ee915e12a102e86e141981bbce60ed81037dfdc +Author: Eamon Walsh +Date: Fri Apr 18 16:30:08 2008 -0400 + + Add Python parser C language-dependent part. + +commit 947a2e26e4217531e612a5110e6f95296c94614f +Author: Eamon Walsh +Date: Thu Jan 24 16:02:34 2008 -0500 + + Add SELinux extension support, disabled by default. + +commit 0b5f684eb0f8a8ad1887514568532037bb46020c +Author: Eamon Walsh +Date: Thu Jan 24 15:57:35 2008 -0500 + + Add XInput extension support, disabled by default. + +commit c72581c844efbaaa7e632377b57678f6668327fe +Author: Eamon Walsh +Date: Tue Jan 15 17:06:14 2008 -0500 + + Inputs to AC_CONFIG_FILES are automatically distributed. + Hence, it is not necessary to explicitly add them to EXTRA_DIST. + +commit 7a74ba3d0212f9bfe021d6da9070f71cbc53f85b +Author: Eamon Walsh +Date: Fri Dec 7 16:22:04 2007 -0500 + + Generated the configure.ac and Makefile.am's in libxcb with the idea of + making each extension library individually selectable for build. + + Signed-off-by: Eamon Walsh + +commit bcd1dcec9b242d7e2185c1ae83d3884844a2647f +Merge: baae582 9bf8329 +Author: Eamon Walsh +Date: Fri Dec 7 16:18:00 2007 -0500 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb/libxcb + +commit 9bf8329b50a8edacf00efb074f73c3bb759f7c8d +Author: Bart Massey +Date: Sat Nov 24 14:53:54 2007 -0800 + + make IPv6 optional + +commit 0593989103c48cc10165066d985c9f2d3355926b +Author: Eamon Walsh +Date: Fri Nov 16 19:38:40 2007 -0500 + + Remove file that wasn't meant to be committed. + +commit baae5826a6f51490e842be931c8b9f76086c4d98 +Merge: c3136d1 46413cd +Author: Eamon Walsh +Date: Fri Nov 16 19:36:08 2007 -0500 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb/libxcb + +commit 46413cd85ee4f3d51a3a3e1d8ee13bc5fa6c2d5d +Author: Eamon Walsh +Date: Fri Nov 16 19:34:42 2007 -0500 + + Add comment noting the requirement to free replies when finished. + +commit c3136d18321df31caa7f582d475132c2e02155de +Author: Eamon Walsh +Date: Fri Nov 16 19:33:20 2007 -0500 + + Add generated comment noting requirement to free replies after use. + +commit 3c6c8f127c2bce4f45bface7dd45cc719af9de0d +Author: Jamey Sharp +Date: Sun Nov 4 17:29:13 2007 -0800 + + Release libxcb 1.1 + +commit af50de26c10c93ccc4cd3bc61e92aff47651b961 +Author: Jamey Sharp +Date: Sun Nov 4 17:26:21 2007 -0800 + + Revert "Generate error constants as XCB_BAD_*, similar to Xlib." + + Since several extensions named their errors like "BadFoo", this patch + results in names like XCB_EXT_BAD_BAD_FOO, which is really awful. Those + extensions are already kind of awful, as they produce structure names + like xcb_ext_bad_foo_error_t, which is redundant. + + A patch that removes "Bad" from the XML extension descriptions, while + maintaining API and ABI compatibility in XCB, is needed before this + patch can be released. + + This reverts commit 158c9b6ba18b39f424bd524fceb66f3fec0d1616. + +commit a29fbc2645fabb96d02c382ffef499b48fb1514a +Author: Jamey Sharp +Date: Sun Oct 28 13:28:18 2007 -0700 + + Don't hold the xlib-xcb lock while sleeping: that allows deadlock. + + With this patch, `ico -threads 2` runs without deadlock. + + Many thanks to Christoph Pfister for + pointing out the problem, providing detailed analyses, explaining it to + me repeatedly until I understood what was going on, and proposing and + reviewing possible solutions. + + Signed-off-by: Jamey Sharp + Acked-by: Christoph Pfister + +commit f6b75d6090dc40918196d2b902e9616d0199af42 +Author: Jamey Sharp +Date: Sun Oct 28 11:56:08 2007 -0700 + + Factor pthread_cond_wait(iolock) to _xcb_wait_io. + + This parallels the _xcb_lock_io and _xcb_unlock_io factoring. + +commit 4d828c5eba9fc7161c5f18650f2dbe218e1db06f +Author: Jamey Sharp +Date: Tue Oct 23 11:03:33 2007 -0700 + + Don't abort() on locking assertions if LIBXCB_ALLOW_SLOPPY_LOCK is set. + + But do still print a full backtrace, on platforms where that's + supported. + + This commit follows the spirit of Novell's libxcb-sloppy-lock.diff. + + I strongly opposed proposals like this one for a long time. Originally I + had a very good reason: libX11, when compiled to use XCB, would crash + soon after a locking correctness violation, so it was better to have an + informative assert failure than a mystifying crash soon after. + + It took some time for me to realize that I'd changed the libX11 + implementation (for unrelated reasons) so that it could survive most + invalid locking situations, as long as it wasn't actually being used + from multiple threads concurrently. + + The other thing that has changed is that most of the code with incorrect + locking has now been fixed. The value of the assert is accordingly + lower. + + However, remaining broken callers do need to be fixed. That's why libXCB + will still noisily print a stacktrace (if possible) on each assertion + failure, even when assert isn't actually invoked to abort() the program; + and that's why aborting is still default. This environment variable is + provided only for use as a temporary workaround for broken applications. + + Signed-off-by: Jamey Sharp + Acked-by: Josh Triplett + +commit 09045eaac34973662aaa820a94ca8ed66d9dcb4e +Author: Egbert Eich +Date: Thu Jul 19 17:00:18 2007 +0200 + + Allow unix: style display names again. + + https://bugzilla.novell.com/show_bug.cgi?id=289007 + This notion is used in a lot of scripts. + +commit 65ffbc6cfdb97b14689d3baef183cd50fbd31a7f +Author: Josh Triplett +Date: Wed Jun 13 23:46:37 2007 -0700 + + Send locking assertion backtraces to stderr. Improve the heading on the backtrace. + +commit 605c778e695a4535c35c5324325f310b5faf80e2 +Author: Christoph Pfister +Date: Wed Jun 6 17:17:49 2007 +0200 + + Print backtraces in case an assert fails inside xlib/xcb. + + As you know there are some nasty libs / apps doing locking + incorrectly. In order to improve the information given to the user + when he encounters such a situation (people don't run apps in gdb + normally) I created the patch attached. + It's very non-intrusive (and affects only xlib/xcb, Josh told me on + irc that it could be useful for other areas too, personally I don't + think that it's really needed at other places ...). + + Some same outputs and the discussion of them: + + lxuser@pdln:/tmp$ ./main + Got a backtrace: + #0 /tmp/usr/lib/libxcb-xlib.so.0 [0xb7f9d728] + #1 /tmp/usr/lib/libxcb-xlib.so.0(xcb_xlib_unlock+0x31) [0xb7f9d861] + #2 ./test.so(function_a+0x11) [0xb7f9f3fd] + #3 ./test.so(function_b+0x11) [0xb7f9f410] + #4 ./main [0x80484a7] + #5 /lib/libc.so.6(__libc_start_main+0xdc) [0xb7e60ebc] + #6 ./main [0x80483f1] + main: xcb_xlib.c:82: xcb_xlib_unlock: Assertion `c->xlib.lock' failed. + Aborted + + That's kinda the normal situation. + + lxuser@pdln:/tmp$ ./main + Got a backtrace: + #0 /tmp/usr/lib/libxcb-xlib.so.0 [0xb7f90728] + #1 /tmp/usr/lib/libxcb-xlib.so.0(xcb_xlib_unlock+0x31) [0xb7f90861] + #2 /tmp/test.so [0xb7f923cd] + #3 /tmp/test.so(function_b+0x11) [0xb7f923e0] + #4 ./main [0x80484ab] + #5 /lib/libc.so.6(__libc_start_main+0xdc) [0xb7e53ebc] + #6 ./main [0x80483f1] + main: xcb_xlib.c:82: xcb_xlib_unlock: Assertion `c->xlib.lock' failed. + Aborted + + There are two possible reasons that the name doesn't appear in #2: + a) a hidden symbol or a symbol with statical linkage in a library + b) a symbol in an app not compiled with -rdynamic. + But in both cases you still know _where_ the caller is. + + Note that in this example test.so was compiled with + -fomit-frame-pointer; this isn't an issue as _one_ (= the caller) + stack trace is still valid (as long as you don't have the insane idea + to compile xcb with -fo-f-p). + + Another issue that may appear is "tail call elimination" (some entries + are mysteriously missing; this is quite ugly, but you still get enough + information so that you can do something useful with the issue e.g. by + disassembling the relevant parts with gdb). + + Signed-off-by: Jamey Sharp + +commit e20a31d72b8838cdf31b568431b5ad78492c1481 +Author: Jamey Sharp +Date: Sat Jun 2 18:29:37 2007 -0700 + + xcb_poll_for_event: Return already-read events before read(2)ing again. + +commit 2ec1383a68bf9f4baf7125a7d6544167f38d8d62 +Merge: 3abd416 158c9b6 +Author: Matthias Hopf +Date: Wed Apr 18 12:46:08 2007 +0200 + + Merge branch 'master' of git://anongit.freedesktop.org/git/xcb/libxcb + +commit 158c9b6ba18b39f424bd524fceb66f3fec0d1616 +Author: Ian Osgood +Date: Fri Apr 13 15:14:12 2007 -0700 + + Generate error constants as XCB_BAD_*, similar to Xlib. + + The previous constants remain for compatibility, but should be deprecated. + +commit f7279d8c8ae33d6e3029e85b14ed8495d3b00e30 +Merge: 0925e47 eaa380e +Author: TORRI Vincent +Date: Thu Apr 12 15:48:44 2007 +0200 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb/libxcb + +commit 0925e470b2abf8837c62e81428660a01bbb990fa +Author: TORRI Vincent +Date: Thu Apr 12 15:46:05 2007 +0200 + + remove the 7th bit of the response_type for the event loops + +commit 3abd41625c7d6db6d01f3167d6bac2b7481965cf +Author: Matthias Hopf +Date: Wed Apr 11 17:31:31 2007 +0200 + + Update autogen.sh to one that does objdir != srcdir + +commit eaa380efefd347abcd11a6c24c008686beaf8257 +Author: Eamon Walsh +Date: Tue Apr 10 11:56:06 2007 -0400 + + Modify new attribute from previous patch so that it is necessary only on + extensions with split names. Tested with diff and found no difference with + previous stylesheet header-file output. + +commit 91be36f845352dea7838853d0f98ae144fe571a4 +Author: Eamon Walsh +Date: Thu Mar 29 12:28:07 2007 -0700 + + Replaces special-casing in c-client stylesheet with support + for new attribute. Tested with diff and found no difference with + previous stylesheet header-file output. + +commit 4a60950b7433eb41e08cb0c74dc8ced8f92fd78a +Author: TORRI Vincent +Date: Tue Feb 27 13:35:02 2007 +0100 + + add the first step toward the documentation of the request/reply functions. The arguments of the requests are not found yet. Josh, can you look at it ? + +commit bca41cdcdb11e2a610d7b7a3d077cbb77bc81e45 +Author: TORRI Vincent +Date: Wed Feb 7 20:08:27 2007 +0100 + + and make the html code valid... + +commit acefe83bea9b2b17a956d68f5be504866d34196f +Author: TORRI Vincent +Date: Wed Feb 7 20:04:10 2007 +0100 + + font part + +commit 8a8c1fa184939ef23f96421990c171b49d16ee33 +Author: TORRI Vincent +Date: Wed Feb 7 18:57:46 2007 +0100 + + no more xid or id fields + +commit 6cedaece0e294d39fe090b87e2f60569b40a4554 +Author: TORRI Vincent +Date: Tue Feb 6 09:31:54 2007 +0100 + + add the complete cursor example. Make the html code valid + +commit ab22a4d61665bbe637b8c1f349fcfaf04e386e88 +Author: TORRI Vincent +Date: Mon Jan 22 11:40:15 2007 +0100 + + add doxygen doc for the *_end functions + +commit 342e9cefcc7d942714488f6b424fee7a5bdc741f +Author: TORRI Vincent +Date: Sat Jan 13 11:20:55 2007 +0100 + + fix all the occurence where a drawable where considered as a union + +commit 70a72f65e438888a5530e9911c36aad68833790f +Author: Josh Triplett +Date: Sun Dec 10 21:10:06 2006 -0800 + + Add autogen.sh to EXTRA_DIST. + +commit 867ae5eb5c19091365daad621b923f56ff699415 +Author: Josh Triplett +Date: Sun Dec 10 21:09:30 2006 -0800 + + Add tools/* to EXTRA_DIST. + +commit 67af2d24e4c46580479570cf09586a54b84b1b63 +Author: TORRI Vincent +Date: Tue Nov 28 20:26:54 2006 +0100 + + add doc tag for the _next functions. It creates doxygen doc in the header files for these functions + +commit 4c8777f87a28ff5bf45cbdddce509163dbcf8137 +Merge: e624cca f486075 +Author: TORRI Vincent +Date: Tue Nov 28 20:15:27 2006 +0100 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb/libxcb + +commit e624cca7df4c2c5bc5e44af1e851e5a0d17c88bd +Author: TORRI Vincent +Date: Tue Nov 28 20:14:16 2006 +0100 + + add some output informations to configure script + +commit f486075fa093846c3f32b3e4b9624c039ea26ba4 +Author: Tilman Sauerbeck +Date: Fri Nov 24 15:48:08 2006 +0100 + + If enable_build_docs is "no", we don't even try to look for doxygen. + + Also set BUILD_DOCS in that branch. Now the disable-build-docs works + as expected. + +commit 2e8e6debac39864450c0a69633086ad92459c25e +Author: Tilman Sauerbeck +Date: Fri Nov 24 15:43:39 2006 +0100 + + Fixed evaluation of the disable-build-docs argument. + + Now at least enable_build_docs is set correctly. + +commit 19dfaf93ac1b5e9d3ce09b1f8e2338e53a5d7324 +Author: Ian Osgood +Date: Sun Nov 26 09:26:32 2006 -0800 + + Fix unit tests for FreeBSD + + putenv() string must contain '=' + environment failure test is invalid if argument is NULL + +commit 98e2a5617ef1c9955b3b5553224c34f55c7c5d29 +Author: Josh Triplett +Date: Sat Nov 25 22:27:33 2006 -0800 + + Use substitition variables in xcb-xinerama.pc.in, not instances of their values + + xcb-xinerama.pc.in looked more like a generated .pc file; replace specific + instances of values provided by an invocation of configure with the general + substitution variables configure replaces. + +commit e74cdcd02e6814222a76c0a237efca16c423bb26 +Author: Ian Osgood +Date: Sat Nov 25 11:00:14 2006 -0800 + + Bug #9119: test xcb_popcount + +commit 05d23a724d4dde42b11d6e9dec9ccaf5a516e287 +Author: Jamey Sharp +Date: Fri Nov 24 16:22:13 2006 -0800 + + libXau didn't have a correct pkg-config file until 0.99.2: fail if an older version is found. + +commit 3360d0c79e98cf6b7f30b2d84f117aea0a28595d +Author: Jamey Sharp +Date: Fri Nov 24 13:24:05 2006 -0800 + + NetBSD doesn't have AI_ADDRCONFIG: use it only if it's available. + +commit 818811a7ac660e46d0dca1cbf9e53ad0475af330 +Author: TORRI Vincent +Date: Fri Nov 24 12:33:15 2006 +0100 + + replace all the _new functions with xcb_generate_id. repalce X11/XCB with xcb. Fix a description of the default background of a window + +commit 27f98afc2f7039f8546d6cab5a72f609c72299d6 +Author: Josh Triplett +Date: Thu Nov 23 07:30:51 2006 -0800 + + Release libxcb 1.0 + +commit 11738b2af0d8bfcf5b2f7c0d3e6ade1a14866b94 +Author: Diego 'Flameeyes' Pettenò +Date: Thu Nov 23 15:15:30 2006 +0100 + + Avoid race condition when using multiple make jobs + + Avoid race condition when symlinking XML files. + When declaring a rule with many files as target, the rule is called + when any of them is requested, resulting in multiple for loops happening + during a make process using more than one job. + Also, use '$(LN_S) -f' rather than removing and recreating a file, + that one should be as supported as 'rm -f' and requires one less command. + +commit 30c768b322f613d697a61997e081a19aecd0b07f +Author: Josh Triplett +Date: Thu Nov 23 02:11:02 2006 -0800 + + Rewrite automake's data installation rules, because they suck. + + Specifically, they didn't handle installing data from both srcdir and builddir. + We have the tutorial in the srcdir, and build the manual in the builddir. + + Also, stop rebuilding the manual for each make target in the doc directory, and + every time any of those targets get called. This change now makes the manual + never rebuild once built; we plan to fix that later, by rewriting the makefiles + to avoid recursive make, and then making the manual depend on the source files. + + Commit by Jamey Sharp and Josh Triplett. + +commit af3a15838fc7dc5b4e52197854deb54da6baeaf1 +Author: Josh Triplett +Date: Thu Nov 23 00:08:30 2006 -0800 + + Rework doxygen build and install to work with srcdir != builddir + + The documentation generation with doxygen now works when built out of tree, + with srcdir != builddir. xcb.doxygen now gets generated from xcb.doxygen.in, + so that it can use top_builddir and top_srcdir to find source and to output + documentation. Also fill in PROJECT_NUMBER from @VERSION@, now that we have + it readily available via autoconf. + +commit 608058ec80edb041ca012d530b42d97474f80320 +Author: Josh Triplett +Date: Wed Nov 22 22:47:15 2006 -0800 + + Remove --with-opt and --with-debug options from configure.ac; use CFLAGS instead + + configure supports using custom CFLAGS, so remove the --with-opt and + --with-debug options from configure.ac, and the corresponding usage of + COPTFLAGS and CDEBUGFLAGS in src/Makefile.am. + +commit 1aade6a15f767c49db5c1b69b97a5b1bf8cdce57 +Author: Josh Triplett +Date: Wed Nov 22 21:49:52 2006 -0800 + + Check for getaddrinfo rather than gethostbyname in configure.ac + + Since the addition of IPv6 support, we now use getaddrinfo rather than + gethostbyname; update configure.ac accordingly. + +commit 183c2ba4cca71f4b12f106f801f0bd30c4c527f1 +Author: Jamey Sharp +Date: Wed Nov 22 21:27:41 2006 -0800 + + xcb-proto has no libraries or headers, so don't use XCBPROTO_CFLAGS or XCBPROTO_LIBS. + +commit e54dfd73a9652bbc103f3f874abc303aed4b5d76 +Author: Jamey Sharp +Date: Wed Nov 22 20:29:04 2006 -0800 + + Use pthread-stubs as needed, and list xdmcp in Requires.private when XCB is built to use it. + +commit 3de6ab7b786775d9e7df1523c27cdfe3ffd3a25f +Author: Josh Triplett +Date: Tue Nov 21 20:29:34 2006 -0800 + + Replace uses of "long" with uint32_t, and similar; fixes 64-bit bugs + +commit 7fbfebaa3fb3a5ca2d2a307a0a5c40c015e18115 +Author: Ian Osgood +Date: Tue Nov 21 09:04:37 2006 -0800 + + Fix IP6 work for FreeBSD/Mac. + +commit 684b8271a4539527daa15da82ad0cc302fb44727 +Author: Josh Triplett +Date: Tue Nov 21 00:57:49 2006 -0800 + + Support XDM-AUTHORIZATION-1 on IPv6 + + Commit by Jamey Sharp and Josh Triplett. + +commit d6abe93b06c421b78e92d76ceb5ca181e3adff31 +Author: Josh Triplett +Date: Mon Nov 20 23:25:41 2006 -0800 + + Refactor auth code to get display number from xcb_connect + + Change xcb_connect to pass the display number to _xcb_get_auth_info, which + passes it to get_authptr. This allows get_authptr to stop hacking the display + number out of the sockaddrs of various address families, such as + port - X_TCP_PORT, or the number after the last X in the UNIX socket path. This + also removes a portability bug introduced during the IPv6 changes: relying on + '\0'-termination of the UNIX socket path in a sockaddr_un. + + Commit by Jamey Sharp and Josh Triplett. + +commit 4a928de402a6e69886921fe428bbffb909c6405e +Author: Josh Triplett +Date: Mon Nov 20 22:26:40 2006 -0800 + + Only use AI_NUMERICSERV if defined. + +commit 907f8c8c4906cbd2352f3bbddfe144ad81a2cfa8 +Author: Josh Triplett +Date: Mon Nov 20 22:16:24 2006 -0800 + + Support authentication for IPv6 connections + + Support AF_INET6 in get_authptr, and refactor to use common code for IPv4 and + v4-mapped IPv6 addresses. + + Commit by Jamey Sharp and Josh Triplett. + +commit 48776ce233bf77fbaddbe972d2356bca69094239 +Author: Josh Triplett +Date: Mon Nov 20 17:53:30 2006 -0800 + + Support displays with IPv6 addresses or hosts which resolve to IPv6 addresses + + xcb_parse_display already correctly handled IPv6 displays. Now, _xcb_open_tcp + uses getaddrinfo, and correctly connects to IPv6 displays. Displays can use + bare IPv6 addresses, square-bracketed IPv6 addresses, or hostnames which + resolve to IPv6 addresses. + + Since IPv6 addresses may include colons, including at the end, revise the + DECnet display parsing code to avoid triggering on IPv6 addresses. + + Authorization may not work with IPv6 connections yet. + + This commit brought to you by the (display) number ::1:1.1, the letter X, + the Gobby collaborative editor, Josh Triplett, and Jamey Sharp. + +commit 6c3a8db3f69aebf2b5c1330ec6c11b3138f9bdfe +Author: Josh Triplett +Date: Mon Nov 20 17:48:49 2006 -0800 + + Add new xcb_parse_display test cases, most related to IPv6 addresses + +commit 3d9bb02012b35fd51ed3352d0bd974a0f6e439d8 +Author: Jamey Sharp +Date: Sun Nov 19 21:48:27 2006 -0800 + + Bug #5958: Also zero out the implicit pad byte in empty requests. + +commit 3fa50020d2d9b78e22cf3597f4688c4e22df5121 +Author: Jamey Sharp +Date: Sun Nov 19 18:31:48 2006 -0800 + + Remove support for the tag: nothing needs it. + + Only one use of remained, for a list length expression in + xv.xml. List length parameters that don't actually appear in the + protocol should be left implicit: if no length expression is given, then + a localfield will be automatically created by c-client.xsl. + +commit 16e7328b4a366b29d54696aafffe62c92e0e0130 +Author: Jamey Sharp +Date: Sun Nov 19 17:56:32 2006 -0800 + + Bug #5958: zero out padding bytes in requests. + +commit 6eee1707ea7bc303620e39911706d5fb71fa16b0 +Author: Jamey Sharp +Date: Sun Nov 19 00:30:37 2006 -0800 + + htmldir was introduced in autoconf 2.59c: set a reasonable value for earlier versions. + +commit da4d56ef5a880eb24014a141e6e16668ab51f180 +Author: Jamey Sharp +Date: Sun Nov 12 15:30:10 2006 -0800 + + Provide xcb_prefetch_maximum_request_length counterpart to xcb_get_maximum_request_length. + +commit aedfa1fe1d91a10ccfe3ee6ac6b7a25885623dc6 +Author: Jamey Sharp +Date: Sat Nov 18 21:30:12 2006 -0800 + + Fix Doxygen warnings. + + Specifically, fixes these two warnings which were emitted for every + generated source file: + + * Warning: end of file while inside a group + * Warning: group XCB_BigRequests_API already documented. Skipping documentation. + +commit 44a2160c95f6c90d461d66c0278348c62d2d77fa +Author: Jamey Sharp +Date: Sat Nov 18 19:36:48 2006 -0800 + + Make doc installation work and simplify doc/Makefile.am. + + Don't override the default htmldir with an unquoted copy. + + Don't suppress `make` echoing on Doxygen commands. + + Ensure the tutorial is always installed even if Doxygen isn't + available. + + Take better advantage of the automake installation infrastructure. + +commit 142fe9a6f2b13d42b0e4baaa25155067f45d065b +Author: Jamey Sharp +Date: Sat Nov 18 16:51:01 2006 -0800 + + Turn off Doxygen warnings for undocumented API, for now. + + But warn about absent parameter documentation for functions that are + otherwise documented. + +commit 3634299ecc5223e8505d19468cf04770ac08ec14 +Author: Jamey Sharp +Date: Thu Nov 16 17:02:17 2006 -0800 + + Switch from the old AM_PATH_CHECK macro to pkg-config. + + check 0.9.4 is now required to build XCB's unit tests. + + The version that we were requiring was not actually new enough to let + our unit tests compile, and the AM_PATH_CHECK macro is now considered + deprecated. We know that versions of check using pkg-config are new + enough to work, and the check dependency was optional anyway, so we've + dropped support for older versions. + +commit 82762555a1af0b170d01e2042eefe34086e6c132 +Author: TORRI Vincent +Date: Sun Nov 5 18:24:30 2006 +0100 + + add Makefile.am for building/installing doxygen doc + +commit f32c7131cc89c64e09e9a88c5f859824c0dfa54f +Author: TORRI Vincent +Date: Sun Nov 5 18:22:55 2006 +0100 + + add xcb.doxygen to EXTRA_DIST + +commit e3b7009dc0be6515d23fbda9c744082506df4cb0 +Merge: 0262cd6 32cd2d2 +Author: TORRI Vincent +Date: Sun Nov 5 18:21:34 2006 +0100 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb/libxcb + +commit 0262cd63a2c10e52daa3bd71cb21a6a37017f234 +Author: TORRI Vincent +Date: Sun Nov 5 18:20:45 2006 +0100 + + add AM_CHECK_DOXYGEN macro + +commit 32cd2d20477ab17704f0a2696c2b3bc2ff8f42de +Author: Jamey Sharp +Date: Thu Nov 2 18:04:16 2006 -0800 + + Release libxcb 1.0 RC3 (0.9.93). + +commit 9d155160546798052533c277c877879e83f85979 +Author: Jeremy Kolb jkolb@brandeis.edu +Date: Sun Oct 29 19:31:09 2006 -0500 + + Added initial doxygen generation stuff. This should probably be cleaned up later. + + Added support for major/minor-version attributes in the xcb tag. This is just to give some reference and help people when using *query_version. + +commit 8eba8690adac2c4425f4cac490c77f9f3b1da6f7 +Author: TORRI Vincent +Date: Fri Oct 20 07:00:15 2006 +0200 + + fix doxy doc + +commit a5529a4f2f1a9ed117e3465f0e422b707db21c68 +Author: Jamey Sharp +Date: Wed Oct 18 23:28:27 2006 -0700 + + Add doxygen config file. + + Thanks to Jeremy Kolb for the initial version. + +commit 094248405fd9c0957b92f13acb92461ab61b2c3f +Author: Jamey Sharp +Date: Wed Oct 18 23:23:00 2006 -0700 + + Quit treating xproto specially: handle it like all the extensions. + +commit 6bc0b37303f26faf6fbdcbbee444c227e83a329c +Author: Jamey Sharp +Date: Wed Oct 18 23:21:39 2006 -0700 + + Ignore generated xinerama files. + +commit 5abb10d63ffebbe34054ae17bbdfd142e0b36396 +Author: Josh Triplett +Date: Mon Oct 16 05:11:57 2006 -0700 + + Also test xcb_parse_display with NULL argument and display in $DISPLAY + +commit 9d619d14e347b9dd1d544627060023a4bca2452b +Author: Jamey Sharp +Date: Sun Oct 15 12:34:30 2006 -0700 + + Match only XCB-namespaced XID generators when converting to xcb_generate_id. + + Thanks to Vincent Torri for pointing out that I screwed up. :-) + +commit 5ec55dc9c0c51137d89dd870ede05cc3268f75ae +Author: Zephaniah E. Hull +Date: Sat Oct 14 19:52:23 2006 -0700 + + Define and use constants for opcode numbers. + + Hard coding the opcode numbers in the function just makes it harder to figure + out what's going on, but much more to the point, not defining the opcodes in + the header makes it impossible to use the generated headers instead of the + x11proto headers in the server. + + The name I settled on is very simple, for an extension by the name of xconf, + and a request by the name of list_devices, we get XCB_XCONF_LIST_DEVICES. If + this somehow causes problems, we can probably add a _OP somewhere in there, + but. + + Acked-by: Jamey Sharp + Closes: #8641 + +commit c1504691ec2786594e8ffc33f3962f460f041971 +Author: Jeremy Kolb +Date: Thu Oct 12 23:52:59 2006 -0400 + + Add library support for xcb-xinerama. + + This is version 1.1 of the Xinerama (PanoramiX) extension. + +commit 7f74dd6b643f7769701c31587bf3cfa9c5a8e980 +Author: Josh Triplett +Date: Sun Oct 8 18:16:14 2006 -0700 + + Add note to xcbxlib.h that nothing except Xlib/XCB should use it. + +commit 431f210bbb20e39a24ac879af5f2a8a7744e6a6c +Author: Jamey Sharp +Date: Sat Oct 7 19:50:55 2006 -0700 + + Release libxcb 1.0 RC2 (0.9.92). + +commit e0fac22caaf27b3e461807f8c563d0457938baa6 +Author: Jamey Sharp +Date: Sat Oct 7 18:35:53 2006 -0700 + + Bugfix: make Plan 7 'checked' requests work correctly. + + The initial implementation of Plan 7 dumped all X errors into the event + queue, because the record of a pending reply was pruned too early if an + error occurred in place of the expected reply. + +commit 7b84d8b650a611d4d76083340e50cb7ea815014d +Author: Ian Osgood +Date: Sat Oct 7 14:09:29 2006 -0700 + + Document xcb_generate_id. + +commit 9e10819a678970928c9f9a1fffb4ba00f5ac7c57 +Author: Josh Triplett +Date: Sat Oct 7 13:16:43 2006 -0700 + + Move xcb_generate_id from xcbext.h to xcb.h + + Since extensions no longer provide type-specific XID-generation functions, + xcb_generate_id now forms part of the xcb client API, rather than the + extension API; move it from xcbext.h to xcb.h accordingly. + +commit b9e49b2a47e7388e20f8a5c009cdaf0b369e117c +Author: Josh Triplett +Date: Sat Oct 7 01:27:26 2006 -0700 + + Stop implicitly importing xproto; goes with proto change to explicitly import it + +commit dd5ece606587d3e41058df803ab1804654195bbb +Author: Jamey Sharp +Date: Sat Oct 7 01:27:03 2006 -0700 + + Declare "struct foo" or "enum foo" as well as the typedef'd name "foo". + +commit 16ec51397e0711526457709605cf6b5ebf00b5e2 +Author: Josh Triplett +Date: Sat Oct 7 00:14:50 2006 -0700 + + Handle "xidunion" instead of "union" for XID unions like DRAWABLE and FONTABLE + +commit 7b786bd8f34e67617beda4f952a5a636a370396a +Author: Jamey Sharp +Date: Fri Oct 6 23:32:18 2006 -0700 + + api_conv.pl: replace xcb_*_new with calls directly to xcb_generate_id, now that we have no type-safety XID wrappers. + +commit c73ff37b907c8af6d03ab69cca27bc837c1cc189 +Author: Josh Triplett +Date: Fri Oct 6 20:11:19 2006 -0700 + + Refer to the "xlib lock" rather than the "IOLock" in xcbxlib.h + +commit 90eeb461be4975ff35d187ba64fedbb16ff13d15 +Author: Josh Triplett +Date: Fri Oct 6 17:44:53 2006 -0700 + + Remove XID wrapper structures and replace them with uint32_t typedefs + + After positive feedback from several people, we have decided to remove the XID + wrapper structures that attempted to provide C type safety, and replace them + with uint32_t typedefs. Feedback has indicated that these type-safety hacks + generated more trouble than help. + + We will bump the libxcb soname at the next release. + +commit 9bd2c0c58fbe4c994e76619c2d67e46ed8b43030 +Author: Jamey Sharp +Date: Fri Oct 6 16:47:50 2006 -0700 + + Remove xcb_get_io_lock from the Xlib-specific API: it is no longer used. + +commit 34168ab549fdf7c6c8a6fbe39824116698d01b12 +Author: Jamey Sharp +Date: Fri Oct 6 16:12:04 2006 -0700 + + Remove the 'int *error' out-parameter for xcb_poll_for_event. + +commit 40589db8124b8c72894deb86a825c6117b0a2cd2 +Author: Jamey Sharp +Date: Wed Oct 4 15:01:00 2006 -0700 + + Add xcb_xlib_lock and xcb_xlib_unlock, a special-purpose two-level recursive lock just for libX11. + +commit 57b0cd8fea498a32ff2322583c7278d5e86aa4e8 +Author: Jamey Sharp +Date: Wed Oct 4 12:23:45 2006 -0700 + + Factor out pthread_mutex_lock and unlock calls for the iolock. + +commit e7f473afbd02c87cc6b1fc9c7c240d6c5cc26763 +Author: TORRI Vincent +Date: Sat Sep 30 13:06:58 2006 +0200 + + fix some indentation, remove args of the main function (not needed), xcb_sync -> xcb_aux_sync. Jamey, it seems that your script transforms XCBGetSetup into a type, instead of a function. Same for XCBSetupVendor. Maybe there are other fuctions that have the same problem. + +commit 408e74538676230e289d79c6b0195b464bfc6606 +Author: TORRI Vincent +Date: Sat Sep 30 12:45:12 2006 +0200 + + update tutorial to the new api. Add some doc about cursors. Add some colors to section 6 (Opening and closing the connection to an X server). Tell me if you want to keep colors or not (colors can be modified in xcb.css) + +commit 15993fccd0b0cba870b793345fb5c5ec13ece0c8 +Author: Jamey Sharp +Date: Mon Sep 25 05:12:07 2006 -0700 + + Release libxcb 1.0 RC1 (0.9.91). + +commit f7cd80142fa83d531850df2c2a3b4a514129170b +Author: Josh Triplett +Date: Mon Sep 25 05:10:37 2006 -0700 + + Stop installing the protocol descriptions for extensions to an extensions/ + subdirectory + +commit 0d7beff580232d4b7adfc840bcd1cae894b57682 +Author: Josh Triplett +Date: Mon Sep 25 04:43:04 2006 -0700 + + Actually install xcb-xlib.pc, and ship xcb-xlib.pc.in in distribution tarballs + +commit d04e7777d3547de2cece0734c0b9be49d3ddb88c +Author: Jamey Sharp +Date: Mon Sep 25 04:14:26 2006 -0700 + + Ensure api_conv.pl is idempotent on names of constants: XCB_[A-Z0-9_]+. + +commit 0bccf7d2eed45ba15a012d090b9b950075e75803 +Author: Jamey Sharp +Date: Mon Sep 25 04:03:01 2006 -0700 + + Move header files to $includedir/xcb (generally $prefix/include/xcb). + +commit 9100981d359f6366ab92b456e6069bac89afeb15 +Author: Josh Triplett +Date: Mon Sep 25 02:02:16 2006 -0700 + + Split the Xlib compatibility functions into a separate library libxcb-xlib + + We don't want to have to change the libxcb soname if we later manage to remove + the Xlib compatibility functions, and nothing except Xlib should ever use + them, so split them into a separate library. + +commit 810dfb886247dc4484886aff2e2e7d80ea945de4 +Author: Jamey Sharp +Date: Mon Sep 25 02:10:44 2006 -0700 + + Move debian/ directory to new branch "debian". + +commit 46b7dbdd9306235ae04da9d0e3431a1b58f89048 +Author: Jamey Sharp +Date: Mon Sep 25 02:00:23 2006 -0700 + + We no longer need xproto: do not list it as a dependency. + +commit cf80bab8e6410915ad27a61cef3bb5f456c7d80f +Author: Jamey Sharp +Date: Mon Sep 25 01:21:42 2006 -0700 + + Lowercase library names to correspond with the new API. + +commit a1a7646d5a791c2e918bc1a9f46d64334d5ab575 +Author: Ian Osgood +Date: Sun Sep 24 14:10:20 2006 -0700 + + Add XCBAllPlanes from xcb-image util library. + +commit dfbde9a4e972ed9bbd701fd6f89c3a6e6f641740 +Author: Josh Triplett +Date: Sun Sep 24 03:15:39 2006 -0700 + + Integrate top-level .gitignore into .gitignore for each subdirectory + + In preparation for the repository split, move the relevant contents of the + top-level .gitignore into the .gitignore for each immediate subdirectory. + +commit 905379e4474c0137e5dd535798ae0afb07070df6 +Author: TORRI Vincent +Date: Sun Sep 24 08:51:20 2006 +0200 + + now, I know how to use api_conv.pl :) + +commit 16516a5e94205edffddde546abc833106c68068e +Author: Josh Triplett +Date: Sat Sep 23 14:44:15 2006 -0700 + + Remove the xcb_[extension]_init functions; use xcb_get_extension_data directly + +commit 9691890529fddc051c15e191a8a5f06017514c1c +Author: Josh Triplett +Date: Sat Sep 23 14:17:52 2006 -0700 + + More fixups for incorrect API conversions by api_conv.pl + +commit 0a867d72337afa88f4ab453b6d3fbb519368c308 +Author: Josh Triplett +Date: Sat Sep 23 13:59:40 2006 -0700 + + Convert the XCB test suite to the new API + +commit 63b38f31974b0a61c923a62a2d224e7024a0fc2b +Author: Jamey Sharp +Date: Sat Sep 23 13:51:10 2006 -0700 + + Apply const-names.xsl to the un-renamed XML; replace the XSL with the result. + +commit 86a4c0cc284366bbb01898a77df360278d5a8194 +Author: Josh Triplett +Date: Sat Sep 23 13:33:27 2006 -0700 + + We do not conflict with Xmd.h anymore; remove the include hack from xcb_auth.c + +commit 4ff12a1a94895837dc85ac9e37fd1a5f40819cf3 +Author: Josh Triplett +Date: Sat Sep 23 13:31:13 2006 -0700 + + Fix some mis-conversions by api_conv.pl, and remove the now-unused Xmd types + +commit a3bd6f4760b5b3f5f360a690920839646e2b9d06 +Author: Josh Triplett +Date: Sat Sep 23 12:22:22 2006 -0700 + + The Great XCB Renaming + + Rename API to follow a new naming convention: + * XCB_CONSTANTS_UPPERCASE_WITH_UNDERSCORES + * xcb_functions_lowercase_with_underscores + * xcb_types_lowercase_with_underscores_and_suffix_t + * expand all abbreviations like "req", "rep", and "iter" + + Word boundaries for the names in the protocol descriptions fall: + * Wherever the protocol descriptions already have an underscore + * Between a lowercase letter and a subsequent uppercase letter + * Before the last uppercase letter in a string of uppercase letters followed + by a lowercase letter (such as in LSBFirst between LSB and First) + * Before and after a string of digits (with exceptions for sized types like + xcb_char2b_t and xcb_glx_float32_t to match the stdint.h convention) + + Also fix up some particular naming issues: + * Rename shape_op and shape_kind to drop the "shape_" prefix, since otherwise + these types end up as xcb_shape_shape_{op,kind}_t. + * Remove leading underscores from enums in the GLX protocol description, + previously needed to ensure a word separator, but now redundant. + + This renaming breaks code written for the previous API naming convention. The + scripts in XCB's tools directory will convert code written for the old API to + use the new API; they work well enough that we used them to convert the + non-program-generated code in XCB, and when run on the old program-generated + code, they almost exactly reproduce the new program-generated code (modulo + whitespace and bugs in the old code generator). + + Authors: Vincent Torri, Thomas Hunger, Josh Triplett + +commit ca72e777740f917753f3c180fdfdb55df91c09c4 +Author: Jamey Sharp +Date: Sat Sep 23 01:33:45 2006 -0700 + + Special cases to agree with the conventions Josh and I have hashed out. + +commit 4168ddc13dff7bf2479c2229f42b114d75098112 +Author: Jamey Sharp +Date: Fri Sep 22 22:53:17 2006 -0700 + + Handle remaining incorrect API translations in api_conv.pl. + + The big change is treating numbers as separate "words" in the + translation, which leads to funny-looking names like xcb_char_2_b_t, but + makes more sense than the alternative in other situations and was + suggested on the mailing list. + + This version still disagrees with Vincent's last proposed XSL, but I + think my output is now preferable. Hopefully Josh has been thinking + along the same lines. + +commit 91568d7070e2c2400dfdbdff515f51da74ca3701 +Author: Jamey Sharp +Date: Fri Sep 22 15:37:49 2006 -0700 + + Make xcb_conn.c agree that XCBSetupReq is now XCBSetupRequest. + +commit 2538acd8c89d73e8c074849c63857cb899a29bbb +Author: Alan Coopersmith +Date: Fri Sep 22 11:53:21 2006 -0700 + + List xproto.xml path explicitly instead of relying on GNU Make $< expansion + + (Some non-gnu makes, such as Solaris make, only recognize $< in implicit + suffix rules, not explicit ones like this.) + +commit 2c8b5994b3fbba343199ef555594a32e29d8bcee +Author: Jamey Sharp +Date: Fri Sep 15 01:51:05 2006 -0700 + + Shut down the connection in all "fatal" error cases. + +commit 79e3227022ae3d66f9f3806d231fdeec2a06cc6b +Author: Jamey Sharp +Date: Fri Sep 15 01:57:53 2006 -0700 + + Add a private connection shutdown method for error cases. + +commit 7f71bf9c0f30536e85907b2c991cb7001861e1d3 +Author: Jamey Sharp +Date: Fri Sep 15 01:09:27 2006 -0700 + + Make all public functions do nothing on an error connection. + +commit 0aa96bfc7abe18889cd85bfaa05b05d53e572bb1 +Author: Jamey Sharp +Date: Fri Sep 15 00:39:51 2006 -0700 + + Convert connection functions to return error objects. + +commit ac17ae62fe1a3a29991e36e35eeee838ac4acb00 +Author: Jamey Sharp +Date: Fri Sep 15 00:29:39 2006 -0700 + + Provide a "has error" property for XCBConnection. + +commit df7fb77d6e22be76ca73f111c586db99a60178ae +Author: Jamey Sharp +Date: Thu Sep 21 12:13:37 2006 -0700 + + Refactor XCBPollForEvent with a shorter critical section. + + This simplifies the patch for bug #8208 later. + +commit b08ca2b4b451a94ece20207766cd5262fd55179b +Author: Jamey Sharp +Date: Mon Sep 18 16:52:00 2006 -0700 + + XCB*Id is a variable, not a type: adjust API conventions accordingly. + +commit 3cc0ddf0e6b72ba553ebfc2b9126d62ef4013bd3 +Author: Jamey Sharp +Date: Wed Sep 13 12:30:11 2006 -0700 + + Fix bug #7261: events do not signal the end of replies for that sequence number. + +commit c912187f15c560c46768acb88aae30e67b0f78ce +Author: Jamey Sharp +Date: Mon Sep 18 00:25:26 2006 -0700 + + Handle names of constants during API conversion. + + Use an XSLT stylesheet to get a list of all the constant names. + +commit 06fba014435cfbdd1ff284d6d513d114503d02c2 +Author: Jamey Sharp +Date: Sun Sep 17 23:38:57 2006 -0700 + + Complete rewrite of api_conv.pl. + + Now handles all API changes except constant names, which are treated like type names. + +commit bf41af718d6a83532d1c2f63ac16e6484e8e8b68 +Author: Jamey Sharp +Date: Thu Sep 14 00:04:47 2006 -0700 + + Simplify the API conversion tool without functionality changes. + +commit cdffbdd7ef9dee58b3c36ca46bb88aa187b46526 +Author: Thomas Coppi +Date: Wed Sep 13 23:50:23 2006 -0700 + + Prototype API conversion tool for upcoming lowercased XCB API. + +commit a92716f1da2741fca850b3c37299e80032726276 +Author: Jamey Sharp +Date: Wed Sep 13 12:15:23 2006 -0700 + + Finish removing deprecated functions. Fixes build failure (oops). + +commit 476ccc1ba3d20f3a545b84089b6fbd40576e7bf5 +Author: Jamey Sharp +Date: Tue Sep 12 13:43:17 2006 -0700 + + Ignore xproto.xml that now gets copied in while building. + +commit 0d7fb3afdd308d714a97144125a69a5f4976916a +Author: Jamey Sharp +Date: Tue Sep 12 13:25:49 2006 -0700 + + Remove deprecated public API functions in preparation for 1.0 release. Xlib-specific deprecation remains. + +commit d4e768fc32ff9ce79a4259d252f4a4a4b11d5db8 +Author: Bart Massey +Date: Tue Sep 12 00:42:11 2006 -0700 + + Cleaned up previous fix for GNU Make stuff. + Got "make distcheck" to work (whatever that does). + +commit 0c3e528563f8e8db45c340e7d050a1b42e65cb73 +Author: Bart Massey +Date: Mon Sep 11 23:29:10 2006 -0700 + + Removed GNU make dependency. + Made extensions directory persist. + +commit 81d6fd64c09255e90104b3c6e37c9023bd0aa6ec +Author: Jamey Sharp +Date: Sat Sep 9 15:52:37 2006 -0700 + + Handle XC-MISC request failure when allocating new XIDs. (fixes #7001) + +commit f6d4fc007fc0f4bdf8f06ab0798aadce87d468d1 +Author: Thomas Hunger +Date: Mon Aug 14 06:59:46 2006 -0700 + + Tutorial corrections. + +commit dbd2d9689305ce5bf24aebd894551bb6b590f6e4 +Author: Josh Triplett +Date: Sun Jul 30 22:02:37 2006 -0700 + + Implement error handling plan 7. + + Needs improvement: should not duplicate the code of every request function. + +commit 65ed274f05ba670eb02a55b098aed141fa9611ec +Author: Josh Triplett +Date: Sun Jul 30 20:28:16 2006 -0700 + + Parameterize context in cookie-type and request-matching template. + +commit f74487e34fd61d11a501c07030f8fd7ed8caeb1c +Author: Jamey Sharp +Date: Sun Jul 30 14:55:14 2006 -0700 + + Fix Keith's 32-bit wrap fix. + + Issue 0, 1, or 2 syncs as needed and do not handle 16-bit wrap until + absolutely necessary. + +commit 13896d8f658b917e891aa18e0ac4906d630881bb +Author: Josh Triplett +Date: Sun Jul 30 15:09:03 2006 -0700 + + Fix typo: s/request/sequence/ + +commit 685d8c76c25fd9f236fa1a74bae61699eaa78579 +Author: Josh Triplett +Date: Sun Jul 30 14:41:19 2006 -0700 + + Add XCBRequestCheck function needed for Plan 7. + +commit b3a2f83f1e4d3567fcd4494e7bae31e99645ef85 +Author: Eric Anholt +Date: Fri Jul 28 15:29:05 2006 -0700 + + Restore netinet/in.h include that was removed in the DECnet commit. + +commit b7c96681b2bfc968b198058122c93050feb7927e +Author: Eric Anholt +Date: Tue Jul 25 09:13:59 2006 -0700 + + Replace HAVE_* tests with just checking for (__solaris__) + + The installed headers can't be relying on the presence of the internal + config.h defines, and it was breaking the xcb build for me as well due to + config.h not being included early enough. + +commit 14faffc326b9ab1f738edb3ec7febdbe0f5bc079 +Author: TORRI Vincent +Date: Tue Jul 25 08:24:59 2006 +0200 + + fix closing tag + +commit 8ba93ebb757706ae8dcf5af57c6e3812f72de80e +Author: Ian Osgood +Date: Fri Jul 7 07:18:41 2006 -0700 + + Fix build on Solaris (use inttypes.h) + +commit e0574a617b9133cd728be8ea3618ef1312eeebbf +Author: Ian Osgood +Date: Sat Jul 1 00:55:08 2006 -0700 + + Finally remove X.h from xcb.h, fix broken image tests. + +commit db2504130bc450bd328830060cb3a243dd06b52f +Author: Keith Packard +Date: Sat Jul 1 00:16:07 2006 -0700 + + Switch sequence comparisons to handle 32-bit sequence number wrap. + + Create a macro, XCB_SEQUENCE_COMPARE, that accepts two sequence numbers and + a comparison operator and correctly handles 32-bit wrap around. + Rewrite all ordered sequence number comparisons to use this macro. + Also, caught one error where a sequence was stored in a signed int variable. + Push out a GetInputFocus request when the sequence number does wrap at 32 + bits so that applications cannot see sequence 0 (as that is an error + indicator). + +commit 75fead5b868a0dfdc9e6fd5ef0dd37eb71761312 +Author: Josh Triplett +Date: Thu Jun 15 03:03:13 2006 -0700 + + Remove arbitrary division between xcb_types and xproto by merging + xcb_types.xml into xproto.xml. + +commit 62749d54fd79b12123607599d58add126ce5de6e +Author: TORRI Vincent +Date: Thu Jun 8 06:59:47 2006 +0200 + + fix compilation with c++ compilers. Remove some trailing spaces + +commit 829188cdd6274b5b5271dff5612b30c978a61a38 +Author: Ian Osgood +Date: Tue May 30 11:54:25 2006 -0700 + + Deprecate XCBSync, move to XCBAuxSync. + +commit 936077cbc87addc914d33ab79a7d066f0f51d3ad +Author: Jamey Sharp +Date: Sun May 14 22:49:18 2006 -0700 + + Use correct word offset when testing for GetFBConfigsSGIX VendorPrivate. + +commit 442730a9a25644e6d09065cdde2f1595ea65caf3 +Author: Josh Triplett +Date: Sun May 14 22:37:55 2006 -0700 + + In the GLX workaround, use !strcmp to check for equality with "GLX", not strcmp. + +commit 2e49f58e4cd670e6bd6a0006833277cfb1da60e6 +Author: Josh Triplett +Date: Wed May 10 14:22:27 2006 -0700 + + Stop overwriting CFLAGS in xcb/src/Makefile.am. + +commit 92456577dbbe3874d6e40a1ef26b63dd405c160c +Author: Donnie Berkholz +Date: Sun May 7 15:44:37 2006 -0700 + + Fix dependencies on libXCB.la to not walk down from $(top_builddir); this fixes parallel builds. + +commit 4a891c6f4e49a04866b2cac7bf8bb679a256d3b4 +Author: Josh Triplett +Date: Sat Apr 29 17:02:43 2006 -0700 + + Work around the unsetting of CFLAGS in src/Makefile.am, by passing CFLAGS to make via DEB_MAKE_INVOKE in debian/rules. + +commit 140c30e522c664f0675b63301bea22e4062cd155 +Author: Josh Triplett +Date: Sat Apr 29 16:28:01 2006 -0700 + + Remove unnecessary dirs files. + +commit 105c6d67e6fa3d636068a2a4407bfa6adfafe0cc +Author: Josh Triplett +Date: Sat Apr 29 16:09:06 2006 -0700 + + Stop setting DEB_CONFIGURE_EXTRA_FLAGS = --with-opt in debian/rules; cdbs does the right thing on its own, and correctly handles DEB_BUILD_OPTS. + +commit 911ae3fbdd12bcfa39e6bbd85a7327ddd1cb9287 +Author: Josh Triplett +Date: Sat Apr 29 15:57:28 2006 -0700 + + Set DEB_MAKE_CHECK_TARGET=check in debian/rules. + +commit 3b7cf7ecf8ae614d7cb833ac4ef9fbcde3df05ae +Author: Josh Triplett +Date: Sat Apr 29 15:34:11 2006 -0700 + + Add a Section field for the source package in debian/control. + +commit 4e26eefcd9a035c4f7ee1d5f267095edc7df7c89 +Author: Josh Triplett +Date: Sat Apr 29 11:15:47 2006 -0700 + + Drop library version from source package name. + +commit eb3521283f91a84ce149fcc416720289ca37e29f +Author: Josh Triplett +Date: Sat Apr 29 10:58:23 2006 -0700 + + Set distribution to experimental. + +commit 2a18842f0f93516ff726a2dfa44348410bb55626 +Author: Josh Triplett +Date: Sat Apr 29 10:56:56 2006 -0700 + + Remove Bugs field in debian/control, so bugs go to the Debian BTS. + +commit e6132aff2fdcd0ab1ef5d7ac84a3c597dc07d370 +Author: Ian Osgood +Date: Fri Apr 28 15:27:09 2006 -0700 + + Move the remainder of the constants in X.h into XML enumerations. + Fix xcb_auth to use one of the new enumerations. + +commit 162c7593adf1577ca8aecfcd53fd5644b6182609 +Author: Josh Triplett +Date: Fri Apr 28 00:51:53 2006 -0700 + + Change libxcbxvmc0-dev Depends to libxcbxv0-dev, not libxv0-dev. + +commit 4f9b6556e2b68d1f05ed4df9d2cc82edb9868872 +Author: Josh Triplett +Date: Thu Apr 27 23:40:55 2006 -0700 + + Update debian packaging to create library, -dev, and -dbg packages for each new extension library. + +commit b7d77a8de79493919281c4f742b1a65c1328b1c4 +Author: Josh Triplett +Date: Thu Apr 27 17:32:20 2006 -0700 + + Fix the year in COPYING. + +commit 5c35ea63db8dcc30bd84eb1ae8f12f0969bb8a63 +Author: Josh Triplett +Date: Thu Apr 27 17:20:52 2006 -0700 + + Add an explanation of libtool -version-info to src/Makefile.am, and add an explicit -version-info 0:0:0 for all libraries. + +commit 08f5cc389275a71821a62c1674622ca85792b3fe +Author: Josh Triplett +Date: Thu Apr 27 16:24:35 2006 -0700 + + Fix tutorial to use XCBSetup rather than the previous deprecated name XCBConnSetupSuccessRep. + +commit 34016bcdab9b8373b4a8f9520b01d3179d35a315 +Author: Josh Triplett +Date: Thu Apr 27 16:15:50 2006 -0700 + + Remove execute bit on tutorial. + +commit 135cda6e9dafeef36efc8c4be49ae99b417034f2 +Author: Josh Triplett +Date: Thu Apr 27 13:47:21 2006 -0700 + + Fix a comment for the renaming of XCBConnSetupSuccessRep to XCBSetup, and fix another comment which had a copy-paste error. + +commit 17c3448f58c1aaf1d89b706dfa00e697061115c7 +Author: Josh Triplett +Date: Thu Apr 27 12:33:41 2006 -0700 + + Rename xcb-xfree86dri.pc.in to xcb-xf86dri.pc.in to match libXCBxf86dri, change its Libs line to use -lXCBxf86dri, and change configure.ac and Makefile.am accordingly. + +commit ef18582d83fac146b1a689bd60d580819dba0ffd +Author: Josh Triplett +Date: Thu Apr 27 12:04:52 2006 -0700 + + Fix typo and rephrase checking message. + +commit 3e213a1becd3081e905e3711ff3fe3e4865cd7dd +Author: Jamey Sharp +Date: Thu Apr 27 10:34:22 2006 -0700 + + Declare arguments const in the various structure accessors, so XCBGetSetup is not so painful to use. + +commit dd932e025b2de0fa33b65971288c63679238e08a +Author: Jamey Sharp +Date: Wed Apr 26 23:19:16 2006 -0700 + + Rename ConnSetup* to Setup*, Setup*Rep to Setup*, and SetupSuccess* to Setup*. Provide deprecated backwards-compatability functions and typedefs for the old names, to be removed before 1.0. + +commit b825f3385becccfcde34626f872721301e82f960 +Author: Josh Triplett +Date: Wed Apr 26 11:23:32 2006 -0700 + + Add .pc.in files for all the new extension libraries. Generate .pc files from the new .pc.in files in configure.ac. Install the new .pc files in Makefile.am, and add the new .pc.in files to EXTRA_DIST. + + Based on a patch by Vincent Torri. Changes from that patch: add Requires to the .pc.in files based on the s in the extensions, add a .pc.in file for libXCBxtest, change Name and Description fields to match extension names. + +commit 1476dcecfd3e817236ae996314c10482aae8e3e9 +Author: Ian Osgood +Date: Wed Apr 26 10:50:31 2006 -0700 + + Changes to makefile to build libXCBxtest + +commit bb8cf58015bae083dd77f8679f9a8299603c58a6 +Author: Patrick Caulfield +Date: Mon Apr 24 08:29:18 2006 -0700 + + Add support for DECnet. Still needs configure-script options to enable. + +commit 771761ccaad31d029d470dde84279e94494310b6 +Author: Jamey Sharp +Date: Thu Apr 20 11:51:01 2006 -0700 + + Minor performance improvement: do not call _xcb_in_expect_reply unless it is needed. It is not often needed. + +commit 8953a14f2b1518042ed0745574e22fa2adfb6cac +Author: Jamey Sharp +Date: Wed Apr 19 22:48:10 2006 -0700 + + Add to xcb_in.c to fix bug #6122. + +commit 05a66af895442b9fceb96c9130e77694927eabaf +Author: Alan Coopersmith +Date: Wed Apr 19 21:51:33 2006 -0700 + + Bugfix: xcb_conn.c included instead of the POSIX-standard . + +commit f705456744fe4beb193d27eb64fa9157102db753 +Author: Alan Coopersmith +Date: Wed Apr 19 21:40:42 2006 -0700 + + Only set CWARNFLAGS to gnu flags if $GCC is set. Otherwise check for Sun compiler and use its enhanced warning flag. + +commit 6f369fde3c676e2b1a67bd71923b61942991d726 +Merge: 922cb61 f090da9 +Author: Ian Osgood +Date: Wed Apr 19 20:45:31 2006 -0700 + + Merge branch 'master' of git+ssh://iano@git.freedesktop.org/git/xcb + +commit f090da98f367ed869fd9277d2fef22555be0f91d +Author: Jamey Sharp +Date: Wed Apr 19 20:31:20 2006 -0700 + + Remove the last goto in XCB: XCBWaitForReply now permits multiple threads to force the same cookie. + +commit d5347485a55e58381781d803e19bfdd982a4685b +Author: Jamey Sharp +Date: Wed Apr 19 20:23:37 2006 -0700 + + Restructure XCBWaitForReply to eliminate two gotos. + +commit d5ab03b4b71648bf0a06e42e3c288a68c46ba497 +Author: Jamey Sharp +Date: Wed Apr 19 20:15:15 2006 -0700 + + Fixed poll_for_reply, added comments, and refactored XCBWaitForReply to call poll_for_reply. + +commit 7667adbc631119ec39f3ef5a316aec42dbf5f393 +Author: Jamey Sharp +Date: Wed Apr 19 16:49:32 2006 -0700 + + Add XCBPollForReply and deprecate XCBGetRequestRead and XCBGetQueuedRequestRead. + +commit 53971ea183d9d1dcfbaec18b135e49c9c118fabb +Merge: 71de16f 8275ac3 +Author: Josh Triplett +Date: Sun Apr 16 11:23:52 2006 -0700 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb + +commit 71de16fac2a145d5ef8069d2d28d7c32cea603cf +Author: Josh Triplett +Date: Sun Apr 16 11:05:50 2006 -0700 + + Improve package descriptions. + +commit e92bde6e5152c6d0c4efa9240604e75178c1a3db +Author: Josh Triplett +Date: Sun Apr 16 09:59:13 2006 -0700 + + Change Depends on x-dev to x11proto-core-dev. + +commit eca61f6b5e9df7321222499a1f660f6eb7e6112e +Author: Josh Triplett +Date: Sun Apr 16 09:25:36 2006 -0700 + + Add Build-Depends on libxdmcp-dev. + +commit a0057d7a48b90b8f11fc9d5c82b5b8d800c34db5 +Author: Josh Triplett +Date: Sun Apr 16 09:24:01 2006 -0700 + + * Debian X11R7 transition: + * Change Build-Depends on x-dev to x11proto-core-dev. + * Install headers to /usr/include/X11, not /usr/X11R6/include/X11. + * Pre-Depends: x11-common (>= 1:1.09). + +commit 11c62f7d9d65c10c796c2199c73c8f167e53f234 +Author: Josh Triplett +Date: Sat Apr 15 22:50:33 2006 -0700 + + Stop installing the libtool .la files. + +commit 057ae541a3a73cffd58533029292c1c721fa3162 +Author: Josh Triplett +Date: Sat Apr 15 20:44:11 2006 -0700 + + Update -dbg package handling to work with debhelper compat level 5. + Increase minimum version on debhelper Build-Depends to 5.0.0. + +commit 8eedb4a487dcede0e52849e36c4da13bdf0c8b51 +Author: Josh Triplett +Date: Sat Apr 15 20:22:05 2006 -0700 + + Stop running autoreconf in debian/rules, and remove Build-Depends for + autoconf, automake, and libtool. + +commit cc075990f4fc2ed09c708036569049ddd24605ac +Author: Josh Triplett +Date: Sat Apr 15 20:21:22 2006 -0700 + + Add xcbint.h to noinst_HEADERS, so it gets distributed. + +commit cb6e1849b66c17f96d79598adb740ed16325a9c1 +Author: Josh Triplett +Date: Sat Apr 15 14:17:52 2006 -0700 + + Use screensaver.xml + +commit 91aeea2a3e72af16733ddcba037541440c0c4739 +Author: Josh Triplett +Date: Sat Apr 15 12:52:05 2006 -0700 + + Put EXTHEADERS and EXTSOURCES in order. + +commit ff38c17c48c271847d12c81cbf80142c6918dc78 +Author: Josh Triplett +Date: Sat Apr 15 12:26:03 2006 -0700 + + Split all non-essential extensions into their own separate libraries, named + libXCBextname. To use extension extname, include extname.h and link with + -lXCBextname. This allows extensions to change without bumping the main + libXCB version. + + bigreq and xc_misc remain in libXCB, because XCB uses them internally to make + big requests and to allocate XIDs, respectively. + +commit 8275ac3a4a23220b5c3b4f191a45befe2d34d6bd +Author: Eric Anholt +Date: Sun Apr 9 19:51:10 2006 -0700 + + Retry a select() if it returns with EINTR. Fixes IO errors in Xephyr, which is + often interrupted by timers. + +commit 66a88ed0e556ca869ddc9df5a35e3d6446d12b02 +Author: Eric Anholt +Date: Sun Apr 9 19:19:12 2006 -0700 + + Remove unnecessary include. Noticed by jamey. + +commit 922cb6137a12982ecd9e1c73ecefdcbc9e193eae +Author: Ian Osgood +Date: Wed Mar 22 17:57:57 2006 -0800 + + Work on the tutorial, and update xproto.xml to match: + * Fixed grammar + * Answered some TODO's and added some more + * Updated X.h constants to those in xproto.h + * Added enumerations used in tutorial to xproto.xml + * Prefered XCBFlush to XCBSync + * Corrected and refactored the "events" example + + I extracted the examples to test them. Where should I put them? + +commit fc577b81bfeb79bb78ee529278ed52d59d489f89 +Author: Josh Triplett +Date: Tue Mar 21 14:22:21 2006 -0800 + + Remove outdated fd.o-* entries from */debian/.gitignore (obsolete since before they came from .cvsignore). + +commit df5d8adc1f18776e4417a03b465dae9273511fb1 +Author: Jamey Sharp +Date: Thu Mar 16 11:27:06 2006 -0800 + + The typedefs replacing Xmd.h conflict with Xmd.h. Here is a hacky workaround: FIXME! + +commit 5ccf7216d266f22755e40a8b9858ebd60fd48f40 +Author: Ian Osgood +Date: Wed Mar 15 22:41:08 2006 -0800 + + Change syntax to n as Jamey and Josh suggested + and add more button, key, and graphics enumerations. + +commit 35ecaf45be75cb78fe18dd4ea9d564b03f6cea67 +Author: Ian Osgood +Date: Wed Mar 15 10:09:47 2006 -0800 + + Remove proto/X11 dependencies from xcb-demo. + +commit 4142e34695310c20a8a30af64e0b40842bfb5dbe +Author: Ian Osgood +Date: Tue Mar 14 18:23:37 2006 -0800 + + Remove xcb-util dependency on proto/X11 + by moving many defs from X.h to s in xproto.xml + +commit f5c4956a81ed5aee3ea46e91785ec14f82e205d5 +Author: Ian Osgood +Date: Tue Mar 14 11:53:01 2006 -0800 + + Fix XCBGetSetup to match prototype. + +commit 9472c251ae426bb496a3112d0ae390f1f1c35515 +Merge: 71ddf29 0d648ac +Author: Ian Osgood +Date: Tue Mar 14 11:44:43 2006 -0800 + + Merge branch 'master' of git+ssh://iano@git.freedesktop.org/git/xcb + +commit 71ddf29d00ad8ff2323faf2cc6c354cbf3eca16c +Author: Ian Osgood +Date: Tue Mar 14 10:18:22 2006 -0800 + + Add an expression construct + for mask enumerations such as CW flags. + Replaces the C-specific use of 1< +Date: Tue Mar 14 07:40:39 2006 +0100 + + doxygen documentation of the API + +commit a810d1ffe4825b9359f13ebb395f5f681961fc89 +Author: Ian Osgood +Date: Mon Mar 13 17:49:17 2006 -0800 + + Remove dependencies on Xmd.h and X.h + (Still including X.h until defs are moved to xproto.xml + and xcb-util and xcb-demo are fixed to use them.) + +commit be1302b6efb33967bce5356af58e3e0ae3b19363 +Author: Ian Osgood +Date: Mon Mar 13 10:36:13 2006 -0800 + + Remove last deprecation warning. + +commit d8de2c7c2a9b8bf59c8f1fcece5faed0b6cbf6f4 +Merge: 5e0cfa8 e757673 +Author: Ian Osgood +Date: Sun Mar 12 23:03:24 2006 -0800 + + Merge branch 'master' of git+ssh://iano@git.freedesktop.org/git/xcb + +commit e7576738c33e73fb4f29c1426c2ec49257564129 +Author: Ian Osgood +Date: Sun Mar 12 23:02:45 2006 -0800 + + Restructure to remove most deprecation warnings. + +commit 5e0cfa84bec3e04f3a1991baaa29da09c7c4a02c +Author: Jamey Sharp +Date: Sun Mar 12 17:15:50 2006 -0800 + + Use libXdmcp, if available with XdmcpWrap, for XDM-AUTHORIZATION-1. Closes bug #6106. + +commit d69c403cba9bdebd1bd41b62ae7e28f5852248d4 +Merge: b83f18a 5cdc02e +Author: Jamey Sharp +Date: Sun Mar 12 13:36:33 2006 -0800 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb + +commit b83f18a4cc2303dfda59807d56e16bbc5c18b09d +Author: Jamey Sharp +Date: Sun Mar 12 13:20:29 2006 -0800 + + Only _xcb_conn_wait calls _xcb_out_write now, so move it to xcb_conn.c and make it static. + +commit fb61c94d685a254ef0702a2e2093b8cdda02d514 +Author: Jamey Sharp +Date: Sun Mar 12 12:40:34 2006 -0800 + + Remove c->out.vec. Pass iovecs directly down the call tree. Add _xcb_out_flush_to, refactor other functions, make write_block static. + +commit 5cdc02e3441dc623e91ebc5d7f735565b83f8435 +Author: Jamey Sharp +Date: Sat Mar 11 20:32:04 2006 -0800 + + Portability fixes. Should help DragonFly and Solaris, and should not hurt anything else. Tested only on linux so far though. + +commit 83e652f566671f96ffc53a3c0099a84a1606c695 +Author: Jamey Sharp +Date: Thu Mar 9 00:02:42 2006 -0800 + + Move c->out.vec refs out of _xcb_conn_wait up to _xcb_out_flush. + +commit 5b0ae3421dd373a8575b7a0d60989edfc056cf71 +Merge: fd1f9cb 1261a41 +Author: Jamey Sharp +Date: Wed Mar 8 22:50:48 2006 -0800 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb + +commit fd1f9cb13f9ab9a6bb6aa0c894d4891809bece8a +Author: Jamey Sharp +Date: Wed Mar 8 22:49:59 2006 -0800 + + Unify autofoo .gitignore bits into one top-level file, and remove resulting redundancies. + +commit 1261a4150c8bd39a6fb6887df52abbbb446f7ffb +Author: Ian Osgood +Date: Wed Mar 8 22:26:20 2006 -0800 + + Add symbols for error and reply response_types, + and use XCBKeymapNotify from xcb-proto. + +commit 6fb661f3ff2fca342b4ea76d5a583c5e4f53e076 +Author: Ian Osgood +Date: Wed Mar 8 21:56:57 2006 -0800 + + Bugfix: null-terminate the path in sockaddr_un before using it. + This may fix itermittant connect failures. + +commit 621f891c49cbf4beba1e20fb9b6fb1be576d42f3 +Author: Jamey Sharp +Date: Wed Mar 8 14:21:16 2006 -0800 + + Move c->out.vec refs out of _xcb_out_write up to _xcb_conn_wait. + +commit c491eeb9a9f670f7d4869d7dae7a5adce4565998 +Author: Jamey Sharp +Date: Tue Mar 7 21:19:58 2006 -0800 + + Fix off-by-one error that kept the last byte(s) of the output queue from being used. + +commit 522a6e0eac9adeaac533a5b700f42d85d46e2dd7 +Author: TORRI Vincent +Date: Tue Mar 7 10:25:23 2006 -0800 + + Use the GCC 4 visibility extension to mark everything in xcbint.h hidden. + +commit 5437032c7dee85da99b612a707fa94d012d40282 +Merge: 2ad5450 d1cfd4d +Author: Jamey Sharp +Date: Tue Mar 7 00:26:38 2006 -0800 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb + +commit d1cfd4d0a21feaa5ccf0a1fd693327b8c5718abf +Author: Jamey Sharp +Date: Mon Mar 6 01:10:20 2006 -0800 + + Off-by-one error in the sequence-wrapping proof, and therefore in the corresponding code. + +commit 2ad5450ff3566a6e378769d7ff68f148c992b468 +Author: TORRI Vincent +Date: Sun Mar 5 09:49:02 2006 +0100 + + wrong spaces + +commit 81ea81c6d9a67fdf664fc502fe3610b37aea8354 +Author: TORRI Vincent +Date: Sun Mar 5 09:41:11 2006 +0100 + + fix some font sizes + +commit 66364da372dc1a2e1d75729a1265d632ae642ad6 +Author: TORRI Vincent +Date: Sun Mar 5 09:40:15 2006 +0100 + + fixes + valid css + +commit 01656220ef275a811a284420121d37bf9aa85f70 +Author: TORRI Vincent +Date: Sun Mar 5 09:22:03 2006 +0100 + + fixes + valid css + +commit e5458e477db95e1e064e46ca28245ecd51b5b524 +Author: Jamey Sharp +Date: Sun Mar 5 00:20:50 2006 -0800 + + Implement provably-correct sequence wrap handling. Add flag XCB_REQUEST_DISCARD_REPLY. + +commit 6659c8c63b82329468b249cc99181d72ec26c698 +Author: TORRI Vincent +Date: Sun Mar 5 09:05:21 2006 +0100 + + lots of fixes. Thanks to Indan Zupancic + +commit 6e4745bbd0c924d846550496a072b0f2b0d4482c +Author: TORRI Vincent +Date: Sun Mar 5 07:54:20 2006 +0100 + + lots of fixes. Thanks to Indan Zupancic + +commit df9c7cb4f9b05caf07900f3c15be379d3f9979fb +Author: Josh Triplett +Date: Sat Mar 4 18:35:53 2006 -0800 + + Add *.tar.{bz2,gz} to .gitignore for the benefit of "make distcheck". + +commit 29f9fe0fc805a1ec6860f167a45664cc1cf0c769 +Author: Jamey Sharp +Date: Fri Mar 3 11:08:10 2006 -0800 + + API/ABI change: XCBSendRequest returns the sequence number instead of using an out-parameter. Now 0 is a special sequence number indicating failure. + +commit 255c21b17f61147388bab6e1d42623a008a4a8d2 +Author: Jamey Sharp +Date: Fri Mar 3 01:45:00 2006 -0800 + + Add 32-bit full_sequence fields to generic errors and events, so callers can always correlate events and errors with requests correctly. + +commit 622b599c8fcf5d677f76ca03f3241a23dba58712 +Author: Jamey Sharp +Date: Thu Mar 2 23:39:38 2006 -0800 + + Tweak to previous API change: Require that spare iovecs fall before vector[0]. Leave vector in well-defined state. + +commit 87905f0579e749ac6d92843780af246160318eca +Author: Jamey Sharp +Date: Thu Mar 2 23:31:35 2006 -0800 + + assert() that XCBSendRequest was handed enough space to set opcodes and short length fields. + +commit 45e1cc0935ca1d7a138e1c700db229f50205a556 +Author: Jamey Sharp +Date: Thu Mar 2 23:12:21 2006 -0800 + + Bugfix: The fixed-length part needs two iovecs reserved, just like all the other parts. + +commit b46953f46c7d0fd8cbb73f922524968c1ac86fa4 +Author: Jamey Sharp +Date: Thu Mar 2 23:05:08 2006 -0800 + + Use XPath position() function instead of xsl:number, to evaluate array indices while generating code for easier readability. + +commit 5e115e2441ed32f5fa495370b36b01c03bbff66d +Author: Jamey Sharp +Date: Thu Mar 2 15:35:31 2006 -0800 + + API/ABI change: XCBSendRequest callers must pad to 4-byte boundaries now. When not in RAW mode, a null pointer for iov_base is replaced by up to 3 padding bytes. + +commit ed823bf65192a72f8c3060698c9bded9f77d49c2 +Author: Jamey Sharp +Date: Thu Mar 2 13:49:00 2006 -0800 + + Separate notion of request-completed from current-request, and mark requests completed more aggressively. Detects some usage errors that are otherwise undetectable. + +commit c05ae15b661bff6b95deb3abc7f48abe16892ac8 +Author: Jamey Sharp +Date: Mon Feb 27 12:12:33 2006 -0800 + + Buffer a couple CARD32s on the stack instead of using an extra iovec. Also a bugfix: do not hold a reference to longlen after it goes out of scope. + +commit 8f991bdd389f6c419cb18cdaea966304529de165 +Author: Jamey Sharp +Date: Mon Feb 27 11:03:13 2006 -0800 + + Add XCB_REQUEST_RAW flag for XCBSendRequest. + +commit 5e350126a728f3c0c3bc8d8673e5ad67dc174f79 +Author: Jamey Sharp +Date: Mon Feb 27 10:53:08 2006 -0800 + + Bugfix: how about *not* leaking all pending_replies when no reply matches, as often happens with Xlib? + +commit 731c85762d8994119f4eaf572cc59c9adbb7abd9 +Author: Jamey Sharp +Date: Mon Feb 27 02:57:36 2006 -0800 + + Move test for other writing threads *before* allocating a sequence number. + +commit 8ab4dcde9db8175ef0093123bd04c72471e205ff +Author: Jamey Sharp +Date: Mon Feb 27 02:14:48 2006 -0800 + + _xcb_list is no longer used, so remove it. Simplify _xcb_map. + +commit 76ad79a7adbb315f7c7d5f08d6f42553210868cd +Author: Jamey Sharp +Date: Mon Feb 27 01:43:07 2006 -0800 + + Replace readers generic list with hand-written typesafe version. + +commit fa71b9b835da6360c374dcb4ab93be3a27dbd737 +Author: Jamey Sharp +Date: Mon Feb 27 01:06:15 2006 -0800 + + Rename struct XCBReplyData to reader_list to follow my naming conventions and better reflect its purpose. + +commit ff665b57266b9e7e9b9a366272c2115bbd516173 +Author: Jamey Sharp +Date: Mon Feb 27 00:54:59 2006 -0800 + + In struct XCBReplyData, change void *data to pthread_cond_t *data. That was dumb. + +commit 50acfeae36f5f67e8b92fd7610141c489ee348c5 +Author: Jamey Sharp +Date: Sun Feb 26 23:43:44 2006 -0800 + + Delete unused xcb_list functions and refactor others. + +commit 86ce18c22c8daebe8796d3c38e8a1d496ab6e8de +Author: Jamey Sharp +Date: Sun Feb 26 22:58:17 2006 -0800 + + Replace current_reply generic queue with hand-written version. No generic queues remain so delete their implementation. + +commit 0f130b4d945a27fd2b4655c351ebe70d61cac598 +Author: Jamey Sharp +Date: Sun Feb 26 18:28:50 2006 -0800 + + Replace events generic queue with hand-written typesafe version. + +commit ff7b6c9124e7caf26381cc7a10fba9eaf1875652 +Author: Jamey Sharp +Date: Sun Feb 26 15:45:08 2006 -0800 + + API/ABI break: Add flags to XCBSendRequest, first for error-checked requests. + There's no more race condition between event and reply handling. + The *RequestBlind and *RequestChecked functions are not yet implemented. + +commit 7875040fa179d8ca3fa4ec046c1b8c2a351a6621 +Author: Jamey Sharp +Date: Sun Feb 26 02:00:03 2006 -0800 + + Replace pending_replies generic queue with a hand-implemented typesafe version. + +commit a1eff0c49a2dbb328a79edbeb2b851fa1dfe9e61 +Author: Jamey Sharp +Date: Sun Feb 26 01:27:01 2006 -0800 + + Replace my old generic map ADT with a growable array for the extension cache. + +commit 46a754998149c5f4a1670787b3ea36731caf6506 +Author: Jamey Sharp +Date: Sat Feb 25 23:27:47 2006 -0800 + + XCB has not had tracing features for a long time: remove the remnants. + +commit b6cbe837748df5819d00682330d34e2c7d24d349 +Author: Jamey Sharp +Date: Sat Feb 25 23:26:55 2006 -0800 + + Rearrange an if statement that's been bothering me. + +commit f27166f49b9ef6bdcce78429bffc724d1e4fb360 +Author: Jamey Sharp +Date: Fri Feb 24 02:17:36 2006 -0800 + + Coalesce _xcb_writev into _xcb_out_write and simplify. + +commit 9463653b1e6dc0a9054266aa3eecb0839129b991 +Author: Jamey Sharp +Date: Fri Feb 24 01:56:18 2006 -0800 + + Take advantage of Requires and *.private fields for a more accurate pkg-config file. + +commit bae98d36040d0cda1862839410cf92bac3927280 +Author: Jamey Sharp +Date: Fri Feb 24 01:50:48 2006 -0800 + + Move _xcb_set_fd_flags to xcb_conn.c and make it static. xcb_util.c now has only public functions. + +commit 67b2649dc4b6726c6d11fb0e41429ae5de82b0e8 +Author: Jamey Sharp +Date: Fri Feb 24 01:40:45 2006 -0800 + + Move _xcb_read_block to xcb_in.c and make it static. Change calls in xcb_conn.c to _xcb_in_read_block instead. + +commit 838317f4d305e07f35ddd99e2ebccfa8fac680c6 +Author: Jamey Sharp +Date: Fri Feb 24 01:17:03 2006 -0800 + + Remove XCB_CEIL and use a simpler definition for XCB_PAD. + +commit 1b50d2ee1ef532429674126eace88ac73d51ec23 +Author: Jamey Sharp +Date: Fri Feb 24 01:04:48 2006 -0800 + + Quit using "-include config.h": use #ifdef HAVE_CONFIG_H etc. like everyone else. + +commit e1c2777abac0479ebdf06f2005120d25fff53935 +Author: Jamey Sharp +Date: Fri Feb 24 00:59:08 2006 -0800 + + Coalesce readn into _xcb_in_read and simplify. + +commit 3f8d0bd5322749132626e8f203017b6da6448fd0 +Author: Jamey Sharp +Date: Fri Feb 24 00:48:18 2006 -0800 + + Move _xcb_readn to xcb_in.c and make it static. Minor change to _xcb_read_block to not depend on _xcb_readn. + +commit cdf362f33a7bc4d412231de32e37ffb65a06d3f1 +Author: Jamey Sharp +Date: Fri Feb 24 00:25:34 2006 -0800 + + Bugfix: protect the output queue from being written while another thread is flushing it. + +commit 4e91ae275e46e76de64ab089d6f13c1e9b6ddee6 +Author: Jamey Sharp +Date: Fri Feb 24 00:02:43 2006 -0800 + + Simplify: Always use writev. (In _xcb_out_flush, convert the output queue to a single iovec if needed.) + +commit 7f0bc778c88ab2f565cc05d5d3d5ee4c8d1388a1 +Author: Jamey Sharp +Date: Thu Feb 23 22:41:59 2006 -0800 + + Factor padding out of _xcb_out_write_block and into its callers, XCBSendRequest and write_setup. + This requires dynamically allocating memory in XCBSendRequest, but this + malloc/free pair turns out to cause a 30% speed hit for the 'x11perf -noop' + test -- so for the moment I use alloca where available and fall back to malloc + on other platforms. Later I think I'll change the contract of XCBSendRequest + so the caller is responsible for memory allocation, because the caller ought + to always be able to stack-allocate here. + +commit 6e29e5f2ee2e6158f1a9480a83e4f906ab9c04d1 +Author: Jamey Sharp +Date: Thu Feb 23 17:50:53 2006 -0800 + + Add XCBGetQueuedRequestRead for Xlib that does no syscalls, just returns whatever XCB already knows about. + +commit 26ac6292ba0535ac3747d23f2f4d284c4b5f42ba +Author: Jamey Sharp +Date: Thu Feb 23 15:29:40 2006 -0800 + + Minor performance fix: Change the contract on XCBGetRequestSent so that it does not waste time re-locking. This is for Xlib, and Xlib has already locked. + +commit a736674943295245ccb90865c13d2b75dc6ecccb +Author: Jamey Sharp +Date: Thu Feb 23 14:57:46 2006 -0800 + + Minor performance fix: Only rearrange buffers for BIG-REQUESTs. + +commit e866bed9348bf3ffd480fd6ec329fd8b9581c328 +Author: Jamey Sharp +Date: Thu Feb 23 14:32:11 2006 -0800 + + Move request_written update back where it was for now: doing it early can cause XCBWaitForReply to wrongly believe that the request has been flushed. Eventually, we should fix bug #6021. + +commit 1b83f8f8f326eca9d8852c82dd36696f81a720dc +Author: Jamey Sharp +Date: Thu Feb 23 14:30:08 2006 -0800 + + Remove _xcb_assert_valid_sequence. One test is trivially true, and the other may be temporarily violated without anything bad happening. + +commit 55c1842686d2e668708cd106b5e08847df0184c3 +Author: Jamey Sharp +Date: Thu Feb 23 12:48:27 2006 -0800 + + Move _xcb_write and _xcb_writev to xcb_out.c and make them static, since only _xcb_out_write calls them. + +commit 213b5725928ccf8aedc807cc40a261b2d5431247 +Author: Jamey Sharp +Date: Thu Feb 23 12:34:08 2006 -0800 + + Ignore test byproducts. + +commit 6149c7a6b57a193bc132fbc35b1772b75e5c7ca7 +Author: Jamey Sharp +Date: Thu Feb 23 12:15:09 2006 -0800 + + More return value changes, and make _xcb_in_read_packet static since it is not called from outside xcb_in.c. + +commit 5b1d39e27b1a966df537ead248da5a57e7d9de97 +Author: Jamey Sharp +Date: Thu Feb 23 11:50:12 2006 -0800 + + More return value changes. + +commit 662479760c42fc38c458381ee3eaed92e2c8b733 +Author: Jamey Sharp +Date: Thu Feb 23 10:17:40 2006 -0800 + + Make the return value of _xcb_conn_wait boolean, instead of syscall-like. + +commit f8a8b465e080faf5479c0b38dc67cc9b9ae24927 +Author: Jamey Sharp +Date: Wed Feb 22 23:38:16 2006 -0800 + + Bugfix: move request_written update *before* _xcb_conn_wait in _xcb_out_flush. Otherwise a reply may be read before we record that we have sent the request, and then XCB gets... confused. + +commit e0a35783837e0d4974cfa20c6a7a073698f3b0a5 +Author: Jamey Sharp +Date: Wed Feb 22 23:11:36 2006 -0800 + + Remove USE_THREAD_ASSERT compile option. _xcb_conn_wait can no longer be re-entered, since we have no callback hooks now. + +commit a7d749ec3fd3303a4e7ace9d4f0f1672f9310ef2 +Author: Jamey Sharp +Date: Wed Feb 22 23:09:29 2006 -0800 + + Remove vestiges of adjacent request combining implementation. It is very dead. + +commit 06c788932bb635da79076728927b7b93f64037c1 +Author: Jamey Sharp +Date: Mon Feb 20 00:41:39 2006 -0800 + + Control debugging, optimization, and warning flags all independently. + +commit 3f98dae4a8274f2430c4967f8354356ef7c45024 +Merge: e346f8c f825a32 +Author: Jamey Sharp +Date: Sat Feb 18 23:57:18 2006 -0800 + + Merge branch 'master' of git+ssh://git.freedesktop.org/git/xcb + +commit e346f8c8efe6f931aa43026087d0ea406258c094 +Author: Jamey Sharp +Date: Sat Feb 18 23:57:14 2006 -0800 + + Update .gitignores for .o files and autofoo stuff. + +commit f825a32135fa613dd6b6dd8553e366d8125bd7a4 +Author: Eric Anholt +Date: Sat Feb 18 23:05:32 2006 -0800 + + Add missing entries to .gitignore files. + +commit 9e013b564cc4479802c51f79ea5054d5f25edacc +Merge: d16efb5 7474473 +Author: Eric Anholt +Date: Sat Feb 18 22:57:42 2006 -0800 + + Merge branch 'master' of git+ssh://anholt@git.freedesktop.org/git/xcb + +commit d16efb51915d9661788c96140635514cf6314d46 +Author: Eric Anholt +Date: Sat Feb 18 22:56:03 2006 -0800 + + Move .cvsignore to .gitignore. + +commit 7474473f3312597f6de736b8f25cedc433427092 +Author: Jamey Sharp +Date: Sat Feb 18 20:03:35 2006 -0800 + + Quit defining _XOPEN_SOURCE. We never needed it... + +commit 1d977c7b2d519e22f319075563e7faf4bbd31d58 +Author: Jamey Sharp +Date: Sat Feb 18 19:23:33 2006 -0800 + + Remove the old ChangeLog file. GIT makes that obsolete. + +commit 5b7182c659391160239467f1041a1d755db45bd3 +Author: Jamey Sharp +Date: Sat Feb 18 18:12:40 2006 -0800 + + Workaround X server bug, fd.o #3210: if a GLXGetFBConfigs request is sent, fix the length field in the reply. + +commit 47ceed78612d48dcda62cc2686fc527d61abe38b +Author: Josh Triplett +Date: Sat Feb 18 16:49:41 2006 -0800 + + Remove xcl and CVSROOT. diff --git a/dist/libxcb/INSTALL b/dist/libxcb/INSTALL index 54caf7c19..a1e89e18a 100644 --- a/dist/libxcb/INSTALL +++ b/dist/libxcb/INSTALL @@ -1,13 +1,25 @@ -Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software -Foundation, Inc. +Installation Instructions +************************* - This file is free documentation; the Free Software Foundation gives -unlimited permission to copy, distribute and modify it. +Copyright (C) 1994-1996, 1999-2002, 2004-2011 Free Software Foundation, +Inc. + + Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. This file is offered as-is, +without warranty of any kind. Basic Installation ================== - These are generic installation instructions. + Briefly, the shell commands `./configure; make; make install' should +configure, build, and install this package. The following +more-detailed instructions are generic; see the `README' file for +instructions specific to this package. Some packages provide this +`INSTALL' file but do not implement all of the features documented +below. The lack of an optional feature in a given package is not +necessarily a bug. More recommendations for GNU packages can be found +in *note Makefile Conventions: (standards)Makefile Conventions. The `configure' shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses @@ -20,9 +32,9 @@ debugging `configure'). It can also use an optional file (typically called `config.cache' and enabled with `--cache-file=config.cache' or simply `-C') that saves -the results of its tests to speed up reconfiguring. (Caching is +the results of its tests to speed up reconfiguring. Caching is disabled by default to prevent problems with accidental use of stale -cache files.) +cache files. If you need to do unusual things to compile the package, please try to figure out how `configure' could check whether to do them, and mail @@ -32,30 +44,37 @@ some point `config.cache' contains results you don't want to keep, you may remove or edit it. The file `configure.ac' (or `configure.in') is used to create -`configure' by a program called `autoconf'. You only need -`configure.ac' if you want to change it or regenerate `configure' using -a newer version of `autoconf'. +`configure' by a program called `autoconf'. You need `configure.ac' if +you want to change it or regenerate `configure' using a newer version +of `autoconf'. -The simplest way to compile this package is: + The simplest way to compile this package is: 1. `cd' to the directory containing the package's source code and type - `./configure' to configure the package for your system. If you're - using `csh' on an old version of System V, you might need to type - `sh ./configure' instead to prevent `csh' from trying to execute - `configure' itself. + `./configure' to configure the package for your system. - Running `configure' takes awhile. While running, it prints some - messages telling which features it is checking for. + Running `configure' might take a while. While running, it prints + some messages telling which features it is checking for. 2. Type `make' to compile the package. 3. Optionally, type `make check' to run any self-tests that come with - the package. + the package, generally using the just-built uninstalled binaries. 4. Type `make install' to install the programs and any data files and - documentation. + documentation. When installing into a prefix owned by root, it is + recommended that the package be configured and built as a regular + user, and only the `make install' phase executed with root + privileges. - 5. You can remove the program binaries and object files from the + 5. Optionally, type `make installcheck' to repeat any self-tests, but + this time using the binaries in their final installed location. + This target does not install anything. Running this target as a + regular user, particularly if the prior `make install' required + root privileges, verifies that the installation completed + correctly. + + 6. You can remove the program binaries and object files from the source code directory by typing `make clean'. To also remove the files that `configure' created (so you can compile the package for a different kind of computer), type `make distclean'. There is @@ -64,6 +83,16 @@ The simplest way to compile this package is: all sorts of other programs in order to regenerate files that came with the distribution. + 7. Often, you can also type `make uninstall' to remove the installed + files again. In practice, not all packages have tested that + uninstallation works correctly, even though it is required by the + GNU Coding Standards. + + 8. Some packages, particularly those that use Automake, provide `make + distcheck', which can by used by developers to test that all other + targets like `make install' and `make uninstall' work correctly. + This target is generally not run by end users. + Compilers and Options ===================== @@ -75,7 +104,7 @@ for details on some of the pertinent environment variables. by setting variables in the command line or in the environment. Here is an example: - ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix + ./configure CC=c99 CFLAGS=-g LIBS=-lposix *Note Defining Variables::, for more details. @@ -84,44 +113,89 @@ Compiling For Multiple Architectures You can compile the package for more than one kind of computer at the same time, by placing the object files for each architecture in their -own directory. To do this, you must use a version of `make' that -supports the `VPATH' variable, such as GNU `make'. `cd' to the +own directory. To do this, you can use GNU `make'. `cd' to the directory where you want the object files and executables to go and run the `configure' script. `configure' automatically checks for the -source code in the directory that `configure' is in and in `..'. +source code in the directory that `configure' is in and in `..'. This +is known as a "VPATH" build. - If you have to use a `make' that does not support the `VPATH' -variable, you have to compile the package for one architecture at a -time in the source code directory. After you have installed the -package for one architecture, use `make distclean' before reconfiguring -for another architecture. + With a non-GNU `make', it is safer to compile the package for one +architecture at a time in the source code directory. After you have +installed the package for one architecture, use `make distclean' before +reconfiguring for another architecture. + + On MacOS X 10.5 and later systems, you can create libraries and +executables that work on multiple system types--known as "fat" or +"universal" binaries--by specifying multiple `-arch' options to the +compiler but only a single `-arch' option to the preprocessor. Like +this: + + ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ + CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ + CPP="gcc -E" CXXCPP="g++ -E" + + This is not guaranteed to produce working output in all cases, you +may have to build one architecture at a time and combine the results +using the `lipo' tool if you have problems. Installation Names ================== - By default, `make install' will install the package's files in -`/usr/local/bin', `/usr/local/man', etc. You can specify an -installation prefix other than `/usr/local' by giving `configure' the -option `--prefix=PATH'. + By default, `make install' installs the package's commands under +`/usr/local/bin', include files under `/usr/local/include', etc. You +can specify an installation prefix other than `/usr/local' by giving +`configure' the option `--prefix=PREFIX', where PREFIX must be an +absolute file name. You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you -give `configure' the option `--exec-prefix=PATH', the package will use -PATH as the prefix for installing programs and libraries. -Documentation and other data files will still use the regular prefix. +pass the option `--exec-prefix=PREFIX' to `configure', the package uses +PREFIX as the prefix for installing programs and libraries. +Documentation and other data files still use the regular prefix. In addition, if you use an unusual directory layout you can give -options like `--bindir=PATH' to specify different values for particular +options like `--bindir=DIR' to specify different values for particular kinds of files. Run `configure --help' for a list of the directories -you can set and what kinds of files go in them. +you can set and what kinds of files go in them. In general, the +default for these options is expressed in terms of `${prefix}', so that +specifying just `--prefix' will affect all of the other directory +specifications that were not explicitly provided. + + The most portable way to affect installation locations is to pass the +correct locations to `configure'; however, many packages provide one or +both of the following shortcuts of passing variable assignments to the +`make install' command line to change installation locations without +having to reconfigure or recompile. + + The first method involves providing an override variable for each +affected directory. For example, `make install +prefix=/alternate/directory' will choose an alternate location for all +directory configuration variables that were expressed in terms of +`${prefix}'. Any directories that were specified during `configure', +but not in terms of `${prefix}', must each be overridden at install +time for the entire installation to be relocated. The approach of +makefile variable overrides for each directory variable is required by +the GNU Coding Standards, and ideally causes no recompilation. +However, some platforms have known limitations with the semantics of +shared libraries that end up requiring recompilation when using this +method, particularly noticeable in packages that use GNU Libtool. + + The second method involves providing the `DESTDIR' variable. For +example, `make install DESTDIR=/alternate/directory' will prepend +`/alternate/directory' before all installation names. The approach of +`DESTDIR' overrides is not required by the GNU Coding Standards, and +does not work on platforms that have drive letters. On the other hand, +it does better at avoiding recompilation issues, and works well even +when some directory options were not specified in terms of `${prefix}' +at `configure' time. + +Optional Features +================= If the package supports it, you can cause programs to be installed with an extra prefix or suffix on their names by giving `configure' the option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. -Optional Features -================= - Some packages pay attention to `--enable-FEATURE' options to `configure', where FEATURE indicates an optional part of the package. They may also pay attention to `--with-PACKAGE' options, where PACKAGE @@ -134,6 +208,50 @@ find the X include and library files automatically, but if it doesn't, you can use the `configure' options `--x-includes=DIR' and `--x-libraries=DIR' to specify their locations. + Some packages offer the ability to configure how verbose the +execution of `make' will be. For these packages, running `./configure +--enable-silent-rules' sets the default to minimal output, which can be +overridden with `make V=1'; while running `./configure +--disable-silent-rules' sets the default to verbose, which can be +overridden with `make V=0'. + +Particular systems +================== + + On HP-UX, the default C compiler is not ANSI C compatible. If GNU +CC is not installed, it is recommended to use the following options in +order to use an ANSI C compiler: + + ./configure CC="cc -Ae -D_XOPEN_SOURCE=500" + +and if that doesn't work, install pre-built binaries of GCC for HP-UX. + + HP-UX `make' updates targets which have the same time stamps as +their prerequisites, which makes it generally unusable when shipped +generated files such as `configure' are involved. Use GNU `make' +instead. + + On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot +parse its `' header file. The option `-nodtk' can be used as +a workaround. If GNU CC is not installed, it is therefore recommended +to try + + ./configure CC="cc" + +and if that doesn't work, try + + ./configure CC="cc -nodtk" + + On Solaris, don't put `/usr/ucb' early in your `PATH'. This +directory contains several dysfunctional programs; working variants of +these programs are available in `/usr/bin'. So, if you need `/usr/ucb' +in your `PATH', put it _after_ `/usr/bin'. + + On Haiku, software installed for all users goes in `/boot/common', +not `/usr/local'. It is recommended to use the following options: + + ./configure --prefix=/boot/common + Specifying the System Type ========================== @@ -149,14 +267,15 @@ type, such as `sun4', or a canonical name which has the form: where SYSTEM can have one of these forms: - OS KERNEL-OS + OS + KERNEL-OS See the file `config.sub' for the possible values of each field. If `config.sub' isn't included in this package, then this package doesn't need to know the machine type. If you are _building_ compiler tools for cross-compiling, you should -use the `--target=TYPE' option to select the type of system they will +use the option `--target=TYPE' to select the type of system they will produce code for. If you want to _use_ a cross compiler, that generates code for a @@ -186,9 +305,14 @@ them in the `configure' command line, using `VAR=value'. For example: ./configure CC=/usr/local2/bin/gcc -will cause the specified gcc to be used as the C compiler (unless it is +causes the specified `gcc' to be used as the C compiler (unless it is overridden in the site shell script). +Unfortunately, this technique does not work for `CONFIG_SHELL' due to +an Autoconf bug. Until the bug is fixed you can use this workaround: + + CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash + `configure' Invocation ====================== @@ -197,7 +321,14 @@ operates. `--help' `-h' - Print a summary of the options to `configure', and exit. + Print a summary of all of the options to `configure', and exit. + +`--help=short' +`--help=recursive' + Print a summary of the options unique to this package's + `configure', and exit. The `short' variant lists options used + only in the top level, while the `recursive' variant lists options + also present in any nested packages. `--version' `-V' @@ -224,6 +355,16 @@ operates. Look for the package's source code in directory DIR. Usually `configure' can determine that directory automatically. +`--prefix=DIR' + Use DIR as the installation prefix. *note Installation Names:: + for more details, including other options available for fine-tuning + the installation locations. + +`--no-create' +`-n' + Run the configure checks, but stop before creating any output + files. + `configure' also accepts some other, not widely useful, options. Run `configure --help' for more details. diff --git a/dist/libxcb/Makefile.am b/dist/libxcb/Makefile.am index e9124892b..2475b6e60 100644 --- a/dist/libxcb/Makefile.am +++ b/dist/libxcb/Makefile.am @@ -97,3 +97,15 @@ tools/api_conv.pl \ tools/constants \ autogen.sh \ $(TESTS) + +MAINTAINERCLEANFILES = ChangeLog INSTALL + +.PHONY: ChangeLog INSTALL + +INSTALL: + $(INSTALL_CMD) + +ChangeLog: + $(CHANGELOG_CMD) + +dist-hook: ChangeLog INSTALL diff --git a/dist/libxcb/Makefile.in b/dist/libxcb/Makefile.in index 439c15c60..16199f983 100644 --- a/dist/libxcb/Makefile.in +++ b/dist/libxcb/Makefile.in @@ -417,11 +417,11 @@ am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/xcb-composite.pc.in \ $(top_srcdir)/build-aux/install-sh \ $(top_srcdir)/build-aux/ltmain.sh \ $(top_srcdir)/build-aux/missing \ - $(top_srcdir)/build-aux/test-driver COPYING INSTALL NEWS \ - README build-aux/compile build-aux/config.guess \ - build-aux/config.sub build-aux/depcomp build-aux/install-sh \ - build-aux/ltmain.sh build-aux/missing compile config.guess \ - config.sub depcomp install-sh ltmain.sh missing + $(top_srcdir)/build-aux/test-driver COPYING ChangeLog INSTALL \ + NEWS README build-aux/compile build-aux/config.guess \ + build-aux/config.sub build-aux/install-sh build-aux/ltmain.sh \ + build-aux/missing compile config.guess config.sub depcomp \ + install-sh ltmain.sh missing DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) distdir = $(PACKAGE)-$(VERSION) top_distdir = $(distdir) @@ -525,6 +525,7 @@ LIB_MAN_SUFFIX = @LIB_MAN_SUFFIX@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ +LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ MAKEINFO = @MAKEINFO@ MANIFEST_TOOL = @MANIFEST_TOOL@ MAN_SUBSTS = @MAN_SUBSTS@ @@ -654,6 +655,7 @@ tools/constants \ autogen.sh \ $(TESTS) +MAINTAINERCLEANFILES = ChangeLog INSTALL all: all-recursive .SUFFIXES: @@ -1102,6 +1104,9 @@ distdir: $(DISTFILES) || exit 1; \ fi; \ done + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$(top_distdir)" distdir="$(distdir)" \ + dist-hook -test -n "$(am__skip_mode_fix)" \ || find "$(distdir)" -type d ! -perm -755 \ -exec chmod u+rwx,go+rx {} \; -o \ @@ -1274,6 +1279,7 @@ distclean-generic: maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." + -test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES) clean: clean-recursive clean-am: clean-generic clean-libtool mostlyclean-am @@ -1349,9 +1355,9 @@ uninstall-am: uninstall-pkgconfigDATA .PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \ am--refresh check check-TESTS check-am clean clean-cscope \ clean-generic clean-libtool cscope cscopelist-am ctags \ - ctags-am dist dist-all dist-bzip2 dist-gzip dist-lzip \ - dist-shar dist-tarZ dist-xz dist-zip distcheck distclean \ - distclean-generic distclean-libtool distclean-tags \ + ctags-am dist dist-all dist-bzip2 dist-gzip dist-hook \ + dist-lzip dist-shar dist-tarZ dist-xz dist-zip distcheck \ + distclean distclean-generic distclean-libtool distclean-tags \ distcleancheck distdir distuninstallcheck dvi dvi-am html \ html-am info info-am install install-am install-data \ install-data-am install-dvi install-dvi-am install-exec \ @@ -1367,6 +1373,16 @@ uninstall-am: uninstall-pkgconfigDATA .PRECIOUS: Makefile +.PHONY: ChangeLog INSTALL + +INSTALL: + $(INSTALL_CMD) + +ChangeLog: + $(CHANGELOG_CMD) + +dist-hook: ChangeLog INSTALL + # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: diff --git a/dist/libxcb/NEWS b/dist/libxcb/NEWS index aee79ed88..e1b46555a 100644 --- a/dist/libxcb/NEWS +++ b/dist/libxcb/NEWS @@ -1,3 +1,30 @@ +Release 1.12 (2016-05-18) +========================= +* configure: Various fixes for dri3 and FD passing support +* configure: Don't report all the warning CFLAGS +* configure: Disable Xevie and Xprint by default +* Add support for various new constructs in the XML schema +* Make some functions also accept connections in an error state +* Never return NULL from xcb_get_setup() +* Use Requires.private in .pc files to avoid overlinking +* Fix align-pads for switches which start at unaligned positions +* Use anonymous structs for some nested structs +* Also generate accessors for variable-sized events and requests +* Improved python3 compatibility +* Generate C99 initializers instead of comments +* Various simplifications to the python code +* Fix line breaks in xcb-requests manual page +* Always close FDs in xcb_send_fd() +* Fix thread-safety issues with FD passing +* Add xcb_send_request_with_fds() and xcb_send_request_with_fds64() +* Fix endless loop with too many outstanding FDs to send +* Link with winsock library on MinGW +* Disable some unfinished API for some server-side code by default +* Use align-offsets computed by xcb-proto instead of low bits of pointers +* Fix iterator interaction with align padding +* Stop serializing padding by default +* Increase unix socket send buffer to at least 64KiB + Release 1.11.1 (2015-09-06) =========================== * Expose 64-bit sequence numbers for XLib diff --git a/dist/libxcb/aclocal.m4 b/dist/libxcb/aclocal.m4 index 02e76eee8..961b0284e 100644 --- a/dist/libxcb/aclocal.m4 +++ b/dist/libxcb/aclocal.m4 @@ -20,32 +20,63 @@ You have another version of autoconf. It may work, but is not guaranteed to. If you have problems, you may need to regenerate the build system entirely. To do so, use the procedure documented by the package, typically 'autoreconf'.])]) -# pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- -# serial 1 (pkg-config-0.24) -# -# Copyright © 2004 Scott James Remnant . -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -# -# As a special exception to the GNU General Public License, if you -# distribute this file as part of a program that contains a -# configuration script generated by Autoconf, you may include it under -# the same distribution terms that you use for the rest of that program. +dnl pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- +dnl serial 11 (pkg-config-0.29) +dnl +dnl Copyright © 2004 Scott James Remnant . +dnl Copyright © 2012-2015 Dan Nicholson +dnl +dnl This program is free software; you can redistribute it and/or modify +dnl it under the terms of the GNU General Public License as published by +dnl the Free Software Foundation; either version 2 of the License, or +dnl (at your option) any later version. +dnl +dnl This program is distributed in the hope that it will be useful, but +dnl WITHOUT ANY WARRANTY; without even the implied warranty of +dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +dnl General Public License for more details. +dnl +dnl You should have received a copy of the GNU General Public License +dnl along with this program; if not, write to the Free Software +dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +dnl 02111-1307, USA. +dnl +dnl As a special exception to the GNU General Public License, if you +dnl distribute this file as part of a program that contains a +dnl configuration script generated by Autoconf, you may include it under +dnl the same distribution terms that you use for the rest of that +dnl program. -# PKG_PROG_PKG_CONFIG([MIN-VERSION]) -# ---------------------------------- +dnl PKG_PREREQ(MIN-VERSION) +dnl ----------------------- +dnl Since: 0.29 +dnl +dnl Verify that the version of the pkg-config macros are at least +dnl MIN-VERSION. Unlike PKG_PROG_PKG_CONFIG, which checks the user's +dnl installed version of pkg-config, this checks the developer's version +dnl of pkg.m4 when generating configure. +dnl +dnl To ensure that this macro is defined, also add: +dnl m4_ifndef([PKG_PREREQ], +dnl [m4_fatal([must install pkg-config 0.29 or later before running autoconf/autogen])]) +dnl +dnl See the "Since" comment for each macro you use to see what version +dnl of the macros you require. +m4_defun([PKG_PREREQ], +[m4_define([PKG_MACROS_VERSION], [0.29]) +m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1, + [m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])]) +])dnl PKG_PREREQ + +dnl PKG_PROG_PKG_CONFIG([MIN-VERSION]) +dnl ---------------------------------- +dnl Since: 0.16 +dnl +dnl Search for the pkg-config tool and set the PKG_CONFIG variable to +dnl first found in the path. Checks that the version of pkg-config found +dnl is at least MIN-VERSION. If MIN-VERSION is not specified, 0.9.0 is +dnl used since that's the first version where most current features of +dnl pkg-config existed. AC_DEFUN([PKG_PROG_PKG_CONFIG], [m4_pattern_forbid([^_?PKG_[A-Z_]+$]) m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$]) @@ -67,18 +98,19 @@ if test -n "$PKG_CONFIG"; then PKG_CONFIG="" fi fi[]dnl -])# PKG_PROG_PKG_CONFIG +])dnl PKG_PROG_PKG_CONFIG -# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) -# -# Check to see whether a particular set of modules exists. Similar -# to PKG_CHECK_MODULES(), but does not set variables or print errors. -# -# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG]) -# only at the first occurence in configure.ac, so if the first place -# it's called might be skipped (such as if it is within an "if", you -# have to call PKG_CHECK_EXISTS manually -# -------------------------------------------------------------- +dnl PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +dnl ------------------------------------------------------------------- +dnl Since: 0.18 +dnl +dnl Check to see whether a particular set of modules exists. Similar to +dnl PKG_CHECK_MODULES(), but does not set variables or print errors. +dnl +dnl Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG]) +dnl only at the first occurence in configure.ac, so if the first place +dnl it's called might be skipped (such as if it is within an "if", you +dnl have to call PKG_CHECK_EXISTS manually AC_DEFUN([PKG_CHECK_EXISTS], [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl if test -n "$PKG_CONFIG" && \ @@ -88,8 +120,10 @@ m4_ifvaln([$3], [else $3])dnl fi]) -# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES]) -# --------------------------------------------- +dnl _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES]) +dnl --------------------------------------------- +dnl Internal wrapper calling pkg-config via PKG_CONFIG and setting +dnl pkg_failed based on the result. m4_define([_PKG_CONFIG], [if test -n "$$1"; then pkg_cv_[]$1="$$1" @@ -101,10 +135,11 @@ m4_define([_PKG_CONFIG], else pkg_failed=untried fi[]dnl -])# _PKG_CONFIG +])dnl _PKG_CONFIG -# _PKG_SHORT_ERRORS_SUPPORTED -# ----------------------------- +dnl _PKG_SHORT_ERRORS_SUPPORTED +dnl --------------------------- +dnl Internal check to see if pkg-config supports short errors. AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED], [AC_REQUIRE([PKG_PROG_PKG_CONFIG]) if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then @@ -112,19 +147,17 @@ if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then else _pkg_short_errors_supported=no fi[]dnl -])# _PKG_SHORT_ERRORS_SUPPORTED +])dnl _PKG_SHORT_ERRORS_SUPPORTED -# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], -# [ACTION-IF-NOT-FOUND]) -# -# -# Note that if there is a possibility the first call to -# PKG_CHECK_MODULES might not happen, you should be sure to include an -# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac -# -# -# -------------------------------------------------------------- +dnl PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], +dnl [ACTION-IF-NOT-FOUND]) +dnl -------------------------------------------------------------- +dnl Since: 0.4.0 +dnl +dnl Note that if there is a possibility the first call to +dnl PKG_CHECK_MODULES might not happen, you should be sure to include an +dnl explicit call to PKG_PROG_PKG_CONFIG in your configure.ac AC_DEFUN([PKG_CHECK_MODULES], [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl @@ -178,16 +211,40 @@ else AC_MSG_RESULT([yes]) $3 fi[]dnl -])# PKG_CHECK_MODULES +])dnl PKG_CHECK_MODULES -# PKG_INSTALLDIR(DIRECTORY) -# ------------------------- -# Substitutes the variable pkgconfigdir as the location where a module -# should install pkg-config .pc files. By default the directory is -# $libdir/pkgconfig, but the default can be changed by passing -# DIRECTORY. The user can override through the --with-pkgconfigdir -# parameter. +dnl PKG_CHECK_MODULES_STATIC(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], +dnl [ACTION-IF-NOT-FOUND]) +dnl --------------------------------------------------------------------- +dnl Since: 0.29 +dnl +dnl Checks for existence of MODULES and gathers its build flags with +dnl static libraries enabled. Sets VARIABLE-PREFIX_CFLAGS from --cflags +dnl and VARIABLE-PREFIX_LIBS from --libs. +dnl +dnl Note that if there is a possibility the first call to +dnl PKG_CHECK_MODULES_STATIC might not happen, you should be sure to +dnl include an explicit call to PKG_PROG_PKG_CONFIG in your +dnl configure.ac. +AC_DEFUN([PKG_CHECK_MODULES_STATIC], +[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl +_save_PKG_CONFIG=$PKG_CONFIG +PKG_CONFIG="$PKG_CONFIG --static" +PKG_CHECK_MODULES($@) +PKG_CONFIG=$_save_PKG_CONFIG[]dnl +])dnl PKG_CHECK_MODULES_STATIC + + +dnl PKG_INSTALLDIR([DIRECTORY]) +dnl ------------------------- +dnl Since: 0.27 +dnl +dnl Substitutes the variable pkgconfigdir as the location where a module +dnl should install pkg-config .pc files. By default the directory is +dnl $libdir/pkgconfig, but the default can be changed by passing +dnl DIRECTORY. The user can override through the --with-pkgconfigdir +dnl parameter. AC_DEFUN([PKG_INSTALLDIR], [m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])]) m4_pushdef([pkg_description], @@ -198,16 +255,18 @@ AC_ARG_WITH([pkgconfigdir], AC_SUBST([pkgconfigdir], [$with_pkgconfigdir]) m4_popdef([pkg_default]) m4_popdef([pkg_description]) -]) dnl PKG_INSTALLDIR +])dnl PKG_INSTALLDIR -# PKG_NOARCH_INSTALLDIR(DIRECTORY) -# ------------------------- -# Substitutes the variable noarch_pkgconfigdir as the location where a -# module should install arch-independent pkg-config .pc files. By -# default the directory is $datadir/pkgconfig, but the default can be -# changed by passing DIRECTORY. The user can override through the -# --with-noarch-pkgconfigdir parameter. +dnl PKG_NOARCH_INSTALLDIR([DIRECTORY]) +dnl -------------------------------- +dnl Since: 0.27 +dnl +dnl Substitutes the variable noarch_pkgconfigdir as the location where a +dnl module should install arch-independent pkg-config .pc files. By +dnl default the directory is $datadir/pkgconfig, but the default can be +dnl changed by passing DIRECTORY. The user can override through the +dnl --with-noarch-pkgconfigdir parameter. AC_DEFUN([PKG_NOARCH_INSTALLDIR], [m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])]) m4_pushdef([pkg_description], @@ -218,13 +277,15 @@ AC_ARG_WITH([noarch-pkgconfigdir], AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir]) m4_popdef([pkg_default]) m4_popdef([pkg_description]) -]) dnl PKG_NOARCH_INSTALLDIR +])dnl PKG_NOARCH_INSTALLDIR -# PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE, -# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) -# ------------------------------------------- -# Retrieves the value of the pkg-config variable for the given module. +dnl PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE, +dnl [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +dnl ------------------------------------------- +dnl Since: 0.28 +dnl +dnl Retrieves the value of the pkg-config variable for the given module. AC_DEFUN([PKG_CHECK_VAR], [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl @@ -233,7 +294,7 @@ _PKG_CONFIG([$1], [variable="][$3]["], [$2]) AS_VAR_COPY([$1], [pkg_cv_][$1]) AS_VAR_IF([$1], [""], [$5], [$4])dnl -])# PKG_CHECK_VAR +])dnl PKG_CHECK_VAR dnl xorg-macros.m4. Generated from xorg-macros.m4.in xorgversion.m4 by configure. dnl @@ -659,13 +720,24 @@ m4_ifval([$1], fi]) # Test for the ability of xmlto to generate a text target +# +# NOTE: xmlto 0.0.27 or higher return a non-zero return code in the +# following test for empty XML docbook files. +# For compatibility reasons use the following empty XML docbook file and if +# it fails try it again with a non-empty XML file. have_xmlto_text=no cat > conftest.xml << "EOF" EOF AS_IF([test "$have_xmlto" = yes], [AS_IF([$XMLTO --skip-validation txt conftest.xml >/dev/null 2>&1], [have_xmlto_text=yes], - [AC_MSG_WARN([xmlto cannot generate text format, this format skipped])])]) + [# Try it again with a non-empty XML file. + cat > conftest.xml << "EOF" + +EOF + AS_IF([$XMLTO --skip-validation txt conftest.xml >/dev/null 2>&1], + [have_xmlto_text=yes], + [AC_MSG_WARN([xmlto cannot generate text format, this format skipped])])])]) rm -f conftest.xml AM_CONDITIONAL([HAVE_XMLTO_TEXT], [test $have_xmlto_text = yes]) AM_CONDITIONAL([HAVE_XMLTO], [test "$have_xmlto" = yes]) diff --git a/dist/libxcb/check-pc-requires b/dist/libxcb/check-pc-requires index 0fd9c6597..063356fb4 100644 --- a/dist/libxcb/check-pc-requires +++ b/dist/libxcb/check-pc-requires @@ -23,7 +23,7 @@ for inc in src/*.h; do included=`grep '# *include' $inc | sed -e 's/[^<"]*[<"]//' -e 's/[>"]//' | grep -v 'xcb.h\|xproto.h'` - requires=`grep '^Requires:' $pcin` + requires=`grep '^Requires.private:' $pcin` missing="" for i in $included; do ibase=`basename $i .h` @@ -58,7 +58,7 @@ for inc in src/*.h; do *) if [ "$fix" = "y" ]; then echo $package adding dependency on $missing - sed -i '/^Requires:/s/$/ '"$missing"'/' $pcin + sed -i '/^Requires.private:/s/$/ '"$missing"'/' $pcin else echo $package missing $missing status=1 diff --git a/dist/libxcb/configure b/dist/libxcb/configure index ae04252af..aedb5176e 100644 --- a/dist/libxcb/configure +++ b/dist/libxcb/configure @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69 for libxcb 1.11.1. +# Generated by GNU Autoconf 2.69 for libxcb 1.12. # # Report bugs to . # @@ -591,8 +591,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='libxcb' PACKAGE_TARNAME='libxcb' -PACKAGE_VERSION='1.11.1' -PACKAGE_STRING='libxcb 1.11.1' +PACKAGE_VERSION='1.12' +PACKAGE_STRING='libxcb 1.12' PACKAGE_BUGREPORT='https://bugs.freedesktop.org/enter_bug.cgi?product=xcb' PACKAGE_URL='' @@ -637,6 +637,8 @@ ac_subst_vars='am__EXEEXT_FALSE am__EXEEXT_TRUE LTLIBOBJS LIBOBJS +XCB_SERVERSIDE_SUPPORT_FALSE +XCB_SERVERSIDE_SUPPORT_TRUE LAUNCHD BUILD_XVMC_FALSE BUILD_XVMC_TRUE @@ -741,6 +743,7 @@ CHANGELOG_CMD STRICT_CFLAGS CWARNFLAGS BASE_CFLAGS +LT_SYS_LIBRARY_PATH OTOOL64 OTOOL LIPO @@ -873,6 +876,7 @@ enable_shared enable_static with_pic enable_fast_install +with_aix_soname with_gnu_ld with_sysroot enable_libtool_lock @@ -880,7 +884,6 @@ enable_selective_werror enable_strict_compilation enable_devel_docs with_doxygen -enable_sendfds with_queue_size enable_composite enable_damage @@ -909,6 +912,7 @@ enable_xtest enable_xv enable_xvmc with_launchd +with_serverside_support ' ac_precious_vars='build_alias host_alias @@ -920,6 +924,7 @@ LDFLAGS LIBS CPPFLAGS CPP +LT_SYS_LIBRARY_PATH PKG_CONFIG PKG_CONFIG_PATH PKG_CONFIG_LIBDIR @@ -1483,7 +1488,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures libxcb 1.11.1 to adapt to many kinds of systems. +\`configure' configures libxcb 1.12 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1554,7 +1559,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of libxcb 1.11.1:";; + short | recursive ) echo "Configuration of libxcb 1.12:";; esac cat <<\_ACEOF @@ -1581,47 +1586,53 @@ Optional Features: errors (default: disabled) --enable-devel-docs Enable building the developer documentation (default: yes) - --disable-sendfds Support FD passing (default: auto) - --enable-composite Build XCB Composite Extension (default: "yes") - --enable-damage Build XCB Damage Extension (default: "yes") - --enable-dpms Build XCB DPMS Extension (default: "yes") - --enable-dri2 Build XCB DRI2 Extension (default: "yes") - --enable-dri3 Build XCB DRI3 Extension (default: "$sendfds") - --enable-glx Build XCB GLX Extension (default: "yes") - --enable-present Build XCB Present Extension (default: "yes") - --enable-randr Build XCB RandR Extension (default: "yes") - --enable-record Build XCB Record Extension (default: "yes") - --enable-render Build XCB Render Extension (default: "yes") - --enable-resource Build XCB Resource Extension (default: "yes") - --enable-screensaver Build XCB Screensaver Extension (default: "yes") - --enable-shape Build XCB Shape Extension (default: "yes") - --enable-shm Build XCB Shm Extension (default: "yes") - --enable-sync Build XCB Sync Extension (default: "yes") - --enable-xevie Build XCB Xevie Extension (default: "yes") - --enable-xfixes Build XCB XFixes Extension (default: "yes") - --enable-xfree86-dri Build XCB XFree86-DRI Extension (default: "yes") - --enable-xinerama Build XCB Xinerama Extension (default: "yes") - --enable-xinput Build XCB XInput Extension (default: "no") - --enable-xkb Build XCB XKB Extension (default: "yes") - --enable-xprint Build XCB Xprint Extension (default: "yes") - --enable-selinux Build XCB SELinux Extension (default: "no") - --enable-xtest Build XCB XTest Extension (default: "yes") - --enable-xv Build XCB Xv Extension (default: "yes") - --enable-xvmc Build XCB XvMC Extension (default: "yes") + --enable-composite Build XCB Composite Extension (default: yes) + --enable-damage Build XCB Damage Extension (default: yes) + --enable-dpms Build XCB DPMS Extension (default: yes) + --enable-dri2 Build XCB DRI2 Extension (default: yes) + --enable-dri3 Build XCB DRI3 Extension (default: auto) + --enable-glx Build XCB GLX Extension (default: yes) + --enable-present Build XCB Present Extension (default: yes) + --enable-randr Build XCB RandR Extension (default: yes) + --enable-record Build XCB Record Extension (default: yes) + --enable-render Build XCB Render Extension (default: yes) + --enable-resource Build XCB Resource Extension (default: yes) + --enable-screensaver Build XCB Screensaver Extension (default: yes) + --enable-shape Build XCB Shape Extension (default: yes) + --enable-shm Build XCB Shm Extension (default: yes) + --enable-sync Build XCB Sync Extension (default: yes) + --enable-xevie Build XCB Xevie Extension (default: no) + --enable-xfixes Build XCB XFixes Extension (default: yes) + --enable-xfree86-dri Build XCB XFree86-DRI Extension (default: yes) + --enable-xinerama Build XCB Xinerama Extension (default: yes) + --enable-xinput Build XCB XInput Extension (default: no) + --enable-xkb Build XCB XKB Extension (default: yes) + --enable-xprint Build XCB Xprint Extension (default: no) + --enable-selinux Build XCB SELinux Extension (default: no) + --enable-xtest Build XCB XTest Extension (default: yes) + --enable-xv Build XCB Xv Extension (default: yes) + --enable-xvmc Build XCB XvMC Extension (default: yes) Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-pic[=PKGS] try to use only PIC/non-PIC objects [default=use both] + --with-aix-soname=aix|svr4|both + shared library versioning (aka "SONAME") variant to + provide on AIX, [default=aix]. --with-gnu-ld assume the C compiler uses GNU ld [default=no] - --with-sysroot=DIR Search for dependent libraries within DIR - (or the compiler's sysroot if not specified). + --with-sysroot[=DIR] Search for dependent libraries within DIR (or the + compiler's sysroot if not specified). --with-doxygen Use doxygen to regenerate documentation (default: auto) --with-queue-size=SIZE Set the XCB buffer queue size (default is 16384) --with-launchd Build with support for Apple's launchd (default: auto) + --with-serverside-support + Build with support for server-side usage of xcb. + This is still EXPERIMENTAL! ABI/API may change! + (default: no) Some influential environment variables: PYTHON the Python interpreter @@ -1633,6 +1644,8 @@ Some influential environment variables: CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor + LT_SYS_LIBRARY_PATH + User-defined run-time library search path. PKG_CONFIG path to pkg-config utility PKG_CONFIG_PATH directories to add to pkg-config's search path @@ -1720,7 +1733,7 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -libxcb configure 1.11.1 +libxcb configure 1.12 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. @@ -2192,7 +2205,7 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by libxcb $as_me 1.11.1, which was +It was created by libxcb $as_me 1.12, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -3061,7 +3074,7 @@ fi # Define the identity of the package. PACKAGE='libxcb' - VERSION='1.11.1' + VERSION='1.12' cat >>confdefs.h <<_ACEOF @@ -4928,8 +4941,8 @@ esac -macro_version='2.4.2' -macro_revision='1.3337' +macro_version='2.4.6' +macro_revision='2.4.6' @@ -4943,7 +4956,7 @@ macro_revision='1.3337' -ltmain="$ac_aux_dir/ltmain.sh" +ltmain=$ac_aux_dir/ltmain.sh # Make sure we can run config.sub. $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || @@ -5063,7 +5076,7 @@ func_echo_all () $ECHO "" } -case "$ECHO" in +case $ECHO in printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5 $as_echo "printf" >&6; } ;; print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5 @@ -5256,19 +5269,19 @@ test -z "$GREP" && GREP=grep # Check whether --with-gnu-ld was given. if test "${with_gnu_ld+set}" = set; then : - withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes + withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes else with_gnu_ld=no fi ac_prog=ld -if test "$GCC" = yes; then +if test yes = "$GCC"; then # Check if gcc -print-prog-name=ld gives a path. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 $as_echo_n "checking for ld used by $CC... " >&6; } case $host in *-*-mingw*) - # gcc leaves a trailing carriage return which upsets mingw + # gcc leaves a trailing carriage return, which upsets mingw ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; *) ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; @@ -5282,7 +5295,7 @@ $as_echo_n "checking for ld used by $CC... " >&6; } while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` done - test -z "$LD" && LD="$ac_prog" + test -z "$LD" && LD=$ac_prog ;; "") # If it fails, then pretend we aren't using GCC. @@ -5293,7 +5306,7 @@ $as_echo_n "checking for ld used by $CC... " >&6; } with_gnu_ld=unknown ;; esac -elif test "$with_gnu_ld" = yes; then +elif test yes = "$with_gnu_ld"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 $as_echo_n "checking for GNU ld... " >&6; } else @@ -5304,32 +5317,32 @@ if ${lt_cv_path_LD+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$LD"; then - lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs test -z "$ac_dir" && ac_dir=. if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then - lt_cv_path_LD="$ac_dir/$ac_prog" + lt_cv_path_LD=$ac_dir/$ac_prog # Check to see if the program is GNU ld. I'd rather use --version, # but apparently some variants of GNU ld only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. case `"$lt_cv_path_LD" -v 2>&1 &5 $as_echo "$LD" >&6; } @@ -5372,33 +5385,38 @@ if ${lt_cv_path_NM+:} false; then : else if test -n "$NM"; then # Let the user override the test. - lt_cv_path_NM="$NM" + lt_cv_path_NM=$NM else - lt_nm_to_check="${ac_tool_prefix}nm" + lt_nm_to_check=${ac_tool_prefix}nm if test -n "$ac_tool_prefix" && test "$build" = "$host"; then lt_nm_to_check="$lt_nm_to_check nm" fi for lt_tmp_nm in $lt_nm_to_check; do - lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs test -z "$ac_dir" && ac_dir=. - tmp_nm="$ac_dir/$lt_tmp_nm" - if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + tmp_nm=$ac_dir/$lt_tmp_nm + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then # Check to see if the nm accepts a BSD-compat flag. - # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # Adding the 'sed 1q' prevents false positives on HP-UX, which says: # nm: unknown option "B" ignored # Tru64's nm complains that /dev/null is an invalid object file - case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in - */dev/null* | *'Invalid file or object type'*) + # MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty + case $build_os in + mingw*) lt_bad_file=conftest.nm/nofile ;; + *) lt_bad_file=/dev/null ;; + esac + case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in + *$lt_bad_file* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" - break + break 2 ;; *) case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in */dev/null*) lt_cv_path_NM="$tmp_nm -p" - break + break 2 ;; *) lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but @@ -5409,15 +5427,15 @@ else esac fi done - IFS="$lt_save_ifs" + IFS=$lt_save_ifs done : ${lt_cv_path_NM=no} fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 $as_echo "$lt_cv_path_NM" >&6; } -if test "$lt_cv_path_NM" != "no"; then - NM="$lt_cv_path_NM" +if test no != "$lt_cv_path_NM"; then + NM=$lt_cv_path_NM else # Didn't find any BSD compatible name lister, look for dumpbin. if test -n "$DUMPBIN"; then : @@ -5523,9 +5541,9 @@ esac fi fi - case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in + case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in *COFF*) - DUMPBIN="$DUMPBIN -symbols" + DUMPBIN="$DUMPBIN -symbols -headers" ;; *) DUMPBIN=: @@ -5533,8 +5551,8 @@ fi esac fi - if test "$DUMPBIN" != ":"; then - NM="$DUMPBIN" + if test : != "$DUMPBIN"; then + NM=$DUMPBIN fi fi test -z "$NM" && NM=nm @@ -5585,7 +5603,7 @@ if ${lt_cv_sys_max_cmd_len+:} false; then : $as_echo_n "(cached) " >&6 else i=0 - teststring="ABCD" + teststring=ABCD case $build_os in msdosdjgpp*) @@ -5625,7 +5643,7 @@ else lt_cv_sys_max_cmd_len=8192; ;; - netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) + bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*) # This has been around since 386BSD, at least. Likely further. if test -x /sbin/sysctl; then lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` @@ -5676,22 +5694,22 @@ else *) lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` if test -n "$lt_cv_sys_max_cmd_len" && \ - test undefined != "$lt_cv_sys_max_cmd_len"; then + test undefined != "$lt_cv_sys_max_cmd_len"; then lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` else # Make teststring a little bigger before we do anything with it. # a 1K string should be a reasonable start. - for i in 1 2 3 4 5 6 7 8 ; do + for i in 1 2 3 4 5 6 7 8; do teststring=$teststring$teststring done SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} # If test is not a shell built-in, we'll probably end up computing a # maximum length that is only half of the actual maximum length, but # we can't tell. - while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \ + while { test X`env echo "$teststring$teststring" 2>/dev/null` \ = "X$teststring$teststring"; } >/dev/null 2>&1 && - test $i != 17 # 1/2 MB should be enough + test 17 != "$i" # 1/2 MB should be enough do i=`expr $i + 1` teststring=$teststring$teststring @@ -5709,7 +5727,7 @@ else fi -if test -n $lt_cv_sys_max_cmd_len ; then +if test -n "$lt_cv_sys_max_cmd_len"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 $as_echo "$lt_cv_sys_max_cmd_len" >&6; } else @@ -5727,30 +5745,6 @@ max_cmd_len=$lt_cv_sys_max_cmd_len : ${MV="mv -f"} : ${RM="rm -f"} -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5 -$as_echo_n "checking whether the shell understands some XSI constructs... " >&6; } -# Try some XSI features -xsi_shell=no -( _lt_dummy="a/b/c" - test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ - = c,a/b,b/c, \ - && eval 'test $(( 1 + 1 )) -eq 2 \ - && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ - && xsi_shell=yes -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5 -$as_echo "$xsi_shell" >&6; } - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5 -$as_echo_n "checking whether the shell understands \"+=\"... " >&6; } -lt_shell_append=no -( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \ - >/dev/null 2>&1 \ - && lt_shell_append=yes -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5 -$as_echo "$lt_shell_append" >&6; } - - if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then lt_unset=unset else @@ -5873,13 +5867,13 @@ esac reload_cmds='$LD$reload_flag -o $output$reload_objs' case $host_os in cygwin* | mingw* | pw32* | cegcc*) - if test "$GCC" != yes; then + if test yes != "$GCC"; then reload_cmds=false fi ;; darwin*) - if test "$GCC" = yes; then - reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs' + if test yes = "$GCC"; then + reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs' else reload_cmds='$LD$reload_flag -o $output$reload_objs' fi @@ -6004,13 +5998,13 @@ lt_cv_deplibs_check_method='unknown' # Need to set the preceding variable on all platforms that support # interlibrary dependencies. # 'none' -- dependencies not supported. -# `unknown' -- same as none, but documents that we really don't know. +# 'unknown' -- same as none, but documents that we really don't know. # 'pass_all' -- all dependencies passed with no checks. # 'test_compile' -- check by making test program. # 'file_magic [[regex]]' -- check by looking for files in library path -# which responds to the $file_magic_cmd with a given extended regex. -# If you have `file' or equivalent on your system and you're not sure -# whether `pass_all' will *always* work, you probably want this one. +# that responds to the $file_magic_cmd with a given extended regex. +# If you have 'file' or equivalent on your system and you're not sure +# whether 'pass_all' will *always* work, you probably want this one. case $host_os in aix[4-9]*) @@ -6037,8 +6031,7 @@ mingw* | pw32*) # Base MSYS/MinGW do not provide the 'file' command needed by # func_win32_libid shell function, so use a weaker test based on 'objdump', # unless we find 'file', for example because we are cross-compiling. - # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin. - if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then + if ( file / ) >/dev/null 2>&1; then lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' lt_cv_file_magic_cmd='func_win32_libid' else @@ -6134,8 +6127,8 @@ newos6*) lt_cv_deplibs_check_method=pass_all ;; -openbsd*) - if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then +openbsd* | bitrig*) + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$' else lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' @@ -6188,6 +6181,9 @@ sysv4 | sysv4.3*) tpf*) lt_cv_deplibs_check_method=pass_all ;; +os2*) + lt_cv_deplibs_check_method=pass_all + ;; esac fi @@ -6342,8 +6338,8 @@ else case $host_os in cygwin* | mingw* | pw32* | cegcc*) - # two different shell functions defined in ltmain.sh - # decide which to use based on capabilities of $DLLTOOL + # two different shell functions defined in ltmain.sh; + # decide which one to use based on capabilities of $DLLTOOL case `$DLLTOOL --help 2>&1` in *--identify-strict*) lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib @@ -6355,7 +6351,7 @@ cygwin* | mingw* | pw32* | cegcc*) ;; *) # fallback: assume linklib IS sharedlib - lt_cv_sharedlib_from_linklib_cmd="$ECHO" + lt_cv_sharedlib_from_linklib_cmd=$ECHO ;; esac @@ -6509,7 +6505,7 @@ if ac_fn_c_try_compile "$LINENO"; then : ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } - if test "$ac_status" -eq 0; then + if test 0 -eq "$ac_status"; then # Ensure the archiver fails upon bogus file names. rm -f conftest.$ac_objext libconftest.a { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 @@ -6517,7 +6513,7 @@ if ac_fn_c_try_compile "$LINENO"; then : ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } - if test "$ac_status" -ne 0; then + if test 0 -ne "$ac_status"; then lt_cv_ar_at_file=@ fi fi @@ -6530,7 +6526,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5 $as_echo "$lt_cv_ar_at_file" >&6; } -if test "x$lt_cv_ar_at_file" = xno; then +if test no = "$lt_cv_ar_at_file"; then archiver_list_spec= else archiver_list_spec=$lt_cv_ar_at_file @@ -6747,7 +6743,7 @@ old_postuninstall_cmds= if test -n "$RANLIB"; then case $host_os in - openbsd*) + bitrig* | openbsd*) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" ;; *) @@ -6837,7 +6833,7 @@ cygwin* | mingw* | pw32* | cegcc*) symcode='[ABCDGISTW]' ;; hpux*) - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then symcode='[ABCDEGRST]' fi ;; @@ -6870,14 +6866,44 @@ case `$NM -V 2>&1` in symcode='[ABCDGIRSTW]' ;; esac +if test "$lt_cv_nm_interface" = "MS dumpbin"; then + # Gets list of data symbols to import. + lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'" + # Adjust the below global symbol transforms to fixup imported variables. + lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'" + lt_c_name_hook=" -e 's/^I .* \(.*\)$/ {\"\1\", (void *) 0},/p'" + lt_c_name_lib_hook="\ + -e 's/^I .* \(lib.*\)$/ {\"\1\", (void *) 0},/p'\ + -e 's/^I .* \(.*\)$/ {\"lib\1\", (void *) 0},/p'" +else + # Disable hooks by default. + lt_cv_sys_global_symbol_to_import= + lt_cdecl_hook= + lt_c_name_hook= + lt_c_name_lib_hook= +fi + # Transform an extracted symbol line into a proper C declaration. # Some systems (esp. on ia64) link data and code symbols differently, # so use this general approach. -lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" +lt_cv_sys_global_symbol_to_cdecl="sed -n"\ +$lt_cdecl_hook\ +" -e 's/^T .* \(.*\)$/extern int \1();/p'"\ +" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'" # Transform an extracted symbol line into symbol name and symbol address -lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"\2\", (void *) \&\2},/p'" -lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \(lib[^ ]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"lib\2\", (void *) \&\2},/p'" +lt_cv_sys_global_symbol_to_c_name_address="sed -n"\ +$lt_c_name_hook\ +" -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ +" -e 's/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/p'" + +# Transform an extracted symbol line into symbol name with lib prefix and +# symbol address. +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\ +$lt_c_name_lib_hook\ +" -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ +" -e 's/^$symcode$symcode* .* \(lib.*\)$/ {\"\1\", (void *) \&\1},/p'"\ +" -e 's/^$symcode$symcode* .* \(.*\)$/ {\"lib\1\", (void *) \&\1},/p'" # Handle CRLF in mingw tool chain opt_cr= @@ -6895,21 +6921,24 @@ for ac_symprfx in "" "_"; do # Write the raw and C identifiers. if test "$lt_cv_nm_interface" = "MS dumpbin"; then - # Fake it for dumpbin and say T for any non-static function - # and D for any global variable. + # Fake it for dumpbin and say T for any non-static function, + # D for any global variable and I for any imported variable. # Also find C++ and __fastcall symbols from MSVC++, # which start with @ or ?. lt_cv_sys_global_symbol_pipe="$AWK '"\ " {last_section=section; section=\$ 3};"\ " /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ " /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ +" /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\ +" /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\ +" /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\ " \$ 0!~/External *\|/{next};"\ " / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ " {if(hide[section]) next};"\ -" {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ -" {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ -" s[1]~/^[@?]/{print s[1], s[1]; next};"\ -" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ +" {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\ +" {split(\$ 0,a,/\||\r/); split(a[2],s)};"\ +" s[1]~/^[@?]/{print f,s[1],s[1]; next};"\ +" s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\ " ' prfx=^$ac_symprfx" else lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ ]\($symcode$symcode*\)[ ][ ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" @@ -6957,11 +6986,11 @@ _LT_EOF if $GREP ' nm_test_func$' "$nlist" >/dev/null; then cat <<_LT_EOF > conftest.$ac_ext /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ -#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) -/* DATA imports from DLLs on WIN32 con't be const, because runtime +#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE +/* DATA imports from DLLs on WIN32 can't be const, because runtime relocations are performed -- see ld's documentation on pseudo-relocs. */ # define LT_DLSYM_CONST -#elif defined(__osf__) +#elif defined __osf__ /* This system does not cope well with relocations in const data. */ # define LT_DLSYM_CONST #else @@ -6987,7 +7016,7 @@ lt__PROGRAM__LTX_preloaded_symbols[] = { { "@PROGRAM@", (void *) 0 }, _LT_EOF - $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext + $SED "s/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext cat <<\_LT_EOF >> conftest.$ac_ext {0, (void *) 0} }; @@ -7007,13 +7036,13 @@ _LT_EOF mv conftest.$ac_objext conftstm.$ac_objext lt_globsym_save_LIBS=$LIBS lt_globsym_save_CFLAGS=$CFLAGS - LIBS="conftstm.$ac_objext" + LIBS=conftstm.$ac_objext CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag" if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && test -s conftest${ac_exeext}; then + test $ac_status = 0; } && test -s conftest$ac_exeext; then pipe_works=yes fi LIBS=$lt_globsym_save_LIBS @@ -7034,7 +7063,7 @@ _LT_EOF rm -rf conftest* conftst* # Do not use the global_symbol_pipe unless it works. - if test "$pipe_works" = yes; then + if test yes = "$pipe_works"; then break else lt_cv_sys_global_symbol_pipe= @@ -7076,6 +7105,16 @@ fi + + + + + + + + + + @@ -7099,9 +7138,9 @@ fi lt_sysroot= -case ${with_sysroot} in #( +case $with_sysroot in #( yes) - if test "$GCC" = yes; then + if test yes = "$GCC"; then lt_sysroot=`$CC --print-sysroot 2>/dev/null` fi ;; #( @@ -7111,8 +7150,8 @@ case ${with_sysroot} in #( no|'') ;; #( *) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5 -$as_echo "${with_sysroot}" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5 +$as_echo "$with_sysroot" >&6; } as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5 ;; esac @@ -7124,18 +7163,99 @@ $as_echo "${lt_sysroot:-no}" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5 +$as_echo_n "checking for a working dd... " >&6; } +if ${ac_cv_path_lt_DD+:} false; then : + $as_echo_n "(cached) " >&6 +else + printf 0123456789abcdef0123456789abcdef >conftest.i +cat conftest.i conftest.i >conftest2.i +: ${lt_DD:=$DD} +if test -z "$lt_DD"; then + ac_path_lt_DD_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in dd; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_lt_DD="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_lt_DD" || continue +if "$ac_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then + cmp -s conftest.i conftest.out \ + && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=: +fi + $ac_path_lt_DD_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_lt_DD"; then + : + fi +else + ac_cv_path_lt_DD=$lt_DD +fi + +rm -f conftest.i conftest2.i conftest.out +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5 +$as_echo "$ac_cv_path_lt_DD" >&6; } + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5 +$as_echo_n "checking how to truncate binary pipes... " >&6; } +if ${lt_cv_truncate_bin+:} false; then : + $as_echo_n "(cached) " >&6 +else + printf 0123456789abcdef0123456789abcdef >conftest.i +cat conftest.i conftest.i >conftest2.i +lt_cv_truncate_bin= +if "$ac_cv_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then + cmp -s conftest.i conftest.out \ + && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1" +fi +rm -f conftest.i conftest2.i conftest.out +test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5 +$as_echo "$lt_cv_truncate_bin" >&6; } + + + + + + + +# Calculate cc_basename. Skip known compiler wrappers and cross-prefix. +func_cc_basename () +{ + for cc_temp in $*""; do + case $cc_temp in + compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; + distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; + \-*) ;; + *) break;; + esac + done + func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` +} + # Check whether --enable-libtool-lock was given. if test "${enable_libtool_lock+set}" = set; then : enableval=$enable_libtool_lock; fi -test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes +test no = "$enable_libtool_lock" || enable_libtool_lock=yes # Some flags need to be propagated to the compiler or linker for good # libtool support. case $host in ia64-*-hpux*) - # Find out which ABI we are using. + # Find out what ABI is being produced by ac_compile, and set mode + # options accordingly. echo 'int i;' > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 @@ -7144,24 +7264,25 @@ ia64-*-hpux*) test $ac_status = 0; }; then case `/usr/bin/file conftest.$ac_objext` in *ELF-32*) - HPUX_IA64_MODE="32" + HPUX_IA64_MODE=32 ;; *ELF-64*) - HPUX_IA64_MODE="64" + HPUX_IA64_MODE=64 ;; esac fi rm -rf conftest* ;; *-*-irix6*) - # Find out which ABI we are using. + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. echo '#line '$LINENO' "configure"' > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then - if test "$lt_cv_prog_gnu_ld" = yes; then + if test yes = "$lt_cv_prog_gnu_ld"; then case `/usr/bin/file conftest.$ac_objext` in *32-bit*) LD="${LD-ld} -melf32bsmip" @@ -7190,9 +7311,50 @@ ia64-*-hpux*) rm -rf conftest* ;; +mips64*-*linux*) + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. + echo '#line '$LINENO' "configure"' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + emul=elf + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + emul="${emul}32" + ;; + *64-bit*) + emul="${emul}64" + ;; + esac + case `/usr/bin/file conftest.$ac_objext` in + *MSB*) + emul="${emul}btsmip" + ;; + *LSB*) + emul="${emul}ltsmip" + ;; + esac + case `/usr/bin/file conftest.$ac_objext` in + *N32*) + emul="${emul}n32" + ;; + esac + LD="${LD-ld} -m $emul" + fi + rm -rf conftest* + ;; + x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) - # Find out which ABI we are using. + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. Note that the listed cases only cover the + # situations where additional linker options are needed (such as when + # doing 32-bit compilation for a host where ld defaults to 64-bit, or + # vice versa); the common cases where no linker options are needed do + # not appear in the list. echo 'int i;' > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 @@ -7215,10 +7377,10 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) ;; esac ;; - powerpc64le-*) + powerpc64le-*linux*) LD="${LD-ld} -m elf32lppclinux" ;; - powerpc64-*) + powerpc64-*linux*) LD="${LD-ld} -m elf32ppclinux" ;; s390x-*linux*) @@ -7237,10 +7399,10 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) x86_64-*linux*) LD="${LD-ld} -m elf_x86_64" ;; - powerpcle-*) + powerpcle-*linux*) LD="${LD-ld} -m elf64lppc" ;; - powerpc-*) + powerpc-*linux*) LD="${LD-ld} -m elf64ppc" ;; s390*-*linux*|s390*-*tpf*) @@ -7258,7 +7420,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) *-*-sco3.2v5*) # On SCO OpenServer 5, we need -belf to get full-featured binaries. - SAVE_CFLAGS="$CFLAGS" + SAVE_CFLAGS=$CFLAGS CFLAGS="$CFLAGS -belf" { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 $as_echo_n "checking whether the C compiler needs -belf... " >&6; } @@ -7298,13 +7460,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 $as_echo "$lt_cv_cc_needs_belf" >&6; } - if test x"$lt_cv_cc_needs_belf" != x"yes"; then + if test yes != "$lt_cv_cc_needs_belf"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf - CFLAGS="$SAVE_CFLAGS" + CFLAGS=$SAVE_CFLAGS fi ;; *-*solaris*) - # Find out which ABI we are using. + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. echo 'int i;' > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 @@ -7316,7 +7479,7 @@ $as_echo "$lt_cv_cc_needs_belf" >&6; } case $lt_cv_prog_gnu_ld in yes*) case $host in - i?86-*-solaris*) + i?86-*-solaris*|x86_64-*-solaris*) LD="${LD-ld} -m elf_x86_64" ;; sparc*-*-solaris*) @@ -7325,7 +7488,7 @@ $as_echo "$lt_cv_cc_needs_belf" >&6; } esac # GNU ld 2.21 introduced _sol2 emulations. Use them if available. if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then - LD="${LD-ld}_sol2" + LD=${LD-ld}_sol2 fi ;; *) @@ -7341,7 +7504,7 @@ $as_echo "$lt_cv_cc_needs_belf" >&6; } ;; esac -need_locks="$enable_libtool_lock" +need_locks=$enable_libtool_lock if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args. @@ -7452,7 +7615,7 @@ else fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5 $as_echo "$lt_cv_path_mainfest_tool" >&6; } -if test "x$lt_cv_path_mainfest_tool" != xyes; then +if test yes != "$lt_cv_path_mainfest_tool"; then MANIFEST_TOOL=: fi @@ -7955,7 +8118,7 @@ if ${lt_cv_apple_cc_single_mod+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_apple_cc_single_mod=no - if test -z "${LT_MULTI_MODULE}"; then + if test -z "$LT_MULTI_MODULE"; then # By default we will add the -single_module flag. You can override # by either setting the environment variable LT_MULTI_MODULE # non-empty at configure time, or by adding -multi_module to the @@ -7973,7 +8136,7 @@ else cat conftest.err >&5 # Otherwise, if the output was created with a 0 exit code from # the compiler, it worked. - elif test -f libconftest.dylib && test $_lt_result -eq 0; then + elif test -f libconftest.dylib && test 0 = "$_lt_result"; then lt_cv_apple_cc_single_mod=yes else cat conftest.err >&5 @@ -8012,7 +8175,7 @@ else fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext - LDFLAGS="$save_LDFLAGS" + LDFLAGS=$save_LDFLAGS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5 @@ -8041,7 +8204,7 @@ _LT_EOF _lt_result=$? if test -s conftest.err && $GREP force_load conftest.err; then cat conftest.err >&5 - elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then + elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then lt_cv_ld_force_load=yes else cat conftest.err >&5 @@ -8054,32 +8217,32 @@ fi $as_echo "$lt_cv_ld_force_load" >&6; } case $host_os in rhapsody* | darwin1.[012]) - _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; + _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;; darwin1.*) - _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;; darwin*) # darwin 5.x on # if running on 10.5 or later, the deployment target defaults # to the OS version, if on x86, and 10.4, the deployment # target defaults to 10.4. Don't you love it? case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in 10.0,*86*-darwin8*|10.0,*-darwin[91]*) - _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; - 10.[012]*) - _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;; + 10.[012][,.]*) + _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;; 10.*) - _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;; esac ;; esac - if test "$lt_cv_apple_cc_single_mod" = "yes"; then + if test yes = "$lt_cv_apple_cc_single_mod"; then _lt_dar_single_mod='$single_module' fi - if test "$lt_cv_ld_exported_symbols_list" = "yes"; then - _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' + if test yes = "$lt_cv_ld_exported_symbols_list"; then + _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym' else - _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' + _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib' fi - if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then + if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then _lt_dsymutil='~$DSYMUTIL $lib || :' else _lt_dsymutil= @@ -8087,6 +8250,41 @@ $as_echo "$lt_cv_ld_force_load" >&6; } ;; esac +# func_munge_path_list VARIABLE PATH +# ----------------------------------- +# VARIABLE is name of variable containing _space_ separated list of +# directories to be munged by the contents of PATH, which is string +# having a format: +# "DIR[:DIR]:" +# string "DIR[ DIR]" will be prepended to VARIABLE +# ":DIR[:DIR]" +# string "DIR[ DIR]" will be appended to VARIABLE +# "DIRP[:DIRP]::[DIRA:]DIRA" +# string "DIRP[ DIRP]" will be prepended to VARIABLE and string +# "DIRA[ DIRA]" will be appended to VARIABLE +# "DIR[:DIR]" +# VARIABLE will be replaced by "DIR[ DIR]" +func_munge_path_list () +{ + case x$2 in + x) + ;; + *:) + eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\" + ;; + x:*) + eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\" + ;; + *::*) + eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" + eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\" + ;; + *) + eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\" + ;; + esac +} + for ac_header in dlfcn.h do : ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default @@ -8421,14 +8619,14 @@ if test "${enable_shared+set}" = set; then : *) enable_shared=no # Look at the argument we got. We use all the common list separators. - lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for pkg in $enableval; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs if test "X$pkg" = "X$p"; then enable_shared=yes fi done - IFS="$lt_save_ifs" + IFS=$lt_save_ifs ;; esac else @@ -8452,14 +8650,14 @@ if test "${enable_static+set}" = set; then : *) enable_static=no # Look at the argument we got. We use all the common list separators. - lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for pkg in $enableval; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs if test "X$pkg" = "X$p"; then enable_static=yes fi done - IFS="$lt_save_ifs" + IFS=$lt_save_ifs ;; esac else @@ -8483,14 +8681,14 @@ if test "${with_pic+set}" = set; then : *) pic_mode=default # Look at the argument we got. We use all the common list separators. - lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for lt_pkg in $withval; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs if test "X$lt_pkg" = "X$lt_p"; then pic_mode=yes fi done - IFS="$lt_save_ifs" + IFS=$lt_save_ifs ;; esac else @@ -8498,8 +8696,6 @@ else fi -test -z "$pic_mode" && pic_mode=default - @@ -8515,14 +8711,14 @@ if test "${enable_fast_install+set}" = set; then : *) enable_fast_install=no # Look at the argument we got. We use all the common list separators. - lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for pkg in $enableval; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs if test "X$pkg" = "X$p"; then enable_fast_install=yes fi done - IFS="$lt_save_ifs" + IFS=$lt_save_ifs ;; esac else @@ -8536,11 +8732,63 @@ fi + shared_archive_member_spec= +case $host,$enable_shared in +power*-*-aix[5-9]*,yes) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5 +$as_echo_n "checking which variant of shared library versioning to provide... " >&6; } + +# Check whether --with-aix-soname was given. +if test "${with_aix_soname+set}" = set; then : + withval=$with_aix_soname; case $withval in + aix|svr4|both) + ;; + *) + as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5 + ;; + esac + lt_cv_with_aix_soname=$with_aix_soname +else + if ${lt_cv_with_aix_soname+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_with_aix_soname=aix +fi + + with_aix_soname=$lt_cv_with_aix_soname +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5 +$as_echo "$with_aix_soname" >&6; } + if test aix != "$with_aix_soname"; then + # For the AIX way of multilib, we name the shared archive member + # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o', + # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File. + # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag, + # the AIX toolchain works better with OBJECT_MODE set (default 32). + if test 64 = "${OBJECT_MODE-32}"; then + shared_archive_member_spec=shr_64 + else + shared_archive_member_spec=shr + fi + fi + ;; +*) + with_aix_soname=aix + ;; +esac + + + + + + + # This can be used to rebuild libtool when needed -LIBTOOL_DEPS="$ltmain" +LIBTOOL_DEPS=$ltmain # Always use our own libtool. LIBTOOL='$(SHELL) $(top_builddir)/libtool' @@ -8589,7 +8837,7 @@ test -z "$LN_S" && LN_S="ln -s" -if test -n "${ZSH_VERSION+set}" ; then +if test -n "${ZSH_VERSION+set}"; then setopt NO_GLOB_SUBST fi @@ -8628,7 +8876,7 @@ aix3*) # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. - if test "X${COLLECT_NAMES+set}" != Xset; then + if test set != "${COLLECT_NAMES+set}"; then COLLECT_NAMES= export COLLECT_NAMES fi @@ -8639,14 +8887,14 @@ esac ofile=libtool can_build_shared=yes -# All known linkers require a `.a' archive for static linking (except MSVC, +# All known linkers require a '.a' archive for static linking (except MSVC, # which needs '.lib'). libext=a -with_gnu_ld="$lt_cv_prog_gnu_ld" +with_gnu_ld=$lt_cv_prog_gnu_ld -old_CC="$CC" -old_CFLAGS="$CFLAGS" +old_CC=$CC +old_CFLAGS=$CFLAGS # Set sane defaults for various variables test -z "$CC" && CC=cc @@ -8655,15 +8903,8 @@ test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS test -z "$LD" && LD=ld test -z "$ac_objext" && ac_objext=o -for cc_temp in $compiler""; do - case $cc_temp in - compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; - distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; - \-*) ;; - *) break;; - esac -done -cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` +func_cc_basename $compiler +cc_basename=$func_cc_basename_result # Only perform the check for file, if the check method requires it @@ -8678,22 +8919,22 @@ if ${lt_cv_path_MAGIC_CMD+:} false; then : else case $MAGIC_CMD in [\\/*] | ?:[\\/]*) - lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path. ;; *) - lt_save_MAGIC_CMD="$MAGIC_CMD" - lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + lt_save_MAGIC_CMD=$MAGIC_CMD + lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" for ac_dir in $ac_dummy; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs test -z "$ac_dir" && ac_dir=. - if test -f $ac_dir/${ac_tool_prefix}file; then - lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file" + if test -f "$ac_dir/${ac_tool_prefix}file"; then + lt_cv_path_MAGIC_CMD=$ac_dir/"${ac_tool_prefix}file" if test -n "$file_magic_test_file"; then case $deplibs_check_method in "file_magic "*) file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` - MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + MAGIC_CMD=$lt_cv_path_MAGIC_CMD if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | $EGREP "$file_magic_regex" > /dev/null; then : @@ -8716,13 +8957,13 @@ _LT_EOF break fi done - IFS="$lt_save_ifs" - MAGIC_CMD="$lt_save_MAGIC_CMD" + IFS=$lt_save_ifs + MAGIC_CMD=$lt_save_MAGIC_CMD ;; esac fi -MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +MAGIC_CMD=$lt_cv_path_MAGIC_CMD if test -n "$MAGIC_CMD"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 $as_echo "$MAGIC_CMD" >&6; } @@ -8744,22 +8985,22 @@ if ${lt_cv_path_MAGIC_CMD+:} false; then : else case $MAGIC_CMD in [\\/*] | ?:[\\/]*) - lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path. ;; *) - lt_save_MAGIC_CMD="$MAGIC_CMD" - lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + lt_save_MAGIC_CMD=$MAGIC_CMD + lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" for ac_dir in $ac_dummy; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs test -z "$ac_dir" && ac_dir=. - if test -f $ac_dir/file; then - lt_cv_path_MAGIC_CMD="$ac_dir/file" + if test -f "$ac_dir/file"; then + lt_cv_path_MAGIC_CMD=$ac_dir/"file" if test -n "$file_magic_test_file"; then case $deplibs_check_method in "file_magic "*) file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` - MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + MAGIC_CMD=$lt_cv_path_MAGIC_CMD if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | $EGREP "$file_magic_regex" > /dev/null; then : @@ -8782,13 +9023,13 @@ _LT_EOF break fi done - IFS="$lt_save_ifs" - MAGIC_CMD="$lt_save_MAGIC_CMD" + IFS=$lt_save_ifs + MAGIC_CMD=$lt_save_MAGIC_CMD ;; esac fi -MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +MAGIC_CMD=$lt_cv_path_MAGIC_CMD if test -n "$MAGIC_CMD"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 $as_echo "$MAGIC_CMD" >&6; } @@ -8809,7 +9050,7 @@ esac # Use C for the default configuration in the libtool script -lt_save_CC="$CC" +lt_save_CC=$CC ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' @@ -8871,7 +9112,7 @@ if test -n "$compiler"; then lt_prog_compiler_no_builtin_flag= -if test "$GCC" = yes; then +if test yes = "$GCC"; then case $cc_basename in nvcc*) lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;; @@ -8887,7 +9128,7 @@ else lt_cv_prog_compiler_rtti_exceptions=no ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" > conftest.$ac_ext - lt_compiler_flag="-fno-rtti -fno-exceptions" + lt_compiler_flag="-fno-rtti -fno-exceptions" ## exclude from sc_useless_quotes_in_assignment # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins @@ -8917,7 +9158,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 $as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; } -if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then +if test yes = "$lt_cv_prog_compiler_rtti_exceptions"; then lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions" else : @@ -8935,17 +9176,18 @@ lt_prog_compiler_pic= lt_prog_compiler_static= - if test "$GCC" = yes; then + if test yes = "$GCC"; then lt_prog_compiler_wl='-Wl,' lt_prog_compiler_static='-static' case $host_os in aix*) # All AIX code is PIC. - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor lt_prog_compiler_static='-Bstatic' fi + lt_prog_compiler_pic='-fPIC' ;; amigaos*) @@ -8956,8 +9198,8 @@ lt_prog_compiler_static= ;; m68k) # FIXME: we need at least 68020 code to build shared libraries, but - # adding the `-m68020' flag to GCC prevents building anything better, - # like `-m68040'. + # adding the '-m68020' flag to GCC prevents building anything better, + # like '-m68040'. lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4' ;; esac @@ -8973,6 +9215,11 @@ lt_prog_compiler_static= # Although the cygwin gcc ignores -fPIC, still need this for old-style # (--disable-auto-import) libraries lt_prog_compiler_pic='-DDLL_EXPORT' + case $host_os in + os2*) + lt_prog_compiler_static='$wl-static' + ;; + esac ;; darwin* | rhapsody*) @@ -9043,7 +9290,7 @@ lt_prog_compiler_static= case $host_os in aix*) lt_prog_compiler_wl='-Wl,' - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor lt_prog_compiler_static='-Bstatic' else @@ -9051,10 +9298,29 @@ lt_prog_compiler_static= fi ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic='-fno-common' + case $cc_basename in + nagfor*) + # NAG Fortran compiler + lt_prog_compiler_wl='-Wl,-Wl,,' + lt_prog_compiler_pic='-PIC' + lt_prog_compiler_static='-Bstatic' + ;; + esac + ;; + mingw* | cygwin* | pw32* | os2* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). lt_prog_compiler_pic='-DDLL_EXPORT' + case $host_os in + os2*) + lt_prog_compiler_static='$wl-static' + ;; + esac ;; hpux9* | hpux10* | hpux11*) @@ -9070,7 +9336,7 @@ lt_prog_compiler_static= ;; esac # Is there a better lt_prog_compiler_static that works with the bundled CC? - lt_prog_compiler_static='${wl}-a ${wl}archive' + lt_prog_compiler_static='$wl-a ${wl}archive' ;; irix5* | irix6* | nonstopux*) @@ -9081,7 +9347,7 @@ lt_prog_compiler_static= linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) case $cc_basename in - # old Intel for x86_64 which still supported -KPIC. + # old Intel for x86_64, which still supported -KPIC. ecc*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-KPIC' @@ -9106,6 +9372,12 @@ lt_prog_compiler_static= lt_prog_compiler_pic='-PIC' lt_prog_compiler_static='-Bstatic' ;; + tcc*) + # Fabrice Bellard et al's Tiny C Compiler + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fPIC' + lt_prog_compiler_static='-static' + ;; pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group compilers (*not* the Pentium gcc compiler, # which looks to be a dead project) @@ -9203,7 +9475,7 @@ lt_prog_compiler_static= ;; sysv4*MP*) - if test -d /usr/nec ;then + if test -d /usr/nec; then lt_prog_compiler_pic='-Kconform_pic' lt_prog_compiler_static='-Bstatic' fi @@ -9232,7 +9504,7 @@ lt_prog_compiler_static= fi case $host_os in - # For platforms which do not support PIC, -DPIC is meaningless: + # For platforms that do not support PIC, -DPIC is meaningless: *djgpp*) lt_prog_compiler_pic= ;; @@ -9264,7 +9536,7 @@ else lt_cv_prog_compiler_pic_works=no ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" > conftest.$ac_ext - lt_compiler_flag="$lt_prog_compiler_pic -DPIC" + lt_compiler_flag="$lt_prog_compiler_pic -DPIC" ## exclude from sc_useless_quotes_in_assignment # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins @@ -9294,7 +9566,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 $as_echo "$lt_cv_prog_compiler_pic_works" >&6; } -if test x"$lt_cv_prog_compiler_pic_works" = xyes; then +if test yes = "$lt_cv_prog_compiler_pic_works"; then case $lt_prog_compiler_pic in "" | " "*) ;; *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;; @@ -9326,7 +9598,7 @@ if ${lt_cv_prog_compiler_static_works+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_static_works=no - save_LDFLAGS="$LDFLAGS" + save_LDFLAGS=$LDFLAGS LDFLAGS="$LDFLAGS $lt_tmp_static_flag" echo "$lt_simple_link_test_code" > conftest.$ac_ext if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then @@ -9345,13 +9617,13 @@ else fi fi $RM -r conftest* - LDFLAGS="$save_LDFLAGS" + LDFLAGS=$save_LDFLAGS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 $as_echo "$lt_cv_prog_compiler_static_works" >&6; } -if test x"$lt_cv_prog_compiler_static_works" = xyes; then +if test yes = "$lt_cv_prog_compiler_static_works"; then : else lt_prog_compiler_static= @@ -9471,8 +9743,8 @@ $as_echo "$lt_cv_prog_compiler_c_o" >&6; } -hard_links="nottested" -if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then +hard_links=nottested +if test no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; then # do not overwrite the value of need_locks provided by the user { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 $as_echo_n "checking if we can lock with hard links... " >&6; } @@ -9484,9 +9756,9 @@ $as_echo_n "checking if we can lock with hard links... " >&6; } ln conftest.a conftest.b 2>/dev/null && hard_links=no { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 $as_echo "$hard_links" >&6; } - if test "$hard_links" = no; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 -$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + if test no = "$hard_links"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;} need_locks=warn fi else @@ -9529,9 +9801,9 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie # included in the symbol list include_expsyms= # exclude_expsyms can be an extended regexp of symbols to exclude - # it will be wrapped by ` (' and `)$', so one must not match beginning or - # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', - # as well as any symbol that contains `d'. + # it will be wrapped by ' (' and ')$', so one must not match beginning or + # end of line. Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc', + # as well as any symbol that contains 'd'. exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out # platforms (ab)use it in PIC code, but their linkers get confused if @@ -9546,7 +9818,7 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie # FIXME: the MSVC++ port hasn't been tested in a loooong time # When not using gcc, we currently assume that we are using # Microsoft Visual C++. - if test "$GCC" != yes; then + if test yes != "$GCC"; then with_gnu_ld=no fi ;; @@ -9554,7 +9826,7 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; - openbsd*) + openbsd* | bitrig*) with_gnu_ld=no ;; linux* | k*bsd*-gnu | gnu*) @@ -9567,7 +9839,7 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie # On some targets, GNU ld is compatible enough with the native linker # that we're better off using the native interface for both. lt_use_gnu_ld_interface=no - if test "$with_gnu_ld" = yes; then + if test yes = "$with_gnu_ld"; then case $host_os in aix*) # The AIX port of GNU ld has always aspired to compatibility @@ -9589,24 +9861,24 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie esac fi - if test "$lt_use_gnu_ld_interface" = yes; then + if test yes = "$lt_use_gnu_ld_interface"; then # If archive_cmds runs LD, not CC, wlarc should be empty - wlarc='${wl}' + wlarc='$wl' # Set some defaults for GNU ld with shared library support. These # are reset later if shared libraries are not supported. Putting them # here allows them to be overridden if necessary. runpath_var=LD_RUN_PATH - hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' - export_dynamic_flag_spec='${wl}--export-dynamic' + hardcode_libdir_flag_spec='$wl-rpath $wl$libdir' + export_dynamic_flag_spec='$wl--export-dynamic' # ancient GNU ld didn't support --whole-archive et. al. if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then - whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + whole_archive_flag_spec=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive' else whole_archive_flag_spec= fi supports_anon_versioning=no - case `$LD -v 2>&1` in + case `$LD -v | $SED -e 's/(^)\+)\s\+//' 2>&1` in *GNU\ gold*) supports_anon_versioning=yes ;; *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... @@ -9619,7 +9891,7 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie case $host_os in aix[3-9]*) # On AIX/PPC, the GNU linker is very broken - if test "$host_cpu" != ia64; then + if test ia64 != "$host_cpu"; then ld_shlibs=no cat <<_LT_EOF 1>&2 @@ -9638,7 +9910,7 @@ _LT_EOF case $host_cpu in powerpc) # see comment about AmigaOS4 .so support - archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' archive_expsym_cmds='' ;; m68k) @@ -9654,7 +9926,7 @@ _LT_EOF allow_undefined_flag=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME - archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' else ld_shlibs=no fi @@ -9664,7 +9936,7 @@ _LT_EOF # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless, # as there is no search path for DLLs. hardcode_libdir_flag_spec='-L$libdir' - export_dynamic_flag_spec='${wl}--export-all-symbols' + export_dynamic_flag_spec='$wl--export-all-symbols' allow_undefined_flag=unsupported always_export_symbols=no enable_shared_with_static_runtimes=yes @@ -9672,61 +9944,89 @@ _LT_EOF exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname' if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then - archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' - # If the export-symbols file already is a .def file (1st line - # is EXPORTS), use it as is; otherwise, prepend... - archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then - cp $export_symbols $output_objdir/$soname.def; - else - echo EXPORTS > $output_objdir/$soname.def; - cat $export_symbols >> $output_objdir/$soname.def; - fi~ - $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file, use it as + # is; otherwise, prepend EXPORTS... + archive_expsym_cmds='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' else ld_shlibs=no fi ;; haiku*) - archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' link_all_deplibs=yes ;; + os2*) + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + allow_undefined_flag=unsupported + shrext_cmds=.dll + archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + prefix_cmds="$SED"~ + if test EXPORTS = "`$SED 1q $export_symbols`"; then + prefix_cmds="$prefix_cmds -e 1d"; + fi~ + prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ + cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' + enable_shared_with_static_runtimes=yes + ;; + interix[3-9]*) hardcode_direct=no hardcode_shlibpath_var=no - hardcode_libdir_flag_spec='${wl}-rpath,$libdir' - export_dynamic_flag_spec='${wl}-E' + hardcode_libdir_flag_spec='$wl-rpath,$libdir' + export_dynamic_flag_spec='$wl-E' # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. # Instead, shared libraries are loaded at an image base (0x10000000 by # default) and relocated if they conflict, which is a slow very memory # consuming and fragmenting process. To avoid this, we pick a random, # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link # time. Moving up from 0x10000000 also allows more sbrk(2) space. - archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' - archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + archive_expsym_cmds='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' ;; gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) tmp_diet=no - if test "$host_os" = linux-dietlibc; then + if test linux-dietlibc = "$host_os"; then case $cc_basename in diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) esac fi if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ - && test "$tmp_diet" = no + && test no = "$tmp_diet" then tmp_addflag=' $pic_flag' tmp_sharedflag='-shared' case $cc_basename,$host_cpu in pgcc*) # Portland Group C compiler - whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' tmp_addflag=' $pic_flag' ;; pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group f77 and f90 compilers - whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' tmp_addflag=' $pic_flag -Mnomain' ;; ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 tmp_addflag=' -i_dynamic' ;; @@ -9737,42 +10037,47 @@ _LT_EOF lf95*) # Lahey Fortran 8.1 whole_archive_flag_spec= tmp_sharedflag='--shared' ;; + nagfor*) # NAGFOR 5.3 + tmp_sharedflag='-Wl,-shared' ;; xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below) tmp_sharedflag='-qmkshrobj' tmp_addflag= ;; nvcc*) # Cuda Compiler Driver 2.2 - whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' compiler_needs_object=yes ;; esac case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C 5.9 - whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + whole_archive_flag_spec='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' compiler_needs_object=yes tmp_sharedflag='-G' ;; *Sun\ F*) # Sun Fortran 8.3 tmp_sharedflag='-G' ;; esac - archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' - if test "x$supports_anon_versioning" = xyes; then + if test yes = "$supports_anon_versioning"; then archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ - cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ - echo "local: *; };" >> $output_objdir/$libname.ver~ - $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib' fi case $cc_basename in + tcc*) + export_dynamic_flag_spec='-rdynamic' + ;; xlf* | bgf* | bgxlf* | mpixlf*) # IBM XL Fortran 10.1 on PPC cannot create shared libs itself whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive' - hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_flag_spec='$wl-rpath $wl$libdir' archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' - if test "x$supports_anon_versioning" = xyes; then + if test yes = "$supports_anon_versioning"; then archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ - cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ - echo "local: *; };" >> $output_objdir/$libname.ver~ - $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' fi ;; esac @@ -9786,8 +10091,8 @@ _LT_EOF archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' wlarc= else - archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' - archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' fi ;; @@ -9805,8 +10110,8 @@ _LT_EOF _LT_EOF elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then - archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' - archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' else ld_shlibs=no fi @@ -9818,7 +10123,7 @@ _LT_EOF ld_shlibs=no cat <<_LT_EOF 1>&2 -*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not +*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot *** reliably create shared libraries on SCO systems. Therefore, libtool *** is disabling shared libraries support. We urge you to upgrade GNU *** binutils to release 2.16.91.0.3 or newer. Another option is to modify @@ -9833,9 +10138,9 @@ _LT_EOF # DT_RUNPATH tag from executables and libraries. But doing so # requires that you compile everything twice, which is a pain. if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then - hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' - archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' - archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + hardcode_libdir_flag_spec='$wl-rpath $wl$libdir' + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' else ld_shlibs=no fi @@ -9852,15 +10157,15 @@ _LT_EOF *) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then - archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' - archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' else ld_shlibs=no fi ;; esac - if test "$ld_shlibs" = no; then + if test no = "$ld_shlibs"; then runpath_var= hardcode_libdir_flag_spec= export_dynamic_flag_spec= @@ -9876,7 +10181,7 @@ _LT_EOF # Note: this linker hardcodes the directories in LIBPATH if there # are no directories specified by -L. hardcode_minus_L=yes - if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then + if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then # Neither direct hardcoding nor static linking is supported with a # broken collect2. hardcode_direct=unsupported @@ -9884,34 +10189,57 @@ _LT_EOF ;; aix[4-9]*) - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # On IA64, the linker does run time linking by default, so we don't # have to do anything special. aix_use_runtimelinking=no exp_sym_flag='-Bexport' - no_entry_flag="" + no_entry_flag= else # If we're using GNU nm, then we don't want the "-C" option. - # -C means demangle to AIX nm, but means don't demangle with GNU nm - # Also, AIX nm treats weak defined symbols like other global - # defined symbols, whereas GNU nm marks them as "W". + # -C means demangle to GNU nm, but means don't demangle to AIX nm. + # Without the "-l" option, or with the "-B" option, AIX nm treats + # weak defined symbols like other global defined symbols, whereas + # GNU nm marks them as "W". + # While the 'weak' keyword is ignored in the Export File, we need + # it in the Import File for the 'aix-soname' feature, so we have + # to replace the "-B" option with "-P" for AIX nm. if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then - export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else - export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols' fi aix_use_runtimelinking=no # Test if we are trying to use run time linking or normal # AIX style linking. If -brtl is somewhere in LDFLAGS, we - # need to do runtime linking. + # have runtime linking enabled, and use it for executables. + # For shared libraries, we enable/disable runtime linking + # depending on the kind of the shared library created - + # when "with_aix_soname,aix_use_runtimelinking" is: + # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables + # "aix,yes" lib.so shared, rtl:yes, for executables + # lib.a static archive + # "both,no" lib.so.V(shr.o) shared, rtl:yes + # lib.a(lib.so.V) shared, rtl:no, for executables + # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables + # lib.a(lib.so.V) shared, rtl:no + # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables + # lib.a static archive case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) for ld_flag in $LDFLAGS; do - if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then aix_use_runtimelinking=yes break fi done + if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then + # With aix-soname=svr4, we create the lib.so.V shared archives only, + # so we don't have lib.a shared libs to link our executables. + # We have to force runtime linking in this case. + aix_use_runtimelinking=yes + LDFLAGS="$LDFLAGS -Wl,-brtl" + fi ;; esac @@ -9930,13 +10258,21 @@ _LT_EOF hardcode_direct_absolute=yes hardcode_libdir_separator=':' link_all_deplibs=yes - file_list_spec='${wl}-f,' + file_list_spec='$wl-f,' + case $with_aix_soname,$aix_use_runtimelinking in + aix,*) ;; # traditional, no import file + svr4,* | *,yes) # use import file + # The Import File defines what to hardcode. + hardcode_direct=no + hardcode_direct_absolute=no + ;; + esac - if test "$GCC" = yes; then + if test yes = "$GCC"; then case $host_os in aix4.[012]|aix4.[012].*) # We only want to do this on AIX 4.2 and lower, the check # below for broken collect2 doesn't work under 4.3+ - collect2name=`${CC} -print-prog-name=collect2` + collect2name=`$CC -print-prog-name=collect2` if test -f "$collect2name" && strings "$collect2name" | $GREP resolve_lib_name >/dev/null then @@ -9955,36 +10291,42 @@ _LT_EOF ;; esac shared_flag='-shared' - if test "$aix_use_runtimelinking" = yes; then - shared_flag="$shared_flag "'${wl}-G' + if test yes = "$aix_use_runtimelinking"; then + shared_flag="$shared_flag "'$wl-G' fi - link_all_deplibs=no + # Need to ensure runtime linking is disabled for the traditional + # shared library, or the linker may eventually find shared libraries + # /with/ Import File - we do not want to mix them. + shared_flag_aix='-shared' + shared_flag_svr4='-shared $wl-G' else # not using gcc - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release # chokes on -Wl,-G. The following line is correct: shared_flag='-G' else - if test "$aix_use_runtimelinking" = yes; then - shared_flag='${wl}-G' + if test yes = "$aix_use_runtimelinking"; then + shared_flag='$wl-G' else - shared_flag='${wl}-bM:SRE' + shared_flag='$wl-bM:SRE' fi + shared_flag_aix='$wl-bM:SRE' + shared_flag_svr4='$wl-G' fi fi - export_dynamic_flag_spec='${wl}-bexpall' + export_dynamic_flag_spec='$wl-bexpall' # It seems that -bexpall does not export symbols beginning with # underscore (_), so it is better to generate a list of symbols to export. always_export_symbols=yes - if test "$aix_use_runtimelinking" = yes; then + if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. allow_undefined_flag='-berok' # Determine the default libpath from the value encoded in an # empty executable. - if test "${lt_cv_aix_libpath+set}" = set; then + if test set = "${lt_cv_aix_libpath+set}"; then aix_libpath=$lt_cv_aix_libpath else if ${lt_cv_aix_libpath_+:} false; then : @@ -10019,7 +10361,7 @@ fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext if test -z "$lt_cv_aix_libpath_"; then - lt_cv_aix_libpath_="/usr/lib:/lib" + lt_cv_aix_libpath_=/usr/lib:/lib fi fi @@ -10027,17 +10369,17 @@ fi aix_libpath=$lt_cv_aix_libpath_ fi - hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" - archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath" + archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else - if test "$host_cpu" = ia64; then - hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib' + if test ia64 = "$host_cpu"; then + hardcode_libdir_flag_spec='$wl-R $libdir:/usr/lib:/lib' allow_undefined_flag="-z nodefs" - archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols" else # Determine the default libpath from the value encoded in an # empty executable. - if test "${lt_cv_aix_libpath+set}" = set; then + if test set = "${lt_cv_aix_libpath+set}"; then aix_libpath=$lt_cv_aix_libpath else if ${lt_cv_aix_libpath_+:} false; then : @@ -10072,7 +10414,7 @@ fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext if test -z "$lt_cv_aix_libpath_"; then - lt_cv_aix_libpath_="/usr/lib:/lib" + lt_cv_aix_libpath_=/usr/lib:/lib fi fi @@ -10080,21 +10422,33 @@ fi aix_libpath=$lt_cv_aix_libpath_ fi - hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath" # Warning - without using the other run time loading flags, # -berok will link without error, but may produce a broken library. - no_undefined_flag=' ${wl}-bernotok' - allow_undefined_flag=' ${wl}-berok' - if test "$with_gnu_ld" = yes; then + no_undefined_flag=' $wl-bernotok' + allow_undefined_flag=' $wl-berok' + if test yes = "$with_gnu_ld"; then # We only use this code for GNU lds that support --whole-archive. - whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + whole_archive_flag_spec='$wl--whole-archive$convenience $wl--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives whole_archive_flag_spec='$convenience' fi archive_cmds_need_lc=yes - # This is similar to how AIX traditionally builds its shared libraries. - archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + archive_expsym_cmds='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' + # -brtl affects multiple linker settings, -berok does not and is overridden later + compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`' + if test svr4 != "$with_aix_soname"; then + # This is similar to how AIX traditionally builds its shared libraries. + archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' + fi + if test aix != "$with_aix_soname"; then + archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' + else + # used by -dlpreopen to get the symbols + archive_expsym_cmds="$archive_expsym_cmds"'~$MV $output_objdir/$realname.d/$soname $output_objdir' + fi + archive_expsym_cmds="$archive_expsym_cmds"'~$RM -r $output_objdir/$realname.d' fi fi ;; @@ -10103,7 +10457,7 @@ fi case $host_cpu in powerpc) # see comment about AmigaOS4 .so support - archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' archive_expsym_cmds='' ;; m68k) @@ -10133,16 +10487,17 @@ fi # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. - shrext_cmds=".dll" + shrext_cmds=.dll # FIXME: Setting linknames here is a bad hack. - archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' - archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then - sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; - else - sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; - fi~ - $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ - linknames=' + archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' + archive_expsym_cmds='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; then + cp "$export_symbols" "$output_objdir/$soname.def"; + echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; + else + $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' # The linker will not automatically build a static lib if we build a DLL. # _LT_TAGVAR(old_archive_from_new_cmds, )='true' enable_shared_with_static_runtimes=yes @@ -10151,18 +10506,18 @@ fi # Don't use ranlib old_postinstall_cmds='chmod 644 $oldlib' postlink_cmds='lt_outputfile="@OUTPUT@"~ - lt_tool_outputfile="@TOOL_OUTPUT@"~ - case $lt_outputfile in - *.exe|*.EXE) ;; - *) - lt_outputfile="$lt_outputfile.exe" - lt_tool_outputfile="$lt_tool_outputfile.exe" - ;; - esac~ - if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then - $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; - $RM "$lt_outputfile.manifest"; - fi' + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile=$lt_outputfile.exe + lt_tool_outputfile=$lt_tool_outputfile.exe + ;; + esac~ + if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' ;; *) # Assume MSVC wrapper @@ -10171,7 +10526,7 @@ fi # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. - shrext_cmds=".dll" + shrext_cmds=.dll # FIXME: Setting linknames here is a bad hack. archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' # The linker will automatically build a .lib file if we build a DLL. @@ -10190,24 +10545,24 @@ fi hardcode_direct=no hardcode_automatic=yes hardcode_shlibpath_var=unsupported - if test "$lt_cv_ld_force_load" = "yes"; then - whole_archive_flag_spec='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + if test yes = "$lt_cv_ld_force_load"; then + whole_archive_flag_spec='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' else whole_archive_flag_spec='' fi link_all_deplibs=yes - allow_undefined_flag="$_lt_dar_allow_undefined" + allow_undefined_flag=$_lt_dar_allow_undefined case $cc_basename in - ifort*) _lt_dar_can_shared=yes ;; + ifort*|nagfor*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac - if test "$_lt_dar_can_shared" = "yes"; then + if test yes = "$_lt_dar_can_shared"; then output_verbose_link_cmd=func_echo_all - archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" - module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" - archive_expsym_cmds="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" - module_expsym_cmds="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil" + module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil" + archive_expsym_cmds="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil" + module_expsym_cmds="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil" else ld_shlibs=no @@ -10249,33 +10604,33 @@ fi ;; hpux9*) - if test "$GCC" = yes; then - archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + if test yes = "$GCC"; then + archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' else - archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' fi - hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_flag_spec='$wl+b $wl$libdir' hardcode_libdir_separator=: hardcode_direct=yes # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. hardcode_minus_L=yes - export_dynamic_flag_spec='${wl}-E' + export_dynamic_flag_spec='$wl-E' ;; hpux10*) - if test "$GCC" = yes && test "$with_gnu_ld" = no; then - archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + if test yes,no = "$GCC,$with_gnu_ld"; then + archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags' else archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' fi - if test "$with_gnu_ld" = no; then - hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + if test no = "$with_gnu_ld"; then + hardcode_libdir_flag_spec='$wl+b $wl$libdir' hardcode_libdir_separator=: hardcode_direct=yes hardcode_direct_absolute=yes - export_dynamic_flag_spec='${wl}-E' + export_dynamic_flag_spec='$wl-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. hardcode_minus_L=yes @@ -10283,25 +10638,25 @@ fi ;; hpux11*) - if test "$GCC" = yes && test "$with_gnu_ld" = no; then + if test yes,no = "$GCC,$with_gnu_ld"; then case $host_cpu in hppa*64*) - archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_cmds='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) - archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) - archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags' ;; esac else case $host_cpu in hppa*64*) - archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_cmds='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) - archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + archive_cmds='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) @@ -10313,7 +10668,7 @@ if ${lt_cv_prog_compiler__b+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler__b=no - save_LDFLAGS="$LDFLAGS" + save_LDFLAGS=$LDFLAGS LDFLAGS="$LDFLAGS -b" echo "$lt_simple_link_test_code" > conftest.$ac_ext if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then @@ -10332,14 +10687,14 @@ else fi fi $RM -r conftest* - LDFLAGS="$save_LDFLAGS" + LDFLAGS=$save_LDFLAGS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5 $as_echo "$lt_cv_prog_compiler__b" >&6; } -if test x"$lt_cv_prog_compiler__b" = xyes; then - archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' +if test yes = "$lt_cv_prog_compiler__b"; then + archive_cmds='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags' else archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' fi @@ -10347,8 +10702,8 @@ fi ;; esac fi - if test "$with_gnu_ld" = no; then - hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + if test no = "$with_gnu_ld"; then + hardcode_libdir_flag_spec='$wl+b $wl$libdir' hardcode_libdir_separator=: case $host_cpu in @@ -10359,7 +10714,7 @@ fi *) hardcode_direct=yes hardcode_direct_absolute=yes - export_dynamic_flag_spec='${wl}-E' + export_dynamic_flag_spec='$wl-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. @@ -10370,8 +10725,8 @@ fi ;; irix5* | irix6* | nonstopux*) - if test "$GCC" = yes; then - archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + if test yes = "$GCC"; then + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib' # Try to use the -exported_symbol ld option, if it does not # work, assume that -exports_file does not work either and # implicitly export all symbols. @@ -10381,8 +10736,8 @@ $as_echo_n "checking whether the $host_os linker accepts -exported_symbol... " > if ${lt_cv_irix_exported_symbol+:} false; then : $as_echo_n "(cached) " >&6 else - save_LDFLAGS="$LDFLAGS" - LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" + save_LDFLAGS=$LDFLAGS + LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int foo (void) { return 0; } @@ -10394,24 +10749,35 @@ else fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext - LDFLAGS="$save_LDFLAGS" + LDFLAGS=$save_LDFLAGS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5 $as_echo "$lt_cv_irix_exported_symbol" >&6; } - if test "$lt_cv_irix_exported_symbol" = yes; then - archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' + if test yes = "$lt_cv_irix_exported_symbol"; then + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib' fi + link_all_deplibs=no else - archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' - archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib' fi archive_cmds_need_lc='no' - hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_flag_spec='$wl-rpath $wl$libdir' hardcode_libdir_separator=: inherit_rpath=yes link_all_deplibs=yes ;; + linux*) + case $cc_basename in + tcc*) + # Fabrice Bellard et al's Tiny C Compiler + ld_shlibs=yes + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + netbsd* | netbsdelf*-gnu) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out @@ -10426,7 +10792,7 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; } newsos6) archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' hardcode_direct=yes - hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_flag_spec='$wl-rpath $wl$libdir' hardcode_libdir_separator=: hardcode_shlibpath_var=no ;; @@ -10434,27 +10800,19 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; } *nto* | *qnx*) ;; - openbsd*) + openbsd* | bitrig*) if test -f /usr/libexec/ld.so; then hardcode_direct=yes hardcode_shlibpath_var=no hardcode_direct_absolute=yes - if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' - archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' - hardcode_libdir_flag_spec='${wl}-rpath,$libdir' - export_dynamic_flag_spec='${wl}-E' + archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols' + hardcode_libdir_flag_spec='$wl-rpath,$libdir' + export_dynamic_flag_spec='$wl-E' else - case $host_os in - openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) - archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' - hardcode_libdir_flag_spec='-R$libdir' - ;; - *) - archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' - hardcode_libdir_flag_spec='${wl}-rpath,$libdir' - ;; - esac + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='$wl-rpath,$libdir' fi else ld_shlibs=no @@ -10465,33 +10823,53 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; } hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes allow_undefined_flag=unsupported - archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' - old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + shrext_cmds=.dll + archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + prefix_cmds="$SED"~ + if test EXPORTS = "`$SED 1q $export_symbols`"; then + prefix_cmds="$prefix_cmds -e 1d"; + fi~ + prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ + cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' + enable_shared_with_static_runtimes=yes ;; osf3*) - if test "$GCC" = yes; then - allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' - archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + if test yes = "$GCC"; then + allow_undefined_flag=' $wl-expect_unresolved $wl\*' + archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib' else allow_undefined_flag=' -expect_unresolved \*' - archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' fi archive_cmds_need_lc='no' - hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_flag_spec='$wl-rpath $wl$libdir' hardcode_libdir_separator=: ;; osf4* | osf5*) # as osf3* with the addition of -msym flag - if test "$GCC" = yes; then - allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' - archive_cmds='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' - hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + if test yes = "$GCC"; then + allow_undefined_flag=' $wl-expect_unresolved $wl\*' + archive_cmds='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib' + hardcode_libdir_flag_spec='$wl-rpath $wl$libdir' else allow_undefined_flag=' -expect_unresolved \*' - archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ - $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' + $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp' # Both c and cxx compiler support -rpath directly hardcode_libdir_flag_spec='-rpath $libdir' @@ -10502,24 +10880,24 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; } solaris*) no_undefined_flag=' -z defs' - if test "$GCC" = yes; then - wlarc='${wl}' - archive_cmds='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + if test yes = "$GCC"; then + wlarc='$wl' + archive_cmds='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ - $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' else case `$CC -V 2>&1` in *"Compilers 5.0"*) wlarc='' - archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_cmds='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags' archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ - $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' + $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' ;; *) - wlarc='${wl}' - archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' + wlarc='$wl' + archive_cmds='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ - $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' ;; esac fi @@ -10529,11 +10907,11 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; } solaris2.[0-5] | solaris2.[0-5].*) ;; *) # The compiler driver will combine and reorder linker options, - # but understands `-z linker_flag'. GCC discards it without `$wl', + # but understands '-z linker_flag'. GCC discards it without '$wl', # but is careful enough not to reorder. # Supported since Solaris 2.6 (maybe 2.5.1?) - if test "$GCC" = yes; then - whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + if test yes = "$GCC"; then + whole_archive_flag_spec='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract' else whole_archive_flag_spec='-z allextract$convenience -z defaultextract' fi @@ -10543,10 +10921,10 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; } ;; sunos4*) - if test "x$host_vendor" = xsequent; then + if test sequent = "$host_vendor"; then # Use $CC to link under sequent, because it throws in some extra .o # files that make .init and .fini sections work. - archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + archive_cmds='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags' else archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' fi @@ -10595,43 +10973,43 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; } ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) - no_undefined_flag='${wl}-z,text' + no_undefined_flag='$wl-z,text' archive_cmds_need_lc=no hardcode_shlibpath_var=no runpath_var='LD_RUN_PATH' - if test "$GCC" = yes; then - archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + if test yes = "$GCC"; then + archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else - archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; sysv5* | sco3.2v5* | sco5v6*) - # Note: We can NOT use -z defs as we might desire, because we do not + # Note: We CANNOT use -z defs as we might desire, because we do not # link with -lc, and that would cause any symbols used from libc to # always be unresolved, which means just about no library would # ever link correctly. If we're not using GNU ld we use -z text # though, which does catch some bad symbols but isn't as heavy-handed # as -z defs. - no_undefined_flag='${wl}-z,text' - allow_undefined_flag='${wl}-z,nodefs' + no_undefined_flag='$wl-z,text' + allow_undefined_flag='$wl-z,nodefs' archive_cmds_need_lc=no hardcode_shlibpath_var=no - hardcode_libdir_flag_spec='${wl}-R,$libdir' + hardcode_libdir_flag_spec='$wl-R,$libdir' hardcode_libdir_separator=':' link_all_deplibs=yes - export_dynamic_flag_spec='${wl}-Bexport' + export_dynamic_flag_spec='$wl-Bexport' runpath_var='LD_RUN_PATH' - if test "$GCC" = yes; then - archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + if test yes = "$GCC"; then + archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else - archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; @@ -10646,10 +11024,10 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; } ;; esac - if test x$host_vendor = xsni; then + if test sni = "$host_vendor"; then case $host in sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) - export_dynamic_flag_spec='${wl}-Blargedynsym' + export_dynamic_flag_spec='$wl-Blargedynsym' ;; esac fi @@ -10657,7 +11035,7 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 $as_echo "$ld_shlibs" >&6; } -test "$ld_shlibs" = no && can_build_shared=no +test no = "$ld_shlibs" && can_build_shared=no with_gnu_ld=$with_gnu_ld @@ -10683,7 +11061,7 @@ x|xyes) # Assume -lc should be added archive_cmds_need_lc=yes - if test "$enable_shared" = yes && test "$GCC" = yes; then + if test yes,yes = "$GCC,$enable_shared"; then case $archive_cmds in *'~'*) # FIXME: we may have to deal with multi-command sequences. @@ -10898,14 +11276,14 @@ esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 $as_echo_n "checking dynamic linker characteristics... " >&6; } -if test "$GCC" = yes; then +if test yes = "$GCC"; then case $host_os in - darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; - *) lt_awk_arg="/^libraries:/" ;; + darwin*) lt_awk_arg='/^libraries:/,/LR/' ;; + *) lt_awk_arg='/^libraries:/' ;; esac case $host_os in - mingw* | cegcc*) lt_sed_strip_eq="s,=\([A-Za-z]:\),\1,g" ;; - *) lt_sed_strip_eq="s,=/,/,g" ;; + mingw* | cegcc*) lt_sed_strip_eq='s|=\([A-Za-z]:\)|\1|g' ;; + *) lt_sed_strip_eq='s|=/|/|g' ;; esac lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` case $lt_search_path_spec in @@ -10921,28 +11299,35 @@ if test "$GCC" = yes; then ;; esac # Ok, now we have the path, separated by spaces, we can step through it - # and add multilib dir if necessary. + # and add multilib dir if necessary... lt_tmp_lt_search_path_spec= - lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + # ...but if some path component already ends with the multilib dir we assume + # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer). + case "$lt_multi_os_dir; $lt_search_path_spec " in + "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*) + lt_multi_os_dir= + ;; + esac for lt_sys_path in $lt_search_path_spec; do - if test -d "$lt_sys_path/$lt_multi_os_dir"; then - lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" - else + if test -d "$lt_sys_path$lt_multi_os_dir"; then + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path$lt_multi_os_dir" + elif test -n "$lt_multi_os_dir"; then test -d "$lt_sys_path" && \ lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" fi done lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' -BEGIN {RS=" "; FS="/|\n";} { - lt_foo=""; - lt_count=0; +BEGIN {RS = " "; FS = "/|\n";} { + lt_foo = ""; + lt_count = 0; for (lt_i = NF; lt_i > 0; lt_i--) { if ($lt_i != "" && $lt_i != ".") { if ($lt_i == "..") { lt_count++; } else { if (lt_count == 0) { - lt_foo="/" $lt_i lt_foo; + lt_foo = "/" $lt_i lt_foo; } else { lt_count--; } @@ -10956,7 +11341,7 @@ BEGIN {RS=" "; FS="/|\n";} { # for these hosts. case $host_os in mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ - $SED 's,/\([A-Za-z]:\),\1,g'` ;; + $SED 's|/\([A-Za-z]:\)|\1|g'` ;; esac sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` else @@ -10965,7 +11350,7 @@ fi library_names_spec= libname_spec='lib$name' soname_spec= -shrext_cmds=".so" +shrext_cmds=.so postinstall_cmds= postuninstall_cmds= finish_cmds= @@ -10982,14 +11367,16 @@ hardcode_into_libs=no # flags to be left without arguments need_version=unknown + + case $host_os in aix3*) version_type=linux # correct to gnu/linux during the next big refactor - library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + library_names_spec='$libname$release$shared_ext$versuffix $libname.a' shlibpath_var=LIBPATH # AIX 3 has no versioning support, so we append a major version to the name. - soname_spec='${libname}${release}${shared_ext}$major' + soname_spec='$libname$release$shared_ext$major' ;; aix[4-9]*) @@ -10997,41 +11384,91 @@ aix[4-9]*) need_lib_prefix=no need_version=no hardcode_into_libs=yes - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # AIX 5 supports IA64 - library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext' shlibpath_var=LD_LIBRARY_PATH else # With GCC up to 2.95.x, collect2 would create an import file # for dependence libraries. The import file would start with - # the line `#! .'. This would cause the generated library to - # depend on `.', always an invalid library. This was fixed in + # the line '#! .'. This would cause the generated library to + # depend on '.', always an invalid library. This was fixed in # development snapshots of GCC prior to 3.0. case $host_os in aix4 | aix4.[01] | aix4.[01].*) if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' echo ' yes ' - echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then : else can_build_shared=no fi ;; esac - # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # Using Import Files as archive members, it is possible to support + # filename-based versioning of shared library archives on AIX. While + # this would work for both with and without runtime linking, it will + # prevent static linking of such archives. So we do filename-based + # shared library versioning with .so extension only, which is used + # when both runtime linking and shared linking is enabled. + # Unfortunately, runtime linking may impact performance, so we do + # not want this to be the default eventually. Also, we use the + # versioned .so libs for executables only if there is the -brtl + # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only. + # To allow for filename-based versioning support, we need to create + # libNAME.so.V as an archive file, containing: + # *) an Import File, referring to the versioned filename of the + # archive as well as the shared archive member, telling the + # bitwidth (32 or 64) of that shared object, and providing the + # list of exported symbols of that shared object, eventually + # decorated with the 'weak' keyword + # *) the shared object with the F_LOADONLY flag set, to really avoid + # it being seen by the linker. + # At run time we better use the real file rather than another symlink, + # but for link time we create the symlink libNAME.so -> libNAME.so.V + + case $with_aix_soname,$aix_use_runtimelinking in + # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. - if test "$aix_use_runtimelinking" = yes; then + aix,yes) # traditional libtool + dynamic_linker='AIX unversionable lib.so' # If using run time linking (on AIX 4.2 or later) use lib.so # instead of lib.a to let people know that these are not # typical AIX shared libraries. - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - else + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + ;; + aix,no) # traditional AIX only + dynamic_linker='AIX lib.a(lib.so.V)' # We preserve .a as extension for shared libraries through AIX4.2 # and later when we are not doing run time linking. - library_names_spec='${libname}${release}.a $libname.a' - soname_spec='${libname}${release}${shared_ext}$major' - fi + library_names_spec='$libname$release.a $libname.a' + soname_spec='$libname$release$shared_ext$major' + ;; + svr4,*) # full svr4 only + dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)" + library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' + # We do not specify a path in Import Files, so LIBPATH fires. + shlibpath_overrides_runpath=yes + ;; + *,yes) # both, prefer svr4 + dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)" + library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' + # unpreferred sharedlib libNAME.a needs extra handling + postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"' + postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"' + # We do not specify a path in Import Files, so LIBPATH fires. + shlibpath_overrides_runpath=yes + ;; + *,no) # both, prefer aix + dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)" + library_names_spec='$libname$release.a $libname.a' + soname_spec='$libname$release$shared_ext$major' + # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling + postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)' + postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"' + ;; + esac shlibpath_var=LIBPATH fi ;; @@ -11041,18 +11478,18 @@ amigaos*) powerpc) # Since July 2007 AmigaOS4 officially supports .so libraries. # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' ;; m68k) library_names_spec='$libname.ixlibrary $libname.a' # Create ${libname}_ixlibrary.a entries in /sys/libs. - finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' ;; esac ;; beos*) - library_names_spec='${libname}${shared_ext}' + library_names_spec='$libname$shared_ext' dynamic_linker="$host_os ld.so" shlibpath_var=LIBRARY_PATH ;; @@ -11060,8 +11497,8 @@ beos*) bsdi[45]*) version_type=linux # correct to gnu/linux during the next big refactor need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" @@ -11073,7 +11510,7 @@ bsdi[45]*) cygwin* | mingw* | pw32* | cegcc*) version_type=windows - shrext_cmds=".dll" + shrext_cmds=.dll need_version=no need_lib_prefix=no @@ -11082,8 +11519,8 @@ cygwin* | mingw* | pw32* | cegcc*) # gcc library_names_spec='$libname.dll.a' # DLL is installed to $(libdir)/../bin by postinstall_cmds - postinstall_cmds='base_file=`basename \${file}`~ - dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + postinstall_cmds='base_file=`basename \$file`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname~ @@ -11099,17 +11536,17 @@ cygwin* | mingw* | pw32* | cegcc*) case $host_os in cygwin*) # Cygwin DLLs use 'cyg' prefix rather than 'lib' - soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext' sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api" ;; mingw* | cegcc*) # MinGW DLLs use traditional 'lib' prefix - soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext' ;; pw32*) # pw32 DLLs use 'pw' prefix rather than 'lib' - library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext' ;; esac dynamic_linker='Win32 ld.exe' @@ -11118,8 +11555,8 @@ cygwin* | mingw* | pw32* | cegcc*) *,cl*) # Native MSVC libname_spec='$name' - soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' - library_names_spec='${libname}.dll.lib' + soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext' + library_names_spec='$libname.dll.lib' case $build_os in mingw*) @@ -11146,7 +11583,7 @@ cygwin* | mingw* | pw32* | cegcc*) sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` ;; *) - sys_lib_search_path_spec="$LIB" + sys_lib_search_path_spec=$LIB if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then # It is most probably a Windows format PATH. sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` @@ -11159,8 +11596,8 @@ cygwin* | mingw* | pw32* | cegcc*) esac # DLL is installed to $(libdir)/../bin by postinstall_cmds - postinstall_cmds='base_file=`basename \${file}`~ - dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + postinstall_cmds='base_file=`basename \$file`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname' @@ -11173,7 +11610,7 @@ cygwin* | mingw* | pw32* | cegcc*) *) # Assume MSVC wrapper - library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + library_names_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext $libname.lib' dynamic_linker='Win32 ld.exe' ;; esac @@ -11186,8 +11623,8 @@ darwin* | rhapsody*) version_type=darwin need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' - soname_spec='${libname}${release}${major}$shared_ext' + library_names_spec='$libname$release$major$shared_ext $libname$shared_ext' + soname_spec='$libname$release$major$shared_ext' shlibpath_overrides_runpath=yes shlibpath_var=DYLD_LIBRARY_PATH shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' @@ -11200,8 +11637,8 @@ dgux*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH ;; @@ -11219,12 +11656,13 @@ freebsd* | dragonfly*) version_type=freebsd-$objformat case $version_type in freebsd-elf*) - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' need_version=no need_lib_prefix=no ;; freebsd-*) - library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' need_version=yes ;; esac @@ -11254,10 +11692,10 @@ haiku*) need_lib_prefix=no need_version=no dynamic_linker="$host_os runtime_loader" - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LIBRARY_PATH - shlibpath_overrides_runpath=yes + shlibpath_overrides_runpath=no sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' hardcode_into_libs=yes ;; @@ -11275,14 +11713,15 @@ hpux9* | hpux10* | hpux11*) dynamic_linker="$host_os dld.so" shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' - if test "X$HPUX_IA64_MODE" = X32; then + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' + if test 32 = "$HPUX_IA64_MODE"; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + sys_lib_dlsearch_path_spec=/usr/lib/hpux32 else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + sys_lib_dlsearch_path_spec=/usr/lib/hpux64 fi - sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; hppa*64*) shrext_cmds='.sl' @@ -11290,8 +11729,8 @@ hpux9* | hpux10* | hpux11*) dynamic_linker="$host_os dld.sl" shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; @@ -11300,8 +11739,8 @@ hpux9* | hpux10* | hpux11*) dynamic_linker="$host_os dld.sl" shlibpath_var=SHLIB_PATH shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' ;; esac # HP-UX runs *really* slowly unless shared libraries are mode 555, ... @@ -11314,8 +11753,8 @@ interix[3-9]*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no @@ -11326,7 +11765,7 @@ irix5* | irix6* | nonstopux*) case $host_os in nonstopux*) version_type=nonstopux ;; *) - if test "$lt_cv_prog_gnu_ld" = yes; then + if test yes = "$lt_cv_prog_gnu_ld"; then version_type=linux # correct to gnu/linux during the next big refactor else version_type=irix @@ -11334,8 +11773,8 @@ irix5* | irix6* | nonstopux*) esac need_lib_prefix=no need_version=no - soname_spec='${libname}${release}${shared_ext}$major' - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='$libname$release$shared_ext$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext' case $host_os in irix5* | nonstopux*) libsuff= shlibsuff= @@ -11354,8 +11793,8 @@ irix5* | irix6* | nonstopux*) esac shlibpath_var=LD_LIBRARY${shlibsuff}_PATH shlibpath_overrides_runpath=no - sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" - sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff" + sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff" hardcode_into_libs=yes ;; @@ -11364,13 +11803,33 @@ linux*oldld* | linux*aout* | linux*coff*) dynamic_linker=no ;; +linux*android*) + version_type=none # Android doesn't support versioned libraries. + need_lib_prefix=no + need_version=no + library_names_spec='$libname$release$shared_ext' + soname_spec='$libname$release$shared_ext' + finish_cmds= + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + dynamic_linker='Android linker' + # Don't embed -rpath directories since the linker doesn't support them. + hardcode_libdir_flag_spec='-L$libdir' + ;; + # This must be glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no @@ -11414,7 +11873,12 @@ fi # before this can be enabled. hardcode_into_libs=yes - # Append ld.so.conf contents to the search path + # Ideally, we could use ldconfig to report *all* directores which are + # searched for libraries, however this is still not possible. Aside from not + # being certain /sbin/ldconfig is available, command + # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64, + # even though it is searched at run-time. Try to do the best guess by + # appending ld.so.conf contents (and includes) to the search path. if test -f /etc/ld.so.conf; then lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" @@ -11446,12 +11910,12 @@ netbsd*) need_lib_prefix=no need_version=no if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' dynamic_linker='NetBSD (a.out) ld.so' else - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' dynamic_linker='NetBSD ld.elf_so' fi shlibpath_var=LD_LIBRARY_PATH @@ -11461,7 +11925,7 @@ netbsd*) newsos6) version_type=linux # correct to gnu/linux during the next big refactor - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes ;; @@ -11470,58 +11934,68 @@ newsos6) version_type=qnx need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes dynamic_linker='ldqnx.so' ;; -openbsd*) +openbsd* | bitrig*) version_type=sunos - sys_lib_dlsearch_path_spec="/usr/lib" + sys_lib_dlsearch_path_spec=/usr/lib need_lib_prefix=no - # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. - case $host_os in - openbsd3.3 | openbsd3.3.*) need_version=yes ;; - *) need_version=no ;; - esac - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then + need_version=no + else + need_version=yes + fi + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' shlibpath_var=LD_LIBRARY_PATH - if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then - case $host_os in - openbsd2.[89] | openbsd2.[89].*) - shlibpath_overrides_runpath=no - ;; - *) - shlibpath_overrides_runpath=yes - ;; - esac - else - shlibpath_overrides_runpath=yes - fi + shlibpath_overrides_runpath=yes ;; os2*) libname_spec='$name' - shrext_cmds=".dll" + version_type=windows + shrext_cmds=.dll + need_version=no need_lib_prefix=no - library_names_spec='$libname${shared_ext} $libname.a' + # OS/2 can only load a DLL with a base name of 8 characters or less. + soname_spec='`test -n "$os2dllname" && libname="$os2dllname"; + v=$($ECHO $release$versuffix | tr -d .-); + n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _); + $ECHO $n$v`$shared_ext' + library_names_spec='${libname}_dll.$libext' dynamic_linker='OS/2 ld.exe' - shlibpath_var=LIBPATH + shlibpath_var=BEGINLIBPATH + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + postinstall_cmds='base_file=`basename \$file`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' ;; osf3* | osf4* | osf5*) version_type=osf need_lib_prefix=no need_version=no - soname_spec='${libname}${release}${shared_ext}$major' - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='$libname$release$shared_ext$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" - sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; rdos*) @@ -11532,8 +12006,8 @@ solaris*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes @@ -11543,11 +12017,11 @@ solaris*) sunos4*) version_type=sunos - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes - if test "$with_gnu_ld" = yes; then + if test yes = "$with_gnu_ld"; then need_lib_prefix=no fi need_version=yes @@ -11555,8 +12029,8 @@ sunos4*) sysv4 | sysv4.3*) version_type=linux # correct to gnu/linux during the next big refactor - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH case $host_vendor in sni) @@ -11577,24 +12051,24 @@ sysv4 | sysv4.3*) ;; sysv4*MP*) - if test -d /usr/nec ;then + if test -d /usr/nec; then version_type=linux # correct to gnu/linux during the next big refactor - library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' - soname_spec='$libname${shared_ext}.$major' + library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext' + soname_spec='$libname$shared_ext.$major' shlibpath_var=LD_LIBRARY_PATH fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) - version_type=freebsd-elf + version_type=sco need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes - if test "$with_gnu_ld" = yes; then + if test yes = "$with_gnu_ld"; then sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' else sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' @@ -11612,7 +12086,7 @@ tpf*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes @@ -11620,8 +12094,8 @@ tpf*) uts4*) version_type=linux # correct to gnu/linux during the next big refactor - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH ;; @@ -11631,20 +12105,35 @@ uts4*) esac { $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 $as_echo "$dynamic_linker" >&6; } -test "$dynamic_linker" = no && can_build_shared=no +test no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" -if test "$GCC" = yes; then +if test yes = "$GCC"; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi -if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then - sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then + sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec fi -if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then - sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" + +if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then + sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec fi +# remember unaugmented sys_lib_dlsearch_path content for libtool script decls... +configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec + +# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code +func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH" + +# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool +configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH + + + + + + @@ -11741,15 +12230,15 @@ $as_echo_n "checking how to hardcode library paths into programs... " >&6; } hardcode_action= if test -n "$hardcode_libdir_flag_spec" || test -n "$runpath_var" || - test "X$hardcode_automatic" = "Xyes" ; then + test yes = "$hardcode_automatic"; then # We can hardcode non-existent directories. - if test "$hardcode_direct" != no && + if test no != "$hardcode_direct" && # If the only mechanism to avoid hardcoding is shlibpath_var, we # have to relink, otherwise we might link with an installed library # when we should be linking with a yet-to-be-installed one - ## test "$_LT_TAGVAR(hardcode_shlibpath_var, )" != no && - test "$hardcode_minus_L" != no; then + ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, )" && + test no != "$hardcode_minus_L"; then # Linking always hardcodes the temporary library directory. hardcode_action=relink else @@ -11764,12 +12253,12 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 $as_echo "$hardcode_action" >&6; } -if test "$hardcode_action" = relink || - test "$inherit_rpath" = yes; then +if test relink = "$hardcode_action" || + test yes = "$inherit_rpath"; then # Fast installation is not supported enable_fast_install=no -elif test "$shlibpath_overrides_runpath" = yes || - test "$enable_shared" = no; then +elif test yes = "$shlibpath_overrides_runpath" || + test no = "$enable_shared"; then # Fast installation is not necessary enable_fast_install=needless fi @@ -11779,7 +12268,7 @@ fi - if test "x$enable_dlopen" != xyes; then + if test yes != "$enable_dlopen"; then enable_dlopen=unknown enable_dlopen_self=unknown enable_dlopen_self_static=unknown @@ -11789,23 +12278,23 @@ else case $host_os in beos*) - lt_cv_dlopen="load_add_on" + lt_cv_dlopen=load_add_on lt_cv_dlopen_libs= lt_cv_dlopen_self=yes ;; mingw* | pw32* | cegcc*) - lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen=LoadLibrary lt_cv_dlopen_libs= ;; cygwin*) - lt_cv_dlopen="dlopen" + lt_cv_dlopen=dlopen lt_cv_dlopen_libs= ;; darwin*) - # if libdl is installed we need to link against it + # if libdl is installed we need to link against it { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 $as_echo_n "checking for dlopen in -ldl... " >&6; } if ${ac_cv_lib_dl_dlopen+:} false; then : @@ -11843,10 +12332,10 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 $as_echo "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes; then : - lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" + lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl else - lt_cv_dlopen="dyld" + lt_cv_dlopen=dyld lt_cv_dlopen_libs= lt_cv_dlopen_self=yes @@ -11854,10 +12343,18 @@ fi ;; + tpf*) + # Don't try to run any link tests for TPF. We know it's impossible + # because TPF is a cross-compiler, and we know how we open DSOs. + lt_cv_dlopen=dlopen + lt_cv_dlopen_libs= + lt_cv_dlopen_self=no + ;; + *) ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" if test "x$ac_cv_func_shl_load" = xyes; then : - lt_cv_dlopen="shl_load" + lt_cv_dlopen=shl_load else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 $as_echo_n "checking for shl_load in -ldld... " >&6; } @@ -11896,11 +12393,11 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 $as_echo "$ac_cv_lib_dld_shl_load" >&6; } if test "x$ac_cv_lib_dld_shl_load" = xyes; then : - lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld" + lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld else ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" if test "x$ac_cv_func_dlopen" = xyes; then : - lt_cv_dlopen="dlopen" + lt_cv_dlopen=dlopen else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 $as_echo_n "checking for dlopen in -ldl... " >&6; } @@ -11939,7 +12436,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 $as_echo "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes; then : - lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" + lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 $as_echo_n "checking for dlopen in -lsvld... " >&6; } @@ -11978,7 +12475,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 $as_echo "$ac_cv_lib_svld_dlopen" >&6; } if test "x$ac_cv_lib_svld_dlopen" = xyes; then : - lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" + lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 $as_echo_n "checking for dld_link in -ldld... " >&6; } @@ -12017,7 +12514,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 $as_echo "$ac_cv_lib_dld_dld_link" >&6; } if test "x$ac_cv_lib_dld_dld_link" = xyes; then : - lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld" + lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld fi @@ -12038,21 +12535,21 @@ fi ;; esac - if test "x$lt_cv_dlopen" != xno; then - enable_dlopen=yes - else + if test no = "$lt_cv_dlopen"; then enable_dlopen=no + else + enable_dlopen=yes fi case $lt_cv_dlopen in dlopen) - save_CPPFLAGS="$CPPFLAGS" - test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + save_CPPFLAGS=$CPPFLAGS + test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" - save_LDFLAGS="$LDFLAGS" + save_LDFLAGS=$LDFLAGS wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" - save_LIBS="$LIBS" + save_LIBS=$LIBS LIBS="$lt_cv_dlopen_libs $LIBS" { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 @@ -12060,7 +12557,7 @@ $as_echo_n "checking whether a program can dlopen itself... " >&6; } if ${lt_cv_dlopen_self+:} false; then : $as_echo_n "(cached) " >&6 else - if test "$cross_compiling" = yes; then : + if test yes = "$cross_compiling"; then : lt_cv_dlopen_self=cross else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 @@ -12107,9 +12604,9 @@ else # endif #endif -/* When -fvisbility=hidden is used, assume the code has been annotated +/* When -fvisibility=hidden is used, assume the code has been annotated correspondingly for the symbols needed. */ -#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) int fnord () __attribute__((visibility("default"))); #endif @@ -12139,7 +12636,7 @@ _LT_EOF (eval $ac_link) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then (./conftest; exit; ) >&5 2>/dev/null lt_status=$? case x$lt_status in @@ -12159,14 +12656,14 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 $as_echo "$lt_cv_dlopen_self" >&6; } - if test "x$lt_cv_dlopen_self" = xyes; then + if test yes = "$lt_cv_dlopen_self"; then wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 $as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } if ${lt_cv_dlopen_self_static+:} false; then : $as_echo_n "(cached) " >&6 else - if test "$cross_compiling" = yes; then : + if test yes = "$cross_compiling"; then : lt_cv_dlopen_self_static=cross else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 @@ -12213,9 +12710,9 @@ else # endif #endif -/* When -fvisbility=hidden is used, assume the code has been annotated +/* When -fvisibility=hidden is used, assume the code has been annotated correspondingly for the symbols needed. */ -#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) int fnord () __attribute__((visibility("default"))); #endif @@ -12245,7 +12742,7 @@ _LT_EOF (eval $ac_link) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then (./conftest; exit; ) >&5 2>/dev/null lt_status=$? case x$lt_status in @@ -12266,9 +12763,9 @@ fi $as_echo "$lt_cv_dlopen_self_static" >&6; } fi - CPPFLAGS="$save_CPPFLAGS" - LDFLAGS="$save_LDFLAGS" - LIBS="$save_LIBS" + CPPFLAGS=$save_CPPFLAGS + LDFLAGS=$save_LDFLAGS + LIBS=$save_LIBS ;; esac @@ -12312,7 +12809,7 @@ else # FIXME - insert some real tests, host_os isn't really good enough case $host_os in darwin*) - if test -n "$STRIP" ; then + if test -n "$STRIP"; then striplib="$STRIP -x" old_striplib="$STRIP -S" { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 @@ -12340,7 +12837,7 @@ fi - # Report which library types will actually be built + # Report what library types will actually be built { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 $as_echo_n "checking if libtool supports shared libraries... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 @@ -12348,13 +12845,13 @@ $as_echo "$can_build_shared" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 $as_echo_n "checking whether to build shared libraries... " >&6; } - test "$can_build_shared" = "no" && enable_shared=no + test no = "$can_build_shared" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) - test "$enable_shared" = yes && enable_static=no + test yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' @@ -12362,8 +12859,12 @@ $as_echo_n "checking whether to build shared libraries... " >&6; } ;; aix[4-9]*) - if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then - test "$enable_shared" = yes && enable_static=no + if test ia64 != "$host_cpu"; then + case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in + yes,aix,yes) ;; # shared object as lib.so file only + yes,svr4,*) ;; # shared object as lib.so archive member only + yes,*) enable_static=no ;; # shared object in lib.a archive as well + esac fi ;; esac @@ -12373,7 +12874,7 @@ $as_echo "$enable_shared" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 $as_echo_n "checking whether to build static libraries... " >&6; } # Make sure either enable_shared or enable_static is yes. - test "$enable_shared" = yes || enable_static=yes + test yes = "$enable_shared" || enable_static=yes { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 $as_echo "$enable_static" >&6; } @@ -12387,7 +12888,7 @@ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu -CC="$lt_save_CC" +CC=$lt_save_CC @@ -19083,12 +19584,12 @@ if test -n "$XCBPROTO_CFLAGS"; then pkg_cv_XCBPROTO_CFLAGS="$XCBPROTO_CFLAGS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ - { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xcb-proto >= 1.11\""; } >&5 - ($PKG_CONFIG --exists --print-errors "xcb-proto >= 1.11") 2>&5 + { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xcb-proto >= 1.12\""; } >&5 + ($PKG_CONFIG --exists --print-errors "xcb-proto >= 1.12") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then - pkg_cv_XCBPROTO_CFLAGS=`$PKG_CONFIG --cflags "xcb-proto >= 1.11" 2>/dev/null` + pkg_cv_XCBPROTO_CFLAGS=`$PKG_CONFIG --cflags "xcb-proto >= 1.12" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes @@ -19100,12 +19601,12 @@ if test -n "$XCBPROTO_LIBS"; then pkg_cv_XCBPROTO_LIBS="$XCBPROTO_LIBS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ - { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xcb-proto >= 1.11\""; } >&5 - ($PKG_CONFIG --exists --print-errors "xcb-proto >= 1.11") 2>&5 + { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xcb-proto >= 1.12\""; } >&5 + ($PKG_CONFIG --exists --print-errors "xcb-proto >= 1.12") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then - pkg_cv_XCBPROTO_LIBS=`$PKG_CONFIG --libs "xcb-proto >= 1.11" 2>/dev/null` + pkg_cv_XCBPROTO_LIBS=`$PKG_CONFIG --libs "xcb-proto >= 1.12" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes @@ -19126,14 +19627,14 @@ else _pkg_short_errors_supported=no fi if test $_pkg_short_errors_supported = yes; then - XCBPROTO_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "xcb-proto >= 1.11" 2>&1` + XCBPROTO_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "xcb-proto >= 1.12" 2>&1` else - XCBPROTO_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "xcb-proto >= 1.11" 2>&1` + XCBPROTO_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "xcb-proto >= 1.12" 2>&1` fi # Put the nasty error message in config.log where it belongs echo "$XCBPROTO_PKG_ERRORS" >&5 - as_fn_error $? "Package requirements (xcb-proto >= 1.11) were not met: + as_fn_error $? "Package requirements (xcb-proto >= 1.12) were not met: $XCBPROTO_PKG_ERRORS @@ -19630,17 +20131,8 @@ if test "$ac_res" != no; then : fi -# Check whether --enable-sendfds was given. -if test "${enable_sendfds+set}" = set; then : - enableval=$enable_sendfds; sendfds=$enableval -else - sendfds=auto -fi - - -case x$sendfds in -xauto) - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing sendmsg" >&5 +# Find support for sending a message from a socket +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing sendmsg" >&5 $as_echo_n "checking for library containing sendmsg... " >&6; } if ${ac_cv_search_sendmsg+:} false; then : $as_echo_n "(cached) " >&6 @@ -19693,13 +20185,11 @@ $as_echo "$ac_cv_search_sendmsg" >&6; } ac_res=$ac_cv_search_sendmsg if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" - sendfds="yes" + have_sendmsg="yes" else - sendfds="no" + have_sendmsg="no" fi - ;; -esac # XPG4v2/UNIX95 added msg_control - check to see if we need to define # _XOPEN_SOURCE to get it (such as on Solaris) @@ -19748,12 +20238,12 @@ $as_echo "#define _XOPEN_SOURCE 500" >>confdefs.h else - sendfds="no" + have_sendmsg="no" fi fi -case x$sendfds in +case x$have_sendmsg in xyes) $as_echo "#define HAVE_SENDMSG 1" >>confdefs.h @@ -19938,16 +20428,62 @@ fi ;; esac +case $host_os in + *mingw*) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lws2_32" >&5 +$as_echo_n "checking for main in -lws2_32... " >&6; } +if ${ac_cv_lib_ws2_32_main+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lws2_32 $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + +int +main () +{ +return main (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_ws2_32_main=yes +else + ac_cv_lib_ws2_32_main=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ws2_32_main" >&5 +$as_echo "$ac_cv_lib_ws2_32_main" >&6; } +if test "x$ac_cv_lib_ws2_32_main" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_LIBWS2_32 1 +_ACEOF + + LIBS="-lws2_32 $LIBS" + +fi + + ;; + *) + ;; +esac # Check whether --enable-composite was given. if test "${enable_composite+set}" = set; then : enableval=$enable_composite; BUILD_COMPOSITE=$enableval else - BUILD_COMPOSITE="yes" + BUILD_COMPOSITE=yes fi + if test "x$BUILD_COMPOSITE" = "xyes"; then BUILD_COMPOSITE_TRUE= BUILD_COMPOSITE_FALSE='#' @@ -19958,15 +20494,15 @@ fi - # Check whether --enable-damage was given. if test "${enable_damage+set}" = set; then : enableval=$enable_damage; BUILD_DAMAGE=$enableval else - BUILD_DAMAGE="yes" + BUILD_DAMAGE=yes fi + if test "x$BUILD_DAMAGE" = "xyes"; then BUILD_DAMAGE_TRUE= BUILD_DAMAGE_FALSE='#' @@ -19977,15 +20513,15 @@ fi - # Check whether --enable-dpms was given. if test "${enable_dpms+set}" = set; then : enableval=$enable_dpms; BUILD_DPMS=$enableval else - BUILD_DPMS="yes" + BUILD_DPMS=yes fi + if test "x$BUILD_DPMS" = "xyes"; then BUILD_DPMS_TRUE= BUILD_DPMS_FALSE='#' @@ -19996,15 +20532,15 @@ fi - # Check whether --enable-dri2 was given. if test "${enable_dri2+set}" = set; then : enableval=$enable_dri2; BUILD_DRI2=$enableval else - BUILD_DRI2="yes" + BUILD_DRI2=yes fi + if test "x$BUILD_DRI2" = "xyes"; then BUILD_DRI2_TRUE= BUILD_DRI2_FALSE='#' @@ -20015,15 +20551,24 @@ fi - # Check whether --enable-dri3 was given. if test "${enable_dri3+set}" = set; then : enableval=$enable_dri3; BUILD_DRI3=$enableval else - BUILD_DRI3="$sendfds" + BUILD_DRI3=auto fi +# This extension has a default value of "auto" and depends on the value of $have_sendmsg +if test "x$BUILD_DRI3" = "xauto" ; then + BUILD_DRI3=$have_sendmsg +fi +if test "x$BUILD_DRI3" = "xyes" ; then + if test "x$have_sendmsg" = "xno" ; then + as_fn_error $? "Extension DRI3 requested, but dependencies are not met" "$LINENO" 5 + fi +fi + if test "x$BUILD_DRI3" = "xyes"; then BUILD_DRI3_TRUE= BUILD_DRI3_FALSE='#' @@ -20034,15 +20579,15 @@ fi - # Check whether --enable-glx was given. if test "${enable_glx+set}" = set; then : enableval=$enable_glx; BUILD_GLX=$enableval else - BUILD_GLX="yes" + BUILD_GLX=yes fi + if test "x$BUILD_GLX" = "xyes"; then BUILD_GLX_TRUE= BUILD_GLX_FALSE='#' @@ -20053,15 +20598,15 @@ fi - # Check whether --enable-present was given. if test "${enable_present+set}" = set; then : enableval=$enable_present; BUILD_PRESENT=$enableval else - BUILD_PRESENT="yes" + BUILD_PRESENT=yes fi + if test "x$BUILD_PRESENT" = "xyes"; then BUILD_PRESENT_TRUE= BUILD_PRESENT_FALSE='#' @@ -20072,15 +20617,15 @@ fi - # Check whether --enable-randr was given. if test "${enable_randr+set}" = set; then : enableval=$enable_randr; BUILD_RANDR=$enableval else - BUILD_RANDR="yes" + BUILD_RANDR=yes fi + if test "x$BUILD_RANDR" = "xyes"; then BUILD_RANDR_TRUE= BUILD_RANDR_FALSE='#' @@ -20091,15 +20636,15 @@ fi - # Check whether --enable-record was given. if test "${enable_record+set}" = set; then : enableval=$enable_record; BUILD_RECORD=$enableval else - BUILD_RECORD="yes" + BUILD_RECORD=yes fi + if test "x$BUILD_RECORD" = "xyes"; then BUILD_RECORD_TRUE= BUILD_RECORD_FALSE='#' @@ -20110,15 +20655,15 @@ fi - # Check whether --enable-render was given. if test "${enable_render+set}" = set; then : enableval=$enable_render; BUILD_RENDER=$enableval else - BUILD_RENDER="yes" + BUILD_RENDER=yes fi + if test "x$BUILD_RENDER" = "xyes"; then BUILD_RENDER_TRUE= BUILD_RENDER_FALSE='#' @@ -20129,15 +20674,15 @@ fi - # Check whether --enable-resource was given. if test "${enable_resource+set}" = set; then : enableval=$enable_resource; BUILD_RESOURCE=$enableval else - BUILD_RESOURCE="yes" + BUILD_RESOURCE=yes fi + if test "x$BUILD_RESOURCE" = "xyes"; then BUILD_RESOURCE_TRUE= BUILD_RESOURCE_FALSE='#' @@ -20148,15 +20693,15 @@ fi - # Check whether --enable-screensaver was given. if test "${enable_screensaver+set}" = set; then : enableval=$enable_screensaver; BUILD_SCREENSAVER=$enableval else - BUILD_SCREENSAVER="yes" + BUILD_SCREENSAVER=yes fi + if test "x$BUILD_SCREENSAVER" = "xyes"; then BUILD_SCREENSAVER_TRUE= BUILD_SCREENSAVER_FALSE='#' @@ -20167,15 +20712,15 @@ fi - # Check whether --enable-shape was given. if test "${enable_shape+set}" = set; then : enableval=$enable_shape; BUILD_SHAPE=$enableval else - BUILD_SHAPE="yes" + BUILD_SHAPE=yes fi + if test "x$BUILD_SHAPE" = "xyes"; then BUILD_SHAPE_TRUE= BUILD_SHAPE_FALSE='#' @@ -20186,15 +20731,15 @@ fi - # Check whether --enable-shm was given. if test "${enable_shm+set}" = set; then : enableval=$enable_shm; BUILD_SHM=$enableval else - BUILD_SHM="yes" + BUILD_SHM=yes fi + if test "x$BUILD_SHM" = "xyes"; then BUILD_SHM_TRUE= BUILD_SHM_FALSE='#' @@ -20205,15 +20750,15 @@ fi - # Check whether --enable-sync was given. if test "${enable_sync+set}" = set; then : enableval=$enable_sync; BUILD_SYNC=$enableval else - BUILD_SYNC="yes" + BUILD_SYNC=yes fi + if test "x$BUILD_SYNC" = "xyes"; then BUILD_SYNC_TRUE= BUILD_SYNC_FALSE='#' @@ -20224,15 +20769,15 @@ fi - # Check whether --enable-xevie was given. if test "${enable_xevie+set}" = set; then : enableval=$enable_xevie; BUILD_XEVIE=$enableval else - BUILD_XEVIE="yes" + BUILD_XEVIE=no fi + if test "x$BUILD_XEVIE" = "xyes"; then BUILD_XEVIE_TRUE= BUILD_XEVIE_FALSE='#' @@ -20243,15 +20788,15 @@ fi - # Check whether --enable-xfixes was given. if test "${enable_xfixes+set}" = set; then : enableval=$enable_xfixes; BUILD_XFIXES=$enableval else - BUILD_XFIXES="yes" + BUILD_XFIXES=yes fi + if test "x$BUILD_XFIXES" = "xyes"; then BUILD_XFIXES_TRUE= BUILD_XFIXES_FALSE='#' @@ -20262,15 +20807,15 @@ fi - # Check whether --enable-xfree86-dri was given. if test "${enable_xfree86_dri+set}" = set; then : enableval=$enable_xfree86_dri; BUILD_XFREE86_DRI=$enableval else - BUILD_XFREE86_DRI="yes" + BUILD_XFREE86_DRI=yes fi + if test "x$BUILD_XFREE86_DRI" = "xyes"; then BUILD_XFREE86_DRI_TRUE= BUILD_XFREE86_DRI_FALSE='#' @@ -20281,15 +20826,15 @@ fi - # Check whether --enable-xinerama was given. if test "${enable_xinerama+set}" = set; then : enableval=$enable_xinerama; BUILD_XINERAMA=$enableval else - BUILD_XINERAMA="yes" + BUILD_XINERAMA=yes fi + if test "x$BUILD_XINERAMA" = "xyes"; then BUILD_XINERAMA_TRUE= BUILD_XINERAMA_FALSE='#' @@ -20300,15 +20845,15 @@ fi - # Check whether --enable-xinput was given. if test "${enable_xinput+set}" = set; then : enableval=$enable_xinput; BUILD_XINPUT=$enableval else - BUILD_XINPUT="no" + BUILD_XINPUT=no fi + if test "x$BUILD_XINPUT" = "xyes"; then BUILD_XINPUT_TRUE= BUILD_XINPUT_FALSE='#' @@ -20319,15 +20864,15 @@ fi - # Check whether --enable-xkb was given. if test "${enable_xkb+set}" = set; then : enableval=$enable_xkb; BUILD_XKB=$enableval else - BUILD_XKB="yes" + BUILD_XKB=yes fi + if test "x$BUILD_XKB" = "xyes"; then BUILD_XKB_TRUE= BUILD_XKB_FALSE='#' @@ -20338,15 +20883,15 @@ fi - # Check whether --enable-xprint was given. if test "${enable_xprint+set}" = set; then : enableval=$enable_xprint; BUILD_XPRINT=$enableval else - BUILD_XPRINT="yes" + BUILD_XPRINT=no fi + if test "x$BUILD_XPRINT" = "xyes"; then BUILD_XPRINT_TRUE= BUILD_XPRINT_FALSE='#' @@ -20357,15 +20902,15 @@ fi - # Check whether --enable-selinux was given. if test "${enable_selinux+set}" = set; then : enableval=$enable_selinux; BUILD_SELINUX=$enableval else - BUILD_SELINUX="no" + BUILD_SELINUX=no fi + if test "x$BUILD_SELINUX" = "xyes"; then BUILD_SELINUX_TRUE= BUILD_SELINUX_FALSE='#' @@ -20376,15 +20921,15 @@ fi - # Check whether --enable-xtest was given. if test "${enable_xtest+set}" = set; then : enableval=$enable_xtest; BUILD_XTEST=$enableval else - BUILD_XTEST="yes" + BUILD_XTEST=yes fi + if test "x$BUILD_XTEST" = "xyes"; then BUILD_XTEST_TRUE= BUILD_XTEST_FALSE='#' @@ -20395,15 +20940,15 @@ fi - # Check whether --enable-xv was given. if test "${enable_xv+set}" = set; then : enableval=$enable_xv; BUILD_XV=$enableval else - BUILD_XV="yes" + BUILD_XV=yes fi + if test "x$BUILD_XV" = "xyes"; then BUILD_XV_TRUE= BUILD_XV_FALSE='#' @@ -20414,15 +20959,15 @@ fi - # Check whether --enable-xvmc was given. if test "${enable_xvmc+set}" = set; then : enableval=$enable_xvmc; BUILD_XVMC=$enableval else - BUILD_XVMC="yes" + BUILD_XVMC=yes fi + if test "x$BUILD_XVMC" = "xyes"; then BUILD_XVMC_TRUE= BUILD_XVMC_FALSE='#' @@ -20489,6 +21034,24 @@ $as_echo "#define HAVE_LAUNCHD 1" >>confdefs.h fi + +# Check whether --with-serverside-support was given. +if test "${with_serverside_support+set}" = set; then : + withval=$with_serverside_support; XCB_SERVERSIDE_SUPPORT=$withval +else + XCB_SERVERSIDE_SUPPORT=no +fi + + + if test "x$XCB_SERVERSIDE_SUPPORT" = "xyes"; then + XCB_SERVERSIDE_SUPPORT_TRUE= + XCB_SERVERSIDE_SUPPORT_FALSE='#' +else + XCB_SERVERSIDE_SUPPORT_TRUE='#' + XCB_SERVERSIDE_SUPPORT_FALSE= +fi + + ac_config_files="$ac_config_files Makefile doc/Makefile man/Makefile src/Makefile tests/Makefile" @@ -20755,6 +21318,10 @@ if test -z "${BUILD_XVMC_TRUE}" && test -z "${BUILD_XVMC_FALSE}"; then as_fn_error $? "conditional \"BUILD_XVMC\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi +if test -z "${XCB_SERVERSIDE_SUPPORT_TRUE}" && test -z "${XCB_SERVERSIDE_SUPPORT_FALSE}"; then + as_fn_error $? "conditional \"XCB_SERVERSIDE_SUPPORT\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 @@ -21152,7 +21719,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by libxcb $as_me 1.11.1, which was +This file was extended by libxcb $as_me 1.12, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -21218,7 +21785,7 @@ _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -libxcb config.status 1.11.1 +libxcb config.status 1.12 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" @@ -21356,6 +21923,7 @@ enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`' enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`' enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`' +shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $SED "$delay_single_quote_subst"`' SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`' ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`' PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`' @@ -21403,10 +21971,13 @@ compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`' GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`' lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`' lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_import='`$ECHO "$lt_cv_sys_global_symbol_to_import" | $SED "$delay_single_quote_subst"`' lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`' lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`' +lt_cv_nm_interface='`$ECHO "$lt_cv_nm_interface" | $SED "$delay_single_quote_subst"`' nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`' lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`' +lt_cv_truncate_bin='`$ECHO "$lt_cv_truncate_bin" | $SED "$delay_single_quote_subst"`' objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`' MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`' lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`' @@ -21471,7 +22042,8 @@ finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`' finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`' hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`' sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`' -sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`' +configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`' +configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`' hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`' enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`' enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`' @@ -21523,9 +22095,12 @@ CFLAGS \ compiler \ lt_cv_sys_global_symbol_pipe \ lt_cv_sys_global_symbol_to_cdecl \ +lt_cv_sys_global_symbol_to_import \ lt_cv_sys_global_symbol_to_c_name_address \ lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \ +lt_cv_nm_interface \ nm_file_list_spec \ +lt_cv_truncate_bin \ lt_prog_compiler_no_builtin_flag \ lt_prog_compiler_pic \ lt_prog_compiler_wl \ @@ -21560,7 +22135,7 @@ old_striplib \ striplib; do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[\\\\\\\`\\"\\\$]*) - eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" @@ -21587,10 +22162,11 @@ postinstall_cmds \ postuninstall_cmds \ finish_cmds \ sys_lib_search_path_spec \ -sys_lib_dlsearch_path_spec; do +configure_time_dlsearch_path \ +configure_time_lt_sys_library_path; do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[\\\\\\\`\\"\\\$]*) - eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" @@ -21599,19 +22175,16 @@ sys_lib_dlsearch_path_spec; do done ac_aux_dir='$ac_aux_dir' -xsi_shell='$xsi_shell' -lt_shell_append='$lt_shell_append' -# See if we are running on zsh, and set the options which allow our +# See if we are running on zsh, and set the options that allow our # commands through without removal of \ escapes INIT. -if test -n "\${ZSH_VERSION+set}" ; then +if test -n "\${ZSH_VERSION+set}"; then setopt NO_GLOB_SUBST fi PACKAGE='$PACKAGE' VERSION='$VERSION' - TIMESTAMP='$TIMESTAMP' RM='$RM' ofile='$ofile' @@ -22352,55 +22925,53 @@ $as_echo X"$file" | ;; "libtool":C) - # See if we are running on zsh, and set the options which allow our + # See if we are running on zsh, and set the options that allow our # commands through without removal of \ escapes. - if test -n "${ZSH_VERSION+set}" ; then + if test -n "${ZSH_VERSION+set}"; then setopt NO_GLOB_SUBST fi - cfgfile="${ofile}T" + cfgfile=${ofile}T trap "$RM \"$cfgfile\"; exit 1" 1 2 15 $RM "$cfgfile" cat <<_LT_EOF >> "$cfgfile" #! $SHELL - -# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. -# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Generated automatically by $as_me ($PACKAGE) $VERSION # Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: # NOTE: Changes made to this file will be lost: look at ltmain.sh. + +# Provide generalized library-building support services. +# Written by Gordon Matzigkeit, 1996 + +# Copyright (C) 2014 Free Software Foundation, Inc. +# This is free software; see the source for copying conditions. There is NO +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +# GNU Libtool is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of of the License, or +# (at your option) any later version. # -# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, -# 2006, 2007, 2008, 2009, 2010, 2011 Free Software -# Foundation, Inc. -# Written by Gordon Matzigkeit, 1996 +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program or library that is built +# using GNU Libtool, you may include this file under the same +# distribution terms that you use for the rest of that program. # -# This file is part of GNU Libtool. -# -# GNU Libtool is free software; you can redistribute it and/or -# modify it under the terms of the GNU General Public License as -# published by the Free Software Foundation; either version 2 of -# the License, or (at your option) any later version. -# -# As a special exception to the GNU General Public License, -# if you distribute this file as part of a program or library that -# is built using GNU Libtool, you may include this file under the -# same distribution terms that you use for the rest of that program. -# -# GNU Libtool is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of +# GNU Libtool is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License -# along with GNU Libtool; see the file COPYING. If not, a copy -# can be downloaded from http://www.gnu.org/licenses/gpl.html, or -# obtained by writing to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# along with this program. If not, see . # The names of the tagged configurations supported by this script. -available_tags="" +available_tags='' + +# Configured defaults for sys_lib_dlsearch_path munging. +: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"} # ### BEGIN LIBTOOL CONFIG @@ -22429,6 +23000,9 @@ pic_mode=$pic_mode # Whether or not to optimize for fast installation. fast_install=$enable_fast_install +# Shared archive member basename,for filename based shared library versioning on AIX. +shared_archive_member_spec=$shared_archive_member_spec + # Shell to use when invoking shell scripts. SHELL=$lt_SHELL @@ -22540,18 +23114,27 @@ global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe # Transform the output of nm in a proper C declaration. global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl +# Transform the output of nm into a list of symbols to manually relocate. +global_symbol_to_import=$lt_lt_cv_sys_global_symbol_to_import + # Transform the output of nm in a C name address pair. global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address # Transform the output of nm in a C name address pair when lib prefix is needed. global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix +# The name lister interface. +nm_interface=$lt_lt_cv_nm_interface + # Specify filename containing input files for \$NM. nm_file_list_spec=$lt_nm_file_list_spec -# The root where to search for dependent libraries,and in which our libraries should be installed. +# The root where to search for dependent libraries,and where our libraries should be installed. lt_sysroot=$lt_sysroot +# Command to truncate a binary pipe. +lt_truncate_bin=$lt_lt_cv_truncate_bin + # The name of the directory that contains temporary libtool files. objdir=$objdir @@ -22642,8 +23225,11 @@ hardcode_into_libs=$hardcode_into_libs # Compile-time system search path for libraries. sys_lib_search_path_spec=$lt_sys_lib_search_path_spec -# Run-time system search path for libraries. -sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec +# Detected run-time system search path for libraries. +sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path + +# Explicit LT_SYS_LIBRARY_PATH set during ./configure time. +configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path # Whether dlopen is supported. dlopen_support=$enable_dlopen @@ -22736,13 +23322,13 @@ hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec # Whether we need a single "-rpath" flag with a separated argument. hardcode_libdir_separator=$lt_hardcode_libdir_separator -# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes # DIR into the resulting binary. hardcode_direct=$hardcode_direct -# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes # DIR into the resulting binary and the resulting library dependency is -# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# "absolute",i.e impossible to change by setting \$shlibpath_var if the # library is relocated. hardcode_direct_absolute=$hardcode_direct_absolute @@ -22792,6 +23378,65 @@ hardcode_action=$hardcode_action # ### END LIBTOOL CONFIG +_LT_EOF + + cat <<'_LT_EOF' >> "$cfgfile" + +# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE + +# func_munge_path_list VARIABLE PATH +# ----------------------------------- +# VARIABLE is name of variable containing _space_ separated list of +# directories to be munged by the contents of PATH, which is string +# having a format: +# "DIR[:DIR]:" +# string "DIR[ DIR]" will be prepended to VARIABLE +# ":DIR[:DIR]" +# string "DIR[ DIR]" will be appended to VARIABLE +# "DIRP[:DIRP]::[DIRA:]DIRA" +# string "DIRP[ DIRP]" will be prepended to VARIABLE and string +# "DIRA[ DIRA]" will be appended to VARIABLE +# "DIR[:DIR]" +# VARIABLE will be replaced by "DIR[ DIR]" +func_munge_path_list () +{ + case x$2 in + x) + ;; + *:) + eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\" + ;; + x:*) + eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\" + ;; + *::*) + eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" + eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\" + ;; + *) + eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\" + ;; + esac +} + + +# Calculate cc_basename. Skip known compiler wrappers and cross-prefix. +func_cc_basename () +{ + for cc_temp in $*""; do + case $cc_temp in + compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; + distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; + \-*) ;; + *) break;; + esac + done + func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` +} + + +# ### END FUNCTIONS SHARED WITH CONFIGURE + _LT_EOF case $host_os in @@ -22800,7 +23445,7 @@ _LT_EOF # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. -if test "X${COLLECT_NAMES+set}" != Xset; then +if test set != "${COLLECT_NAMES+set}"; then COLLECT_NAMES= export COLLECT_NAMES fi @@ -22809,7 +23454,7 @@ _LT_EOF esac -ltmain="$ac_aux_dir/ltmain.sh" +ltmain=$ac_aux_dir/ltmain.sh # We use sed instead of cat because bash on DJGPP gets confused if @@ -22819,165 +23464,6 @@ ltmain="$ac_aux_dir/ltmain.sh" sed '$q' "$ltmain" >> "$cfgfile" \ || (rm -f "$cfgfile"; exit 1) - if test x"$xsi_shell" = xyes; then - sed -e '/^func_dirname ()$/,/^} # func_dirname /c\ -func_dirname ()\ -{\ -\ case ${1} in\ -\ */*) func_dirname_result="${1%/*}${2}" ;;\ -\ * ) func_dirname_result="${3}" ;;\ -\ esac\ -} # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - sed -e '/^func_basename ()$/,/^} # func_basename /c\ -func_basename ()\ -{\ -\ func_basename_result="${1##*/}"\ -} # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\ -func_dirname_and_basename ()\ -{\ -\ case ${1} in\ -\ */*) func_dirname_result="${1%/*}${2}" ;;\ -\ * ) func_dirname_result="${3}" ;;\ -\ esac\ -\ func_basename_result="${1##*/}"\ -} # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - sed -e '/^func_stripname ()$/,/^} # func_stripname /c\ -func_stripname ()\ -{\ -\ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\ -\ # positional parameters, so assign one to ordinary parameter first.\ -\ func_stripname_result=${3}\ -\ func_stripname_result=${func_stripname_result#"${1}"}\ -\ func_stripname_result=${func_stripname_result%"${2}"}\ -} # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\ -func_split_long_opt ()\ -{\ -\ func_split_long_opt_name=${1%%=*}\ -\ func_split_long_opt_arg=${1#*=}\ -} # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\ -func_split_short_opt ()\ -{\ -\ func_split_short_opt_arg=${1#??}\ -\ func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\ -} # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\ -func_lo2o ()\ -{\ -\ case ${1} in\ -\ *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\ -\ *) func_lo2o_result=${1} ;;\ -\ esac\ -} # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - sed -e '/^func_xform ()$/,/^} # func_xform /c\ -func_xform ()\ -{\ - func_xform_result=${1%.*}.lo\ -} # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - sed -e '/^func_arith ()$/,/^} # func_arith /c\ -func_arith ()\ -{\ - func_arith_result=$(( $* ))\ -} # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - sed -e '/^func_len ()$/,/^} # func_len /c\ -func_len ()\ -{\ - func_len_result=${#1}\ -} # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - -fi - -if test x"$lt_shell_append" = xyes; then - sed -e '/^func_append ()$/,/^} # func_append /c\ -func_append ()\ -{\ - eval "${1}+=\\${2}"\ -} # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\ -func_append_quoted ()\ -{\ -\ func_quote_for_eval "${2}"\ -\ eval "${1}+=\\\\ \\$func_quote_for_eval_result"\ -} # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: - - - # Save a `func_append' function call where possible by direct use of '+=' - sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") - test 0 -eq $? || _lt_function_replace_fail=: -else - # Save a `func_append' function call even when '+=' is not available - sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") - test 0 -eq $? || _lt_function_replace_fail=: -fi - -if test x"$_lt_function_replace_fail" = x":"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5 -$as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;} -fi - - mv -f "$cfgfile" "$ofile" || (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") chmod +x "$ofile" @@ -23028,7 +23514,7 @@ echo " Package: ${PACKAGE_NAME} ${PACKAGE_VERSION}" echo "" echo " Configuration" echo " XDM support.........: ${have_xdmcp}" -echo " sendmsg fd passing..: ${sendfds}" +echo " sendmsg fd passing..: ${have_sendmsg}" echo " Build unit tests....: ${HAVE_CHECK}" echo " with html results.: ${HTML_CHECK_RESULT}" echo " XCB buffer size.....: ${xcb_queue_buffer_size}" @@ -23063,7 +23549,6 @@ echo "" echo " Used CFLAGS:" echo " CPPFLAGS............: ${CPPFLAGS}" echo " CFLAGS..............: ${CFLAGS}" -echo " Warning CFLAGS......: ${BASE_CFLAGS}" echo "" echo " Installation:" echo " Prefix..............: ${prefix}" diff --git a/dist/libxcb/configure.ac b/dist/libxcb/configure.ac index 8a14a9633..ec315420d 100644 --- a/dist/libxcb/configure.ac +++ b/dist/libxcb/configure.ac @@ -2,7 +2,7 @@ dnl Process this file with autoconf to produce a configure script. # Initialize Autoconf AC_PREREQ([2.60]) -AC_INIT([libxcb],[1.11.1], +AC_INIT([libxcb],[1.12], [https://bugs.freedesktop.org/enter_bug.cgi?product=xcb], [libxcb]) AC_CONFIG_AUX_DIR([build-aux]) @@ -50,7 +50,7 @@ fi AC_SUBST(HTML_CHECK_RESULT) # Checks for pkg-config packages -PKG_CHECK_MODULES(XCBPROTO, xcb-proto >= 1.11) +PKG_CHECK_MODULES(XCBPROTO, xcb-proto >= 1.12) NEEDED="pthread-stubs xau >= 0.99.2" PKG_CHECK_MODULES(NEEDED, $NEEDED) @@ -90,14 +90,8 @@ AC_HEADER_STDC AC_SEARCH_LIBS(getaddrinfo, socket) AC_SEARCH_LIBS(connect, socket) -AC_ARG_ENABLE(sendfds, AS_HELP_STRING([--disable-sendfds], [Support FD passing (default: auto)]), - [sendfds=$enableval], [sendfds=auto]) - -case x$sendfds in -xauto) - AC_SEARCH_LIBS(sendmsg, socket, [sendfds="yes"], [sendfds="no"]) - ;; -esac +# Find support for sending a message from a socket +AC_SEARCH_LIBS(sendmsg, socket, [have_sendmsg="yes"], [have_sendmsg="no"]) # XPG4v2/UNIX95 added msg_control - check to see if we need to define # _XOPEN_SOURCE to get it (such as on Solaris) @@ -126,14 +120,14 @@ if test "x$ac_cv_member_struct_msghdr_msg_control" = xno; then AC_CHECK_MEMBER([struct msghdr.msg_control], [AC_DEFINE([_XOPEN_SOURCE], [500], [Defined if needed to expose struct msghdr.msg_control]) - ], [sendfds="no"], [ + ], [have_sendmsg="no"], [ #define _XOPEN_SOURCE 500 AC_INCLUDES_DEFAULT #include ]) fi -case x$sendfds in +case x$have_sendmsg in xyes) AC_DEFINE([HAVE_SENDMSG],1,[Define if your platform supports sendmsg]) ;; @@ -212,32 +206,41 @@ case $host_os in ;; esac -XCB_EXTENSION(Composite, "yes") -XCB_EXTENSION(Damage, "yes") -XCB_EXTENSION(DPMS, "yes") -XCB_EXTENSION(DRI2, "yes") -XCB_EXTENSION(DRI3, "$sendfds") -XCB_EXTENSION(GLX, "yes") -XCB_EXTENSION(Present, "yes") -XCB_EXTENSION(RandR, "yes") -XCB_EXTENSION(Record, "yes") -XCB_EXTENSION(Render, "yes") -XCB_EXTENSION(Resource, "yes") -XCB_EXTENSION(Screensaver, "yes") -XCB_EXTENSION(Shape, "yes") -XCB_EXTENSION(Shm, "yes") -XCB_EXTENSION(Sync, "yes") -XCB_EXTENSION(Xevie, "yes") -XCB_EXTENSION(XFixes, "yes") -XCB_EXTENSION(XFree86-DRI, "yes") -XCB_EXTENSION(Xinerama, "yes") -XCB_EXTENSION(XInput, "no") -XCB_EXTENSION(XKB, "yes") -XCB_EXTENSION(Xprint, "yes") -XCB_EXTENSION(SELinux, "no") -XCB_EXTENSION(XTest, "yes") -XCB_EXTENSION(Xv, "yes") -XCB_EXTENSION(XvMC, "yes") +dnl Link with winsock for socket functions on MinGW +case $host_os in + *mingw*) + AC_CHECK_LIB([ws2_32],[main]) + ;; + *) + ;; +esac + +XCB_EXTENSION(Composite, yes) +XCB_EXTENSION(Damage, yes) +XCB_EXTENSION(DPMS, yes) +XCB_EXTENSION(DRI2, yes) +XCB_EXTENSION(DRI3, $have_sendmsg) +XCB_EXTENSION(GLX, yes) +XCB_EXTENSION(Present, yes) +XCB_EXTENSION(RandR, yes) +XCB_EXTENSION(Record, yes) +XCB_EXTENSION(Render, yes) +XCB_EXTENSION(Resource, yes) +XCB_EXTENSION(Screensaver, yes) +XCB_EXTENSION(Shape, yes) +XCB_EXTENSION(Shm, yes) +XCB_EXTENSION(Sync, yes) +XCB_EXTENSION(Xevie, no) +XCB_EXTENSION(XFixes, yes) +XCB_EXTENSION(XFree86-DRI, yes) +XCB_EXTENSION(Xinerama, yes) +XCB_EXTENSION(XInput, no) +XCB_EXTENSION(XKB, yes) +XCB_EXTENSION(Xprint, no) +XCB_EXTENSION(SELinux, no) +XCB_EXTENSION(XTest, yes) +XCB_EXTENSION(Xv, yes) +XCB_EXTENSION(XvMC, yes) AC_ARG_WITH(launchd, AS_HELP_STRING([--with-launchd], [Build with support for Apple's launchd (default: auto)]), [LAUNCHD=$withval], [LAUNCHD=auto]) if test "x$LAUNCHD" = xauto; then @@ -249,6 +252,10 @@ if test "x$LAUNCHD" = xyes ; then AC_DEFINE(HAVE_LAUNCHD, 1, [launchd support available]) fi +AC_ARG_WITH(serverside-support, AS_HELP_STRING([--with-serverside-support], [Build with support for server-side usage of xcb. This is still EXPERIMENTAL! ABI/API may change! (default: no)]), [XCB_SERVERSIDE_SUPPORT=$withval], [XCB_SERVERSIDE_SUPPORT=no]) + +AM_CONDITIONAL(XCB_SERVERSIDE_SUPPORT, test "x$XCB_SERVERSIDE_SUPPORT" = "xyes") + AC_CONFIG_FILES([ Makefile doc/Makefile @@ -300,7 +307,7 @@ echo " Package: ${PACKAGE_NAME} ${PACKAGE_VERSION}" echo "" echo " Configuration" echo " XDM support.........: ${have_xdmcp}" -echo " sendmsg fd passing..: ${sendfds}" +echo " sendmsg fd passing..: ${have_sendmsg}" echo " Build unit tests....: ${HAVE_CHECK}" echo " with html results.: ${HTML_CHECK_RESULT}" echo " XCB buffer size.....: ${xcb_queue_buffer_size}" @@ -335,7 +342,6 @@ echo "" echo " Used CFLAGS:" echo " CPPFLAGS............: ${CPPFLAGS}" echo " CFLAGS..............: ${CFLAGS}" -echo " Warning CFLAGS......: ${BASE_CFLAGS}" echo "" echo " Installation:" echo " Prefix..............: ${prefix}" diff --git a/dist/libxcb/doc/Makefile.in b/dist/libxcb/doc/Makefile.in index 2ca0861d9..f6ef8646a 100644 --- a/dist/libxcb/doc/Makefile.in +++ b/dist/libxcb/doc/Makefile.in @@ -184,6 +184,7 @@ LIB_MAN_SUFFIX = @LIB_MAN_SUFFIX@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ +LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ MAKEINFO = @MAKEINFO@ MANIFEST_TOOL = @MANIFEST_TOOL@ MAN_SUBSTS = @MAN_SUBSTS@ diff --git a/dist/libxcb/m4/libtool.m4 b/dist/libxcb/m4/libtool.m4 index d7c043f4f..10ab2844c 100644 --- a/dist/libxcb/m4/libtool.m4 +++ b/dist/libxcb/m4/libtool.m4 @@ -1,8 +1,6 @@ # libtool.m4 - Configure libtool for the host system. -*-Autoconf-*- # -# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, -# 2006, 2007, 2008, 2009, 2010, 2011 Free Software -# Foundation, Inc. +# Copyright (C) 1996-2001, 2003-2015 Free Software Foundation, Inc. # Written by Gordon Matzigkeit, 1996 # # This file is free software; the Free Software Foundation gives @@ -10,36 +8,30 @@ # modifications, as long as this notice is preserved. m4_define([_LT_COPYING], [dnl -# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, -# 2006, 2007, 2008, 2009, 2010, 2011 Free Software -# Foundation, Inc. -# Written by Gordon Matzigkeit, 1996 +# Copyright (C) 2014 Free Software Foundation, Inc. +# This is free software; see the source for copying conditions. There is NO +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +# GNU Libtool is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of of the License, or +# (at your option) any later version. # -# This file is part of GNU Libtool. +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program or library that is built +# using GNU Libtool, you may include this file under the same +# distribution terms that you use for the rest of that program. # -# GNU Libtool is free software; you can redistribute it and/or -# modify it under the terms of the GNU General Public License as -# published by the Free Software Foundation; either version 2 of -# the License, or (at your option) any later version. -# -# As a special exception to the GNU General Public License, -# if you distribute this file as part of a program or library that -# is built using GNU Libtool, you may include this file under the -# same distribution terms that you use for the rest of that program. -# -# GNU Libtool is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of +# GNU Libtool is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License -# along with GNU Libtool; see the file COPYING. If not, a copy -# can be downloaded from http://www.gnu.org/licenses/gpl.html, or -# obtained by writing to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# along with this program. If not, see . ]) -# serial 57 LT_INIT +# serial 58 LT_INIT # LT_PREREQ(VERSION) @@ -67,7 +59,7 @@ esac # LT_INIT([OPTIONS]) # ------------------ AC_DEFUN([LT_INIT], -[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT +[AC_PREREQ([2.62])dnl We use AC_PATH_PROGS_FEATURE_CHECK AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl AC_BEFORE([$0], [LT_LANG])dnl AC_BEFORE([$0], [LT_OUTPUT])dnl @@ -91,7 +83,7 @@ dnl Parse OPTIONS _LT_SET_OPTIONS([$0], [$1]) # This can be used to rebuild libtool when needed -LIBTOOL_DEPS="$ltmain" +LIBTOOL_DEPS=$ltmain # Always use our own libtool. LIBTOOL='$(SHELL) $(top_builddir)/libtool' @@ -111,26 +103,43 @@ dnl AC_DEFUN([AC_PROG_LIBTOOL], []) dnl AC_DEFUN([AM_PROG_LIBTOOL], []) +# _LT_PREPARE_CC_BASENAME +# ----------------------- +m4_defun([_LT_PREPARE_CC_BASENAME], [ +# Calculate cc_basename. Skip known compiler wrappers and cross-prefix. +func_cc_basename () +{ + for cc_temp in @S|@*""; do + case $cc_temp in + compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;; + distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;; + \-*) ;; + *) break;; + esac + done + func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` +} +])# _LT_PREPARE_CC_BASENAME + + # _LT_CC_BASENAME(CC) # ------------------- -# Calculate cc_basename. Skip known compiler wrappers and cross-prefix. +# It would be clearer to call AC_REQUIREs from _LT_PREPARE_CC_BASENAME, +# but that macro is also expanded into generated libtool script, which +# arranges for $SED and $ECHO to be set by different means. m4_defun([_LT_CC_BASENAME], -[for cc_temp in $1""; do - case $cc_temp in - compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;; - distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;; - \-*) ;; - *) break;; - esac -done -cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` +[m4_require([_LT_PREPARE_CC_BASENAME])dnl +AC_REQUIRE([_LT_DECL_SED])dnl +AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl +func_cc_basename $1 +cc_basename=$func_cc_basename_result ]) # _LT_FILEUTILS_DEFAULTS # ---------------------- # It is okay to use these file commands and assume they have been set -# sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'. +# sensibly after 'm4_require([_LT_FILEUTILS_DEFAULTS])'. m4_defun([_LT_FILEUTILS_DEFAULTS], [: ${CP="cp -f"} : ${MV="mv -f"} @@ -177,15 +186,16 @@ m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl m4_require([_LT_CMD_OLD_ARCHIVE])dnl m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl m4_require([_LT_WITH_SYSROOT])dnl +m4_require([_LT_CMD_TRUNCATE])dnl _LT_CONFIG_LIBTOOL_INIT([ -# See if we are running on zsh, and set the options which allow our +# See if we are running on zsh, and set the options that allow our # commands through without removal of \ escapes INIT. -if test -n "\${ZSH_VERSION+set}" ; then +if test -n "\${ZSH_VERSION+set}"; then setopt NO_GLOB_SUBST fi ]) -if test -n "${ZSH_VERSION+set}" ; then +if test -n "${ZSH_VERSION+set}"; then setopt NO_GLOB_SUBST fi @@ -198,7 +208,7 @@ aix3*) # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. - if test "X${COLLECT_NAMES+set}" != Xset; then + if test set != "${COLLECT_NAMES+set}"; then COLLECT_NAMES= export COLLECT_NAMES fi @@ -209,14 +219,14 @@ esac ofile=libtool can_build_shared=yes -# All known linkers require a `.a' archive for static linking (except MSVC, +# All known linkers require a '.a' archive for static linking (except MSVC, # which needs '.lib'). libext=a -with_gnu_ld="$lt_cv_prog_gnu_ld" +with_gnu_ld=$lt_cv_prog_gnu_ld -old_CC="$CC" -old_CFLAGS="$CFLAGS" +old_CC=$CC +old_CFLAGS=$CFLAGS # Set sane defaults for various variables test -z "$CC" && CC=cc @@ -269,14 +279,14 @@ no_glob_subst='s/\*/\\\*/g' # _LT_PROG_LTMAIN # --------------- -# Note that this code is called both from `configure', and `config.status' +# Note that this code is called both from 'configure', and 'config.status' # now that we use AC_CONFIG_COMMANDS to generate libtool. Notably, -# `config.status' has no value for ac_aux_dir unless we are using Automake, +# 'config.status' has no value for ac_aux_dir unless we are using Automake, # so we pass a copy along to make sure it has a sensible value anyway. m4_defun([_LT_PROG_LTMAIN], [m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl _LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir']) -ltmain="$ac_aux_dir/ltmain.sh" +ltmain=$ac_aux_dir/ltmain.sh ])# _LT_PROG_LTMAIN @@ -286,7 +296,7 @@ ltmain="$ac_aux_dir/ltmain.sh" # So that we can recreate a full libtool script including additional # tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS -# in macros and then make a single call at the end using the `libtool' +# in macros and then make a single call at the end using the 'libtool' # label. @@ -421,8 +431,8 @@ m4_define([_lt_decl_all_varnames], # _LT_CONFIG_STATUS_DECLARE([VARNAME]) # ------------------------------------ -# Quote a variable value, and forward it to `config.status' so that its -# declaration there will have the same value as in `configure'. VARNAME +# Quote a variable value, and forward it to 'config.status' so that its +# declaration there will have the same value as in 'configure'. VARNAME # must have a single quote delimited value for this to work. m4_define([_LT_CONFIG_STATUS_DECLARE], [$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`']) @@ -446,7 +456,7 @@ m4_defun([_LT_CONFIG_STATUS_DECLARATIONS], # Output comment and list of tags supported by the script m4_defun([_LT_LIBTOOL_TAGS], [_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl -available_tags="_LT_TAGS"dnl +available_tags='_LT_TAGS'dnl ]) @@ -474,7 +484,7 @@ m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl # _LT_LIBTOOL_CONFIG_VARS # ----------------------- # Produce commented declarations of non-tagged libtool config variables -# suitable for insertion in the LIBTOOL CONFIG section of the `libtool' +# suitable for insertion in the LIBTOOL CONFIG section of the 'libtool' # script. Tagged libtool config variables (even for the LIBTOOL CONFIG # section) are produced by _LT_LIBTOOL_TAG_VARS. m4_defun([_LT_LIBTOOL_CONFIG_VARS], @@ -500,8 +510,8 @@ m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])]) # Send accumulated output to $CONFIG_STATUS. Thanks to the lists of # variables for single and double quote escaping we saved from calls # to _LT_DECL, we can put quote escaped variables declarations -# into `config.status', and then the shell code to quote escape them in -# for loops in `config.status'. Finally, any additional code accumulated +# into 'config.status', and then the shell code to quote escape them in +# for loops in 'config.status'. Finally, any additional code accumulated # from calls to _LT_CONFIG_LIBTOOL_INIT is expanded. m4_defun([_LT_CONFIG_COMMANDS], [AC_PROVIDE_IFELSE([LT_OUTPUT], @@ -547,7 +557,7 @@ for var in lt_decl_all_varnames([[ \ ]], lt_decl_quote_varnames); do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[[\\\\\\\`\\"\\\$]]*) - eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" @@ -560,7 +570,7 @@ for var in lt_decl_all_varnames([[ \ ]], lt_decl_dquote_varnames); do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[[\\\\\\\`\\"\\\$]]*) - eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" @@ -576,7 +586,7 @@ _LT_OUTPUT_LIBTOOL_INIT # Generate a child script FILE with all initialization necessary to # reuse the environment learned by the parent script, and make the # file executable. If COMMENT is supplied, it is inserted after the -# `#!' sequence but before initialization text begins. After this +# '#!' sequence but before initialization text begins. After this # macro, additional text can be appended to FILE to form the body of # the child script. The macro ends with non-zero status if the # file could not be fully written (such as if the disk is full). @@ -598,7 +608,7 @@ AS_SHELL_SANITIZE _AS_PREPARE exec AS_MESSAGE_FD>&1 _ASEOF -test $lt_write_fail = 0 && chmod +x $1[]dnl +test 0 = "$lt_write_fail" && chmod +x $1[]dnl m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT # LT_OUTPUT @@ -621,7 +631,7 @@ exec AS_MESSAGE_LOG_FD>>config.log } >&AS_MESSAGE_LOG_FD lt_cl_help="\ -\`$as_me' creates a local libtool stub from the current configuration, +'$as_me' creates a local libtool stub from the current configuration, for use in further configure time tests before the real libtool is generated. @@ -643,7 +653,7 @@ Copyright (C) 2011 Free Software Foundation, Inc. This config.lt script is free software; the Free Software Foundation gives unlimited permision to copy, distribute and modify it." -while test $[#] != 0 +while test 0 != $[#] do case $[1] in --version | --v* | -V ) @@ -656,10 +666,10 @@ do lt_cl_silent=: ;; -*) AC_MSG_ERROR([unrecognized option: $[1] -Try \`$[0] --help' for more information.]) ;; +Try '$[0] --help' for more information.]) ;; *) AC_MSG_ERROR([unrecognized argument: $[1] -Try \`$[0] --help' for more information.]) ;; +Try '$[0] --help' for more information.]) ;; esac shift done @@ -685,7 +695,7 @@ chmod +x "$CONFIG_LT" # open by configure. Here we exec the FD to /dev/null, effectively closing # config.log, so it can be properly (re)opened and appended to by config.lt. lt_cl_success=: -test "$silent" = yes && +test yes = "$silent" && lt_config_lt_args="$lt_config_lt_args --quiet" exec AS_MESSAGE_LOG_FD>/dev/null $SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false @@ -705,32 +715,47 @@ m4_defun([_LT_CONFIG], _LT_CONFIG_SAVE_COMMANDS([ m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl m4_if(_LT_TAG, [C], [ - # See if we are running on zsh, and set the options which allow our + # See if we are running on zsh, and set the options that allow our # commands through without removal of \ escapes. - if test -n "${ZSH_VERSION+set}" ; then + if test -n "${ZSH_VERSION+set}"; then setopt NO_GLOB_SUBST fi - cfgfile="${ofile}T" + cfgfile=${ofile}T trap "$RM \"$cfgfile\"; exit 1" 1 2 15 $RM "$cfgfile" cat <<_LT_EOF >> "$cfgfile" #! $SHELL - -# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. -# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Generated automatically by $as_me ($PACKAGE) $VERSION # Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: # NOTE: Changes made to this file will be lost: look at ltmain.sh. -# + +# Provide generalized library-building support services. +# Written by Gordon Matzigkeit, 1996 + _LT_COPYING _LT_LIBTOOL_TAGS +# Configured defaults for sys_lib_dlsearch_path munging. +: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"} + # ### BEGIN LIBTOOL CONFIG _LT_LIBTOOL_CONFIG_VARS _LT_LIBTOOL_TAG_VARS # ### END LIBTOOL CONFIG +_LT_EOF + + cat <<'_LT_EOF' >> "$cfgfile" + +# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE + +_LT_PREPARE_MUNGE_PATH_LIST +_LT_PREPARE_CC_BASENAME + +# ### END FUNCTIONS SHARED WITH CONFIGURE + _LT_EOF case $host_os in @@ -739,7 +764,7 @@ _LT_EOF # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. -if test "X${COLLECT_NAMES+set}" != Xset; then +if test set != "${COLLECT_NAMES+set}"; then COLLECT_NAMES= export COLLECT_NAMES fi @@ -756,8 +781,6 @@ _LT_EOF sed '$q' "$ltmain" >> "$cfgfile" \ || (rm -f "$cfgfile"; exit 1) - _LT_PROG_REPLACE_SHELLFNS - mv -f "$cfgfile" "$ofile" || (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") chmod +x "$ofile" @@ -775,7 +798,6 @@ _LT_EOF [m4_if([$1], [], [ PACKAGE='$PACKAGE' VERSION='$VERSION' - TIMESTAMP='$TIMESTAMP' RM='$RM' ofile='$ofile'], []) ])dnl /_LT_CONFIG_SAVE_COMMANDS @@ -974,7 +996,7 @@ m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[ AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod], [lt_cv_apple_cc_single_mod=no - if test -z "${LT_MULTI_MODULE}"; then + if test -z "$LT_MULTI_MODULE"; then # By default we will add the -single_module flag. You can override # by either setting the environment variable LT_MULTI_MODULE # non-empty at configure time, or by adding -multi_module to the @@ -992,7 +1014,7 @@ m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[ cat conftest.err >&AS_MESSAGE_LOG_FD # Otherwise, if the output was created with a 0 exit code from # the compiler, it worked. - elif test -f libconftest.dylib && test $_lt_result -eq 0; then + elif test -f libconftest.dylib && test 0 = "$_lt_result"; then lt_cv_apple_cc_single_mod=yes else cat conftest.err >&AS_MESSAGE_LOG_FD @@ -1010,7 +1032,7 @@ m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[ AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [lt_cv_ld_exported_symbols_list=yes], [lt_cv_ld_exported_symbols_list=no]) - LDFLAGS="$save_LDFLAGS" + LDFLAGS=$save_LDFLAGS ]) AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load], @@ -1032,7 +1054,7 @@ _LT_EOF _lt_result=$? if test -s conftest.err && $GREP force_load conftest.err; then cat conftest.err >&AS_MESSAGE_LOG_FD - elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then + elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then lt_cv_ld_force_load=yes else cat conftest.err >&AS_MESSAGE_LOG_FD @@ -1042,32 +1064,32 @@ _LT_EOF ]) case $host_os in rhapsody* | darwin1.[[012]]) - _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; + _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;; darwin1.*) - _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;; darwin*) # darwin 5.x on # if running on 10.5 or later, the deployment target defaults # to the OS version, if on x86, and 10.4, the deployment # target defaults to 10.4. Don't you love it? case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in 10.0,*86*-darwin8*|10.0,*-darwin[[91]]*) - _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; - 10.[[012]]*) - _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;; + 10.[[012]][[,.]]*) + _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;; 10.*) - _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;; esac ;; esac - if test "$lt_cv_apple_cc_single_mod" = "yes"; then + if test yes = "$lt_cv_apple_cc_single_mod"; then _lt_dar_single_mod='$single_module' fi - if test "$lt_cv_ld_exported_symbols_list" = "yes"; then - _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' + if test yes = "$lt_cv_ld_exported_symbols_list"; then + _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym' else - _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' + _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib' fi - if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then + if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then _lt_dsymutil='~$DSYMUTIL $lib || :' else _lt_dsymutil= @@ -1087,29 +1109,29 @@ m4_defun([_LT_DARWIN_LINKER_FEATURES], _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_automatic, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported - if test "$lt_cv_ld_force_load" = "yes"; then - _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + if test yes = "$lt_cv_ld_force_load"; then + _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes], [FC], [_LT_TAGVAR(compiler_needs_object, $1)=yes]) else _LT_TAGVAR(whole_archive_flag_spec, $1)='' fi _LT_TAGVAR(link_all_deplibs, $1)=yes - _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined" + _LT_TAGVAR(allow_undefined_flag, $1)=$_lt_dar_allow_undefined case $cc_basename in - ifort*) _lt_dar_can_shared=yes ;; + ifort*|nagfor*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac - if test "$_lt_dar_can_shared" = "yes"; then + if test yes = "$_lt_dar_can_shared"; then output_verbose_link_cmd=func_echo_all - _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" - _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" - _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" - _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil" + _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil" + _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil" + _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil" m4_if([$1], [CXX], -[ if test "$lt_cv_apple_cc_single_mod" != "yes"; then - _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}" - _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}" +[ if test yes != "$lt_cv_apple_cc_single_mod"; then + _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil" + _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil" fi ],[]) else @@ -1129,7 +1151,7 @@ m4_defun([_LT_DARWIN_LINKER_FEATURES], # Allow to override them for all tags through lt_cv_aix_libpath. m4_defun([_LT_SYS_MODULE_PATH_AIX], [m4_require([_LT_DECL_SED])dnl -if test "${lt_cv_aix_libpath+set}" = set; then +if test set = "${lt_cv_aix_libpath+set}"; then aix_libpath=$lt_cv_aix_libpath else AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])], @@ -1147,7 +1169,7 @@ else _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` fi],[]) if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then - _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib" + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=/usr/lib:/lib fi ]) aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1]) @@ -1167,8 +1189,8 @@ m4_define([_LT_SHELL_INIT], # ----------------------- # Find how we can fake an echo command that does not interpret backslash. # In particular, with Autoconf 2.60 or later we add some code to the start -# of the generated configure script which will find a shell with a builtin -# printf (which we can use as an echo command). +# of the generated configure script that will find a shell with a builtin +# printf (that we can use as an echo command). m4_defun([_LT_PROG_ECHO_BACKSLASH], [ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO @@ -1196,10 +1218,10 @@ fi # Invoke $ECHO with all args, space-separated. func_echo_all () { - $ECHO "$*" + $ECHO "$*" } -case "$ECHO" in +case $ECHO in printf*) AC_MSG_RESULT([printf]) ;; print*) AC_MSG_RESULT([print -r]) ;; *) AC_MSG_RESULT([cat]) ;; @@ -1225,16 +1247,17 @@ _LT_DECL([], [ECHO], [1], [An echo program that protects backslashes]) AC_DEFUN([_LT_WITH_SYSROOT], [AC_MSG_CHECKING([for sysroot]) AC_ARG_WITH([sysroot], -[ --with-sysroot[=DIR] Search for dependent libraries within DIR - (or the compiler's sysroot if not specified).], +[AS_HELP_STRING([--with-sysroot@<:@=DIR@:>@], + [Search for dependent libraries within DIR (or the compiler's sysroot + if not specified).])], [], [with_sysroot=no]) dnl lt_sysroot will always be passed unquoted. We quote it here dnl in case the user passed a directory name. lt_sysroot= -case ${with_sysroot} in #( +case $with_sysroot in #( yes) - if test "$GCC" = yes; then + if test yes = "$GCC"; then lt_sysroot=`$CC --print-sysroot 2>/dev/null` fi ;; #( @@ -1244,14 +1267,14 @@ case ${with_sysroot} in #( no|'') ;; #( *) - AC_MSG_RESULT([${with_sysroot}]) + AC_MSG_RESULT([$with_sysroot]) AC_MSG_ERROR([The sysroot must be an absolute path.]) ;; esac AC_MSG_RESULT([${lt_sysroot:-no}]) _LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl -[dependent libraries, and in which our libraries should be installed.])]) +[dependent libraries, and where our libraries should be installed.])]) # _LT_ENABLE_LOCK # --------------- @@ -1259,31 +1282,33 @@ m4_defun([_LT_ENABLE_LOCK], [AC_ARG_ENABLE([libtool-lock], [AS_HELP_STRING([--disable-libtool-lock], [avoid locking (might break parallel builds)])]) -test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes +test no = "$enable_libtool_lock" || enable_libtool_lock=yes # Some flags need to be propagated to the compiler or linker for good # libtool support. case $host in ia64-*-hpux*) - # Find out which ABI we are using. + # Find out what ABI is being produced by ac_compile, and set mode + # options accordingly. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then case `/usr/bin/file conftest.$ac_objext` in *ELF-32*) - HPUX_IA64_MODE="32" + HPUX_IA64_MODE=32 ;; *ELF-64*) - HPUX_IA64_MODE="64" + HPUX_IA64_MODE=64 ;; esac fi rm -rf conftest* ;; *-*-irix6*) - # Find out which ABI we are using. + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then - if test "$lt_cv_prog_gnu_ld" = yes; then + if test yes = "$lt_cv_prog_gnu_ld"; then case `/usr/bin/file conftest.$ac_objext` in *32-bit*) LD="${LD-ld} -melf32bsmip" @@ -1312,9 +1337,46 @@ ia64-*-hpux*) rm -rf conftest* ;; +mips64*-*linux*) + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. + echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + emul=elf + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + emul="${emul}32" + ;; + *64-bit*) + emul="${emul}64" + ;; + esac + case `/usr/bin/file conftest.$ac_objext` in + *MSB*) + emul="${emul}btsmip" + ;; + *LSB*) + emul="${emul}ltsmip" + ;; + esac + case `/usr/bin/file conftest.$ac_objext` in + *N32*) + emul="${emul}n32" + ;; + esac + LD="${LD-ld} -m $emul" + fi + rm -rf conftest* + ;; + x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) - # Find out which ABI we are using. + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. Note that the listed cases only cover the + # situations where additional linker options are needed (such as when + # doing 32-bit compilation for a host where ld defaults to 64-bit, or + # vice versa); the common cases where no linker options are needed do + # not appear in the list. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then case `/usr/bin/file conftest.o` in @@ -1333,10 +1395,10 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) ;; esac ;; - powerpc64le-*) + powerpc64le-*linux*) LD="${LD-ld} -m elf32lppclinux" ;; - powerpc64-*) + powerpc64-*linux*) LD="${LD-ld} -m elf32ppclinux" ;; s390x-*linux*) @@ -1355,10 +1417,10 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) x86_64-*linux*) LD="${LD-ld} -m elf_x86_64" ;; - powerpcle-*) + powerpcle-*linux*) LD="${LD-ld} -m elf64lppc" ;; - powerpc-*) + powerpc-*linux*) LD="${LD-ld} -m elf64ppc" ;; s390*-*linux*|s390*-*tpf*) @@ -1376,19 +1438,20 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) *-*-sco3.2v5*) # On SCO OpenServer 5, we need -belf to get full-featured binaries. - SAVE_CFLAGS="$CFLAGS" + SAVE_CFLAGS=$CFLAGS CFLAGS="$CFLAGS -belf" AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf, [AC_LANG_PUSH(C) AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no]) AC_LANG_POP]) - if test x"$lt_cv_cc_needs_belf" != x"yes"; then + if test yes != "$lt_cv_cc_needs_belf"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf - CFLAGS="$SAVE_CFLAGS" + CFLAGS=$SAVE_CFLAGS fi ;; *-*solaris*) - # Find out which ABI we are using. + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then case `/usr/bin/file conftest.o` in @@ -1396,7 +1459,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) case $lt_cv_prog_gnu_ld in yes*) case $host in - i?86-*-solaris*) + i?86-*-solaris*|x86_64-*-solaris*) LD="${LD-ld} -m elf_x86_64" ;; sparc*-*-solaris*) @@ -1405,7 +1468,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) esac # GNU ld 2.21 introduced _sol2 emulations. Use them if available. if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then - LD="${LD-ld}_sol2" + LD=${LD-ld}_sol2 fi ;; *) @@ -1421,7 +1484,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) ;; esac -need_locks="$enable_libtool_lock" +need_locks=$enable_libtool_lock ])# _LT_ENABLE_LOCK @@ -1440,11 +1503,11 @@ AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file], [echo conftest.$ac_objext > conftest.lst lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD' AC_TRY_EVAL([lt_ar_try]) - if test "$ac_status" -eq 0; then + if test 0 -eq "$ac_status"; then # Ensure the archiver fails upon bogus file names. rm -f conftest.$ac_objext libconftest.a AC_TRY_EVAL([lt_ar_try]) - if test "$ac_status" -ne 0; then + if test 0 -ne "$ac_status"; then lt_cv_ar_at_file=@ fi fi @@ -1452,7 +1515,7 @@ AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file], ]) ]) -if test "x$lt_cv_ar_at_file" = xno; then +if test no = "$lt_cv_ar_at_file"; then archiver_list_spec= else archiver_list_spec=$lt_cv_ar_at_file @@ -1483,7 +1546,7 @@ old_postuninstall_cmds= if test -n "$RANLIB"; then case $host_os in - openbsd*) + bitrig* | openbsd*) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" ;; *) @@ -1519,7 +1582,7 @@ AC_CACHE_CHECK([$1], [$2], [$2=no m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4]) echo "$lt_simple_compile_test_code" > conftest.$ac_ext - lt_compiler_flag="$3" + lt_compiler_flag="$3" ## exclude from sc_useless_quotes_in_assignment # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins @@ -1546,7 +1609,7 @@ AC_CACHE_CHECK([$1], [$2], $RM conftest* ]) -if test x"[$]$2" = xyes; then +if test yes = "[$]$2"; then m4_if([$5], , :, [$5]) else m4_if([$6], , :, [$6]) @@ -1568,7 +1631,7 @@ AC_DEFUN([_LT_LINKER_OPTION], m4_require([_LT_DECL_SED])dnl AC_CACHE_CHECK([$1], [$2], [$2=no - save_LDFLAGS="$LDFLAGS" + save_LDFLAGS=$LDFLAGS LDFLAGS="$LDFLAGS $3" echo "$lt_simple_link_test_code" > conftest.$ac_ext if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then @@ -1587,10 +1650,10 @@ AC_CACHE_CHECK([$1], [$2], fi fi $RM -r conftest* - LDFLAGS="$save_LDFLAGS" + LDFLAGS=$save_LDFLAGS ]) -if test x"[$]$2" = xyes; then +if test yes = "[$]$2"; then m4_if([$4], , :, [$4]) else m4_if([$5], , :, [$5]) @@ -1611,7 +1674,7 @@ AC_DEFUN([LT_CMD_MAX_LEN], AC_MSG_CHECKING([the maximum length of command line arguments]) AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl i=0 - teststring="ABCD" + teststring=ABCD case $build_os in msdosdjgpp*) @@ -1651,7 +1714,7 @@ AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl lt_cv_sys_max_cmd_len=8192; ;; - netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) + bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*) # This has been around since 386BSD, at least. Likely further. if test -x /sbin/sysctl; then lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` @@ -1702,22 +1765,22 @@ AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl *) lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` if test -n "$lt_cv_sys_max_cmd_len" && \ - test undefined != "$lt_cv_sys_max_cmd_len"; then + test undefined != "$lt_cv_sys_max_cmd_len"; then lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` else # Make teststring a little bigger before we do anything with it. # a 1K string should be a reasonable start. - for i in 1 2 3 4 5 6 7 8 ; do + for i in 1 2 3 4 5 6 7 8; do teststring=$teststring$teststring done SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} # If test is not a shell built-in, we'll probably end up computing a # maximum length that is only half of the actual maximum length, but # we can't tell. - while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \ + while { test X`env echo "$teststring$teststring" 2>/dev/null` \ = "X$teststring$teststring"; } >/dev/null 2>&1 && - test $i != 17 # 1/2 MB should be enough + test 17 != "$i" # 1/2 MB should be enough do i=`expr $i + 1` teststring=$teststring$teststring @@ -1733,7 +1796,7 @@ AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl ;; esac ]) -if test -n $lt_cv_sys_max_cmd_len ; then +if test -n "$lt_cv_sys_max_cmd_len"; then AC_MSG_RESULT($lt_cv_sys_max_cmd_len) else AC_MSG_RESULT(none) @@ -1761,7 +1824,7 @@ m4_defun([_LT_HEADER_DLFCN], # ---------------------------------------------------------------- m4_defun([_LT_TRY_DLOPEN_SELF], [m4_require([_LT_HEADER_DLFCN])dnl -if test "$cross_compiling" = yes; then : +if test yes = "$cross_compiling"; then : [$4] else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 @@ -1808,9 +1871,9 @@ else # endif #endif -/* When -fvisbility=hidden is used, assume the code has been annotated +/* When -fvisibility=hidden is used, assume the code has been annotated correspondingly for the symbols needed. */ -#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) int fnord () __attribute__((visibility("default"))); #endif @@ -1836,7 +1899,7 @@ int main () return status; }] _LT_EOF - if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then + if AC_TRY_EVAL(ac_link) && test -s "conftest$ac_exeext" 2>/dev/null; then (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null lt_status=$? case x$lt_status in @@ -1857,7 +1920,7 @@ rm -fr conftest* # ------------------ AC_DEFUN([LT_SYS_DLOPEN_SELF], [m4_require([_LT_HEADER_DLFCN])dnl -if test "x$enable_dlopen" != xyes; then +if test yes != "$enable_dlopen"; then enable_dlopen=unknown enable_dlopen_self=unknown enable_dlopen_self_static=unknown @@ -1867,44 +1930,52 @@ else case $host_os in beos*) - lt_cv_dlopen="load_add_on" + lt_cv_dlopen=load_add_on lt_cv_dlopen_libs= lt_cv_dlopen_self=yes ;; mingw* | pw32* | cegcc*) - lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen=LoadLibrary lt_cv_dlopen_libs= ;; cygwin*) - lt_cv_dlopen="dlopen" + lt_cv_dlopen=dlopen lt_cv_dlopen_libs= ;; darwin*) - # if libdl is installed we need to link against it + # if libdl is installed we need to link against it AC_CHECK_LIB([dl], [dlopen], - [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[ - lt_cv_dlopen="dyld" + [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl],[ + lt_cv_dlopen=dyld lt_cv_dlopen_libs= lt_cv_dlopen_self=yes ]) ;; + tpf*) + # Don't try to run any link tests for TPF. We know it's impossible + # because TPF is a cross-compiler, and we know how we open DSOs. + lt_cv_dlopen=dlopen + lt_cv_dlopen_libs= + lt_cv_dlopen_self=no + ;; + *) AC_CHECK_FUNC([shl_load], - [lt_cv_dlopen="shl_load"], + [lt_cv_dlopen=shl_load], [AC_CHECK_LIB([dld], [shl_load], - [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"], + [lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld], [AC_CHECK_FUNC([dlopen], - [lt_cv_dlopen="dlopen"], + [lt_cv_dlopen=dlopen], [AC_CHECK_LIB([dl], [dlopen], - [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"], + [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl], [AC_CHECK_LIB([svld], [dlopen], - [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"], + [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld], [AC_CHECK_LIB([dld], [dld_link], - [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"]) + [lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld]) ]) ]) ]) @@ -1913,21 +1984,21 @@ else ;; esac - if test "x$lt_cv_dlopen" != xno; then - enable_dlopen=yes - else + if test no = "$lt_cv_dlopen"; then enable_dlopen=no + else + enable_dlopen=yes fi case $lt_cv_dlopen in dlopen) - save_CPPFLAGS="$CPPFLAGS" - test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + save_CPPFLAGS=$CPPFLAGS + test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" - save_LDFLAGS="$LDFLAGS" + save_LDFLAGS=$LDFLAGS wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" - save_LIBS="$LIBS" + save_LIBS=$LIBS LIBS="$lt_cv_dlopen_libs $LIBS" AC_CACHE_CHECK([whether a program can dlopen itself], @@ -1937,7 +2008,7 @@ else lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross) ]) - if test "x$lt_cv_dlopen_self" = xyes; then + if test yes = "$lt_cv_dlopen_self"; then wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" AC_CACHE_CHECK([whether a statically linked program can dlopen itself], lt_cv_dlopen_self_static, [dnl @@ -1947,9 +2018,9 @@ else ]) fi - CPPFLAGS="$save_CPPFLAGS" - LDFLAGS="$save_LDFLAGS" - LIBS="$save_LIBS" + CPPFLAGS=$save_CPPFLAGS + LDFLAGS=$save_LDFLAGS + LIBS=$save_LIBS ;; esac @@ -2041,8 +2112,8 @@ m4_defun([_LT_COMPILER_FILE_LOCKS], m4_require([_LT_FILEUTILS_DEFAULTS])dnl _LT_COMPILER_C_O([$1]) -hard_links="nottested" -if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then +hard_links=nottested +if test no = "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" && test no != "$need_locks"; then # do not overwrite the value of need_locks provided by the user AC_MSG_CHECKING([if we can lock with hard links]) hard_links=yes @@ -2052,8 +2123,8 @@ if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != ln conftest.a conftest.b 2>&5 || hard_links=no ln conftest.a conftest.b 2>/dev/null && hard_links=no AC_MSG_RESULT([$hard_links]) - if test "$hard_links" = no; then - AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe]) + if test no = "$hard_links"; then + AC_MSG_WARN(['$CC' does not support '-c -o', so 'make -j' may be unsafe]) need_locks=warn fi else @@ -2080,8 +2151,8 @@ objdir=$lt_cv_objdir _LT_DECL([], [objdir], [0], [The name of the directory that contains temporary libtool files])dnl m4_pattern_allow([LT_OBJDIR])dnl -AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/", - [Define to the sub-directory in which libtool stores uninstalled libraries.]) +AC_DEFINE_UNQUOTED([LT_OBJDIR], "$lt_cv_objdir/", + [Define to the sub-directory where libtool stores uninstalled libraries.]) ])# _LT_CHECK_OBJDIR @@ -2093,15 +2164,15 @@ m4_defun([_LT_LINKER_HARDCODE_LIBPATH], _LT_TAGVAR(hardcode_action, $1)= if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" || test -n "$_LT_TAGVAR(runpath_var, $1)" || - test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then + test yes = "$_LT_TAGVAR(hardcode_automatic, $1)"; then # We can hardcode non-existent directories. - if test "$_LT_TAGVAR(hardcode_direct, $1)" != no && + if test no != "$_LT_TAGVAR(hardcode_direct, $1)" && # If the only mechanism to avoid hardcoding is shlibpath_var, we # have to relink, otherwise we might link with an installed library # when we should be linking with a yet-to-be-installed one - ## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no && - test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then + ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" && + test no != "$_LT_TAGVAR(hardcode_minus_L, $1)"; then # Linking always hardcodes the temporary library directory. _LT_TAGVAR(hardcode_action, $1)=relink else @@ -2115,12 +2186,12 @@ else fi AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)]) -if test "$_LT_TAGVAR(hardcode_action, $1)" = relink || - test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then +if test relink = "$_LT_TAGVAR(hardcode_action, $1)" || + test yes = "$_LT_TAGVAR(inherit_rpath, $1)"; then # Fast installation is not supported enable_fast_install=no -elif test "$shlibpath_overrides_runpath" = yes || - test "$enable_shared" = no; then +elif test yes = "$shlibpath_overrides_runpath" || + test no = "$enable_shared"; then # Fast installation is not necessary enable_fast_install=needless fi @@ -2144,7 +2215,7 @@ else # FIXME - insert some real tests, host_os isn't really good enough case $host_os in darwin*) - if test -n "$STRIP" ; then + if test -n "$STRIP"; then striplib="$STRIP -x" old_striplib="$STRIP -S" AC_MSG_RESULT([yes]) @@ -2162,6 +2233,47 @@ _LT_DECL([], [striplib], [1]) ])# _LT_CMD_STRIPLIB +# _LT_PREPARE_MUNGE_PATH_LIST +# --------------------------- +# Make sure func_munge_path_list() is defined correctly. +m4_defun([_LT_PREPARE_MUNGE_PATH_LIST], +[[# func_munge_path_list VARIABLE PATH +# ----------------------------------- +# VARIABLE is name of variable containing _space_ separated list of +# directories to be munged by the contents of PATH, which is string +# having a format: +# "DIR[:DIR]:" +# string "DIR[ DIR]" will be prepended to VARIABLE +# ":DIR[:DIR]" +# string "DIR[ DIR]" will be appended to VARIABLE +# "DIRP[:DIRP]::[DIRA:]DIRA" +# string "DIRP[ DIRP]" will be prepended to VARIABLE and string +# "DIRA[ DIRA]" will be appended to VARIABLE +# "DIR[:DIR]" +# VARIABLE will be replaced by "DIR[ DIR]" +func_munge_path_list () +{ + case x@S|@2 in + x) + ;; + *:) + eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'` \@S|@@S|@1\" + ;; + x:*) + eval @S|@1=\"\@S|@@S|@1 `$ECHO @S|@2 | $SED 's/:/ /g'`\" + ;; + *::*) + eval @S|@1=\"\@S|@@S|@1\ `$ECHO @S|@2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" + eval @S|@1=\"`$ECHO @S|@2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \@S|@@S|@1\" + ;; + *) + eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'`\" + ;; + esac +} +]])# _LT_PREPARE_PATH_LIST + + # _LT_SYS_DYNAMIC_LINKER([TAG]) # ----------------------------- # PORTME Fill in your ld.so characteristics @@ -2172,17 +2284,18 @@ m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_OBJDUMP])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_CHECK_SHELL_FEATURES])dnl +m4_require([_LT_PREPARE_MUNGE_PATH_LIST])dnl AC_MSG_CHECKING([dynamic linker characteristics]) m4_if([$1], [], [ -if test "$GCC" = yes; then +if test yes = "$GCC"; then case $host_os in - darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; - *) lt_awk_arg="/^libraries:/" ;; + darwin*) lt_awk_arg='/^libraries:/,/LR/' ;; + *) lt_awk_arg='/^libraries:/' ;; esac case $host_os in - mingw* | cegcc*) lt_sed_strip_eq="s,=\([[A-Za-z]]:\),\1,g" ;; - *) lt_sed_strip_eq="s,=/,/,g" ;; + mingw* | cegcc*) lt_sed_strip_eq='s|=\([[A-Za-z]]:\)|\1|g' ;; + *) lt_sed_strip_eq='s|=/|/|g' ;; esac lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` case $lt_search_path_spec in @@ -2198,28 +2311,35 @@ if test "$GCC" = yes; then ;; esac # Ok, now we have the path, separated by spaces, we can step through it - # and add multilib dir if necessary. + # and add multilib dir if necessary... lt_tmp_lt_search_path_spec= - lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + # ...but if some path component already ends with the multilib dir we assume + # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer). + case "$lt_multi_os_dir; $lt_search_path_spec " in + "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*) + lt_multi_os_dir= + ;; + esac for lt_sys_path in $lt_search_path_spec; do - if test -d "$lt_sys_path/$lt_multi_os_dir"; then - lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" - else + if test -d "$lt_sys_path$lt_multi_os_dir"; then + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path$lt_multi_os_dir" + elif test -n "$lt_multi_os_dir"; then test -d "$lt_sys_path" && \ lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" fi done lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' -BEGIN {RS=" "; FS="/|\n";} { - lt_foo=""; - lt_count=0; +BEGIN {RS = " "; FS = "/|\n";} { + lt_foo = ""; + lt_count = 0; for (lt_i = NF; lt_i > 0; lt_i--) { if ($lt_i != "" && $lt_i != ".") { if ($lt_i == "..") { lt_count++; } else { if (lt_count == 0) { - lt_foo="/" $lt_i lt_foo; + lt_foo = "/" $lt_i lt_foo; } else { lt_count--; } @@ -2233,7 +2353,7 @@ BEGIN {RS=" "; FS="/|\n";} { # for these hosts. case $host_os in mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ - $SED 's,/\([[A-Za-z]]:\),\1,g'` ;; + $SED 's|/\([[A-Za-z]]:\)|\1|g'` ;; esac sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` else @@ -2242,7 +2362,7 @@ fi]) library_names_spec= libname_spec='lib$name' soname_spec= -shrext_cmds=".so" +shrext_cmds=.so postinstall_cmds= postuninstall_cmds= finish_cmds= @@ -2259,14 +2379,17 @@ hardcode_into_libs=no # flags to be left without arguments need_version=unknown +AC_ARG_VAR([LT_SYS_LIBRARY_PATH], +[User-defined run-time library search path.]) + case $host_os in aix3*) version_type=linux # correct to gnu/linux during the next big refactor - library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + library_names_spec='$libname$release$shared_ext$versuffix $libname.a' shlibpath_var=LIBPATH # AIX 3 has no versioning support, so we append a major version to the name. - soname_spec='${libname}${release}${shared_ext}$major' + soname_spec='$libname$release$shared_ext$major' ;; aix[[4-9]]*) @@ -2274,41 +2397,91 @@ aix[[4-9]]*) need_lib_prefix=no need_version=no hardcode_into_libs=yes - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # AIX 5 supports IA64 - library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext' shlibpath_var=LD_LIBRARY_PATH else # With GCC up to 2.95.x, collect2 would create an import file # for dependence libraries. The import file would start with - # the line `#! .'. This would cause the generated library to - # depend on `.', always an invalid library. This was fixed in + # the line '#! .'. This would cause the generated library to + # depend on '.', always an invalid library. This was fixed in # development snapshots of GCC prior to 3.0. case $host_os in aix4 | aix4.[[01]] | aix4.[[01]].*) if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' echo ' yes ' - echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then : else can_build_shared=no fi ;; esac - # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # Using Import Files as archive members, it is possible to support + # filename-based versioning of shared library archives on AIX. While + # this would work for both with and without runtime linking, it will + # prevent static linking of such archives. So we do filename-based + # shared library versioning with .so extension only, which is used + # when both runtime linking and shared linking is enabled. + # Unfortunately, runtime linking may impact performance, so we do + # not want this to be the default eventually. Also, we use the + # versioned .so libs for executables only if there is the -brtl + # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only. + # To allow for filename-based versioning support, we need to create + # libNAME.so.V as an archive file, containing: + # *) an Import File, referring to the versioned filename of the + # archive as well as the shared archive member, telling the + # bitwidth (32 or 64) of that shared object, and providing the + # list of exported symbols of that shared object, eventually + # decorated with the 'weak' keyword + # *) the shared object with the F_LOADONLY flag set, to really avoid + # it being seen by the linker. + # At run time we better use the real file rather than another symlink, + # but for link time we create the symlink libNAME.so -> libNAME.so.V + + case $with_aix_soname,$aix_use_runtimelinking in + # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. - if test "$aix_use_runtimelinking" = yes; then + aix,yes) # traditional libtool + dynamic_linker='AIX unversionable lib.so' # If using run time linking (on AIX 4.2 or later) use lib.so # instead of lib.a to let people know that these are not # typical AIX shared libraries. - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - else + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + ;; + aix,no) # traditional AIX only + dynamic_linker='AIX lib.a[(]lib.so.V[)]' # We preserve .a as extension for shared libraries through AIX4.2 # and later when we are not doing run time linking. - library_names_spec='${libname}${release}.a $libname.a' - soname_spec='${libname}${release}${shared_ext}$major' - fi + library_names_spec='$libname$release.a $libname.a' + soname_spec='$libname$release$shared_ext$major' + ;; + svr4,*) # full svr4 only + dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)]" + library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' + # We do not specify a path in Import Files, so LIBPATH fires. + shlibpath_overrides_runpath=yes + ;; + *,yes) # both, prefer svr4 + dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)], lib.a[(]lib.so.V[)]" + library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' + # unpreferred sharedlib libNAME.a needs extra handling + postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"' + postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"' + # We do not specify a path in Import Files, so LIBPATH fires. + shlibpath_overrides_runpath=yes + ;; + *,no) # both, prefer aix + dynamic_linker="AIX lib.a[(]lib.so.V[)], lib.so.V[(]$shared_archive_member_spec.o[)]" + library_names_spec='$libname$release.a $libname.a' + soname_spec='$libname$release$shared_ext$major' + # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling + postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)' + postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"' + ;; + esac shlibpath_var=LIBPATH fi ;; @@ -2318,18 +2491,18 @@ amigaos*) powerpc) # Since July 2007 AmigaOS4 officially supports .so libraries. # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' ;; m68k) library_names_spec='$libname.ixlibrary $libname.a' # Create ${libname}_ixlibrary.a entries in /sys/libs. - finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' ;; esac ;; beos*) - library_names_spec='${libname}${shared_ext}' + library_names_spec='$libname$shared_ext' dynamic_linker="$host_os ld.so" shlibpath_var=LIBRARY_PATH ;; @@ -2337,8 +2510,8 @@ beos*) bsdi[[45]]*) version_type=linux # correct to gnu/linux during the next big refactor need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" @@ -2350,7 +2523,7 @@ bsdi[[45]]*) cygwin* | mingw* | pw32* | cegcc*) version_type=windows - shrext_cmds=".dll" + shrext_cmds=.dll need_version=no need_lib_prefix=no @@ -2359,8 +2532,8 @@ cygwin* | mingw* | pw32* | cegcc*) # gcc library_names_spec='$libname.dll.a' # DLL is installed to $(libdir)/../bin by postinstall_cmds - postinstall_cmds='base_file=`basename \${file}`~ - dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + postinstall_cmds='base_file=`basename \$file`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname~ @@ -2376,17 +2549,17 @@ cygwin* | mingw* | pw32* | cegcc*) case $host_os in cygwin*) # Cygwin DLLs use 'cyg' prefix rather than 'lib' - soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext' m4_if([$1], [],[ sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"]) ;; mingw* | cegcc*) # MinGW DLLs use traditional 'lib' prefix - soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext' ;; pw32*) # pw32 DLLs use 'pw' prefix rather than 'lib' - library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext' ;; esac dynamic_linker='Win32 ld.exe' @@ -2395,8 +2568,8 @@ m4_if([$1], [],[ *,cl*) # Native MSVC libname_spec='$name' - soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' - library_names_spec='${libname}.dll.lib' + soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext' + library_names_spec='$libname.dll.lib' case $build_os in mingw*) @@ -2423,7 +2596,7 @@ m4_if([$1], [],[ sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` ;; *) - sys_lib_search_path_spec="$LIB" + sys_lib_search_path_spec=$LIB if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then # It is most probably a Windows format PATH. sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` @@ -2436,8 +2609,8 @@ m4_if([$1], [],[ esac # DLL is installed to $(libdir)/../bin by postinstall_cmds - postinstall_cmds='base_file=`basename \${file}`~ - dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + postinstall_cmds='base_file=`basename \$file`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname' @@ -2450,7 +2623,7 @@ m4_if([$1], [],[ *) # Assume MSVC wrapper - library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib' + library_names_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext $libname.lib' dynamic_linker='Win32 ld.exe' ;; esac @@ -2463,8 +2636,8 @@ darwin* | rhapsody*) version_type=darwin need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' - soname_spec='${libname}${release}${major}$shared_ext' + library_names_spec='$libname$release$major$shared_ext $libname$shared_ext' + soname_spec='$libname$release$major$shared_ext' shlibpath_overrides_runpath=yes shlibpath_var=DYLD_LIBRARY_PATH shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' @@ -2477,8 +2650,8 @@ dgux*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH ;; @@ -2496,12 +2669,13 @@ freebsd* | dragonfly*) version_type=freebsd-$objformat case $version_type in freebsd-elf*) - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' need_version=no need_lib_prefix=no ;; freebsd-*) - library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' need_version=yes ;; esac @@ -2531,10 +2705,10 @@ haiku*) need_lib_prefix=no need_version=no dynamic_linker="$host_os runtime_loader" - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LIBRARY_PATH - shlibpath_overrides_runpath=yes + shlibpath_overrides_runpath=no sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' hardcode_into_libs=yes ;; @@ -2552,14 +2726,15 @@ hpux9* | hpux10* | hpux11*) dynamic_linker="$host_os dld.so" shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' - if test "X$HPUX_IA64_MODE" = X32; then + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' + if test 32 = "$HPUX_IA64_MODE"; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + sys_lib_dlsearch_path_spec=/usr/lib/hpux32 else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + sys_lib_dlsearch_path_spec=/usr/lib/hpux64 fi - sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; hppa*64*) shrext_cmds='.sl' @@ -2567,8 +2742,8 @@ hpux9* | hpux10* | hpux11*) dynamic_linker="$host_os dld.sl" shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; @@ -2577,8 +2752,8 @@ hpux9* | hpux10* | hpux11*) dynamic_linker="$host_os dld.sl" shlibpath_var=SHLIB_PATH shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' ;; esac # HP-UX runs *really* slowly unless shared libraries are mode 555, ... @@ -2591,8 +2766,8 @@ interix[[3-9]]*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no @@ -2603,7 +2778,7 @@ irix5* | irix6* | nonstopux*) case $host_os in nonstopux*) version_type=nonstopux ;; *) - if test "$lt_cv_prog_gnu_ld" = yes; then + if test yes = "$lt_cv_prog_gnu_ld"; then version_type=linux # correct to gnu/linux during the next big refactor else version_type=irix @@ -2611,8 +2786,8 @@ irix5* | irix6* | nonstopux*) esac need_lib_prefix=no need_version=no - soname_spec='${libname}${release}${shared_ext}$major' - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='$libname$release$shared_ext$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext' case $host_os in irix5* | nonstopux*) libsuff= shlibsuff= @@ -2631,8 +2806,8 @@ irix5* | irix6* | nonstopux*) esac shlibpath_var=LD_LIBRARY${shlibsuff}_PATH shlibpath_overrides_runpath=no - sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" - sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff" + sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff" hardcode_into_libs=yes ;; @@ -2641,13 +2816,33 @@ linux*oldld* | linux*aout* | linux*coff*) dynamic_linker=no ;; +linux*android*) + version_type=none # Android doesn't support versioned libraries. + need_lib_prefix=no + need_version=no + library_names_spec='$libname$release$shared_ext' + soname_spec='$libname$release$shared_ext' + finish_cmds= + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + dynamic_linker='Android linker' + # Don't embed -rpath directories since the linker doesn't support them. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + ;; + # This must be glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no @@ -2672,7 +2867,12 @@ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) # before this can be enabled. hardcode_into_libs=yes - # Append ld.so.conf contents to the search path + # Ideally, we could use ldconfig to report *all* directores which are + # searched for libraries, however this is still not possible. Aside from not + # being certain /sbin/ldconfig is available, command + # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64, + # even though it is searched at run-time. Try to do the best guess by + # appending ld.so.conf contents (and includes) to the search path. if test -f /etc/ld.so.conf; then lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" @@ -2704,12 +2904,12 @@ netbsd*) need_lib_prefix=no need_version=no if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' dynamic_linker='NetBSD (a.out) ld.so' else - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' dynamic_linker='NetBSD ld.elf_so' fi shlibpath_var=LD_LIBRARY_PATH @@ -2719,7 +2919,7 @@ netbsd*) newsos6) version_type=linux # correct to gnu/linux during the next big refactor - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes ;; @@ -2728,58 +2928,68 @@ newsos6) version_type=qnx need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes dynamic_linker='ldqnx.so' ;; -openbsd*) +openbsd* | bitrig*) version_type=sunos - sys_lib_dlsearch_path_spec="/usr/lib" + sys_lib_dlsearch_path_spec=/usr/lib need_lib_prefix=no - # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. - case $host_os in - openbsd3.3 | openbsd3.3.*) need_version=yes ;; - *) need_version=no ;; - esac - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then + need_version=no + else + need_version=yes + fi + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' shlibpath_var=LD_LIBRARY_PATH - if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then - case $host_os in - openbsd2.[[89]] | openbsd2.[[89]].*) - shlibpath_overrides_runpath=no - ;; - *) - shlibpath_overrides_runpath=yes - ;; - esac - else - shlibpath_overrides_runpath=yes - fi + shlibpath_overrides_runpath=yes ;; os2*) libname_spec='$name' - shrext_cmds=".dll" + version_type=windows + shrext_cmds=.dll + need_version=no need_lib_prefix=no - library_names_spec='$libname${shared_ext} $libname.a' + # OS/2 can only load a DLL with a base name of 8 characters or less. + soname_spec='`test -n "$os2dllname" && libname="$os2dllname"; + v=$($ECHO $release$versuffix | tr -d .-); + n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _); + $ECHO $n$v`$shared_ext' + library_names_spec='${libname}_dll.$libext' dynamic_linker='OS/2 ld.exe' - shlibpath_var=LIBPATH + shlibpath_var=BEGINLIBPATH + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + postinstall_cmds='base_file=`basename \$file`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' ;; osf3* | osf4* | osf5*) version_type=osf need_lib_prefix=no need_version=no - soname_spec='${libname}${release}${shared_ext}$major' - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='$libname$release$shared_ext$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" - sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; rdos*) @@ -2790,8 +3000,8 @@ solaris*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes @@ -2801,11 +3011,11 @@ solaris*) sunos4*) version_type=sunos - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes - if test "$with_gnu_ld" = yes; then + if test yes = "$with_gnu_ld"; then need_lib_prefix=no fi need_version=yes @@ -2813,8 +3023,8 @@ sunos4*) sysv4 | sysv4.3*) version_type=linux # correct to gnu/linux during the next big refactor - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH case $host_vendor in sni) @@ -2835,24 +3045,24 @@ sysv4 | sysv4.3*) ;; sysv4*MP*) - if test -d /usr/nec ;then + if test -d /usr/nec; then version_type=linux # correct to gnu/linux during the next big refactor - library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' - soname_spec='$libname${shared_ext}.$major' + library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext' + soname_spec='$libname$shared_ext.$major' shlibpath_var=LD_LIBRARY_PATH fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) - version_type=freebsd-elf + version_type=sco need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes - if test "$with_gnu_ld" = yes; then + if test yes = "$with_gnu_ld"; then sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' else sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' @@ -2870,7 +3080,7 @@ tpf*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes @@ -2878,8 +3088,8 @@ tpf*) uts4*) version_type=linux # correct to gnu/linux during the next big refactor - library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' - soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' shlibpath_var=LD_LIBRARY_PATH ;; @@ -2888,20 +3098,30 @@ uts4*) ;; esac AC_MSG_RESULT([$dynamic_linker]) -test "$dynamic_linker" = no && can_build_shared=no +test no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" -if test "$GCC" = yes; then +if test yes = "$GCC"; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi -if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then - sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then + sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec fi -if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then - sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" + +if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then + sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec fi +# remember unaugmented sys_lib_dlsearch_path content for libtool script decls... +configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec + +# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code +func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH" + +# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool +configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH + _LT_DECL([], [variables_saved_for_relink], [1], [Variables whose values should be saved in libtool wrapper scripts and restored at link time]) @@ -2934,39 +3154,41 @@ _LT_DECL([], [hardcode_into_libs], [0], [Whether we should hardcode library paths into libraries]) _LT_DECL([], [sys_lib_search_path_spec], [2], [Compile-time system search path for libraries]) -_LT_DECL([], [sys_lib_dlsearch_path_spec], [2], - [Run-time system search path for libraries]) +_LT_DECL([sys_lib_dlsearch_path_spec], [configure_time_dlsearch_path], [2], + [Detected run-time system search path for libraries]) +_LT_DECL([], [configure_time_lt_sys_library_path], [2], + [Explicit LT_SYS_LIBRARY_PATH set during ./configure time]) ])# _LT_SYS_DYNAMIC_LINKER # _LT_PATH_TOOL_PREFIX(TOOL) # -------------------------- -# find a file program which can recognize shared library +# find a file program that can recognize shared library AC_DEFUN([_LT_PATH_TOOL_PREFIX], [m4_require([_LT_DECL_EGREP])dnl AC_MSG_CHECKING([for $1]) AC_CACHE_VAL(lt_cv_path_MAGIC_CMD, [case $MAGIC_CMD in [[\\/*] | ?:[\\/]*]) - lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path. ;; *) - lt_save_MAGIC_CMD="$MAGIC_CMD" - lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + lt_save_MAGIC_CMD=$MAGIC_CMD + lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR dnl $ac_dummy forces splitting on constant user-supplied paths. dnl POSIX.2 word splitting is done only on the output of word expansions, dnl not every word. This closes a longstanding sh security hole. ac_dummy="m4_if([$2], , $PATH, [$2])" for ac_dir in $ac_dummy; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs test -z "$ac_dir" && ac_dir=. - if test -f $ac_dir/$1; then - lt_cv_path_MAGIC_CMD="$ac_dir/$1" + if test -f "$ac_dir/$1"; then + lt_cv_path_MAGIC_CMD=$ac_dir/"$1" if test -n "$file_magic_test_file"; then case $deplibs_check_method in "file_magic "*) file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` - MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + MAGIC_CMD=$lt_cv_path_MAGIC_CMD if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | $EGREP "$file_magic_regex" > /dev/null; then : @@ -2989,11 +3211,11 @@ _LT_EOF break fi done - IFS="$lt_save_ifs" - MAGIC_CMD="$lt_save_MAGIC_CMD" + IFS=$lt_save_ifs + MAGIC_CMD=$lt_save_MAGIC_CMD ;; esac]) -MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +MAGIC_CMD=$lt_cv_path_MAGIC_CMD if test -n "$MAGIC_CMD"; then AC_MSG_RESULT($MAGIC_CMD) else @@ -3011,7 +3233,7 @@ dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], []) # _LT_PATH_MAGIC # -------------- -# find a file program which can recognize a shared library +# find a file program that can recognize a shared library m4_defun([_LT_PATH_MAGIC], [_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH) if test -z "$lt_cv_path_MAGIC_CMD"; then @@ -3038,16 +3260,16 @@ m4_require([_LT_PROG_ECHO_BACKSLASH])dnl AC_ARG_WITH([gnu-ld], [AS_HELP_STRING([--with-gnu-ld], [assume the C compiler uses GNU ld @<:@default=no@:>@])], - [test "$withval" = no || with_gnu_ld=yes], + [test no = "$withval" || with_gnu_ld=yes], [with_gnu_ld=no])dnl ac_prog=ld -if test "$GCC" = yes; then +if test yes = "$GCC"; then # Check if gcc -print-prog-name=ld gives a path. AC_MSG_CHECKING([for ld used by $CC]) case $host in *-*-mingw*) - # gcc leaves a trailing carriage return which upsets mingw + # gcc leaves a trailing carriage return, which upsets mingw ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; *) ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; @@ -3061,7 +3283,7 @@ if test "$GCC" = yes; then while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` done - test -z "$LD" && LD="$ac_prog" + test -z "$LD" && LD=$ac_prog ;; "") # If it fails, then pretend we aren't using GCC. @@ -3072,37 +3294,37 @@ if test "$GCC" = yes; then with_gnu_ld=unknown ;; esac -elif test "$with_gnu_ld" = yes; then +elif test yes = "$with_gnu_ld"; then AC_MSG_CHECKING([for GNU ld]) else AC_MSG_CHECKING([for non-GNU ld]) fi AC_CACHE_VAL(lt_cv_path_LD, [if test -z "$LD"; then - lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs test -z "$ac_dir" && ac_dir=. if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then - lt_cv_path_LD="$ac_dir/$ac_prog" + lt_cv_path_LD=$ac_dir/$ac_prog # Check to see if the program is GNU ld. I'd rather use --version, # but apparently some variants of GNU ld only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. case `"$lt_cv_path_LD" -v 2>&1 conftest.i +cat conftest.i conftest.i >conftest2.i +: ${lt_DD:=$DD} +AC_PATH_PROGS_FEATURE_CHECK([lt_DD], [dd], +[if "$ac_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then + cmp -s conftest.i conftest.out \ + && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=: +fi]) +rm -f conftest.i conftest2.i conftest.out]) +])# _LT_PATH_DD + + +# _LT_CMD_TRUNCATE +# ---------------- +# find command to truncate a binary pipe +m4_defun([_LT_CMD_TRUNCATE], +[m4_require([_LT_PATH_DD]) +AC_CACHE_CHECK([how to truncate binary pipes], [lt_cv_truncate_bin], +[printf 0123456789abcdef0123456789abcdef >conftest.i +cat conftest.i conftest.i >conftest2.i +lt_cv_truncate_bin= +if "$ac_cv_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then + cmp -s conftest.i conftest.out \ + && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1" +fi +rm -f conftest.i conftest2.i conftest.out +test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"]) +_LT_DECL([lt_truncate_bin], [lt_cv_truncate_bin], [1], + [Command to truncate a binary pipe]) +])# _LT_CMD_TRUNCATE + + # _LT_CHECK_MAGIC_METHOD # ---------------------- # how to check for library dependencies @@ -3188,13 +3447,13 @@ lt_cv_deplibs_check_method='unknown' # Need to set the preceding variable on all platforms that support # interlibrary dependencies. # 'none' -- dependencies not supported. -# `unknown' -- same as none, but documents that we really don't know. +# 'unknown' -- same as none, but documents that we really don't know. # 'pass_all' -- all dependencies passed with no checks. # 'test_compile' -- check by making test program. # 'file_magic [[regex]]' -- check by looking for files in library path -# which responds to the $file_magic_cmd with a given extended regex. -# If you have `file' or equivalent on your system and you're not sure -# whether `pass_all' will *always* work, you probably want this one. +# that responds to the $file_magic_cmd with a given extended regex. +# If you have 'file' or equivalent on your system and you're not sure +# whether 'pass_all' will *always* work, you probably want this one. case $host_os in aix[[4-9]]*) @@ -3221,8 +3480,7 @@ mingw* | pw32*) # Base MSYS/MinGW do not provide the 'file' command needed by # func_win32_libid shell function, so use a weaker test based on 'objdump', # unless we find 'file', for example because we are cross-compiling. - # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin. - if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then + if ( file / ) >/dev/null 2>&1; then lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' lt_cv_file_magic_cmd='func_win32_libid' else @@ -3318,8 +3576,8 @@ newos6*) lt_cv_deplibs_check_method=pass_all ;; -openbsd*) - if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then +openbsd* | bitrig*) + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$' else lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' @@ -3372,6 +3630,9 @@ sysv4 | sysv4.3*) tpf*) lt_cv_deplibs_check_method=pass_all ;; +os2*) + lt_cv_deplibs_check_method=pass_all + ;; esac ]) @@ -3412,33 +3673,38 @@ AC_DEFUN([LT_PATH_NM], AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM, [if test -n "$NM"; then # Let the user override the test. - lt_cv_path_NM="$NM" + lt_cv_path_NM=$NM else - lt_nm_to_check="${ac_tool_prefix}nm" + lt_nm_to_check=${ac_tool_prefix}nm if test -n "$ac_tool_prefix" && test "$build" = "$host"; then lt_nm_to_check="$lt_nm_to_check nm" fi for lt_tmp_nm in $lt_nm_to_check; do - lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs test -z "$ac_dir" && ac_dir=. - tmp_nm="$ac_dir/$lt_tmp_nm" - if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + tmp_nm=$ac_dir/$lt_tmp_nm + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then # Check to see if the nm accepts a BSD-compat flag. - # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # Adding the 'sed 1q' prevents false positives on HP-UX, which says: # nm: unknown option "B" ignored # Tru64's nm complains that /dev/null is an invalid object file - case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in - */dev/null* | *'Invalid file or object type'*) + # MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty + case $build_os in + mingw*) lt_bad_file=conftest.nm/nofile ;; + *) lt_bad_file=/dev/null ;; + esac + case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in + *$lt_bad_file* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" - break + break 2 ;; *) case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in */dev/null*) lt_cv_path_NM="$tmp_nm -p" - break + break 2 ;; *) lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but @@ -3449,21 +3715,21 @@ else esac fi done - IFS="$lt_save_ifs" + IFS=$lt_save_ifs done : ${lt_cv_path_NM=no} fi]) -if test "$lt_cv_path_NM" != "no"; then - NM="$lt_cv_path_NM" +if test no != "$lt_cv_path_NM"; then + NM=$lt_cv_path_NM else # Didn't find any BSD compatible name lister, look for dumpbin. if test -n "$DUMPBIN"; then : # Let the user override the test. else AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :) - case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in + case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in *COFF*) - DUMPBIN="$DUMPBIN -symbols" + DUMPBIN="$DUMPBIN -symbols -headers" ;; *) DUMPBIN=: @@ -3471,8 +3737,8 @@ else esac fi AC_SUBST([DUMPBIN]) - if test "$DUMPBIN" != ":"; then - NM="$DUMPBIN" + if test : != "$DUMPBIN"; then + NM=$DUMPBIN fi fi test -z "$NM" && NM=nm @@ -3518,8 +3784,8 @@ lt_cv_sharedlib_from_linklib_cmd, case $host_os in cygwin* | mingw* | pw32* | cegcc*) - # two different shell functions defined in ltmain.sh - # decide which to use based on capabilities of $DLLTOOL + # two different shell functions defined in ltmain.sh; + # decide which one to use based on capabilities of $DLLTOOL case `$DLLTOOL --help 2>&1` in *--identify-strict*) lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib @@ -3531,7 +3797,7 @@ cygwin* | mingw* | pw32* | cegcc*) ;; *) # fallback: assume linklib IS sharedlib - lt_cv_sharedlib_from_linklib_cmd="$ECHO" + lt_cv_sharedlib_from_linklib_cmd=$ECHO ;; esac ]) @@ -3558,13 +3824,28 @@ AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool lt_cv_path_mainfest_tool=yes fi rm -f conftest*]) -if test "x$lt_cv_path_mainfest_tool" != xyes; then +if test yes != "$lt_cv_path_mainfest_tool"; then MANIFEST_TOOL=: fi _LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl ])# _LT_PATH_MANIFEST_TOOL +# _LT_DLL_DEF_P([FILE]) +# --------------------- +# True iff FILE is a Windows DLL '.def' file. +# Keep in sync with func_dll_def_p in the libtool script +AC_DEFUN([_LT_DLL_DEF_P], +[dnl + test DEF = "`$SED -n dnl + -e '\''s/^[[ ]]*//'\'' dnl Strip leading whitespace + -e '\''/^\(;.*\)*$/d'\'' dnl Delete empty lines and comments + -e '\''s/^\(EXPORTS\|LIBRARY\)\([[ ]].*\)*$/DEF/p'\'' dnl + -e q dnl Only consider the first "real" line + $1`" dnl +])# _LT_DLL_DEF_P + + # LT_LIB_M # -------- # check for math library @@ -3576,11 +3857,11 @@ case $host in # These system don't have libm, or don't need it ;; *-ncr-sysv4.3*) - AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw") + AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM=-lmw) AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm") ;; *) - AC_CHECK_LIB(m, cos, LIBM="-lm") + AC_CHECK_LIB(m, cos, LIBM=-lm) ;; esac AC_SUBST([LIBM]) @@ -3599,7 +3880,7 @@ m4_defun([_LT_COMPILER_NO_RTTI], _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= -if test "$GCC" = yes; then +if test yes = "$GCC"; then case $cc_basename in nvcc*) _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;; @@ -3651,7 +3932,7 @@ cygwin* | mingw* | pw32* | cegcc*) symcode='[[ABCDGISTW]]' ;; hpux*) - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then symcode='[[ABCDEGRST]]' fi ;; @@ -3684,14 +3965,44 @@ case `$NM -V 2>&1` in symcode='[[ABCDGIRSTW]]' ;; esac +if test "$lt_cv_nm_interface" = "MS dumpbin"; then + # Gets list of data symbols to import. + lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'" + # Adjust the below global symbol transforms to fixup imported variables. + lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'" + lt_c_name_hook=" -e 's/^I .* \(.*\)$/ {\"\1\", (void *) 0},/p'" + lt_c_name_lib_hook="\ + -e 's/^I .* \(lib.*\)$/ {\"\1\", (void *) 0},/p'\ + -e 's/^I .* \(.*\)$/ {\"lib\1\", (void *) 0},/p'" +else + # Disable hooks by default. + lt_cv_sys_global_symbol_to_import= + lt_cdecl_hook= + lt_c_name_hook= + lt_c_name_lib_hook= +fi + # Transform an extracted symbol line into a proper C declaration. # Some systems (esp. on ia64) link data and code symbols differently, # so use this general approach. -lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" +lt_cv_sys_global_symbol_to_cdecl="sed -n"\ +$lt_cdecl_hook\ +" -e 's/^T .* \(.*\)$/extern int \1();/p'"\ +" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'" # Transform an extracted symbol line into symbol name and symbol address -lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p'" -lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"lib\2\", (void *) \&\2},/p'" +lt_cv_sys_global_symbol_to_c_name_address="sed -n"\ +$lt_c_name_hook\ +" -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ +" -e 's/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/p'" + +# Transform an extracted symbol line into symbol name with lib prefix and +# symbol address. +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\ +$lt_c_name_lib_hook\ +" -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ +" -e 's/^$symcode$symcode* .* \(lib.*\)$/ {\"\1\", (void *) \&\1},/p'"\ +" -e 's/^$symcode$symcode* .* \(.*\)$/ {\"lib\1\", (void *) \&\1},/p'" # Handle CRLF in mingw tool chain opt_cr= @@ -3709,21 +4020,24 @@ for ac_symprfx in "" "_"; do # Write the raw and C identifiers. if test "$lt_cv_nm_interface" = "MS dumpbin"; then - # Fake it for dumpbin and say T for any non-static function - # and D for any global variable. + # Fake it for dumpbin and say T for any non-static function, + # D for any global variable and I for any imported variable. # Also find C++ and __fastcall symbols from MSVC++, # which start with @ or ?. lt_cv_sys_global_symbol_pipe="$AWK ['"\ " {last_section=section; section=\$ 3};"\ " /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ " /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ +" /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\ +" /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\ +" /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\ " \$ 0!~/External *\|/{next};"\ " / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ " {if(hide[section]) next};"\ -" {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ -" {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ -" s[1]~/^[@?]/{print s[1], s[1]; next};"\ -" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ +" {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\ +" {split(\$ 0,a,/\||\r/); split(a[2],s)};"\ +" s[1]~/^[@?]/{print f,s[1],s[1]; next};"\ +" s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\ " ' prfx=^$ac_symprfx]" else lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]\($symcode$symcode*\)[[ ]][[ ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" @@ -3763,11 +4077,11 @@ _LT_EOF if $GREP ' nm_test_func$' "$nlist" >/dev/null; then cat <<_LT_EOF > conftest.$ac_ext /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ -#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) -/* DATA imports from DLLs on WIN32 con't be const, because runtime +#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE +/* DATA imports from DLLs on WIN32 can't be const, because runtime relocations are performed -- see ld's documentation on pseudo-relocs. */ # define LT@&t@_DLSYM_CONST -#elif defined(__osf__) +#elif defined __osf__ /* This system does not cope well with relocations in const data. */ # define LT@&t@_DLSYM_CONST #else @@ -3793,7 +4107,7 @@ lt__PROGRAM__LTX_preloaded_symbols[[]] = { { "@PROGRAM@", (void *) 0 }, _LT_EOF - $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext + $SED "s/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext cat <<\_LT_EOF >> conftest.$ac_ext {0, (void *) 0} }; @@ -3813,9 +4127,9 @@ _LT_EOF mv conftest.$ac_objext conftstm.$ac_objext lt_globsym_save_LIBS=$LIBS lt_globsym_save_CFLAGS=$CFLAGS - LIBS="conftstm.$ac_objext" + LIBS=conftstm.$ac_objext CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)" - if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then + if AC_TRY_EVAL(ac_link) && test -s conftest$ac_exeext; then pipe_works=yes fi LIBS=$lt_globsym_save_LIBS @@ -3836,7 +4150,7 @@ _LT_EOF rm -rf conftest* conftst* # Do not use the global_symbol_pipe unless it works. - if test "$pipe_works" = yes; then + if test yes = "$pipe_works"; then break else lt_cv_sys_global_symbol_pipe= @@ -3863,12 +4177,16 @@ _LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1], [Take the output of nm and produce a listing of raw symbols and C names]) _LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1], [Transform the output of nm in a proper C declaration]) +_LT_DECL([global_symbol_to_import], [lt_cv_sys_global_symbol_to_import], [1], + [Transform the output of nm into a list of symbols to manually relocate]) _LT_DECL([global_symbol_to_c_name_address], [lt_cv_sys_global_symbol_to_c_name_address], [1], [Transform the output of nm in a C name address pair]) _LT_DECL([global_symbol_to_c_name_address_lib_prefix], [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1], [Transform the output of nm in a C name address pair when lib prefix is needed]) +_LT_DECL([nm_interface], [lt_cv_nm_interface], [1], + [The name lister interface]) _LT_DECL([], [nm_file_list_spec], [1], [Specify filename containing input files for $NM]) ]) # _LT_CMD_GLOBAL_SYMBOLS @@ -3884,17 +4202,18 @@ _LT_TAGVAR(lt_prog_compiler_static, $1)= m4_if([$1], [CXX], [ # C++ specific cases for pic, static, wl, etc. - if test "$GXX" = yes; then + if test yes = "$GXX"; then _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' case $host_os in aix*) # All AIX code is PIC. - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; amigaos*) @@ -3905,8 +4224,8 @@ m4_if([$1], [CXX], [ ;; m68k) # FIXME: we need at least 68020 code to build shared libraries, but - # adding the `-m68020' flag to GCC prevents building anything better, - # like `-m68040'. + # adding the '-m68020' flag to GCC prevents building anything better, + # like '-m68040'. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' ;; esac @@ -3922,6 +4241,11 @@ m4_if([$1], [CXX], [ # (--disable-auto-import) libraries m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + case $host_os in + os2*) + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' + ;; + esac ;; darwin* | rhapsody*) # PIC is the default on this platform @@ -3971,7 +4295,7 @@ m4_if([$1], [CXX], [ case $host_os in aix[[4-9]]*) # All AIX code is PIC. - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' else @@ -4012,14 +4336,14 @@ m4_if([$1], [CXX], [ case $cc_basename in CC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' - _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' - if test "$host_cpu" != ia64; then + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive' + if test ia64 != "$host_cpu"; then _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' fi ;; aCC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' - _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive' case $host_cpu in hppa*64*|ia64*) # +Z the default @@ -4056,7 +4380,7 @@ m4_if([$1], [CXX], [ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; ecpc* ) - # old Intel C++ for x86_64 which still supported -KPIC. + # old Intel C++ for x86_64, which still supported -KPIC. _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' @@ -4201,17 +4525,18 @@ m4_if([$1], [CXX], [ fi ], [ - if test "$GCC" = yes; then + if test yes = "$GCC"; then _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' case $host_os in aix*) # All AIX code is PIC. - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; amigaos*) @@ -4222,8 +4547,8 @@ m4_if([$1], [CXX], [ ;; m68k) # FIXME: we need at least 68020 code to build shared libraries, but - # adding the `-m68020' flag to GCC prevents building anything better, - # like `-m68040'. + # adding the '-m68020' flag to GCC prevents building anything better, + # like '-m68040'. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' ;; esac @@ -4240,6 +4565,11 @@ m4_if([$1], [CXX], [ # (--disable-auto-import) libraries m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + case $host_os in + os2*) + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' + ;; + esac ;; darwin* | rhapsody*) @@ -4310,7 +4640,7 @@ m4_if([$1], [CXX], [ case $host_os in aix*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' else @@ -4318,11 +4648,30 @@ m4_if([$1], [CXX], [ fi ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + case $cc_basename in + nagfor*) + # NAG Fortran compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + esac + ;; + mingw* | cygwin* | pw32* | os2* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + case $host_os in + os2*) + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' + ;; + esac ;; hpux9* | hpux10* | hpux11*) @@ -4338,7 +4687,7 @@ m4_if([$1], [CXX], [ ;; esac # Is there a better lt_prog_compiler_static that works with the bundled CC? - _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive' ;; irix5* | irix6* | nonstopux*) @@ -4349,7 +4698,7 @@ m4_if([$1], [CXX], [ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) case $cc_basename in - # old Intel for x86_64 which still supported -KPIC. + # old Intel for x86_64, which still supported -KPIC. ecc*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' @@ -4374,6 +4723,12 @@ m4_if([$1], [CXX], [ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; + tcc*) + # Fabrice Bellard et al's Tiny C Compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group compilers (*not* the Pentium gcc compiler, # which looks to be a dead project) @@ -4471,7 +4826,7 @@ m4_if([$1], [CXX], [ ;; sysv4*MP*) - if test -d /usr/nec ;then + if test -d /usr/nec; then _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi @@ -4500,7 +4855,7 @@ m4_if([$1], [CXX], [ fi ]) case $host_os in - # For platforms which do not support PIC, -DPIC is meaningless: + # For platforms that do not support PIC, -DPIC is meaningless: *djgpp*) _LT_TAGVAR(lt_prog_compiler_pic, $1)= ;; @@ -4566,17 +4921,21 @@ m4_if([$1], [CXX], [ case $host_os in aix[[4-9]]*) # If we're using GNU nm, then we don't want the "-C" option. - # -C means demangle to AIX nm, but means don't demangle with GNU nm - # Also, AIX nm treats weak defined symbols like other global defined - # symbols, whereas GNU nm marks them as "W". + # -C means demangle to GNU nm, but means don't demangle to AIX nm. + # Without the "-l" option, or with the "-B" option, AIX nm treats + # weak defined symbols like other global defined symbols, whereas + # GNU nm marks them as "W". + # While the 'weak' keyword is ignored in the Export File, we need + # it in the Import File for the 'aix-soname' feature, so we have + # to replace the "-B" option with "-P" for AIX nm. if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then - _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else - _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols' fi ;; pw32*) - _LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds" + _LT_TAGVAR(export_symbols_cmds, $1)=$ltdll_cmds ;; cygwin* | mingw* | cegcc*) case $cc_basename in @@ -4625,9 +4984,9 @@ m4_if([$1], [CXX], [ # included in the symbol list _LT_TAGVAR(include_expsyms, $1)= # exclude_expsyms can be an extended regexp of symbols to exclude - # it will be wrapped by ` (' and `)$', so one must not match beginning or - # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', - # as well as any symbol that contains `d'. + # it will be wrapped by ' (' and ')$', so one must not match beginning or + # end of line. Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc', + # as well as any symbol that contains 'd'. _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out # platforms (ab)use it in PIC code, but their linkers get confused if @@ -4643,7 +5002,7 @@ dnl Note also adjust exclude_expsyms for C++ above. # FIXME: the MSVC++ port hasn't been tested in a loooong time # When not using gcc, we currently assume that we are using # Microsoft Visual C++. - if test "$GCC" != yes; then + if test yes != "$GCC"; then with_gnu_ld=no fi ;; @@ -4651,7 +5010,7 @@ dnl Note also adjust exclude_expsyms for C++ above. # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; - openbsd*) + openbsd* | bitrig*) with_gnu_ld=no ;; linux* | k*bsd*-gnu | gnu*) @@ -4664,7 +5023,7 @@ dnl Note also adjust exclude_expsyms for C++ above. # On some targets, GNU ld is compatible enough with the native linker # that we're better off using the native interface for both. lt_use_gnu_ld_interface=no - if test "$with_gnu_ld" = yes; then + if test yes = "$with_gnu_ld"; then case $host_os in aix*) # The AIX port of GNU ld has always aspired to compatibility @@ -4686,24 +5045,24 @@ dnl Note also adjust exclude_expsyms for C++ above. esac fi - if test "$lt_use_gnu_ld_interface" = yes; then + if test yes = "$lt_use_gnu_ld_interface"; then # If archive_cmds runs LD, not CC, wlarc should be empty - wlarc='${wl}' + wlarc='$wl' # Set some defaults for GNU ld with shared library support. These # are reset later if shared libraries are not supported. Putting them # here allows them to be overridden if necessary. runpath_var=LD_RUN_PATH - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' # ancient GNU ld didn't support --whole-archive et. al. if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then - _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive' else _LT_TAGVAR(whole_archive_flag_spec, $1)= fi supports_anon_versioning=no - case `$LD -v 2>&1` in + case `$LD -v | $SED -e 's/([^)]\+)\s\+//' 2>&1` in *GNU\ gold*) supports_anon_versioning=yes ;; *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11 *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... @@ -4716,7 +5075,7 @@ dnl Note also adjust exclude_expsyms for C++ above. case $host_os in aix[[3-9]]*) # On AIX/PPC, the GNU linker is very broken - if test "$host_cpu" != ia64; then + if test ia64 != "$host_cpu"; then _LT_TAGVAR(ld_shlibs, $1)=no cat <<_LT_EOF 1>&2 @@ -4735,7 +5094,7 @@ _LT_EOF case $host_cpu in powerpc) # see comment about AmigaOS4 .so support - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='' ;; m68k) @@ -4751,7 +5110,7 @@ _LT_EOF _LT_TAGVAR(allow_undefined_flag, $1)=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME - _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi @@ -4761,7 +5120,7 @@ _LT_EOF # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, # as there is no search path for DLLs. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes @@ -4769,61 +5128,89 @@ _LT_EOF _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' - # If the export-symbols file already is a .def file (1st line - # is EXPORTS), use it as is; otherwise, prepend... - _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then - cp $export_symbols $output_objdir/$soname.def; - else - echo EXPORTS > $output_objdir/$soname.def; - cat $export_symbols >> $output_objdir/$soname.def; - fi~ - $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file, use it as + # is; otherwise, prepend EXPORTS... + _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; haiku*) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(link_all_deplibs, $1)=yes ;; + os2*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + shrext_cmds=.dll + _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + prefix_cmds="$SED"~ + if test EXPORTS = "`$SED 1q $export_symbols`"; then + prefix_cmds="$prefix_cmds -e 1d"; + fi~ + prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ + cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + ;; + interix[[3-9]]*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. # Instead, shared libraries are loaded at an image base (0x10000000 by # default) and relocated if they conflict, which is a slow very memory # consuming and fragmenting process. To avoid this, we pick a random, # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link # time. Moving up from 0x10000000 also allows more sbrk(2) space. - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' ;; gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) tmp_diet=no - if test "$host_os" = linux-dietlibc; then + if test linux-dietlibc = "$host_os"; then case $cc_basename in diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) esac fi if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ - && test "$tmp_diet" = no + && test no = "$tmp_diet" then tmp_addflag=' $pic_flag' tmp_sharedflag='-shared' case $cc_basename,$host_cpu in pgcc*) # Portland Group C compiler - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' tmp_addflag=' $pic_flag' ;; pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group f77 and f90 compilers - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' tmp_addflag=' $pic_flag -Mnomain' ;; ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 tmp_addflag=' -i_dynamic' ;; @@ -4834,42 +5221,47 @@ _LT_EOF lf95*) # Lahey Fortran 8.1 _LT_TAGVAR(whole_archive_flag_spec, $1)= tmp_sharedflag='--shared' ;; + nagfor*) # NAGFOR 5.3 + tmp_sharedflag='-Wl,-shared' ;; xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below) tmp_sharedflag='-qmkshrobj' tmp_addflag= ;; nvcc*) # Cuda Compiler Driver 2.2 - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' _LT_TAGVAR(compiler_needs_object, $1)=yes ;; esac case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C 5.9 - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' _LT_TAGVAR(compiler_needs_object, $1)=yes tmp_sharedflag='-G' ;; *Sun\ F*) # Sun Fortran 8.3 tmp_sharedflag='-G' ;; esac - _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' - if test "x$supports_anon_versioning" = xyes; then + if test yes = "$supports_anon_versioning"; then _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ - cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ - echo "local: *; };" >> $output_objdir/$libname.ver~ - $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib' fi case $cc_basename in + tcc*) + _LT_TAGVAR(export_dynamic_flag_spec, $1)='-rdynamic' + ;; xlf* | bgf* | bgxlf* | mpixlf*) # IBM XL Fortran 10.1 on PPC cannot create shared libs itself _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' - if test "x$supports_anon_versioning" = xyes; then + if test yes = "$supports_anon_versioning"; then _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ - cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ - echo "local: *; };" >> $output_objdir/$libname.ver~ - $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' fi ;; esac @@ -4883,8 +5275,8 @@ _LT_EOF _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' wlarc= else - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' fi ;; @@ -4902,8 +5294,8 @@ _LT_EOF _LT_EOF elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi @@ -4915,7 +5307,7 @@ _LT_EOF _LT_TAGVAR(ld_shlibs, $1)=no cat <<_LT_EOF 1>&2 -*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not +*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot *** reliably create shared libraries on SCO systems. Therefore, libtool *** is disabling shared libraries support. We urge you to upgrade GNU *** binutils to release 2.16.91.0.3 or newer. Another option is to modify @@ -4930,9 +5322,9 @@ _LT_EOF # DT_RUNPATH tag from executables and libraries. But doing so # requires that you compile everything twice, which is a pain. if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi @@ -4949,15 +5341,15 @@ _LT_EOF *) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac - if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then + if test no = "$_LT_TAGVAR(ld_shlibs, $1)"; then runpath_var= _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(export_dynamic_flag_spec, $1)= @@ -4973,7 +5365,7 @@ _LT_EOF # Note: this linker hardcodes the directories in LIBPATH if there # are no directories specified by -L. _LT_TAGVAR(hardcode_minus_L, $1)=yes - if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then + if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then # Neither direct hardcoding nor static linking is supported with a # broken collect2. _LT_TAGVAR(hardcode_direct, $1)=unsupported @@ -4981,34 +5373,57 @@ _LT_EOF ;; aix[[4-9]]*) - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # On IA64, the linker does run time linking by default, so we don't # have to do anything special. aix_use_runtimelinking=no exp_sym_flag='-Bexport' - no_entry_flag="" + no_entry_flag= else # If we're using GNU nm, then we don't want the "-C" option. - # -C means demangle to AIX nm, but means don't demangle with GNU nm - # Also, AIX nm treats weak defined symbols like other global - # defined symbols, whereas GNU nm marks them as "W". + # -C means demangle to GNU nm, but means don't demangle to AIX nm. + # Without the "-l" option, or with the "-B" option, AIX nm treats + # weak defined symbols like other global defined symbols, whereas + # GNU nm marks them as "W". + # While the 'weak' keyword is ignored in the Export File, we need + # it in the Import File for the 'aix-soname' feature, so we have + # to replace the "-B" option with "-P" for AIX nm. if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then - _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else - _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols' fi aix_use_runtimelinking=no # Test if we are trying to use run time linking or normal # AIX style linking. If -brtl is somewhere in LDFLAGS, we - # need to do runtime linking. + # have runtime linking enabled, and use it for executables. + # For shared libraries, we enable/disable runtime linking + # depending on the kind of the shared library created - + # when "with_aix_soname,aix_use_runtimelinking" is: + # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables + # "aix,yes" lib.so shared, rtl:yes, for executables + # lib.a static archive + # "both,no" lib.so.V(shr.o) shared, rtl:yes + # lib.a(lib.so.V) shared, rtl:no, for executables + # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables + # lib.a(lib.so.V) shared, rtl:no + # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables + # lib.a static archive case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) for ld_flag in $LDFLAGS; do - if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then aix_use_runtimelinking=yes break fi done + if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then + # With aix-soname=svr4, we create the lib.so.V shared archives only, + # so we don't have lib.a shared libs to link our executables. + # We have to force runtime linking in this case. + aix_use_runtimelinking=yes + LDFLAGS="$LDFLAGS -Wl,-brtl" + fi ;; esac @@ -5027,13 +5442,21 @@ _LT_EOF _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes - _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' + _LT_TAGVAR(file_list_spec, $1)='$wl-f,' + case $with_aix_soname,$aix_use_runtimelinking in + aix,*) ;; # traditional, no import file + svr4,* | *,yes) # use import file + # The Import File defines what to hardcode. + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=no + ;; + esac - if test "$GCC" = yes; then + if test yes = "$GCC"; then case $host_os in aix4.[[012]]|aix4.[[012]].*) # We only want to do this on AIX 4.2 and lower, the check # below for broken collect2 doesn't work under 4.3+ - collect2name=`${CC} -print-prog-name=collect2` + collect2name=`$CC -print-prog-name=collect2` if test -f "$collect2name" && strings "$collect2name" | $GREP resolve_lib_name >/dev/null then @@ -5052,62 +5475,80 @@ _LT_EOF ;; esac shared_flag='-shared' - if test "$aix_use_runtimelinking" = yes; then - shared_flag="$shared_flag "'${wl}-G' + if test yes = "$aix_use_runtimelinking"; then + shared_flag="$shared_flag "'$wl-G' fi - _LT_TAGVAR(link_all_deplibs, $1)=no + # Need to ensure runtime linking is disabled for the traditional + # shared library, or the linker may eventually find shared libraries + # /with/ Import File - we do not want to mix them. + shared_flag_aix='-shared' + shared_flag_svr4='-shared $wl-G' else # not using gcc - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release # chokes on -Wl,-G. The following line is correct: shared_flag='-G' else - if test "$aix_use_runtimelinking" = yes; then - shared_flag='${wl}-G' + if test yes = "$aix_use_runtimelinking"; then + shared_flag='$wl-G' else - shared_flag='${wl}-bM:SRE' + shared_flag='$wl-bM:SRE' fi + shared_flag_aix='$wl-bM:SRE' + shared_flag_svr4='$wl-G' fi fi - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-bexpall' # It seems that -bexpall does not export symbols beginning with # underscore (_), so it is better to generate a list of symbols to export. _LT_TAGVAR(always_export_symbols, $1)=yes - if test "$aix_use_runtimelinking" = yes; then + if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. _LT_TAGVAR(allow_undefined_flag, $1)='-berok' # Determine the default libpath from the value encoded in an # empty executable. _LT_SYS_MODULE_PATH_AIX([$1]) - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath" + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else - if test "$host_cpu" = ia64; then - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' + if test ia64 = "$host_cpu"; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib' _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" - _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols" else # Determine the default libpath from the value encoded in an # empty executable. _LT_SYS_MODULE_PATH_AIX([$1]) - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath" # Warning - without using the other run time loading flags, # -berok will link without error, but may produce a broken library. - _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' - _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' - if test "$with_gnu_ld" = yes; then + _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok' + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok' + if test yes = "$with_gnu_ld"; then # We only use this code for GNU lds that support --whole-archive. - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' fi _LT_TAGVAR(archive_cmds_need_lc, $1)=yes - # This is similar to how AIX traditionally builds its shared libraries. - _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' + # -brtl affects multiple linker settings, -berok does not and is overridden later + compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`' + if test svr4 != "$with_aix_soname"; then + # This is similar to how AIX traditionally builds its shared libraries. + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' + fi + if test aix != "$with_aix_soname"; then + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' + else + # used by -dlpreopen to get the symbols + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV $output_objdir/$realname.d/$soname $output_objdir' + fi + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d' fi fi ;; @@ -5116,7 +5557,7 @@ _LT_EOF case $host_cpu in powerpc) # see comment about AmigaOS4 .so support - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='' ;; m68k) @@ -5146,16 +5587,17 @@ _LT_EOF # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. - shrext_cmds=".dll" + shrext_cmds=.dll # FIXME: Setting linknames here is a bad hack. - _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' - _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then - sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; - else - sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; - fi~ - $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ - linknames=' + _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' + _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then + cp "$export_symbols" "$output_objdir/$soname.def"; + echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; + else + $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' # The linker will not automatically build a static lib if we build a DLL. # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes @@ -5164,18 +5606,18 @@ _LT_EOF # Don't use ranlib _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ - lt_tool_outputfile="@TOOL_OUTPUT@"~ - case $lt_outputfile in - *.exe|*.EXE) ;; - *) - lt_outputfile="$lt_outputfile.exe" - lt_tool_outputfile="$lt_tool_outputfile.exe" - ;; - esac~ - if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then - $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; - $RM "$lt_outputfile.manifest"; - fi' + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile=$lt_outputfile.exe + lt_tool_outputfile=$lt_tool_outputfile.exe + ;; + esac~ + if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' ;; *) # Assume MSVC wrapper @@ -5184,7 +5626,7 @@ _LT_EOF # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. - shrext_cmds=".dll" + shrext_cmds=.dll # FIXME: Setting linknames here is a bad hack. _LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' # The linker will automatically build a .lib file if we build a DLL. @@ -5234,33 +5676,33 @@ _LT_EOF ;; hpux9*) - if test "$GCC" = yes; then - _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + if test yes = "$GCC"; then + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' else - _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' fi - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_direct, $1)=yes # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' ;; hpux10*) - if test "$GCC" = yes && test "$with_gnu_ld" = no; then - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + if test yes,no = "$GCC,$with_gnu_ld"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' fi - if test "$with_gnu_ld" = no; then - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + if test no = "$with_gnu_ld"; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes @@ -5268,25 +5710,25 @@ _LT_EOF ;; hpux11*) - if test "$GCC" = yes && test "$with_gnu_ld" = no; then + if test yes,no = "$GCC,$with_gnu_ld"; then case $host_cpu in hppa*64*) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags' ;; esac else case $host_cpu in hppa*64*) - _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) - _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) m4_if($1, [], [ @@ -5294,14 +5736,14 @@ _LT_EOF # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) _LT_LINKER_OPTION([if $CC understands -b], _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b], - [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'], + [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'], [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])], - [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags']) + [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags']) ;; esac fi - if test "$with_gnu_ld" = no; then - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + if test no = "$with_gnu_ld"; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: case $host_cpu in @@ -5312,7 +5754,7 @@ _LT_EOF *) _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. @@ -5323,16 +5765,16 @@ _LT_EOF ;; irix5* | irix6* | nonstopux*) - if test "$GCC" = yes; then - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + if test yes = "$GCC"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib' # Try to use the -exported_symbol ld option, if it does not # work, assume that -exports_file does not work either and # implicitly export all symbols. # This should be the same for all languages, so no per-tag cache variable. AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol], [lt_cv_irix_exported_symbol], - [save_LDFLAGS="$LDFLAGS" - LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" + [save_LDFLAGS=$LDFLAGS + LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null" AC_LINK_IFELSE( [AC_LANG_SOURCE( [AC_LANG_CASE([C], [[int foo (void) { return 0; }]], @@ -5345,21 +5787,32 @@ _LT_EOF end]])])], [lt_cv_irix_exported_symbol=yes], [lt_cv_irix_exported_symbol=no]) - LDFLAGS="$save_LDFLAGS"]) - if test "$lt_cv_irix_exported_symbol" = yes; then - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' + LDFLAGS=$save_LDFLAGS]) + if test yes = "$lt_cv_irix_exported_symbol"; then + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib' fi + _LT_TAGVAR(link_all_deplibs, $1)=no else - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib' fi _LT_TAGVAR(archive_cmds_need_lc, $1)='no' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(inherit_rpath, $1)=yes _LT_TAGVAR(link_all_deplibs, $1)=yes ;; + linux*) + case $cc_basename in + tcc*) + # Fabrice Bellard et al's Tiny C Compiler + _LT_TAGVAR(ld_shlibs, $1)=yes + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + netbsd* | netbsdelf*-gnu) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out @@ -5374,7 +5827,7 @@ _LT_EOF newsos6) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=yes - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; @@ -5382,27 +5835,19 @@ _LT_EOF *nto* | *qnx*) ;; - openbsd*) + openbsd* | bitrig*) if test -f /usr/libexec/ld.so; then _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=yes - if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' else - case $host_os in - openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*) - _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' - ;; - *) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' - ;; - esac + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' fi else _LT_TAGVAR(ld_shlibs, $1)=no @@ -5413,33 +5858,53 @@ _LT_EOF _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)=unsupported - _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' - _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + shrext_cmds=.dll + _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + prefix_cmds="$SED"~ + if test EXPORTS = "`$SED 1q $export_symbols`"; then + prefix_cmds="$prefix_cmds -e 1d"; + fi~ + prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ + cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes ;; osf3*) - if test "$GCC" = yes; then - _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' - _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + if test yes = "$GCC"; then + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib' else _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' - _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' fi _LT_TAGVAR(archive_cmds_need_lc, $1)='no' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: ;; osf4* | osf5*) # as osf3* with the addition of -msym flag - if test "$GCC" = yes; then - _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' - _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + if test yes = "$GCC"; then + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' else _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' - _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ - $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' + $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp' # Both c and cxx compiler support -rpath directly _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' @@ -5450,24 +5915,24 @@ _LT_EOF solaris*) _LT_TAGVAR(no_undefined_flag, $1)=' -z defs' - if test "$GCC" = yes; then - wlarc='${wl}' - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + if test yes = "$GCC"; then + wlarc='$wl' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ - $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' else case `$CC -V 2>&1` in *"Compilers 5.0"*) wlarc='' - _LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(archive_cmds, $1)='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ - $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' + $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' ;; *) - wlarc='${wl}' - _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' + wlarc='$wl' + _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ - $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' ;; esac fi @@ -5477,11 +5942,11 @@ _LT_EOF solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; *) # The compiler driver will combine and reorder linker options, - # but understands `-z linker_flag'. GCC discards it without `$wl', + # but understands '-z linker_flag'. GCC discards it without '$wl', # but is careful enough not to reorder. # Supported since Solaris 2.6 (maybe 2.5.1?) - if test "$GCC" = yes; then - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + if test yes = "$GCC"; then + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract' else _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' fi @@ -5491,10 +5956,10 @@ _LT_EOF ;; sunos4*) - if test "x$host_vendor" = xsequent; then + if test sequent = "$host_vendor"; then # Use $CC to link under sequent, because it throws in some extra .o # files that make .init and .fini sections work. - _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' fi @@ -5543,43 +6008,43 @@ _LT_EOF ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) - _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var='LD_RUN_PATH' - if test "$GCC" = yes; then - _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + if test yes = "$GCC"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else - _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; sysv5* | sco3.2v5* | sco5v6*) - # Note: We can NOT use -z defs as we might desire, because we do not + # Note: We CANNOT use -z defs as we might desire, because we do not # link with -lc, and that would cause any symbols used from libc to # always be unresolved, which means just about no library would # ever link correctly. If we're not using GNU ld we use -z text # though, which does catch some bad symbols but isn't as heavy-handed # as -z defs. - _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' - _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' + _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' + _LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport' runpath_var='LD_RUN_PATH' - if test "$GCC" = yes; then - _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + if test yes = "$GCC"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else - _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; @@ -5594,17 +6059,17 @@ _LT_EOF ;; esac - if test x$host_vendor = xsni; then + if test sni = "$host_vendor"; then case $host in sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Blargedynsym' ;; esac fi fi ]) AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) -test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no +test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no _LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld @@ -5621,7 +6086,7 @@ x|xyes) # Assume -lc should be added _LT_TAGVAR(archive_cmds_need_lc, $1)=yes - if test "$enable_shared" = yes && test "$GCC" = yes; then + if test yes,yes = "$GCC,$enable_shared"; then case $_LT_TAGVAR(archive_cmds, $1) in *'~'*) # FIXME: we may have to deal with multi-command sequences. @@ -5701,12 +6166,12 @@ _LT_TAGDECL([], [hardcode_libdir_flag_spec], [1], _LT_TAGDECL([], [hardcode_libdir_separator], [1], [Whether we need a single "-rpath" flag with a separated argument]) _LT_TAGDECL([], [hardcode_direct], [0], - [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes + [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes DIR into the resulting binary]) _LT_TAGDECL([], [hardcode_direct_absolute], [0], - [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes + [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes DIR into the resulting binary and the resulting library dependency is - "absolute", i.e impossible to change by setting ${shlibpath_var} if the + "absolute", i.e impossible to change by setting $shlibpath_var if the library is relocated]) _LT_TAGDECL([], [hardcode_minus_L], [0], [Set to "yes" if using the -LDIR flag during linking hardcodes DIR @@ -5747,10 +6212,10 @@ dnl [Compiler flag to generate thread safe objects]) # ------------------------ # Ensure that the configuration variables for a C compiler are suitably # defined. These variables are subsequently used by _LT_CONFIG to write -# the compiler configuration to `libtool'. +# the compiler configuration to 'libtool'. m4_defun([_LT_LANG_C_CONFIG], [m4_require([_LT_DECL_EGREP])dnl -lt_save_CC="$CC" +lt_save_CC=$CC AC_LANG_PUSH(C) # Source file extension for C test sources. @@ -5790,18 +6255,18 @@ if test -n "$compiler"; then LT_SYS_DLOPEN_SELF _LT_CMD_STRIPLIB - # Report which library types will actually be built + # Report what library types will actually be built AC_MSG_CHECKING([if libtool supports shared libraries]) AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) - test "$can_build_shared" = "no" && enable_shared=no + test no = "$can_build_shared" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) - test "$enable_shared" = yes && enable_static=no + test yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' @@ -5809,8 +6274,12 @@ if test -n "$compiler"; then ;; aix[[4-9]]*) - if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then - test "$enable_shared" = yes && enable_static=no + if test ia64 != "$host_cpu"; then + case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in + yes,aix,yes) ;; # shared object as lib.so file only + yes,svr4,*) ;; # shared object as lib.so archive member only + yes,*) enable_static=no ;; # shared object in lib.a archive as well + esac fi ;; esac @@ -5818,13 +6287,13 @@ if test -n "$compiler"; then AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. - test "$enable_shared" = yes || enable_static=yes + test yes = "$enable_shared" || enable_static=yes AC_MSG_RESULT([$enable_static]) _LT_CONFIG($1) fi AC_LANG_POP -CC="$lt_save_CC" +CC=$lt_save_CC ])# _LT_LANG_C_CONFIG @@ -5832,14 +6301,14 @@ CC="$lt_save_CC" # -------------------------- # Ensure that the configuration variables for a C++ compiler are suitably # defined. These variables are subsequently used by _LT_CONFIG to write -# the compiler configuration to `libtool'. +# the compiler configuration to 'libtool'. m4_defun([_LT_LANG_CXX_CONFIG], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_PATH_MANIFEST_TOOL])dnl -if test -n "$CXX" && ( test "X$CXX" != "Xno" && - ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) || - (test "X$CXX" != "Xg++"))) ; then +if test -n "$CXX" && ( test no != "$CXX" && + ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) || + (test g++ != "$CXX"))); then AC_PROG_CXXCPP else _lt_caught_CXX_error=yes @@ -5881,7 +6350,7 @@ _LT_TAGVAR(objext, $1)=$objext # the CXX compiler isn't working. Some variables (like enable_shared) # are currently assumed to apply to all compilers on this platform, # and will be corrupted by setting them based on a non-working compiler. -if test "$_lt_caught_CXX_error" != yes; then +if test yes != "$_lt_caught_CXX_error"; then # Code to be used in simple compile tests lt_simple_compile_test_code="int some_variable = 0;" @@ -5923,35 +6392,35 @@ if test "$_lt_caught_CXX_error" != yes; then if test -n "$compiler"; then # We don't want -fno-exception when compiling C++ code, so set the # no_builtin_flag separately - if test "$GXX" = yes; then + if test yes = "$GXX"; then _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' else _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= fi - if test "$GXX" = yes; then + if test yes = "$GXX"; then # Set up default GNU C++ configuration LT_PATH_LD # Check if GNU C++ uses GNU ld as the underlying linker, since the # archiving commands below assume that GNU ld is being used. - if test "$with_gnu_ld" = yes; then - _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + if test yes = "$with_gnu_ld"; then + _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' # If archive_cmds runs LD, not CC, wlarc should be empty # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to # investigate it a little bit more. (MM) - wlarc='${wl}' + wlarc='$wl' # ancient GNU ld didn't support --whole-archive et. al. if eval "`$CC -print-prog-name=ld` --help 2>&1" | $GREP 'no-whole-archive' > /dev/null; then - _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive' else _LT_TAGVAR(whole_archive_flag_spec, $1)= fi @@ -5987,18 +6456,30 @@ if test "$_lt_caught_CXX_error" != yes; then _LT_TAGVAR(ld_shlibs, $1)=no ;; aix[[4-9]]*) - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # On IA64, the linker does run time linking by default, so we don't # have to do anything special. aix_use_runtimelinking=no exp_sym_flag='-Bexport' - no_entry_flag="" + no_entry_flag= else aix_use_runtimelinking=no # Test if we are trying to use run time linking or normal # AIX style linking. If -brtl is somewhere in LDFLAGS, we - # need to do runtime linking. + # have runtime linking enabled, and use it for executables. + # For shared libraries, we enable/disable runtime linking + # depending on the kind of the shared library created - + # when "with_aix_soname,aix_use_runtimelinking" is: + # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables + # "aix,yes" lib.so shared, rtl:yes, for executables + # lib.a static archive + # "both,no" lib.so.V(shr.o) shared, rtl:yes + # lib.a(lib.so.V) shared, rtl:no, for executables + # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables + # lib.a(lib.so.V) shared, rtl:no + # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables + # lib.a static archive case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) for ld_flag in $LDFLAGS; do case $ld_flag in @@ -6008,6 +6489,13 @@ if test "$_lt_caught_CXX_error" != yes; then ;; esac done + if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then + # With aix-soname=svr4, we create the lib.so.V shared archives only, + # so we don't have lib.a shared libs to link our executables. + # We have to force runtime linking in this case. + aix_use_runtimelinking=yes + LDFLAGS="$LDFLAGS -Wl,-brtl" + fi ;; esac @@ -6026,13 +6514,21 @@ if test "$_lt_caught_CXX_error" != yes; then _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes - _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' + _LT_TAGVAR(file_list_spec, $1)='$wl-f,' + case $with_aix_soname,$aix_use_runtimelinking in + aix,*) ;; # no import file + svr4,* | *,yes) # use import file + # The Import File defines what to hardcode. + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=no + ;; + esac - if test "$GXX" = yes; then + if test yes = "$GXX"; then case $host_os in aix4.[[012]]|aix4.[[012]].*) # We only want to do this on AIX 4.2 and lower, the check # below for broken collect2 doesn't work under 4.3+ - collect2name=`${CC} -print-prog-name=collect2` + collect2name=`$CC -print-prog-name=collect2` if test -f "$collect2name" && strings "$collect2name" | $GREP resolve_lib_name >/dev/null then @@ -6050,64 +6546,84 @@ if test "$_lt_caught_CXX_error" != yes; then fi esac shared_flag='-shared' - if test "$aix_use_runtimelinking" = yes; then - shared_flag="$shared_flag "'${wl}-G' + if test yes = "$aix_use_runtimelinking"; then + shared_flag=$shared_flag' $wl-G' fi + # Need to ensure runtime linking is disabled for the traditional + # shared library, or the linker may eventually find shared libraries + # /with/ Import File - we do not want to mix them. + shared_flag_aix='-shared' + shared_flag_svr4='-shared $wl-G' else # not using gcc - if test "$host_cpu" = ia64; then + if test ia64 = "$host_cpu"; then # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release # chokes on -Wl,-G. The following line is correct: shared_flag='-G' else - if test "$aix_use_runtimelinking" = yes; then - shared_flag='${wl}-G' + if test yes = "$aix_use_runtimelinking"; then + shared_flag='$wl-G' else - shared_flag='${wl}-bM:SRE' + shared_flag='$wl-bM:SRE' fi + shared_flag_aix='$wl-bM:SRE' + shared_flag_svr4='$wl-G' fi fi - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-bexpall' # It seems that -bexpall does not export symbols beginning with # underscore (_), so it is better to generate a list of symbols to # export. _LT_TAGVAR(always_export_symbols, $1)=yes - if test "$aix_use_runtimelinking" = yes; then + if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. - _LT_TAGVAR(allow_undefined_flag, $1)='-berok' + # The "-G" linker flag allows undefined symbols. + _LT_TAGVAR(no_undefined_flag, $1)='-bernotok' # Determine the default libpath from the value encoded in an empty # executable. _LT_SYS_MODULE_PATH_AIX([$1]) - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath" - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else - if test "$host_cpu" = ia64; then - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' + if test ia64 = "$host_cpu"; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib' _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" - _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols" else # Determine the default libpath from the value encoded in an # empty executable. _LT_SYS_MODULE_PATH_AIX([$1]) - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath" # Warning - without using the other run time loading flags, # -berok will link without error, but may produce a broken library. - _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' - _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' - if test "$with_gnu_ld" = yes; then + _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok' + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok' + if test yes = "$with_gnu_ld"; then # We only use this code for GNU lds that support --whole-archive. - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' fi _LT_TAGVAR(archive_cmds_need_lc, $1)=yes - # This is similar to how AIX traditionally builds its shared - # libraries. - _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' + # -brtl affects multiple linker settings, -berok does not and is overridden later + compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`' + if test svr4 != "$with_aix_soname"; then + # This is similar to how AIX traditionally builds its shared + # libraries. Need -bnortl late, we may have -brtl in LDFLAGS. + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' + fi + if test aix != "$with_aix_soname"; then + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' + else + # used by -dlpreopen to get the symbols + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV $output_objdir/$realname.d/$soname $output_objdir' + fi + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d' fi fi ;; @@ -6117,7 +6633,7 @@ if test "$_lt_caught_CXX_error" != yes; then _LT_TAGVAR(allow_undefined_flag, $1)=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME - _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi @@ -6145,57 +6661,58 @@ if test "$_lt_caught_CXX_error" != yes; then # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. - shrext_cmds=".dll" + shrext_cmds=.dll # FIXME: Setting linknames here is a bad hack. - _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' - _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then - $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; - else - $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; - fi~ - $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ - linknames=' + _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' + _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then + cp "$export_symbols" "$output_objdir/$soname.def"; + echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; + else + $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' # The linker will not automatically build a static lib if we build a DLL. # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes # Don't use ranlib _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ - lt_tool_outputfile="@TOOL_OUTPUT@"~ - case $lt_outputfile in - *.exe|*.EXE) ;; - *) - lt_outputfile="$lt_outputfile.exe" - lt_tool_outputfile="$lt_tool_outputfile.exe" - ;; - esac~ - func_to_tool_file "$lt_outputfile"~ - if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then - $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; - $RM "$lt_outputfile.manifest"; - fi' + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile=$lt_outputfile.exe + lt_tool_outputfile=$lt_tool_outputfile.exe + ;; + esac~ + func_to_tool_file "$lt_outputfile"~ + if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' ;; *) # g++ # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, # as there is no search path for DLLs. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then - _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' - # If the export-symbols file already is a .def file (1st line - # is EXPORTS), use it as is; otherwise, prepend... - _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then - cp $export_symbols $output_objdir/$soname.def; - else - echo EXPORTS > $output_objdir/$soname.def; - cat $export_symbols >> $output_objdir/$soname.def; - fi~ - $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file, use it as + # is; otherwise, prepend EXPORTS... + _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi @@ -6206,6 +6723,34 @@ if test "$_lt_caught_CXX_error" != yes; then _LT_DARWIN_LINKER_FEATURES($1) ;; + os2*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + shrext_cmds=.dll + _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + prefix_cmds="$SED"~ + if test EXPORTS = "`$SED 1q $export_symbols`"; then + prefix_cmds="$prefix_cmds -e 1d"; + fi~ + prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ + cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + ;; + dgux*) case $cc_basename in ec++*) @@ -6241,14 +6786,14 @@ if test "$_lt_caught_CXX_error" != yes; then ;; haiku*) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(link_all_deplibs, $1)=yes ;; hpux9*) - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, # but as the default @@ -6260,7 +6805,7 @@ if test "$_lt_caught_CXX_error" != yes; then _LT_TAGVAR(ld_shlibs, $1)=no ;; aCC*) - _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. @@ -6269,11 +6814,11 @@ if test "$_lt_caught_CXX_error" != yes; then # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. - output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) - if test "$GXX" = yes; then - _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + if test yes = "$GXX"; then + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' else # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no @@ -6283,15 +6828,15 @@ if test "$_lt_caught_CXX_error" != yes; then ;; hpux10*|hpux11*) - if test $with_gnu_ld = no; then - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + if test no = "$with_gnu_ld"; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: case $host_cpu in hppa*64*|ia64*) ;; *) - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' ;; esac fi @@ -6317,13 +6862,13 @@ if test "$_lt_caught_CXX_error" != yes; then aCC*) case $host_cpu in hppa*64*) - _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; ia64*) - _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; *) - _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; esac # Commands to make compiler produce verbose output that lists @@ -6334,20 +6879,20 @@ if test "$_lt_caught_CXX_error" != yes; then # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. - output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) - if test "$GXX" = yes; then - if test $with_gnu_ld = no; then + if test yes = "$GXX"; then + if test no = "$with_gnu_ld"; then case $host_cpu in hppa*64*) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; ia64*) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; *) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; esac fi @@ -6362,22 +6907,22 @@ if test "$_lt_caught_CXX_error" != yes; then interix[[3-9]]*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. # Instead, shared libraries are loaded at an image base (0x10000000 by # default) and relocated if they conflict, which is a slow very memory # consuming and fragmenting process. To avoid this, we pick a random, # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link # time. Moving up from 0x10000000 also allows more sbrk(2) space. - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' ;; irix5* | irix6*) case $cc_basename in CC*) # SGI C++ - _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' # Archives containing C++ object files must be created using # "CC -ar", where "CC" is the IRIX C++ compiler. This is @@ -6386,17 +6931,17 @@ if test "$_lt_caught_CXX_error" != yes; then _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs' ;; *) - if test "$GXX" = yes; then - if test "$with_gnu_ld" = no; then - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + if test yes = "$GXX"; then + if test no = "$with_gnu_ld"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib' else - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` -o $lib' fi fi _LT_TAGVAR(link_all_deplibs, $1)=yes ;; esac - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(inherit_rpath, $1)=yes ;; @@ -6409,8 +6954,8 @@ if test "$_lt_caught_CXX_error" != yes; then # KCC will only create a shared library if the output file # ends with ".so" (or ".sl" for HP-UX), so rename the library # to its proper name (with version) after linking. - _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' + _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib $wl-retain-symbols-file,$export_symbols; mv \$templib $lib' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. @@ -6419,10 +6964,10 @@ if test "$_lt_caught_CXX_error" != yes; then # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. - output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' # Archives containing C++ object files must be created using # "CC -Bstatic", where "CC" is the KAI C++ compiler. @@ -6436,59 +6981,59 @@ if test "$_lt_caught_CXX_error" != yes; then # earlier do not add the objects themselves. case `$CC -V 2>&1` in *"Version 7."*) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' ;; *) # Version 8.0 or newer tmp_idyn= case $host_cpu in ia64*) tmp_idyn=' -i_dynamic';; esac - _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' ;; esac _LT_TAGVAR(archive_cmds_need_lc, $1)=no - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive' ;; pgCC* | pgcpp*) # Portland Group C++ compiler case `$CC -V` in *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*) _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~ - rm -rf $tpldir~ - $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ - compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ + compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~ - rm -rf $tpldir~ - $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ - $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ - $RANLIB $oldlib' + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ + $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ + $RANLIB $oldlib' _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~ - rm -rf $tpldir~ - $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ - $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~ - rm -rf $tpldir~ - $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ - $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' ;; *) # Version 6 and above use weak symbols - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' ;; esac - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl--rpath $wl$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' ;; cxx*) # Compaq C++ - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib $wl-retain-symbols-file $wl$export_symbols' runpath_var=LD_RUN_PATH _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' @@ -6502,18 +7047,18 @@ if test "$_lt_caught_CXX_error" != yes; then # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. - output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' ;; xl* | mpixl* | bgxl*) # IBM XL 8.0 on PPC, with GNU ld - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' - _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' - if test "x$supports_anon_versioning" = xyes; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' + _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + if test yes = "$supports_anon_versioning"; then _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ - cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ - echo "local: *; };" >> $output_objdir/$libname.ver~ - $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib' fi ;; *) @@ -6521,10 +7066,10 @@ if test "$_lt_caught_CXX_error" != yes; then *Sun\ C*) # Sun C++ 5.9 _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' - _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols' + _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file $wl$export_symbols' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' _LT_TAGVAR(compiler_needs_object, $1)=yes # Not sure whether something based on @@ -6582,22 +7127,17 @@ if test "$_lt_caught_CXX_error" != yes; then _LT_TAGVAR(ld_shlibs, $1)=yes ;; - openbsd2*) - # C++ shared libraries are fairly broken - _LT_TAGVAR(ld_shlibs, $1)=no - ;; - - openbsd*) + openbsd* | bitrig*) if test -f /usr/libexec/ld.so; then _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' - if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib' - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' - _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`"; then + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file,$export_symbols -o $lib' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' + _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive' fi output_verbose_link_cmd=func_echo_all else @@ -6613,9 +7153,9 @@ if test "$_lt_caught_CXX_error" != yes; then # KCC will only create a shared library if the output file # ends with ".so" (or ".sl" for HP-UX), so rename the library # to its proper name (with version) after linking. - _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Archives containing C++ object files must be created using @@ -6633,17 +7173,17 @@ if test "$_lt_caught_CXX_error" != yes; then cxx*) case $host in osf3*) - _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' - _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $soname `test -n "$verstring" && func_echo_all "$wl-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' ;; *) _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' - _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ - echo "-hidden">> $lib.exp~ - $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~ - $RM $lib.exp' + echo "-hidden">> $lib.exp~ + $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname $wl-input $wl$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~ + $RM $lib.exp' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' ;; esac @@ -6658,21 +7198,21 @@ if test "$_lt_caught_CXX_error" != yes; then # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. - output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) - if test "$GXX" = yes && test "$with_gnu_ld" = no; then - _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + if test yes,no = "$GXX,$with_gnu_ld"; then + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' case $host in osf3*) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib' ;; *) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib' ;; esac - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Commands to make compiler produce verbose output that lists @@ -6718,9 +7258,9 @@ if test "$_lt_caught_CXX_error" != yes; then # Sun C++ 4.2, 5.x and Centerline C++ _LT_TAGVAR(archive_cmds_need_lc,$1)=yes _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' - _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ - $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + $CC -G$allow_undefined_flag $wl-M $wl$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no @@ -6728,7 +7268,7 @@ if test "$_lt_caught_CXX_error" != yes; then solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; *) # The compiler driver will combine and reorder linker options, - # but understands `-z linker_flag'. + # but understands '-z linker_flag'. # Supported since Solaris 2.6 (maybe 2.5.1?) _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;; @@ -6745,30 +7285,30 @@ if test "$_lt_caught_CXX_error" != yes; then ;; gcx*) # Green Hills C++ Compiler - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib' # The C++ compiler must be used to create the archive. _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs' ;; *) # GNU C++ compiler with Solaris linker - if test "$GXX" = yes && test "$with_gnu_ld" = no; then - _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs' + if test yes,no = "$GXX,$with_gnu_ld"; then + _LT_TAGVAR(no_undefined_flag, $1)=' $wl-z ${wl}defs' if $CC --version | $GREP -v '^2\.7' > /dev/null; then - _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ - $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + $CC -shared $pic_flag -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' else - # g++ 2.7 appears to require `-G' NOT `-shared' on this + # g++ 2.7 appears to require '-G' NOT '-shared' on this # platform. - _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ - $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + $CC -G -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when @@ -6776,11 +7316,11 @@ if test "$_lt_caught_CXX_error" != yes; then output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' fi - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $wl$libdir' case $host_os in solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; *) - _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract' ;; esac fi @@ -6789,52 +7329,52 @@ if test "$_lt_caught_CXX_error" != yes; then ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) - _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var='LD_RUN_PATH' case $cc_basename in CC*) - _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; *) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; sysv5* | sco3.2v5* | sco5v6*) - # Note: We can NOT use -z defs as we might desire, because we do not + # Note: We CANNOT use -z defs as we might desire, because we do not # link with -lc, and that would cause any symbols used from libc to # always be unresolved, which means just about no library would # ever link correctly. If we're not using GNU ld we use -z text # though, which does catch some bad symbols but isn't as heavy-handed # as -z defs. - _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' - _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' + _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' + _LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no - _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes - _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport' runpath_var='LD_RUN_PATH' case $cc_basename in CC*) - _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~ - '"$_LT_TAGVAR(old_archive_cmds, $1)" + '"$_LT_TAGVAR(old_archive_cmds, $1)" _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~ - '"$_LT_TAGVAR(reload_cmds, $1)" + '"$_LT_TAGVAR(reload_cmds, $1)" ;; *) - _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' - _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; @@ -6865,10 +7405,10 @@ if test "$_lt_caught_CXX_error" != yes; then esac AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) - test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no + test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no - _LT_TAGVAR(GCC, $1)="$GXX" - _LT_TAGVAR(LD, $1)="$LD" + _LT_TAGVAR(GCC, $1)=$GXX + _LT_TAGVAR(LD, $1)=$LD ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change @@ -6895,7 +7435,7 @@ if test "$_lt_caught_CXX_error" != yes; then lt_cv_path_LD=$lt_save_path_LD lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld -fi # test "$_lt_caught_CXX_error" != yes +fi # test yes != "$_lt_caught_CXX_error" AC_LANG_POP ])# _LT_LANG_CXX_CONFIG @@ -6917,13 +7457,14 @@ AC_REQUIRE([_LT_DECL_SED]) AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH]) func_stripname_cnf () { - case ${2} in - .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; - *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; + case @S|@2 in + .*) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%\\\\@S|@2\$%%"`;; + *) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%@S|@2\$%%"`;; esac } # func_stripname_cnf ])# _LT_FUNC_STRIPNAME_CNF + # _LT_SYS_HIDDEN_LIBDEPS([TAGNAME]) # --------------------------------- # Figure out "hidden" library dependencies from verbose @@ -7007,13 +7548,13 @@ if AC_TRY_EVAL(ac_compile); then pre_test_object_deps_done=no for p in `eval "$output_verbose_link_cmd"`; do - case ${prev}${p} in + case $prev$p in -L* | -R* | -l*) # Some compilers place space between "-{L,R}" and the path. # Remove the space. - if test $p = "-L" || - test $p = "-R"; then + if test x-L = "$p" || + test x-R = "$p"; then prev=$p continue fi @@ -7029,16 +7570,16 @@ if AC_TRY_EVAL(ac_compile); then case $p in =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; esac - if test "$pre_test_object_deps_done" = no; then - case ${prev} in + if test no = "$pre_test_object_deps_done"; then + case $prev in -L | -R) # Internal compiler library paths should come after those # provided the user. The postdeps already come after the # user supplied libs so there is no need to process them. if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then - _LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}" + _LT_TAGVAR(compiler_lib_search_path, $1)=$prev$p else - _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}" + _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} $prev$p" fi ;; # The "-l" case would never come before the object being @@ -7046,9 +7587,9 @@ if AC_TRY_EVAL(ac_compile); then esac else if test -z "$_LT_TAGVAR(postdeps, $1)"; then - _LT_TAGVAR(postdeps, $1)="${prev}${p}" + _LT_TAGVAR(postdeps, $1)=$prev$p else - _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}" + _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} $prev$p" fi fi prev= @@ -7063,15 +7604,15 @@ if AC_TRY_EVAL(ac_compile); then continue fi - if test "$pre_test_object_deps_done" = no; then + if test no = "$pre_test_object_deps_done"; then if test -z "$_LT_TAGVAR(predep_objects, $1)"; then - _LT_TAGVAR(predep_objects, $1)="$p" + _LT_TAGVAR(predep_objects, $1)=$p else _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p" fi else if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then - _LT_TAGVAR(postdep_objects, $1)="$p" + _LT_TAGVAR(postdep_objects, $1)=$p else _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p" fi @@ -7102,51 +7643,6 @@ interix[[3-9]]*) _LT_TAGVAR(postdep_objects,$1)= _LT_TAGVAR(postdeps,$1)= ;; - -linux*) - case `$CC -V 2>&1 | sed 5q` in - *Sun\ C*) - # Sun C++ 5.9 - - # The more standards-conforming stlport4 library is - # incompatible with the Cstd library. Avoid specifying - # it if it's in CXXFLAGS. Ignore libCrun as - # -library=stlport4 depends on it. - case " $CXX $CXXFLAGS " in - *" -library=stlport4 "*) - solaris_use_stlport4=yes - ;; - esac - - if test "$solaris_use_stlport4" != yes; then - _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' - fi - ;; - esac - ;; - -solaris*) - case $cc_basename in - CC* | sunCC*) - # The more standards-conforming stlport4 library is - # incompatible with the Cstd library. Avoid specifying - # it if it's in CXXFLAGS. Ignore libCrun as - # -library=stlport4 depends on it. - case " $CXX $CXXFLAGS " in - *" -library=stlport4 "*) - solaris_use_stlport4=yes - ;; - esac - - # Adding this requires a known-good setup of shared libraries for - # Sun compiler versions before 5.6, else PIC objects from an old - # archive will be linked into the output, leading to subtle bugs. - if test "$solaris_use_stlport4" != yes; then - _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' - fi - ;; - esac - ;; esac ]) @@ -7155,7 +7651,7 @@ case " $_LT_TAGVAR(postdeps, $1) " in esac _LT_TAGVAR(compiler_lib_search_dirs, $1)= if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then - _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'` + _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | $SED -e 's! -L! !g' -e 's!^ !!'` fi _LT_TAGDECL([], [compiler_lib_search_dirs], [1], [The directories searched by this compiler when creating a shared library]) @@ -7175,10 +7671,10 @@ _LT_TAGDECL([], [compiler_lib_search_path], [1], # -------------------------- # Ensure that the configuration variables for a Fortran 77 compiler are # suitably defined. These variables are subsequently used by _LT_CONFIG -# to write the compiler configuration to `libtool'. +# to write the compiler configuration to 'libtool'. m4_defun([_LT_LANG_F77_CONFIG], [AC_LANG_PUSH(Fortran 77) -if test -z "$F77" || test "X$F77" = "Xno"; then +if test -z "$F77" || test no = "$F77"; then _lt_disable_F77=yes fi @@ -7215,7 +7711,7 @@ _LT_TAGVAR(objext, $1)=$objext # the F77 compiler isn't working. Some variables (like enable_shared) # are currently assumed to apply to all compilers on this platform, # and will be corrupted by setting them based on a non-working compiler. -if test "$_lt_disable_F77" != yes; then +if test yes != "$_lt_disable_F77"; then # Code to be used in simple compile tests lt_simple_compile_test_code="\ subroutine t @@ -7237,7 +7733,7 @@ if test "$_lt_disable_F77" != yes; then _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. - lt_save_CC="$CC" + lt_save_CC=$CC lt_save_GCC=$GCC lt_save_CFLAGS=$CFLAGS CC=${F77-"f77"} @@ -7251,21 +7747,25 @@ if test "$_lt_disable_F77" != yes; then AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) - test "$can_build_shared" = "no" && enable_shared=no + test no = "$can_build_shared" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) - test "$enable_shared" = yes && enable_static=no + test yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) - if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then - test "$enable_shared" = yes && enable_static=no + if test ia64 != "$host_cpu"; then + case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in + yes,aix,yes) ;; # shared object as lib.so file only + yes,svr4,*) ;; # shared object as lib.so archive member only + yes,*) enable_static=no ;; # shared object in lib.a archive as well + esac fi ;; esac @@ -7273,11 +7773,11 @@ if test "$_lt_disable_F77" != yes; then AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. - test "$enable_shared" = yes || enable_static=yes + test yes = "$enable_shared" || enable_static=yes AC_MSG_RESULT([$enable_static]) - _LT_TAGVAR(GCC, $1)="$G77" - _LT_TAGVAR(LD, $1)="$LD" + _LT_TAGVAR(GCC, $1)=$G77 + _LT_TAGVAR(LD, $1)=$LD ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change @@ -7294,9 +7794,9 @@ if test "$_lt_disable_F77" != yes; then fi # test -n "$compiler" GCC=$lt_save_GCC - CC="$lt_save_CC" - CFLAGS="$lt_save_CFLAGS" -fi # test "$_lt_disable_F77" != yes + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS +fi # test yes != "$_lt_disable_F77" AC_LANG_POP ])# _LT_LANG_F77_CONFIG @@ -7306,11 +7806,11 @@ AC_LANG_POP # ------------------------- # Ensure that the configuration variables for a Fortran compiler are # suitably defined. These variables are subsequently used by _LT_CONFIG -# to write the compiler configuration to `libtool'. +# to write the compiler configuration to 'libtool'. m4_defun([_LT_LANG_FC_CONFIG], [AC_LANG_PUSH(Fortran) -if test -z "$FC" || test "X$FC" = "Xno"; then +if test -z "$FC" || test no = "$FC"; then _lt_disable_FC=yes fi @@ -7347,7 +7847,7 @@ _LT_TAGVAR(objext, $1)=$objext # the FC compiler isn't working. Some variables (like enable_shared) # are currently assumed to apply to all compilers on this platform, # and will be corrupted by setting them based on a non-working compiler. -if test "$_lt_disable_FC" != yes; then +if test yes != "$_lt_disable_FC"; then # Code to be used in simple compile tests lt_simple_compile_test_code="\ subroutine t @@ -7369,7 +7869,7 @@ if test "$_lt_disable_FC" != yes; then _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. - lt_save_CC="$CC" + lt_save_CC=$CC lt_save_GCC=$GCC lt_save_CFLAGS=$CFLAGS CC=${FC-"f95"} @@ -7385,21 +7885,25 @@ if test "$_lt_disable_FC" != yes; then AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) - test "$can_build_shared" = "no" && enable_shared=no + test no = "$can_build_shared" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) - test "$enable_shared" = yes && enable_static=no + test yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) - if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then - test "$enable_shared" = yes && enable_static=no + if test ia64 != "$host_cpu"; then + case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in + yes,aix,yes) ;; # shared object as lib.so file only + yes,svr4,*) ;; # shared object as lib.so archive member only + yes,*) enable_static=no ;; # shared object in lib.a archive as well + esac fi ;; esac @@ -7407,11 +7911,11 @@ if test "$_lt_disable_FC" != yes; then AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. - test "$enable_shared" = yes || enable_static=yes + test yes = "$enable_shared" || enable_static=yes AC_MSG_RESULT([$enable_static]) - _LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu" - _LT_TAGVAR(LD, $1)="$LD" + _LT_TAGVAR(GCC, $1)=$ac_cv_fc_compiler_gnu + _LT_TAGVAR(LD, $1)=$LD ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change @@ -7431,7 +7935,7 @@ if test "$_lt_disable_FC" != yes; then GCC=$lt_save_GCC CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS -fi # test "$_lt_disable_FC" != yes +fi # test yes != "$_lt_disable_FC" AC_LANG_POP ])# _LT_LANG_FC_CONFIG @@ -7441,7 +7945,7 @@ AC_LANG_POP # -------------------------- # Ensure that the configuration variables for the GNU Java Compiler compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG -# to write the compiler configuration to `libtool'. +# to write the compiler configuration to 'libtool'. m4_defun([_LT_LANG_GCJ_CONFIG], [AC_REQUIRE([LT_PROG_GCJ])dnl AC_LANG_SAVE @@ -7475,7 +7979,7 @@ CC=${GCJ-"gcj"} CFLAGS=$GCJFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC -_LT_TAGVAR(LD, $1)="$LD" +_LT_TAGVAR(LD, $1)=$LD _LT_CC_BASENAME([$compiler]) # GCJ did not exist at the time GCC didn't implicitly link libc in. @@ -7512,7 +8016,7 @@ CFLAGS=$lt_save_CFLAGS # -------------------------- # Ensure that the configuration variables for the GNU Go compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG -# to write the compiler configuration to `libtool'. +# to write the compiler configuration to 'libtool'. m4_defun([_LT_LANG_GO_CONFIG], [AC_REQUIRE([LT_PROG_GO])dnl AC_LANG_SAVE @@ -7546,7 +8050,7 @@ CC=${GOC-"gccgo"} CFLAGS=$GOFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC -_LT_TAGVAR(LD, $1)="$LD" +_LT_TAGVAR(LD, $1)=$LD _LT_CC_BASENAME([$compiler]) # Go did not exist at the time GCC didn't implicitly link libc in. @@ -7583,7 +8087,7 @@ CFLAGS=$lt_save_CFLAGS # ------------------------- # Ensure that the configuration variables for the Windows resource compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG -# to write the compiler configuration to `libtool'. +# to write the compiler configuration to 'libtool'. m4_defun([_LT_LANG_RC_CONFIG], [AC_REQUIRE([LT_PROG_RC])dnl AC_LANG_SAVE @@ -7599,7 +8103,7 @@ _LT_TAGVAR(objext, $1)=$objext lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }' # Code to be used in simple link tests -lt_simple_link_test_code="$lt_simple_compile_test_code" +lt_simple_link_test_code=$lt_simple_compile_test_code # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER @@ -7609,7 +8113,7 @@ _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. -lt_save_CC="$CC" +lt_save_CC=$CC lt_save_CFLAGS=$CFLAGS lt_save_GCC=$GCC GCC= @@ -7638,7 +8142,7 @@ AC_DEFUN([LT_PROG_GCJ], [m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ], [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ], [AC_CHECK_TOOL(GCJ, gcj,) - test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2" + test set = "${GCJFLAGS+set}" || GCJFLAGS="-g -O2" AC_SUBST(GCJFLAGS)])])[]dnl ]) @@ -7749,7 +8253,7 @@ lt_ac_count=0 # Add /usr/xpg4/bin/sed as it is typically found on Solaris # along with /bin/sed that truncates output. for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do - test ! -f $lt_ac_sed && continue + test ! -f "$lt_ac_sed" && continue cat /dev/null > conftest.in lt_ac_count=0 echo $ECHO_N "0123456789$ECHO_C" >conftest.in @@ -7766,9 +8270,9 @@ for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break cmp -s conftest.out conftest.nl || break # 10000 chars as input seems more than enough - test $lt_ac_count -gt 10 && break + test 10 -lt "$lt_ac_count" && break lt_ac_count=`expr $lt_ac_count + 1` - if test $lt_ac_count -gt $lt_ac_max; then + if test "$lt_ac_count" -gt "$lt_ac_max"; then lt_ac_max=$lt_ac_count lt_cv_path_SED=$lt_ac_sed fi @@ -7792,27 +8296,7 @@ dnl AC_DEFUN([LT_AC_PROG_SED], []) # Find out whether the shell is Bourne or XSI compatible, # or has some other useful features. m4_defun([_LT_CHECK_SHELL_FEATURES], -[AC_MSG_CHECKING([whether the shell understands some XSI constructs]) -# Try some XSI features -xsi_shell=no -( _lt_dummy="a/b/c" - test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ - = c,a/b,b/c, \ - && eval 'test $(( 1 + 1 )) -eq 2 \ - && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ - && xsi_shell=yes -AC_MSG_RESULT([$xsi_shell]) -_LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell']) - -AC_MSG_CHECKING([whether the shell understands "+="]) -lt_shell_append=no -( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \ - >/dev/null 2>&1 \ - && lt_shell_append=yes -AC_MSG_RESULT([$lt_shell_append]) -_LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append']) - -if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then +[if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then lt_unset=unset else lt_unset=false @@ -7836,102 +8320,9 @@ _LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl ])# _LT_CHECK_SHELL_FEATURES -# _LT_PROG_FUNCTION_REPLACE (FUNCNAME, REPLACEMENT-BODY) -# ------------------------------------------------------ -# In `$cfgfile', look for function FUNCNAME delimited by `^FUNCNAME ()$' and -# '^} FUNCNAME ', and replace its body with REPLACEMENT-BODY. -m4_defun([_LT_PROG_FUNCTION_REPLACE], -[dnl { -sed -e '/^$1 ()$/,/^} # $1 /c\ -$1 ()\ -{\ -m4_bpatsubsts([$2], [$], [\\], [^\([ ]\)], [\\\1]) -} # Extended-shell $1 implementation' "$cfgfile" > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") -test 0 -eq $? || _lt_function_replace_fail=: -]) - - -# _LT_PROG_REPLACE_SHELLFNS -# ------------------------- -# Replace existing portable implementations of several shell functions with -# equivalent extended shell implementations where those features are available.. -m4_defun([_LT_PROG_REPLACE_SHELLFNS], -[if test x"$xsi_shell" = xyes; then - _LT_PROG_FUNCTION_REPLACE([func_dirname], [dnl - case ${1} in - */*) func_dirname_result="${1%/*}${2}" ;; - * ) func_dirname_result="${3}" ;; - esac]) - - _LT_PROG_FUNCTION_REPLACE([func_basename], [dnl - func_basename_result="${1##*/}"]) - - _LT_PROG_FUNCTION_REPLACE([func_dirname_and_basename], [dnl - case ${1} in - */*) func_dirname_result="${1%/*}${2}" ;; - * ) func_dirname_result="${3}" ;; - esac - func_basename_result="${1##*/}"]) - - _LT_PROG_FUNCTION_REPLACE([func_stripname], [dnl - # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are - # positional parameters, so assign one to ordinary parameter first. - func_stripname_result=${3} - func_stripname_result=${func_stripname_result#"${1}"} - func_stripname_result=${func_stripname_result%"${2}"}]) - - _LT_PROG_FUNCTION_REPLACE([func_split_long_opt], [dnl - func_split_long_opt_name=${1%%=*} - func_split_long_opt_arg=${1#*=}]) - - _LT_PROG_FUNCTION_REPLACE([func_split_short_opt], [dnl - func_split_short_opt_arg=${1#??} - func_split_short_opt_name=${1%"$func_split_short_opt_arg"}]) - - _LT_PROG_FUNCTION_REPLACE([func_lo2o], [dnl - case ${1} in - *.lo) func_lo2o_result=${1%.lo}.${objext} ;; - *) func_lo2o_result=${1} ;; - esac]) - - _LT_PROG_FUNCTION_REPLACE([func_xform], [ func_xform_result=${1%.*}.lo]) - - _LT_PROG_FUNCTION_REPLACE([func_arith], [ func_arith_result=$(( $[*] ))]) - - _LT_PROG_FUNCTION_REPLACE([func_len], [ func_len_result=${#1}]) -fi - -if test x"$lt_shell_append" = xyes; then - _LT_PROG_FUNCTION_REPLACE([func_append], [ eval "${1}+=\\${2}"]) - - _LT_PROG_FUNCTION_REPLACE([func_append_quoted], [dnl - func_quote_for_eval "${2}" -dnl m4 expansion turns \\\\ into \\, and then the shell eval turns that into \ - eval "${1}+=\\\\ \\$func_quote_for_eval_result"]) - - # Save a `func_append' function call where possible by direct use of '+=' - sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") - test 0 -eq $? || _lt_function_replace_fail=: -else - # Save a `func_append' function call even when '+=' is not available - sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ - && mv -f "$cfgfile.tmp" "$cfgfile" \ - || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") - test 0 -eq $? || _lt_function_replace_fail=: -fi - -if test x"$_lt_function_replace_fail" = x":"; then - AC_MSG_WARN([Unable to substitute extended shell functions in $ofile]) -fi -]) - # _LT_PATH_CONVERSION_FUNCTIONS # ----------------------------- -# Determine which file name conversion functions should be used by +# Determine what file name conversion functions should be used by # func_to_host_file (and, implicitly, by func_to_host_path). These are needed # for certain cross-compile configurations and native mingw. m4_defun([_LT_PATH_CONVERSION_FUNCTIONS], diff --git a/dist/libxcb/m4/ltoptions.m4 b/dist/libxcb/m4/ltoptions.m4 index 5d9acd8e2..94b082976 100644 --- a/dist/libxcb/m4/ltoptions.m4 +++ b/dist/libxcb/m4/ltoptions.m4 @@ -1,14 +1,14 @@ # Helper functions for option handling. -*- Autoconf -*- # -# Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, -# Inc. +# Copyright (C) 2004-2005, 2007-2009, 2011-2015 Free Software +# Foundation, Inc. # Written by Gary V. Vaughan, 2004 # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. -# serial 7 ltoptions.m4 +# serial 8 ltoptions.m4 # This is to help aclocal find these macros, as it can't see m4_define. AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])]) @@ -29,7 +29,7 @@ m4_define([_LT_SET_OPTION], [m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]), _LT_MANGLE_DEFUN([$1], [$2]), - [m4_warning([Unknown $1 option `$2'])])[]dnl + [m4_warning([Unknown $1 option '$2'])])[]dnl ]) @@ -75,13 +75,15 @@ m4_if([$1],[LT_INIT],[ dnl dnl If no reference was made to various pairs of opposing options, then dnl we run the default mode handler for the pair. For example, if neither - dnl `shared' nor `disable-shared' was passed, we enable building of shared + dnl 'shared' nor 'disable-shared' was passed, we enable building of shared dnl archives by default: _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED]) _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC]) _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC]) _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install], - [_LT_ENABLE_FAST_INSTALL]) + [_LT_ENABLE_FAST_INSTALL]) + _LT_UNLESS_OPTIONS([LT_INIT], [aix-soname=aix aix-soname=both aix-soname=svr4], + [_LT_WITH_AIX_SONAME([aix])]) ]) ])# _LT_SET_OPTIONS @@ -112,7 +114,7 @@ AU_DEFUN([AC_LIBTOOL_DLOPEN], [_LT_SET_OPTION([LT_INIT], [dlopen]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you -put the `dlopen' option into LT_INIT's first parameter.]) +put the 'dlopen' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: @@ -148,7 +150,7 @@ AU_DEFUN([AC_LIBTOOL_WIN32_DLL], _LT_SET_OPTION([LT_INIT], [win32-dll]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you -put the `win32-dll' option into LT_INIT's first parameter.]) +put the 'win32-dll' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: @@ -157,9 +159,9 @@ dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], []) # _LT_ENABLE_SHARED([DEFAULT]) # ---------------------------- -# implement the --enable-shared flag, and supports the `shared' and -# `disable-shared' LT_INIT options. -# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +# implement the --enable-shared flag, and supports the 'shared' and +# 'disable-shared' LT_INIT options. +# DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'. m4_define([_LT_ENABLE_SHARED], [m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([shared], @@ -172,14 +174,14 @@ AC_ARG_ENABLE([shared], *) enable_shared=no # Look at the argument we got. We use all the common list separators. - lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for pkg in $enableval; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs if test "X$pkg" = "X$p"; then enable_shared=yes fi done - IFS="$lt_save_ifs" + IFS=$lt_save_ifs ;; esac], [enable_shared=]_LT_ENABLE_SHARED_DEFAULT) @@ -211,9 +213,9 @@ dnl AC_DEFUN([AM_DISABLE_SHARED], []) # _LT_ENABLE_STATIC([DEFAULT]) # ---------------------------- -# implement the --enable-static flag, and support the `static' and -# `disable-static' LT_INIT options. -# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +# implement the --enable-static flag, and support the 'static' and +# 'disable-static' LT_INIT options. +# DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'. m4_define([_LT_ENABLE_STATIC], [m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([static], @@ -226,14 +228,14 @@ AC_ARG_ENABLE([static], *) enable_static=no # Look at the argument we got. We use all the common list separators. - lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for pkg in $enableval; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs if test "X$pkg" = "X$p"; then enable_static=yes fi done - IFS="$lt_save_ifs" + IFS=$lt_save_ifs ;; esac], [enable_static=]_LT_ENABLE_STATIC_DEFAULT) @@ -265,9 +267,9 @@ dnl AC_DEFUN([AM_DISABLE_STATIC], []) # _LT_ENABLE_FAST_INSTALL([DEFAULT]) # ---------------------------------- -# implement the --enable-fast-install flag, and support the `fast-install' -# and `disable-fast-install' LT_INIT options. -# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +# implement the --enable-fast-install flag, and support the 'fast-install' +# and 'disable-fast-install' LT_INIT options. +# DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'. m4_define([_LT_ENABLE_FAST_INSTALL], [m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([fast-install], @@ -280,14 +282,14 @@ AC_ARG_ENABLE([fast-install], *) enable_fast_install=no # Look at the argument we got. We use all the common list separators. - lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for pkg in $enableval; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs if test "X$pkg" = "X$p"; then enable_fast_install=yes fi done - IFS="$lt_save_ifs" + IFS=$lt_save_ifs ;; esac], [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT) @@ -304,14 +306,14 @@ AU_DEFUN([AC_ENABLE_FAST_INSTALL], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put -the `fast-install' option into LT_INIT's first parameter.]) +the 'fast-install' option into LT_INIT's first parameter.]) ]) AU_DEFUN([AC_DISABLE_FAST_INSTALL], [_LT_SET_OPTION([LT_INIT], [disable-fast-install]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put -the `disable-fast-install' option into LT_INIT's first parameter.]) +the 'disable-fast-install' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: @@ -319,11 +321,64 @@ dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], []) dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], []) +# _LT_WITH_AIX_SONAME([DEFAULT]) +# ---------------------------------- +# implement the --with-aix-soname flag, and support the `aix-soname=aix' +# and `aix-soname=both' and `aix-soname=svr4' LT_INIT options. DEFAULT +# is either `aix', `both' or `svr4'. If omitted, it defaults to `aix'. +m4_define([_LT_WITH_AIX_SONAME], +[m4_define([_LT_WITH_AIX_SONAME_DEFAULT], [m4_if($1, svr4, svr4, m4_if($1, both, both, aix))])dnl +shared_archive_member_spec= +case $host,$enable_shared in +power*-*-aix[[5-9]]*,yes) + AC_MSG_CHECKING([which variant of shared library versioning to provide]) + AC_ARG_WITH([aix-soname], + [AS_HELP_STRING([--with-aix-soname=aix|svr4|both], + [shared library versioning (aka "SONAME") variant to provide on AIX, @<:@default=]_LT_WITH_AIX_SONAME_DEFAULT[@:>@.])], + [case $withval in + aix|svr4|both) + ;; + *) + AC_MSG_ERROR([Unknown argument to --with-aix-soname]) + ;; + esac + lt_cv_with_aix_soname=$with_aix_soname], + [AC_CACHE_VAL([lt_cv_with_aix_soname], + [lt_cv_with_aix_soname=]_LT_WITH_AIX_SONAME_DEFAULT) + with_aix_soname=$lt_cv_with_aix_soname]) + AC_MSG_RESULT([$with_aix_soname]) + if test aix != "$with_aix_soname"; then + # For the AIX way of multilib, we name the shared archive member + # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o', + # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File. + # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag, + # the AIX toolchain works better with OBJECT_MODE set (default 32). + if test 64 = "${OBJECT_MODE-32}"; then + shared_archive_member_spec=shr_64 + else + shared_archive_member_spec=shr + fi + fi + ;; +*) + with_aix_soname=aix + ;; +esac + +_LT_DECL([], [shared_archive_member_spec], [0], + [Shared archive member basename, for filename based shared library versioning on AIX])dnl +])# _LT_WITH_AIX_SONAME + +LT_OPTION_DEFINE([LT_INIT], [aix-soname=aix], [_LT_WITH_AIX_SONAME([aix])]) +LT_OPTION_DEFINE([LT_INIT], [aix-soname=both], [_LT_WITH_AIX_SONAME([both])]) +LT_OPTION_DEFINE([LT_INIT], [aix-soname=svr4], [_LT_WITH_AIX_SONAME([svr4])]) + + # _LT_WITH_PIC([MODE]) # -------------------- -# implement the --with-pic flag, and support the `pic-only' and `no-pic' +# implement the --with-pic flag, and support the 'pic-only' and 'no-pic' # LT_INIT options. -# MODE is either `yes' or `no'. If omitted, it defaults to `both'. +# MODE is either 'yes' or 'no'. If omitted, it defaults to 'both'. m4_define([_LT_WITH_PIC], [AC_ARG_WITH([pic], [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@], @@ -334,19 +389,17 @@ m4_define([_LT_WITH_PIC], *) pic_mode=default # Look at the argument we got. We use all the common list separators. - lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, for lt_pkg in $withval; do - IFS="$lt_save_ifs" + IFS=$lt_save_ifs if test "X$lt_pkg" = "X$lt_p"; then pic_mode=yes fi done - IFS="$lt_save_ifs" + IFS=$lt_save_ifs ;; esac], - [pic_mode=default]) - -test -z "$pic_mode" && pic_mode=m4_default([$1], [default]) + [pic_mode=m4_default([$1], [default])]) _LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl ])# _LT_WITH_PIC @@ -359,7 +412,7 @@ AU_DEFUN([AC_LIBTOOL_PICMODE], [_LT_SET_OPTION([LT_INIT], [pic-only]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you -put the `pic-only' option into LT_INIT's first parameter.]) +put the 'pic-only' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: diff --git a/dist/libxcb/m4/ltsugar.m4 b/dist/libxcb/m4/ltsugar.m4 index 9000a057d..48bc9344a 100644 --- a/dist/libxcb/m4/ltsugar.m4 +++ b/dist/libxcb/m4/ltsugar.m4 @@ -1,6 +1,7 @@ # ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- # -# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc. +# Copyright (C) 2004-2005, 2007-2008, 2011-2015 Free Software +# Foundation, Inc. # Written by Gary V. Vaughan, 2004 # # This file is free software; the Free Software Foundation gives @@ -33,7 +34,7 @@ m4_define([_lt_join], # ------------ # Manipulate m4 lists. # These macros are necessary as long as will still need to support -# Autoconf-2.59 which quotes differently. +# Autoconf-2.59, which quotes differently. m4_define([lt_car], [[$1]]) m4_define([lt_cdr], [m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], @@ -44,7 +45,7 @@ m4_define([lt_unquote], $1) # lt_append(MACRO-NAME, STRING, [SEPARATOR]) # ------------------------------------------ -# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'. +# Redefine MACRO-NAME to hold its former content plus 'SEPARATOR''STRING'. # Note that neither SEPARATOR nor STRING are expanded; they are appended # to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked). # No SEPARATOR is output if MACRO-NAME was previously undefined (different diff --git a/dist/libxcb/m4/ltversion.m4 b/dist/libxcb/m4/ltversion.m4 index 07a8602d4..fa04b52a3 100644 --- a/dist/libxcb/m4/ltversion.m4 +++ b/dist/libxcb/m4/ltversion.m4 @@ -1,6 +1,6 @@ # ltversion.m4 -- version numbers -*- Autoconf -*- # -# Copyright (C) 2004 Free Software Foundation, Inc. +# Copyright (C) 2004, 2011-2015 Free Software Foundation, Inc. # Written by Scott James Remnant, 2004 # # This file is free software; the Free Software Foundation gives @@ -9,15 +9,15 @@ # @configure_input@ -# serial 3337 ltversion.m4 +# serial 4179 ltversion.m4 # This file is part of GNU Libtool -m4_define([LT_PACKAGE_VERSION], [2.4.2]) -m4_define([LT_PACKAGE_REVISION], [1.3337]) +m4_define([LT_PACKAGE_VERSION], [2.4.6]) +m4_define([LT_PACKAGE_REVISION], [2.4.6]) AC_DEFUN([LTVERSION_VERSION], -[macro_version='2.4.2' -macro_revision='1.3337' +[macro_version='2.4.6' +macro_revision='2.4.6' _LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) _LT_DECL(, macro_revision, 0) ]) diff --git a/dist/libxcb/m4/lt~obsolete.m4 b/dist/libxcb/m4/lt~obsolete.m4 index c573da90c..c6b26f88f 100644 --- a/dist/libxcb/m4/lt~obsolete.m4 +++ b/dist/libxcb/m4/lt~obsolete.m4 @@ -1,6 +1,7 @@ # lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- # -# Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc. +# Copyright (C) 2004-2005, 2007, 2009, 2011-2015 Free Software +# Foundation, Inc. # Written by Scott James Remnant, 2004. # # This file is free software; the Free Software Foundation gives @@ -11,7 +12,7 @@ # These exist entirely to fool aclocal when bootstrapping libtool. # -# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN) +# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN), # which have later been changed to m4_define as they aren't part of the # exported API, or moved to Autoconf or Automake where they belong. # @@ -25,7 +26,7 @@ # included after everything else. This provides aclocal with the # AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything # because those macros already exist, or will be overwritten later. -# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. +# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. # # Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here. # Yes, that means every name once taken will need to remain here until diff --git a/dist/libxcb/m4/xcb.m4 b/dist/libxcb/m4/xcb.m4 index 32e852dd5..a43082a8e 100644 --- a/dist/libxcb/m4/xcb.m4 +++ b/dist/libxcb/m4/xcb.m4 @@ -38,15 +38,32 @@ dnl XCB_EXTENSION(name, default) dnl set the X extension dnl AC_DEFUN([XCB_EXTENSION], -[ +[dnl pushdef([UP], translit([$1], [-a-z], [_A-Z]))dnl pushdef([DOWN], translit([$1], [A-Z], [a-z]))dnl +dnl +m4_if([$2], [yes], [m4_define([xcb_defopt], [yes])], + [$2], [no], [m4_define([xcb_defopt], [no])], + m4_define([xcb_defopt], [auto]))dnl AC_ARG_ENABLE(DOWN, - [AS_HELP_STRING([--enable-[]DOWN], [Build XCB $1 Extension (default: $2)])], + [AS_HELP_STRING([--enable-[]DOWN], + [Build XCB $1 Extension (default: ]xcb_defopt[)])], [BUILD_[]UP=$enableval], - [BUILD_[]UP=$2]) + [BUILD_[]UP=xcb_defopt]) +dnl +m4_if(xcb_defopt, [auto], [ +# This extension has a default value of "auto" and depends on the value of $2 +if test "x$BUILD_[]UP" = "xauto" ; then + BUILD_[]UP=$2 +fi +if test "x$BUILD_[]UP" = "xyes" ; then + if test "x$2" = "xno" ; then + AC_MSG_ERROR([Extension []UP requested, but dependencies are not met]) + fi +fi]) +m4_undefine([xcb_defopt])dnl AM_CONDITIONAL(BUILD_[]UP, [test "x$BUILD_[]UP" = "xyes"]) ]) diff --git a/dist/libxcb/src/Makefile.am b/dist/libxcb/src/Makefile.am index 5a3c52abd..e06e70bc9 100644 --- a/dist/libxcb/src/Makefile.am +++ b/dist/libxcb/src/Makefile.am @@ -248,9 +248,15 @@ libman_DATA = $(BUILT_MAN_PAGES) BUILT_SOURCES = $(EXTSOURCES) $(BUILT_MAN_PAGES) CLEANFILES = $(EXTSOURCES) $(EXTHEADERS) $(BUILT_MAN_PAGES) +C_CLIENT_PY_EXTRA_ARGS = +if XCB_SERVERSIDE_SUPPORT +C_CLIENT_PY_EXTRA_ARGS += --server-side +endif + $(EXTSOURCES): c_client.py $(XCBPROTO_XCBINCLUDEDIR)/$(@:.c=.xml) $(AM_V_GEN)$(PYTHON) $(srcdir)/c_client.py -c "$(PACKAGE_STRING)" -l "$(XORG_MAN_PAGE)" \ -s "$(LIB_MAN_SUFFIX)" -p $(XCBPROTO_XCBPYTHONDIR) \ + $(C_CLIENT_PY_EXTRA_ARGS) \ $(XCBPROTO_XCBINCLUDEDIR)/$(@:.c=.xml) $(BUILT_MAN_PAGES): $(EXTSOURCES) diff --git a/dist/libxcb/src/Makefile.in b/dist/libxcb/src/Makefile.in index f42d05b87..91491d16a 100644 --- a/dist/libxcb/src/Makefile.in +++ b/dist/libxcb/src/Makefile.in @@ -117,6 +117,7 @@ host_triplet = @host@ @BUILD_XV_TRUE@am__append_25 = libxcb-xv.la @BUILD_XVMC_TRUE@am__append_26 = libxcb-xvmc.la @XCB_HAVE_WIN32_TRUE@am__append_27 = xcb_windefs.h +@XCB_SERVERSIDE_SUPPORT_TRUE@am__append_28 = --server-side subdir = src ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \ @@ -538,6 +539,7 @@ LIB_MAN_SUFFIX = @LIB_MAN_SUFFIX@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ +LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ MAKEINFO = @MAKEINFO@ MANIFEST_TOOL = @MANIFEST_TOOL@ MAN_SUBSTS = @MAN_SUBSTS@ @@ -764,6 +766,7 @@ libmandir = $(LIB_MAN_DIR) libman_DATA = $(BUILT_MAN_PAGES) BUILT_SOURCES = $(EXTSOURCES) $(BUILT_MAN_PAGES) CLEANFILES = $(EXTSOURCES) $(EXTHEADERS) $(BUILT_MAN_PAGES) +C_CLIENT_PY_EXTRA_ARGS = $(am__append_28) all: $(BUILT_SOURCES) config.h $(MAKE) $(AM_MAKEFLAGS) all-am @@ -1286,6 +1289,7 @@ uninstall-am: uninstall-libLTLIBRARIES uninstall-libmanDATA \ $(EXTSOURCES): c_client.py $(XCBPROTO_XCBINCLUDEDIR)/$(@:.c=.xml) $(AM_V_GEN)$(PYTHON) $(srcdir)/c_client.py -c "$(PACKAGE_STRING)" -l "$(XORG_MAN_PAGE)" \ -s "$(LIB_MAN_SUFFIX)" -p $(XCBPROTO_XCBPYTHONDIR) \ + $(C_CLIENT_PY_EXTRA_ARGS) \ $(XCBPROTO_XCBINCLUDEDIR)/$(@:.c=.xml) $(BUILT_MAN_PAGES): $(EXTSOURCES) diff --git a/dist/libxcb/src/c_client.py b/dist/libxcb/src/c_client.py index 54e56c42d..57de3fb9d 100644 --- a/dist/libxcb/src/c_client.py +++ b/dist/libxcb/src/c_client.py @@ -1,16 +1,16 @@ #!/usr/bin/env python -from xml.etree.cElementTree import * -from os.path import basename -from functools import reduce +from __future__ import print_function import getopt import os import sys import errno -import time import re # Jump to the bottom of this file for the main routine +#config settings (can be changed with commandline options) +config_server_side = False + # Some hacks to make the API more readable, and to keep backwards compability _cname_re = re.compile('([A-Z0-9][a-z]+|[A-Z0-9]+(?![a-z])|[a-z]+)') _cname_special_cases = {'DECnet':'decnet'} @@ -58,6 +58,107 @@ def _hc(fmt, *args): _h(fmt, *args) _c(fmt, *args) +def _c_wr_stringlist(indent, strlist): + ''' + Writes the given list of strings to the source file. + Each line is prepended by the indent string + ''' + for str in strlist: + _c("%s%s", indent, str) + + +class PreCode(object): + ''' + For pre-code generated by expression generation + (for example, the for-loop of a sumof) + This has to account for recursiveness of the expression + generation, i.e., there may be pre-code for pre-code. + Therefore this is implemented as a stack of lists of lines. + + If redirection is switched on, then all output is collected in + self.redirect_code and self.redirect_tempvars instead of + being sent to the output via _h und _c. + ''' + def __init__(self): + self.nesting_level = 0 + self.tempvars = [] + self.codelines = [] + self.redirect_code = None + self.redirect_tempvars = None + self.indent_str = ' ' + self.indent_stack = [] + self.tempvar_num = 0 + + + # start and end of pre-code blocks + def start(self): + self.nesting_level += 1 + + def end(self): + self.nesting_level -= 1 + if self.nesting_level == 0: + # lowest pre-code level is finished -> output to source + if self.redirect_tempvars is None: + _c_wr_stringlist('', self.tempvars) + self.tempvars = [] + else: + self.redirect_tempvars.extend(self.tempvars) + self.tempvars = [] + if self.redirect_code == None: + _c_wr_stringlist('', self.codelines) + self.codelines = [] + else: + self.redirect_code.extend(self.codelines) + self.codelines = [] + + + def output_tempvars(self): + if self.redirect_code == None: + _c_wr_stringlist('', self.tempvars) + self.tempvars = [] + + # output to precode + def code(self, fmt, *args): + self.codelines.append(self.indent_str + fmt % args) + + def tempvar(self, fmt, *args): + self.tempvars.append(' ' + (fmt % args)) + + # get a unique name for a temporary variable + def get_tempvarname(self): + self.tempvar_num += 1 + return "xcb_pre_tmp_%d" % self.tempvar_num + + # indentation + + def push_indent(self, indentstr): + self.indent_stack.append(self.indent_str) + self.indent_str = indentstr + + def push_addindent(self, indent_add_str): + self.push_indent(self.indent_str + indent_add_str) + + def indent(self): + self.push_addindent(' ') + + def pop_indent(self): + self.indent_str = self.indent_stack.pop() + + # redirection to lists + def redirect_start(self, redirect_code, redirect_tempvars=None): + self.redirect_code = redirect_code + self.redirect_tempvars = redirect_tempvars + if redirect_tempvars is not None: + self.tempvar_num = 0 + + def redirect_end(self): + self.redirect_code = None + self.redirect_tempvars = None + +# global PreCode handler +_c_pre = PreCode() + + # XXX See if this level thing is really necessary. def _h_setlevel(idx): ''' @@ -336,12 +437,6 @@ def _c_type_setup(self, name, postfix): first_field_after_varsized = None for field in self.fields: - _c_type_setup(field.type, field.field_type, ()) - if field.type.is_list: - _c_type_setup(field.type.member, field.field_type, ()) - if (field.type.nmemb is None): - self.c_need_sizeof = True - field.c_field_type = _t(field.field_type) field.c_field_const_type = ('' if field.type.nmemb == 1 else 'const ') + field.c_field_type field.c_field_name = _cpp(field.field_name) @@ -358,7 +453,8 @@ def _c_type_setup(self, name, postfix): field.c_pointer = '*' field.c_field_const_type = 'const ' + field.c_field_type self.c_need_aux = True - elif not field.type.fixed_size() and not field.type.is_bitcase: + + if not field.type.fixed_size() and not field.type.is_case_or_bitcase: self.c_need_sizeof = True field.c_iterator_type = _t(field.field_type + ('iterator',)) # xcb_fieldtype_iterator_t @@ -375,7 +471,8 @@ def _c_type_setup(self, name, postfix): field.first_field_after_varsized = first_field_after_varsized if field.type.fixed_size(): - prev_varsized_offset += field.type.size + if field.wire: + prev_varsized_offset += field.type.size # special case: intermixed fixed and variable size fields if prev_varsized_field is not None and not field.type.is_pad and field.wire: if not self.is_union: @@ -390,6 +487,15 @@ def _c_type_setup(self, name, postfix): if field.type.fixed_size(): field.prev_varsized_field = None + # recurse into this field this has to be done here, i.e., + # after the field has been set up. Otherwise the function + # _c_helper_fieldaccess_expr will produce garbage or crash + _c_type_setup(field.type, field.field_type, ()) + if field.type.is_list: + _c_type_setup(field.type.member, field.field_type, ()) + if (field.type.nmemb is None): + self.c_need_sizeof = True + if self.c_need_serialize: # when _unserialize() is wanted, create _sizeof() as well for consistency reasons self.c_need_sizeof = True @@ -407,7 +513,7 @@ def _c_type_setup(self, name, postfix): # no list with switch as element, so no call to # _c_iterator(field.type, field_name) necessary - if not self.is_bitcase: + if not self.is_case_or_bitcase: if self.c_need_serialize: if self.c_serialize_name not in finished_serializers: finished_serializers.append(self.c_serialize_name) @@ -424,27 +530,66 @@ def _c_type_setup(self, name, postfix): if not module.namespace.is_ext or self.name[:2] == module.namespace.prefix: finished_sizeof.append(self.c_sizeof_name) _c_serialize('sizeof', self) -# _c_type_setup() -def _c_helper_absolute_name(prefix, field=None): +# Functions for querying field properties +def _c_field_needs_list_accessor(field): + return field.type.is_list and not field.type.fixed_size() + +def _c_field_needs_field_accessor(field): + if field.type.is_list: + return False + else: + return (field.prev_varsized_field is not None or + not field.type.fixed_size()) + +def _c_field_needs_accessor(field): + return (_c_field_needs_list_accessor(field) or + _c_field_needs_field_accessor(field)) + +def _c_field_is_member_of_case_or_bitcase(field): + return field.parent and field.parent.is_case_or_bitcase + +def _c_helper_fieldaccess_expr(prefix, field=None): """ turn prefix, which is a list of tuples (name, separator, Type obj) into a string - representing a valid name in C (based on the context) - if field is not None, append the field name as well + representing a valid field-access-expression in C (based on the context) + if field is not None, append access to the field as well. + + "separator" is one of the C-operators "." or "->". + + A field access expression can consist of the following components: + * struct/union member access from a value with the "."-operator + * struct/union member access from a pointer with "->"-operator + * function-call of an accessor function: + This is used when a xcb-field is not contained in a struct. + This can, e.g., happen for fields after var-sized fields, etc. """ prefix_str = '' + last_sep ='' for name, sep, obj in prefix: - prefix_str += name - if '' == sep: - sep = '->' - if ((obj.is_bitcase and obj.has_name) or # named bitcase - (obj.is_switch and len(obj.parents)>1)): - sep = '.' - prefix_str += sep - if field is not None: - prefix_str += _cpp(field.field_name) + prefix_str += last_sep + name + last_sep = sep + + if field is None: + # add separator for access to a yet unknown field + prefix_str += last_sep + else: + if _c_field_needs_accessor(field): + if _c_field_is_member_of_case_or_bitcase(field): + # case members are available in the deserialized struct, + # so there is no need to use the accessor function + # (also, their accessor function needs a different arglist + # so this would require special treatment here) + # Therefore: Access as struct member + prefix_str += last_sep + _cpp(field.field_name) + else: + # Access with the accessor function + prefix_str = field.c_accessor_name + "(" + prefix_str + ")" + else: + # Access as struct member + prefix_str += last_sep + _cpp(field.field_name) + return prefix_str -# _c_absolute_name def _c_helper_field_mapping(complex_type, prefix, flat=False): """ @@ -460,17 +605,17 @@ def _c_helper_field_mapping(complex_type, prefix, flat=False): else: bitcase_prefix = prefix - if (True==flat and not b.type.has_name) or False==flat: + if (flat and not b.type.has_name) or not flat: all_fields.update(_c_helper_field_mapping(b.type, bitcase_prefix, flat)) else: for f in complex_type.fields: - fname = _c_helper_absolute_name(prefix, f) + fname = _c_helper_fieldaccess_expr(prefix, f) if f.field_name in all_fields: raise Exception("field name %s has been registered before" % f.field_name) all_fields[f.field_name] = (fname, f) - if f.type.is_container and flat==False: - if f.type.is_bitcase and not f.type.has_name: + if f.type.is_container and not flat: + if f.type.is_case_or_bitcase and not f.type.has_name: new_prefix = prefix elif f.type.is_switch and len(f.type.parents)>1: # nested switch gets another separator @@ -480,7 +625,6 @@ def _c_helper_field_mapping(complex_type, prefix, flat=False): all_fields.update(_c_helper_field_mapping(f.type, new_prefix, flat)) return all_fields -# _c_field_mapping() def _c_helper_resolve_field_names (prefix): """ @@ -489,26 +633,24 @@ def _c_helper_resolve_field_names (prefix): all_fields = {} tmp_prefix = [] # look for fields in the remaining containers - for idx, p in enumerate(prefix): - name, sep, obj = p + for idx, (name, sep, obj) in enumerate(prefix): if ''==sep: # sep can be preset in prefix, if not, make a sensible guess - sep = '.' if (obj.is_switch or obj.is_bitcase) else '->' + sep = '.' if (obj.is_switch or obj.is_case_or_bitcase) else '->' # exception: 'toplevel' object (switch as well!) always have sep '->' sep = '->' if idx<1 else sep - if not obj.is_bitcase or (obj.is_bitcase and obj.has_name): + if not obj.is_case_or_bitcase or (obj.is_case_or_bitcase and obj.has_name): tmp_prefix.append((name, sep, obj)) all_fields.update(_c_helper_field_mapping(obj, tmp_prefix, flat=True)) return all_fields -# _c_helper_resolve_field_names def get_expr_fields(self): """ get the Fields referenced by switch or list expression """ def get_expr_field_names(expr): - if expr.op is None: + if expr.op is None or expr.op == 'calculate_len': if expr.lenfield_name is not None: return [expr.lenfield_name] else: @@ -546,13 +688,12 @@ def get_expr_fields(self): prefix.append(('', '', self)) all_fields = _c_helper_resolve_field_names (prefix) - resolved_fields_names = list(filter(lambda x: x in all_fields.keys(), unresolved_fields_names)) + resolved_fields_names = [x for x in unresolved_fields_names if x in all_fields] if len(unresolved_fields_names) != len(resolved_fields_names): raise Exception("could not resolve all fields for %s" % self.name) resolved_fields = [all_fields[n][1] for n in resolved_fields_names] return resolved_fields -# get_expr_fields() def resolve_expr_fields(complex_obj): """ @@ -575,7 +716,33 @@ def resolve_expr_fields(complex_obj): if e not in all_fields and e not in unresolved: unresolved.append(e) return unresolved -# resolve_expr_fields() + +def resolve_expr_fields_list(self, parents): + """ + Find expr fields appearing in a list and descendents + that cannot be resolved within the parents of the list. + These are normally fields that need to be given as function parameters + for length and iterator functions. + """ + all_fields = [] + expr_fields = get_expr_fields(self) + unresolved = [] + dont_resolve_this = '' + for complex_obj in parents: + for field in complex_obj.fields: + if field.type.is_list and field.type.expr.op == 'calculate_len': + dont_resolve_this = field.type.expr.lenfield_name + if field.wire: + all_fields.append(field) + + # try to resolve expr fields + for e in expr_fields: + if e not in all_fields and e not in unresolved and e.field_name != dont_resolve_this: + unresolved.append(e) + + return unresolved +# resolve_expr_fields_list() + def get_serialize_params(context, self, buffer_var='_buffer', aux_var='_aux'): """ @@ -611,7 +778,9 @@ def get_serialize_params(context, self, buffer_var='_buffer', aux_var='_aux'): # _serialize()/_unserialize()/_unpack() function parameters # note: don't use set() for params, it is unsorted params = [] - + parameter = '' + if self.is_list: + parameter = self.type.expr.lenfield_name # 1. the parameter for the void * buffer if 'serialize' == context: params.append(('void', '**', buffer_var)) @@ -631,7 +800,7 @@ def get_serialize_params(context, self, buffer_var='_buffer', aux_var='_aux'): pointerspec = p.c_pointer add_param(params, (typespec, pointerspec, p.c_field_name)) else: - if p.visible and not p.wire and not p.auto: + if p.visible and not p.wire and not p.auto and p.field_name != parameter: typespec = p.c_field_type pointerspec = '' add_param(params, (typespec, pointerspec, p.c_field_name)) @@ -654,12 +823,16 @@ def get_serialize_params(context, self, buffer_var='_buffer', aux_var='_aux'): add_param(params, (p.c_field_const_type, '*', p.c_field_name)) return (param_fields, wire_fields, params) -# get_serialize_params() -def _c_serialize_helper_insert_padding(context, code_lines, space, postpone): +def _c_serialize_helper_insert_padding(context, complex_type, code_lines, space, postpone, is_case_or_bitcase): code_lines.append('%s /* insert padding */' % space) - code_lines.append('%s xcb_pad = -xcb_block_len & (xcb_align_to - 1);' % space) -# code_lines.append('%s printf("automatically inserting padding: %%%%d\\n", xcb_pad);' % space) + if is_case_or_bitcase: + code_lines.append( + '%s xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);' + % space) + else: + code_lines.append( + '%s xcb_pad = -xcb_block_len & (xcb_align_to - 1);' % space) code_lines.append('%s xcb_buffer_len += xcb_block_len + xcb_pad;' % space) if not postpone: @@ -676,10 +849,11 @@ def _c_serialize_helper_insert_padding(context, code_lines, space, postpone): code_lines.append('%s }' % space) code_lines.append('%s xcb_block_len = 0;' % space) + if is_case_or_bitcase: + code_lines.append('%s xcb_padding_offset = 0;' % space) # keep tracking of xcb_parts entries for serialize return 1 -# _c_serialize_helper_insert_padding() def _c_serialize_helper_switch(context, self, complex_name, code_lines, temp_vars, @@ -689,18 +863,29 @@ def _c_serialize_helper_switch(context, self, complex_name, for b in self.bitcases: len_expr = len(b.type.expr) + + compare_operator = '&' + if b.type.is_case: + compare_operator = '==' + else: + compare_operator = '&' + for n, expr in enumerate(b.type.expr): bitcase_expr = _c_accessor_get_expr(expr, None) # only one in the if len_expr == 1: - code_lines.append(' if(%s & %s) {' % (switch_expr, bitcase_expr)) + code_lines.append( + ' if(%s %s %s) {' % (switch_expr, compare_operator, bitcase_expr)) # multiple in the elif n == 0: # first - code_lines.append(' if((%s & %s) ||' % (switch_expr, bitcase_expr)) + code_lines.append( + ' if((%s %s %s) ||' % (switch_expr, compare_operator, bitcase_expr)) elif len_expr == (n + 1): # last - code_lines.append(' (%s & %s)) {' % (switch_expr, bitcase_expr)) + code_lines.append( + ' (%s %s %s)) {' % (switch_expr, compare_operator, bitcase_expr)) else: # between first and last - code_lines.append(' (%s & %s) ||' % (switch_expr, bitcase_expr)) + code_lines.append( + ' (%s %s %s) ||' % (switch_expr, compare_operator, bitcase_expr)) b_prefix = prefix if b.type.has_name: @@ -710,27 +895,25 @@ def _c_serialize_helper_switch(context, self, complex_name, code_lines, temp_vars, "%s " % space, b_prefix, - is_bitcase = True) + is_case_or_bitcase = True) code_lines.append(' }') # if 'serialize' == context: -# count += _c_serialize_helper_insert_padding(context, code_lines, space, False) +# count += _c_serialize_helper_insert_padding(context, self, code_lines, space, False) # elif context in ('unserialize', 'unpack', 'sizeof'): # # padding # code_lines.append('%s xcb_pad = -xcb_block_len & 3;' % space) # code_lines.append('%s xcb_buffer_len += xcb_block_len + xcb_pad;' % space) return count -# _c_serialize_helper_switch def _c_serialize_helper_switch_field(context, self, field, c_switch_variable, prefix): """ handle switch by calling _serialize() or _unpack(), depending on context """ # switch is handled by this function as a special case - param_fields, wire_fields, params = get_serialize_params(context, self) field_mapping = _c_helper_field_mapping(self, prefix) - prefix_str = _c_helper_absolute_name(prefix) + prefix_str = _c_helper_fieldaccess_expr(prefix) # find the parameters that need to be passed to _serialize()/_unpack(): # all switch expr fields must be given as parameters @@ -759,9 +942,22 @@ def _c_serialize_helper_switch_field(context, self, field, c_switch_variable, pr elif context in ('unserialize', 'unpack'): length = "%s(xcb_tmp, %s&%s%s)" % (field.type.c_unpack_name, c_field_names, prefix_str, field.c_field_name) + elif 'sizeof' == context: + # remove trailing ", " from c_field_names because it will be used at end of arglist + my_c_field_names = c_field_names[:-2] + length = "%s(xcb_tmp, %s)" % (field.type.c_sizeof_name, my_c_field_names) return length -# _c_serialize_helper_switch_field() + +def _c_get_additional_type_params(type): + """ + compute list of additional params for functions created for the given type + """ + if type.is_simple: + return [] + else: + param_fields, wire_fields, params = get_serialize_params('sizeof', type) + return params[1:] def _c_serialize_helper_list_field(context, self, field, code_lines, temp_vars, @@ -770,13 +966,13 @@ def _c_serialize_helper_list_field(context, self, field, helper function to cope with lists of variable length """ expr = field.type.expr - prefix_str = _c_helper_absolute_name(prefix) + prefix_str = _c_helper_fieldaccess_expr(prefix) param_fields, wire_fields, params = get_serialize_params('sizeof', self) param_names = [p[2] for p in params] expr_fields_names = [f.field_name for f in get_expr_fields(field.type)] - resolved = list(filter(lambda x: x in param_names, expr_fields_names)) - unresolved = list(filter(lambda x: x not in param_names, expr_fields_names)) + resolved = [x for x in expr_fields_names if x in param_names] + unresolved = [x for x in expr_fields_names if x not in param_names] field_mapping = {} for r in resolved: @@ -789,18 +985,28 @@ def _c_serialize_helper_list_field(context, self, field, field.c_field_name) field_mapping.update(_c_helper_resolve_field_names(prefix)) - resolved += list(filter(lambda x: x in field_mapping, unresolved)) - unresolved = list(filter(lambda x: x not in field_mapping, unresolved)) + resolved += [x for x in unresolved if x in field_mapping] + unresolved = [x for x in unresolved if x not in field_mapping] if len(unresolved)>0: raise Exception('could not resolve the length fields required for list %s' % field.c_field_name) - - list_length = _c_accessor_get_expr(expr, field_mapping) + if expr.op == 'calculate_len': + list_length = field.type.expr.lenfield_name + else: + list_length = _c_accessor_get_expr(expr, field_mapping) # default: list with fixed size elements length = '%s * sizeof(%s)' % (list_length, field.type.member.c_wiretype) # list with variable-sized elements if not field.type.member.fixed_size(): + # compute string for argumentlist for member-type functions + member_params = _c_get_additional_type_params(field.type.member) + member_arg_names = [p[2] for p in member_params] + member_arg_str = '' + for member_arg_name in member_arg_names: + member_arg_str += ', ' + field_mapping[member_arg_name][0] + + # length = '' if context in ('unserialize', 'sizeof', 'unpack'): int_i = ' unsigned int i;' @@ -812,8 +1018,8 @@ def _c_serialize_helper_list_field(context, self, field, # loop over all list elements and call sizeof repeatedly # this should be a bit faster than using the iterators code_lines.append("%s for(i=0; i<%s; i++) {" % (space, list_length)) - code_lines.append("%s xcb_tmp_len = %s(xcb_tmp);" % - (space, field.type.c_sizeof_name)) + code_lines.append("%s xcb_tmp_len = %s(xcb_tmp%s);" % + (space, field.type.c_sizeof_name, member_arg_str)) code_lines.append("%s xcb_block_len += xcb_tmp_len;" % space) code_lines.append("%s xcb_tmp += xcb_tmp_len;" % space) code_lines.append("%s }" % space) @@ -822,26 +1028,25 @@ def _c_serialize_helper_list_field(context, self, field, code_lines.append('%s xcb_parts[xcb_parts_idx].iov_len = 0;' % space) code_lines.append('%s xcb_tmp = (char *) %s%s;' % (space, prefix_str, field.c_field_name)) code_lines.append('%s for(i=0; i<%s; i++) { ' % (space, list_length)) - code_lines.append('%s xcb_block_len = %s(xcb_tmp);' % (space, field.type.c_sizeof_name)) + code_lines.append('%s xcb_block_len = %s(xcb_tmp%s);' % (space, field.type.c_sizeof_name, member_arg_str)) code_lines.append('%s xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;' % space) code_lines.append('%s }' % space) code_lines.append('%s xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;' % space) return length -# _c_serialize_helper_list_field() def _c_serialize_helper_fields_fixed_size(context, self, field, code_lines, temp_vars, space, prefix): # keep the C code a bit more readable by giving the field name - if not self.is_bitcase: + if not self.is_case_or_bitcase: code_lines.append('%s /* %s.%s */' % (space, self.c_type, field.c_field_name)) else: - scoped_name = [p[2].c_type if idx==0 else p[0] for idx, p in enumerate(prefix)] - typename = reduce(lambda x,y: "%s.%s" % (x, y), scoped_name) + scoped_name = [obj.c_type if idx==0 else name for idx, (name, _, obj) in enumerate(prefix)] + typename = ".".join(scoped_name) code_lines.append('%s /* %s.%s */' % (space, typename, field.c_field_name)) - abs_field_name = _c_helper_absolute_name(prefix, field) + abs_field_name = _c_helper_fieldaccess_expr(prefix, field) # default for simple cases: call sizeof() length = "sizeof(%s)" % field.c_field_type @@ -858,9 +1063,13 @@ def _c_serialize_helper_fields_fixed_size(context, self, field, # total padding = sizeof(pad0) * nmemb length += " * %d" % field.type.nmemb - if field.type.is_list: - # no such case in the protocol, cannot be tested and therefore ignored for now - raise Exception('list with fixed number of elemens unhandled in _unserialize()') + elif field.type.is_list: + # list with fixed number of elements + # length of array = sizeof(arrayElementType) * nmemb + length += " * %d" % field.type.nmemb + # use memcpy because C cannot assign whole arrays with operator= + value = ' memcpy(%s, xcb_tmp, %s);' % (abs_field_name, length) + elif 'serialize' == context: value = ' xcb_parts[xcb_parts_idx].iov_base = (char *) ' @@ -894,12 +1103,11 @@ def _c_serialize_helper_fields_fixed_size(context, self, field, length = '%d' % field.type.nmemb return (value, length) -# _c_serialize_helper_fields_fixed_size() def _c_serialize_helper_fields_variable_size(context, self, field, code_lines, temp_vars, space, prefix): - prefix_str = _c_helper_absolute_name(prefix) + prefix_str = _c_helper_fieldaccess_expr(prefix) if context in ('unserialize', 'unpack', 'sizeof'): value = '' @@ -947,15 +1155,16 @@ def _c_serialize_helper_fields_variable_size(context, self, field, length = "%s(%s)" % (field.type.c_sizeof_name, var_field_name) return (value, length) -# _c_serialize_helper_fields_variable_size def _c_serialize_helper_fields(context, self, code_lines, temp_vars, - space, prefix, is_bitcase): + space, prefix, is_case_or_bitcase): count = 0 need_padding = False prev_field_was_variable = False + _c_pre.push_indent(space + ' ') + for field in self.fields: if not field.visible: if not ((field.wire and not field.auto) or 'unserialize' == context): @@ -963,10 +1172,10 @@ def _c_serialize_helper_fields(context, self, # switch/bitcase: fixed size fields must be considered explicitly if field.type.fixed_size(): - if self.is_bitcase or self.c_var_followed_by_fixed_fields: + if self.is_case_or_bitcase or self.c_var_followed_by_fixed_fields: if prev_field_was_variable and need_padding: # insert padding -# count += _c_serialize_helper_insert_padding(context, code_lines, space, +# count += _c_serialize_helper_insert_padding(context, self, code_lines, space, # self.c_var_followed_by_fixed_fields) prev_field_was_variable = False @@ -984,14 +1193,16 @@ def _c_serialize_helper_fields(context, self, if field.type.is_pad: # Variable length pad is code_lines.append('%s xcb_align_to = %d;' % (space, field.type.align)) - count += _c_serialize_helper_insert_padding(context, code_lines, space, - self.c_var_followed_by_fixed_fields) + count += _c_serialize_helper_insert_padding(context, self, code_lines, space, + self.c_var_followed_by_fixed_fields, + is_case_or_bitcase) continue else: # switch/bitcase: always calculate padding before and after variable sized fields - if need_padding or is_bitcase: - count += _c_serialize_helper_insert_padding(context, code_lines, space, - self.c_var_followed_by_fixed_fields) + if need_padding or is_case_or_bitcase: + count += _c_serialize_helper_insert_padding(context, self, code_lines, space, + self.c_var_followed_by_fixed_fields, + is_case_or_bitcase) value, length = _c_serialize_helper_fields_variable_size(context, self, field, code_lines, temp_vars, @@ -1003,7 +1214,7 @@ def _c_serialize_helper_fields(context, self, code_lines.append('%s%s' % (space, value)) if field.type.fixed_size(): - if is_bitcase or self.c_var_followed_by_fixed_fields: + if is_case_or_bitcase or self.c_var_followed_by_fixed_fields: # keep track of (un)serialized object's size code_lines.append('%s xcb_block_len += %s;' % (space, length)) if context in ('unserialize', 'unpack', 'sizeof'): @@ -1031,14 +1242,20 @@ def _c_serialize_helper_fields(context, self, code_lines.append('%s xcb_parts_idx++;' % space) count += 1 - code_lines.append('%s xcb_align_to = ALIGNOF(%s);' % (space, 'char' if field.c_field_type == 'void' else field.c_field_type)) + code_lines.append( + '%s xcb_align_to = ALIGNOF(%s);' + % (space, + 'char' + if field.c_field_type == 'void' or field.type.is_switch + else field.c_field_type)) need_padding = True if self.c_var_followed_by_fixed_fields: need_padding = False + _c_pre.pop_indent() + return count -# _c_serialize_helper_fields() def _c_serialize_helper(context, complex_type, code_lines, temp_vars, @@ -1075,10 +1292,9 @@ def _c_serialize_helper(context, complex_type, code_lines, temp_vars, space, prefix, False) # "final padding" - count += _c_serialize_helper_insert_padding(context, code_lines, space, False) + count += _c_serialize_helper_insert_padding(context, complex_type, code_lines, space, False, self.is_switch) return count -# _c_serialize_helper() def _c_serialize(context, self): """ @@ -1112,8 +1328,7 @@ def _c_serialize(context, self): if not field.type.fixed_size() or self.is_switch: variable_size_fields += 1 # determine maxtypelen - for p in params: - maxtypelen = max(maxtypelen, len(p[0]) + len(p[1])) + maxtypelen = max(len(p[0]) + len(p[1]) for p in params) # write to .c/.h indent = ' '*(len(func_name)+2) @@ -1121,10 +1336,10 @@ def _c_serialize(context, self): for p in params: typespec, pointerspec, field_name = p spacing = ' '*(maxtypelen-len(typespec)-len(pointerspec)) - param_str.append("%s%s%s %s%s /**< */" % (indent, typespec, spacing, pointerspec, field_name)) + param_str.append("%s%s%s %s%s" % (indent, typespec, spacing, pointerspec, field_name)) # insert function name param_str[0] = "%s (%s" % (func_name, param_str[0].strip()) - param_str = list(map(lambda x: "%s," % x, param_str)) + param_str = ["%s," % x for x in param_str] for s in param_str[:-1]: _hc(s) _h("%s);" % param_str[-1].rstrip(',')) @@ -1135,6 +1350,8 @@ def _c_serialize(context, self): temp_vars = [] prefix = [] + _c_pre.redirect_start(code_lines, temp_vars) + if 'serialize' == context: if not self.is_switch and not self.c_var_followed_by_fixed_fields: _c(' %s *xcb_out = *_buffer;', self.c_type) @@ -1145,6 +1362,9 @@ def _c_serialize(context, self): _c(' char *xcb_out = *_buffer;') _c(' unsigned int xcb_buffer_len = 0;') _c(' unsigned int xcb_align_to = 0;') + if self.is_switch: + _c(' unsigned int xcb_padding_offset = %d;', + self.get_align_offset() ) prefix = [('_aux', '->', self)] aux_ptr = 'xcb_out' @@ -1168,23 +1388,30 @@ def _c_serialize(context, self): _c(' unsigned int xcb_block_len = 0;') _c(' unsigned int xcb_pad = 0;') _c(' unsigned int xcb_align_to = 0;') + if self.is_switch: + _c(' unsigned int xcb_padding_offset = %d;', + self.get_align_offset() ) elif 'sizeof' == context: param_names = [p[2] for p in params] if self.is_switch: # switch: call _unpack() _c(' %s _aux;', self.c_type) - _c(' return %s(%s, &_aux);', self.c_unpack_name, reduce(lambda x,y: "%s, %s" % (x, y), param_names)) + _c(' return %s(%s, &_aux);', self.c_unpack_name, ", ".join(param_names)) _c('}') + _c_pre.redirect_end() return elif self.c_var_followed_by_fixed_fields: # special case: call _unserialize() - _c(' return %s(%s, NULL);', self.c_unserialize_name, reduce(lambda x,y: "%s, %s" % (x, y), param_names)) + _c(' return %s(%s, NULL);', self.c_unserialize_name, ", ".join(param_names)) _c('}') + _c_pre.redirect_end() return else: _c(' char *xcb_tmp = (char *)_buffer;') prefix = [('_aux', '->', self)] + if self.is_switch: + _c(' unsigned int xcb_padding_offset = 0;') count = _c_serialize_helper(context, self, code_lines, temp_vars, prefix=prefix) # update variable size fields (only important for context=='serialize' @@ -1203,7 +1430,7 @@ def _c_serialize(context, self): if not (self.is_switch or self.c_var_followed_by_fixed_fields): # look if we have to declare an '_aux' variable at all - if len(list(filter(lambda x: x.find('_aux')!=-1, code_lines)))>0: + if any('_aux' in x for x in code_lines): if not self.c_var_followed_by_fixed_fields: _c(' const %s *_aux = (%s *)_buffer;', self.c_type, self.c_type) else: @@ -1214,6 +1441,8 @@ def _c_serialize(context, self): _c(' unsigned int xcb_pad = 0;') _c(' unsigned int xcb_align_to = 0;') + _c_pre.redirect_end() + _c('') for t in temp_vars: _c(t) @@ -1275,7 +1504,6 @@ def _c_serialize(context, self): _c('') _c(' return xcb_buffer_len;') _c('}') -# _c_serialize() def _c_iterator_get_end(field, accum): ''' @@ -1303,9 +1531,17 @@ def _c_iterator(self, name): _h(' * @brief %s', self.c_iterator_type) _h(' **/') _h('typedef struct %s {', self.c_iterator_type) - _h(' %s *data; /**< */', self.c_type) - _h(' int%s rem; /**< */', ' ' * (len(self.c_type) - 2)) - _h(' int%s index; /**< */', ' ' * (len(self.c_type) - 2)) + _h(' %s *data;', self.c_type) + _h(' int%s rem;', ' ' * (len(self.c_type) - 2)) + _h(' int%s index;', ' ' * (len(self.c_type) - 2)) + # add additional params of the type "self" as fields to the iterator struct + # so that they can be passed to the sizeof-function by the iterator's next-function + params = _c_get_additional_type_params(self) + for param in params: + _h(' %s%s %s; /**< */', + param[0], + ' ' * (len(self.c_type) + 1 - len(param[0])), + param[2]) _h('} %s;', self.c_iterator_type) _h_setlevel(1) @@ -1321,8 +1557,8 @@ def _c_iterator(self, name): _h(' */') _c('') _hc('void') - _h('%s (%s *i /**< */);', self.c_next_name, self.c_iterator_type) - _c('%s (%s *i /**< */)', self.c_next_name, self.c_iterator_type) + _h('%s (%s *i);', self.c_next_name, self.c_iterator_type) + _c('%s (%s *i)', self.c_next_name, self.c_iterator_type) _c('{') if not self.fixed_size(): @@ -1333,9 +1569,14 @@ def _c_iterator(self, name): _c(' /* FIXME - determine the size of the union %s */', self.c_type) else: if self.c_need_sizeof: + # compute the string of additional arguments for the sizeof-function + additional_args = '' + for param in params: + additional_args += ', i->' + param[2] + _c(' xcb_generic_iterator_t child;') - _c(' child.data = (%s *)(((char *)R) + %s(R));', - self.c_type, self.c_sizeof_name) + _c(' child.data = (%s *)(((char *)R) + %s(R%s));', + self.c_type, self.c_sizeof_name, additional_args) _c(' i->index = (char *) child.data - (char *) i->data;') else: _c(' xcb_generic_iterator_t child = %s;', _c_iterator_get_end(self.last_varsized_field, 'R')) @@ -1362,8 +1603,8 @@ def _c_iterator(self, name): _h(' */') _c('') _hc('xcb_generic_iterator_t') - _h('%s (%s i /**< */);', self.c_end_name, self.c_iterator_type) - _c('%s (%s i /**< */)', self.c_end_name, self.c_iterator_type) + _h('%s (%s i);', self.c_end_name, self.c_iterator_type) + _c('%s (%s i)', self.c_end_name, self.c_iterator_type) _c('{') _c(' xcb_generic_iterator_t ret;') @@ -1394,12 +1635,7 @@ def _c_accessor_get_length(expr, field_mapping=None): if field_mapping is not None: lenfield_name = field_mapping[lenfield_name][0] - if expr.lenfield is not None and expr.lenfield.prev_varsized_field is not None: - # special case: variable and fixed size fields are intermixed - # if the lenfield is among the fixed size fields, there is no need - # to call a special accessor function like - return field_mapping(expr.lenfield_name) - elif expr.lenfield_name is not None: + if expr.lenfield_name is not None: return lenfield_name else: return str(expr.nmemb) @@ -1425,7 +1661,6 @@ def _c_accessor_get_expr(expr, field_mapping): return c_name elif expr.op == 'sumof': # locate the referenced list object - list_obj = expr.lenfield_type field = None for f in expr.lenfield_parent.fields: if f.field_name == expr.lenfield_name: @@ -1436,10 +1671,66 @@ def _c_accessor_get_expr(expr, field_mapping): raise Exception("list field '%s' referenced by sumof not found" % expr.lenfield_name) list_name = field_mapping[field.c_field_name][0] c_length_func = "%s(%s)" % (field.c_length_name, list_name) - # note: xcb_sumof() has only been defined for integers c_length_func = _c_accessor_get_expr(field.type.expr, field_mapping) - return 'xcb_sumof(%s, %s)' % (list_name, c_length_func) - elif expr.op != None: + # create explicit code for computing the sum. + # This works for all C-types which can be added to int64_t with += + _c_pre.start() + lengthvar = _c_pre.get_tempvarname() + loopvar = _c_pre.get_tempvarname() + sumvar = _c_pre.get_tempvarname() + listvar = _c_pre.get_tempvarname() + _c_pre.tempvar("int %s; /* sumof length */", lengthvar) + _c_pre.tempvar("int %s; /* sumof loop counter */", loopvar) + _c_pre.tempvar("int64_t %s; /* sumof sum */", sumvar) + _c_pre.tempvar("const %s* %s; /* sumof list ptr */", field.c_field_type, listvar) + _c_pre.code("/* sumof start */") + _c_pre.code("%s = %s;", lengthvar, c_length_func) + _c_pre.code("%s = 0;", sumvar) + _c_pre.code("%s = %s;", listvar, list_name) + _c_pre.code("for (%s = 0; %s < %s; %s++) {", loopvar, loopvar, lengthvar, loopvar) + _c_pre.indent() + + # define and set xcb_listelement, so that it can be used by + # listelement-ref expressions. + if expr.contains_listelement_ref: + _c_pre.code( + "const %s *xcb_listelement = %s;", + field.c_field_type, listvar) + + # summation + if expr.rhs is None: + _c_pre.code("%s += *%s;", sumvar, listvar) + else: + # sumof has a nested expression which has to be evaluated in + # the context of this list element + + # field mapping for the subexpression needs to include + # the fields of the list-member type + scoped_field_mapping = field_mapping.copy() + if not field.type.member.is_simple: + scoped_field_mapping.update( + _c_helper_field_mapping( + field.type.member, + [(listvar, '->', field.type.member)])) + + # cause pre-code of the subexpression be added right here + _c_pre.end() + # compute the subexpression + rhs_expr_str = _c_accessor_get_expr(expr.rhs, scoped_field_mapping) + # resume with our code + _c_pre.start() + # output the summation expression + _c_pre.code("%s += %s;", sumvar, rhs_expr_str) + + _c_pre.code("%s++;", listvar) + _c_pre.pop_indent() + _c_pre.code("}") + _c_pre.code("/* sumof end. Result is in %s */", sumvar) + _c_pre.end() + return sumvar + elif expr.op == 'listelement-ref': + return '(*xcb_listelement)' + elif expr.op != None and expr.op != 'calculate_len': return ('(' + _c_accessor_get_expr(expr.lhs, field_mapping) + ' ' + expr.op + ' ' + _c_accessor_get_expr(expr.rhs, field_mapping) + ')') @@ -1461,7 +1752,7 @@ def _c_accessors_field(self, field): # special case: switch switch_obj = self if self.is_switch else None - if self.is_bitcase: + if self.is_case_or_bitcase: switch_obj = self.parents[-1] if switch_obj is not None: c_type = switch_obj.c_type @@ -1469,8 +1760,8 @@ def _c_accessors_field(self, field): if field.type.is_simple: _hc('') _hc('%s', field.c_field_type) - _h('%s (const %s *R /**< */);', field.c_accessor_name, c_type) - _c('%s (const %s *R /**< */)', field.c_accessor_name, c_type) + _h('%s (const %s *R);', field.c_accessor_name, c_type) + _c('%s (const %s *R)', field.c_accessor_name, c_type) _c('{') if field.prev_varsized_field is None: _c(' return (%s *) (R + 1);', field.c_field_type) @@ -1487,8 +1778,8 @@ def _c_accessors_field(self, field): return_type = '%s *' % field.c_field_type _hc(return_type) - _h('%s (const %s *R /**< */);', field.c_accessor_name, c_type) - _c('%s (const %s *R /**< */)', field.c_accessor_name, c_type) + _h('%s (const %s *R);', field.c_accessor_name, c_type) + _c('%s (const %s *R)', field.c_accessor_name, c_type) _c('{') if field.prev_varsized_field is None: _c(' return (%s) (R + 1);', return_type) @@ -1510,14 +1801,13 @@ def _c_accessors_list(self, field): ''' def get_align_pad(field): - prev = field.prev_varsized_field - prev_prev = field.prev_varsized_field.prev_varsized_field - - if (prev.type.is_pad and prev.type.align > 0 and prev_prev is not None): - return (prev_prev, '((-prev.index) & (%d - 1))' % prev.type.align) - else: - return (prev, None) + prev = field.prev_varsized_field + prev_prev = field.prev_varsized_field.prev_varsized_field + if prev.type.is_pad and prev.type.align > 0 and prev_prev is not None: + return (prev_prev, '((-prev.index) & (%d - 1))' % prev.type.align) + else: + return (prev, None) list = field.type c_type = self.c_type @@ -1529,7 +1819,7 @@ def _c_accessors_list(self, field): # the reason is that switch is either a child of a request/reply or nested in another switch, # so whenever we need to access a length field, we might need to refer to some anchestor type switch_obj = self if self.is_switch else None - if self.is_bitcase: + if self.is_case_or_bitcase: switch_obj = self.parents[-1] if switch_obj is not None: c_type = switch_obj.c_type @@ -1554,20 +1844,42 @@ def _c_accessors_list(self, field): fields.update(_c_helper_field_mapping(toplevel_switch, [('S', '->', toplevel_switch)], flat=True)) # initialize prefix for everything "below" S - prefix_str = '/* %s */ S' % toplevel_switch.name[-1] - prefix = [(prefix_str, '->', toplevel_switch)] + prefix = [('S', '->', toplevel_switch)] # look for fields in the remaining containers for p in parents[2:] + [self]: # the separator between parent and child is always '.' here, # because of nested switch statements - if not p.is_bitcase or (p.is_bitcase and p.has_name): + if not p.is_case_or_bitcase or (p.is_case_or_bitcase and p.has_name): prefix.append((p.name[-1], '.', p)) fields.update(_c_helper_field_mapping(p, prefix, flat=True)) # auxiliary object for 'S' parameter S_obj = parents[1] + # for functions generated below: + # * compute list of additional parameters which contains as parameter + # any expr fields that cannot be resolved within self and descendants. + # * and make sure that they are accessed without prefix within the function. + unresolved_fields = resolve_expr_fields_list(list, parents) + additional_params = [] + additional_param_names = set(); + for f in unresolved_fields: + if f.c_field_name not in additional_param_names: + # add to the list of additional params + additional_params.append((f.c_field_type, f.c_field_name)); + # make sure that the param is accessed without prefix within the function + fields[ f.c_field_name ] = (f.c_field_name, f) + + # internal function to compute the parameterlist with given indentation + # such that the formatting of the additional parameters is consistent with + # the other parameters. + def additional_params_to_str(indent): + if len(additional_params) == 0: + return '' + else: + return (',\n' + indent).join([''] + ['%s %s' % p for p in additional_params]) + _h_setlevel(1) _c_setlevel(1) if list.member.fixed_size(): @@ -1575,8 +1887,8 @@ def _c_accessors_list(self, field): _hc('') _hc('%s *', field.c_field_type) - _h('%s (%s /**< */);', field.c_accessor_name, params[idx][0]) - _c('%s (%s /**< */)', field.c_accessor_name, params[idx][0]) + _h('%s (%s);', field.c_accessor_name, params[idx][0]) + _c('%s (%s)', field.c_accessor_name, params[idx][0]) _c('{') if switch_obj is not None: @@ -1598,46 +1910,80 @@ def _c_accessors_list(self, field): _hc('') _hc('int') + spacing = ' '*(len(field.c_length_name)+2) + add_param_str = additional_params_to_str(spacing) if switch_obj is not None: - _hc('%s (const %s *R /**< */,', field.c_length_name, R_obj.c_type) - spacing = ' '*(len(field.c_length_name)+2) - _h('%sconst %s *S /**< */);', spacing, S_obj.c_type) - _c('%sconst %s *S /**< */)', spacing, S_obj.c_type) - length = _c_accessor_get_expr(field.type.expr, fields) + _hc('%s (const %s *R,', field.c_length_name, R_obj.c_type) + _h('%sconst %s *S%s);', spacing, S_obj.c_type, add_param_str) + _c('%sconst %s *S%s)', spacing, S_obj.c_type, add_param_str) else: - _h('%s (const %s *R /**< */);', field.c_length_name, c_type) - _c('%s (const %s *R /**< */)', field.c_length_name, c_type) - length = _c_accessor_get_expr(field.type.expr, fields) + _h('%s (const %s *R%s);', field.c_length_name, c_type, add_param_str) + _c('%s (const %s *R%s)', field.c_length_name, c_type, add_param_str) _c('{') - _c(' return %s;', length) + + def get_length(): + if field.type.expr.op == 'calculate_len': + if field.type.member.fixed_size(): + if field.prev_varsized_field is None: + # the list is directly after the fixed size part of the + # request: simply subtract the size of the fixed-size part + # from the request size and divide that by the member size + return '(((R->length * 4) - sizeof('+ self.c_type + '))/'+'sizeof('+field.type.member.c_wiretype+'))' + else: + # use the accessor to get the start of the list, then + # compute the length of it by subtracting it from + # the adress of the first byte after the end of the + # request + after_end_of_request = '(((char*)R) + R->length * 4)' + start_of_list = '%s(R)' % (field.c_accessor_name) + bytesize_of_list = '%s - (char*)(%s)' % (after_end_of_request, start_of_list) + return '(%s) / sizeof(%s)' % (bytesize_of_list, field.type.member.c_wiretype) + else: + raise Exception( + "lengthless lists with varsized members are not supported. Fieldname '%s'" + % + (field.c_field_name) + ); + else: + return _c_accessor_get_expr(field.type.expr, fields) + + _c(' return %s;', get_length()) _c('}') if field.type.member.is_simple: _hc('') _hc('xcb_generic_iterator_t') + spacing = ' '*(len(field.c_end_name)+2) + add_param_str = additional_params_to_str(spacing) if switch_obj is not None: - _hc('%s (const %s *R /**< */,', field.c_end_name, R_obj.c_type) - spacing = ' '*(len(field.c_end_name)+2) - _h('%sconst %s *S /**< */);', spacing, S_obj.c_type) - _c('%sconst %s *S /**< */)', spacing, S_obj.c_type) + _hc('%s (const %s *R,', field.c_end_name, R_obj.c_type) + _h('%sconst %s *S%s);', spacing, S_obj.c_type, add_param_str) + _c('%sconst %s *S%s)', spacing, S_obj.c_type, add_param_str) else: - _h('%s (const %s *R /**< */);', field.c_end_name, c_type) - _c('%s (const %s *R /**< */)', field.c_end_name, c_type) + _h('%s (const %s *R%s);', field.c_end_name, c_type, add_param_str) + _c('%s (const %s *R%s)', field.c_end_name, c_type, add_param_str) _c('{') _c(' xcb_generic_iterator_t i;') param = 'R' if switch_obj is None else 'S' if switch_obj is not None: _c(' i.data = %s + %s;', fields[field.c_field_name][0], - _c_accessor_get_expr(field.type.expr, fields)) + get_length()) elif field.prev_varsized_field == None: _c(' i.data = ((%s *) (R + 1)) + (%s);', field.type.c_wiretype, - _c_accessor_get_expr(field.type.expr, fields)) + get_length()) else: - _c(' xcb_generic_iterator_t child = %s;', - _c_iterator_get_end(field.prev_varsized_field, 'R')) - _c(' i.data = ((%s *) child.data) + (%s);', field.type.c_wiretype, - _c_accessor_get_expr(field.type.expr, fields)) + (prev_varsized_field, align_pad) = get_align_pad(field) + + if align_pad is None: + align_pad = ('XCB_TYPE_PAD(%s, prev.index)' % + type_pad_type(field.first_field_after_varsized.type.c_type)) + + _c(' xcb_generic_iterator_t prev = %s;', + _c_iterator_get_end(prev_varsized_field, 'R')) + _c(' i.data = ((%s *) ((char*) prev.data + %s)) + (%s);', + field.type.c_wiretype, align_pad, + get_length()) _c(' i.rem = 0;') _c(' i.index = (char *) i.data - (char *) %s;', param) @@ -1647,21 +1993,26 @@ def _c_accessors_list(self, field): else: _hc('') _hc('%s', field.c_iterator_type) + spacing = ' '*(len(field.c_iterator_name)+2) if switch_obj is not None: - _hc('%s (const %s *R /**< */,', field.c_iterator_name, R_obj.c_type) - spacing = ' '*(len(field.c_iterator_name)+2) - _h('%sconst %s *S /**< */);', spacing, S_obj.c_type) - _c('%sconst %s *S /**< */)', spacing, S_obj.c_type) + _hc('%s (const %s *R,', field.c_iterator_name, R_obj.c_type) + _h('%sconst %s *S%s);', spacing, S_obj.c_type, add_param_str) + _c('%sconst %s *S%s)', spacing, S_obj.c_type, add_param_str) else: - _h('%s (const %s *R /**< */);', field.c_iterator_name, c_type) - _c('%s (const %s *R /**< */)', field.c_iterator_name, c_type) + _h('%s (const %s *R%s);', field.c_iterator_name, c_type, add_param_str) + _c('%s (const %s *R%s)', field.c_iterator_name, c_type, add_param_str) _c('{') _c(' %s i;', field.c_iterator_type) + _c_pre.start() + length_expr_str = get_length() + if switch_obj is not None: + _c_pre.end() _c(' i.data = %s;', fields[field.c_field_name][0]) - _c(' i.rem = %s;', _c_accessor_get_expr(field.type.expr, fields)) + _c(' i.rem = %s;', length_expr_str) elif field.prev_varsized_field == None: + _c_pre.end() _c(' i.data = (%s *) (R + 1);', field.c_field_type) else: (prev_varsized_field, align_pad) = get_align_pad(field) @@ -1672,12 +2023,20 @@ def _c_accessors_list(self, field): _c(' xcb_generic_iterator_t prev = %s;', _c_iterator_get_end(prev_varsized_field, 'R')) + _c_pre.end() _c(' i.data = (%s *) ((char *) prev.data + %s);', field.c_field_type, align_pad) if switch_obj is None: - _c(' i.rem = %s;', _c_accessor_get_expr(field.type.expr, fields)) + _c(' i.rem = %s;', length_expr_str) _c(' i.index = (char *) i.data - (char *) %s;', 'R' if switch_obj is None else 'S' ) + + # initialize additional iterator fields which are derived from + # additional type parameters for the list member type. + additional_iter_fields = _c_get_additional_type_params(field.type.member) + for iter_field in additional_iter_fields: + _c(' i.%s = %s;', iter_field[2], fields[iter_field[2]][0]) + _c(' return i;') _c('}') @@ -1693,9 +2052,9 @@ def _c_accessors(self, name, base): if True: for field in self.fields: if not field.type.is_pad: - if field.type.is_list and not field.type.fixed_size(): + if _c_field_needs_list_accessor(field): _c_accessors_list(self, field) - elif field.prev_varsized_field is not None or not field.type.fixed_size(): + elif _c_field_needs_field_accessor(field): _c_accessors_field(self, field) def c_simple(self, name): @@ -1730,12 +2089,8 @@ def _c_complex(self, force_packed = False): struct_fields = [] maxtypelen = 0 - varfield = None for field in self.fields: - if not field.type.fixed_size() and not self.is_switch and not self.is_union: - varfield = field.c_field_name - continue - if field.wire: + if field.wire and (field.type.fixed_size() or self.is_switch or self.is_union): struct_fields.append(field) for field in struct_fields: @@ -1751,10 +2106,11 @@ def _c_complex(self, force_packed = False): # necessary for unserialize to work (self.is_switch and field.type.is_switch)): spacing = ' ' * (maxtypelen - len(field.c_field_type)) - _h('%s %s%s %s%s; /**< */', space, field.c_field_type, spacing, field.c_field_name, field.c_subscript) - else: + _h('%s %s%s %s%s;', space, field.c_field_type, spacing, field.c_field_name, field.c_subscript) + elif (not field.type.is_pad) or field.type.serialize: + # serialize everything except pads (unless serialization of pads is enforced by serialize=true) spacing = ' ' * (maxtypelen - (len(field.c_field_type) + 1)) - _h('%s %s%s *%s%s; /**< */', space, field.c_field_type, spacing, field.c_field_name, field.c_subscript) + _h('%s %s%s *%s%s;', space, field.c_field_type, spacing, field.c_field_name, field.c_subscript) if not self.is_switch: for field in struct_fields: @@ -1763,7 +2119,7 @@ def _c_complex(self, force_packed = False): for b in self.bitcases: space = '' if b.type.has_name: - _h(' struct _%s {', b.c_field_name) + _h(' struct {') space = ' ' for field in b.type.fields: _c_complex_field(self, field, space) @@ -1789,7 +2145,7 @@ def c_union(self, name): _c_complex(self) _c_iterator(self, name) -def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_fds=False): +def _c_request_helper(self, name, void, regular, aux=False, reply_fds=False): ''' Declares a request function. ''' @@ -1927,13 +2283,13 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f _h(' * placed in the event queue.') _h(' */') _c('') - _hc('%s', cookie_type) + _hc('%s', func_cookie) spacing = ' ' * (maxtypelen - len('xcb_connection_t')) comma = ',' if len(param_fields) else ');' - _h('%s (xcb_connection_t%s *c /**< */%s', func_name, spacing, comma) + _h('%s (xcb_connection_t%s *c%s', func_name, spacing, comma) comma = ',' if len(param_fields) else ')' - _c('%s (xcb_connection_t%s *c /**< */%s', func_name, spacing, comma) + _c('%s (xcb_connection_t%s *c%s', func_name, spacing, comma) func_spacing = ' ' * (len(func_name) + 2) count = len(param_fields) @@ -1946,10 +2302,10 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f c_pointer = '*' spacing = ' ' * (maxtypelen - len(c_field_const_type)) comma = ',' if count else ');' - _h('%s%s%s %s%s /**< */%s', func_spacing, c_field_const_type, + _h('%s%s%s %s%s%s', func_spacing, c_field_const_type, spacing, c_pointer, field.c_field_name, comma) comma = ',' if count else ')' - _c('%s%s%s %s%s /**< */%s', func_spacing, c_field_const_type, + _c('%s%s%s %s%s%s', func_spacing, c_field_const_type, spacing, c_pointer, field.c_field_name, comma) count = 2 @@ -1964,10 +2320,10 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f _c('{') _c(' static const xcb_protocol_request_t xcb_req = {') - _c(' /* count */ %d,', count) - _c(' /* ext */ %s,', func_ext_global) - _c(' /* opcode */ %s,', self.c_request_name.upper()) - _c(' /* isvoid */ %d', 1 if void else 0) + _c(' .count = %d,', count) + _c(' .ext = %s,', func_ext_global) + _c(' .opcode = %s,', self.c_request_name.upper()) + _c(' .isvoid = %d', 1 if void else 0) _c(' };') _c('') @@ -1979,16 +2335,17 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f _c(' void *xcb_aux = 0;') - for idx, f in enumerate(serial_fields): + for idx, _ in enumerate(serial_fields): if aux: _c(' void *xcb_aux%d = 0;' % (idx)) if list_with_var_size_elems: _c(' unsigned int i;') _c(' unsigned int xcb_tmp_len;') _c(' char *xcb_tmp;') + num_fds = len([field for field in param_fields if field.isfd]) + if num_fds > 0: + _c(' int fds[%d];' % (num_fds)) _c('') - # simple request call tracing -# _c(' printf("in function %s\\n");' % func_name) # fixed size fields for field in wire_fields: @@ -2010,7 +2367,7 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f serialize_args = get_serialize_params(context, type_obj, c_field_name, aux_var)[2] - return reduce(lambda x,y: "%s, %s" % (x,y), [a[2] for a in serialize_args]) + return ", ".join(a[2] for a in serialize_args) # calls in order to free dyn. all. memory free_calls = [] @@ -2032,13 +2389,17 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f _c(' xcb_parts[%d].iov_base = (char *) %s;', count, field.c_field_name) if field.type.is_list: if field.type.member.fixed_size(): - _c(' xcb_parts[%d].iov_len = %s * sizeof(%s);', count, - _c_accessor_get_expr(field.type.expr, None), - field.type.member.c_wiretype) + if field.type.expr.op == 'calculate_len': + lenfield = field.type.expr.lenfield_name + else: + lenfield = _c_accessor_get_expr(field.type.expr, None) + + _c(' xcb_parts[%d].iov_len = %s * sizeof(%s);', count, lenfield, + field.type.member.c_wiretype) else: list_length = _c_accessor_get_expr(field.type.expr, None) - length = '' + _c(" xcb_parts[%d].iov_len = 0;" % count) _c(" xcb_tmp = (char *)%s;", field.c_field_name) _c(" for(i=0; i<%s; i++) {" % list_length) @@ -2089,11 +2450,16 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f # no padding necessary - _serialize() keeps track of padding automatically _c('') + fd_index = 0 for field in param_fields: if field.isfd: - _c(' xcb_send_fd(c, %s);', field.c_field_name) + _c(' fds[%d] = %s;', fd_index, field.c_field_name) + fd_index = fd_index + 1 - _c(' xcb_ret.sequence = xcb_send_request(c, %s, xcb_parts + 2, &xcb_req);', func_flags) + if num_fds == 0: + _c(' xcb_ret.sequence = xcb_send_request(c, %s, xcb_parts + 2, &xcb_req);', func_flags) + else: + _c(' xcb_ret.sequence = xcb_send_request_with_fds(c, %s, xcb_parts + 2, &xcb_req, %d, fds);', func_flags, num_fds) # free dyn. all. data, if any for f in free_calls: @@ -2148,10 +2514,10 @@ def _c_reply(self, name): _h(' */') _c('') _hc('%s *', self.c_reply_type) - _hc('%s (xcb_connection_t%s *c /**< */,', self.c_reply_name, spacing1) + _hc('%s (xcb_connection_t%s *c,', self.c_reply_name, spacing1) _hc('%s%s cookie /**< */,', spacing3, self.c_cookie_type) - _h('%sxcb_generic_error_t%s **e /**< */);', spacing3, spacing2) - _c('%sxcb_generic_error_t%s **e /**< */)', spacing3, spacing2) + _h('%sxcb_generic_error_t%s **e);', spacing3, spacing2) + _c('%sxcb_generic_error_t%s **e)', spacing3, spacing2) _c('{') if len(unserialize_fields)>0: @@ -2185,10 +2551,7 @@ def _c_reply(self, name): _c('}') def _c_reply_has_fds(self): - for field in self.fields: - if field.isfd: - return True - return False + return any(field.isfd for field in self.fields) def _c_reply_fds(self, name): ''' @@ -2209,8 +2572,8 @@ def _c_reply_fds(self, name): _c('') _hc('int *') _hc('%s (xcb_connection_t%s *c /**< */,', self.c_reply_fds_name, spacing1) - _h('%s%s *reply /**< */);', spacing3, self.c_reply_type) - _c('%s%s *reply /**< */)', spacing3, self.c_reply_type) + _h('%s%s *reply);', spacing3, self.c_reply_type) + _c('%s%s *reply)', spacing3, self.c_reply_type) _c('{') _c(' return xcb_get_reply_fds(c, reply, sizeof(%s) + 4 * reply->length);', self.c_reply_type) @@ -2237,10 +2600,10 @@ def _c_cookie(self, name): _h(' * @brief %s', self.c_cookie_type) _h(' **/') _h('typedef struct %s {', self.c_cookie_type) - _h(' unsigned int sequence; /**< */') + _h(' unsigned int sequence;') _h('} %s;', self.c_cookie_type) -def _man_request(self, name, cookie_type, void, aux): +def _man_request(self, name, void, aux): param_fields = [f for f in self.fields if f.visible] func_name = self.c_request_name if not aux else self.c_aux_name @@ -2286,7 +2649,8 @@ def _man_request(self, name, cookie_type, void, aux): f.write('.SS Request function\n') f.write('.HP\n') base_func_name = self.c_request_name if not aux else self.c_aux_name - f.write('%s \\fB%s\\fP(xcb_connection_t\\ *\\fIconn\\fP, %s\n' % (cookie_type, base_func_name, prototype)) + func_cookie = 'xcb_void_cookie_t' if void else self.c_cookie_type + f.write('%s \\fB%s\\fP(xcb_connection_t\\ *\\fIconn\\fP, %s\n' % (func_cookie, base_func_name, prototype)) create_link('%s_%s' % (base_func_name, ('checked' if void else 'unchecked'))) if not void: f.write('.PP\n') @@ -2333,8 +2697,7 @@ def _man_request(self, name, cookie_type, void, aux): for field in b.type.fields: _c_complex_field(self, field, space) if b.type.has_name: - print >> sys.stderr, 'ERROR: New unhandled documentation case' - pass + print('ERROR: New unhandled documentation case\n', file=sys.stderr) f.write('} \\fB%s\\fP;\n' % self.reply.c_type) f.write('.fi\n') @@ -2364,7 +2727,7 @@ def _man_request(self, name, cookie_type, void, aux): # special case: switch switch_obj = self if self.is_switch else None - if self.is_bitcase: + if self.is_case_or_bitcase: switch_obj = self.parents[-1] if switch_obj is not None: c_type = switch_obj.c_type @@ -2392,7 +2755,7 @@ def _man_request(self, name, cookie_type, void, aux): # the reason is that switch is either a child of a request/reply or nested in another switch, # so whenever we need to access a length field, we might need to refer to some anchestor type switch_obj = self if self.is_switch else None - if self.is_bitcase: + if self.is_case_or_bitcase: switch_obj = self.parents[-1] if switch_obj is not None: c_type = switch_obj.c_type @@ -2403,8 +2766,6 @@ def _man_request(self, name, cookie_type, void, aux): # 'R': parents[0] is always the 'toplevel' container type params.append(('const %s *\\fIreply\\fP' % parents[0].c_type, parents[0])) fields.update(_c_helper_field_mapping(parents[0], [('R', '->', parents[0])], flat=True)) - # auxiliary object for 'R' parameters - R_obj = parents[0] if switch_obj is not None: # now look where the fields are defined that are needed to evaluate @@ -2417,20 +2778,16 @@ def _man_request(self, name, cookie_type, void, aux): fields.update(_c_helper_field_mapping(toplevel_switch, [('S', '->', toplevel_switch)], flat=True)) # initialize prefix for everything "below" S - prefix_str = '/* %s */ S' % toplevel_switch.name[-1] - prefix = [(prefix_str, '->', toplevel_switch)] + prefix = [('S', '->', toplevel_switch)] # look for fields in the remaining containers for p in parents[2:] + [self]: # the separator between parent and child is always '.' here, # because of nested switch statements - if not p.is_bitcase or (p.is_bitcase and p.has_name): + if not p.is_case_or_bitcase or (p.is_case_or_bitcase and p.has_name): prefix.append((p.name[-1], '.', p)) fields.update(_c_helper_field_mapping(p, prefix, flat=True)) - # auxiliary object for 'S' parameter - S_obj = parents[1] - if list.member.fixed_size(): idx = 1 if switch_obj is not None else 0 f.write('.HP\n') @@ -2589,7 +2946,7 @@ def _man_request(self, name, cookie_type, void, aux): 'handle errors in the event loop instead, use ' '\\fI%s_unchecked\\fP. See \\fBxcb-requests(%s)\\fP for ' 'details.\n') % - (cookie_type, self.c_reply_name, base_func_name, section)) + (self.c_cookie_type, self.c_reply_name, base_func_name, section)) f.write('.SH ERRORS\n') if hasattr(self, "doc") and self.doc: for errtype, errtext in sorted(self.doc.errors.items()): @@ -2671,7 +3028,7 @@ def _man_event(self, name): spacing = ' ' * (maxtypelen - len(field.c_field_type)) f.write('%s %s%s \\fI%s\\fP%s;\n' % (space, field.c_field_type, spacing, field.c_field_name, field.c_subscript)) else: - print >> sys.stderr, 'ERROR: New unhandled documentation case' + print('ERROR: New unhandled documentation case', file=sys.stderr) if not self.is_switch: for field in struct_fields: @@ -2684,7 +3041,7 @@ def _man_event(self, name): for field in b.type.fields: _c_complex_field(self, field, space) if b.type.has_name: - print >> sys.stderr, 'ERROR: New unhandled documentation case' + print('ERROR: New unhandled documentation case', file=sys.stderr) pass f.write('} \\fB%s\\fP;\n' % self.c_type) @@ -2779,11 +3136,11 @@ def c_request(self, name): _c_complex(self.reply) # Request prototypes has_fds = _c_reply_has_fds(self.reply) - _c_request_helper(self, name, self.c_cookie_type, False, True, False, has_fds) - _c_request_helper(self, name, self.c_cookie_type, False, False, False, has_fds) + _c_request_helper(self, name, void=False, regular=True, aux=False, reply_fds=has_fds) + _c_request_helper(self, name, void=False, regular=False, aux=False, reply_fds=has_fds) if self.c_need_aux: - _c_request_helper(self, name, self.c_cookie_type, False, True, True, has_fds) - _c_request_helper(self, name, self.c_cookie_type, False, False, True, has_fds) + _c_request_helper(self, name, void=False, regular=True, aux=True, reply_fs=has_fds) + _c_request_helper(self, name, void=False, regular=False, aux=True, reply_fs=has_fds) # Reply accessors _c_accessors(self.reply, name + ('reply',), name) _c_reply(self, name) @@ -2791,16 +3148,20 @@ def c_request(self, name): _c_reply_fds(self, name) else: # Request prototypes - _c_request_helper(self, name, 'xcb_void_cookie_t', True, False) - _c_request_helper(self, name, 'xcb_void_cookie_t', True, True) + _c_request_helper(self, name, void=True, regular=False) + _c_request_helper(self, name, void=True, regular=True) if self.c_need_aux: - _c_request_helper(self, name, 'xcb_void_cookie_t', True, False, True) - _c_request_helper(self, name, 'xcb_void_cookie_t', True, True, True) - + _c_request_helper(self, name, void=True, regular=False, aux=True) + _c_request_helper(self, name, void=True, regular=True, aux=True) + for field in self.fields: + if not field.type.is_pad and field.wire: + if _c_field_needs_list_accessor(field): + _c_accessors_list(self, field) + elif _c_field_needs_field_accessor(field): + _c_accessors_field(self, field) # We generate the manpage afterwards because _c_type_setup has been called. # TODO: what about aux helpers? - cookie_type = self.c_cookie_type if self.reply else 'xcb_void_cookie_t' - _man_request(self, name, cookie_type, not self.reply, False) + _man_request(self, name, void=not self.reply, aux=False) def c_event(self, name): ''' @@ -2829,7 +3190,18 @@ def c_event(self, name): force_packed = any(f.type.size == 8 and f.type.is_simple for f in self.fields[(idx+1):]) break - _c_type_setup(self, name, ('event',)) + if self.name == name: + _c_type_setup(self, name, ('event',)) + # generate accessors + # (needed for fields after var-sized fields, for lists with var-sized elements, + # switches, ...) + _c_accessors(self, name, name) + else: + # no type-setup needed for eventcopies + # (the type-setup of an eventcopy would overwrite members of the original + # event, and it would create sizeof-etc funtions which + # called undefined accessor functions) + pass # Opcode define _c_opcode(name, self.opcodes[name]) @@ -2842,6 +3214,22 @@ def c_event(self, name): _h('') _h('typedef %s %s;', _t(self.name + ('event',)), _t(name + ('event',))) + # Create sizeof-function for eventcopies for compatibility reasons + if self.c_need_sizeof: + _h_setlevel(1) + _c_setlevel(1) + _h('') + _h('int') + _h('%s (const void *_buffer /**< */);', _n(name + ('sizeof',))) + _c('') + _c('int') + _c('%s (const void *_buffer /**< */)', _n(name + ('sizeof',))) + _c('{'); + _c(' return %s(_buffer);', _n(self.name + ('sizeof',))) + _c('}'); + _h_setlevel(0) + _c_setlevel(0) + _man_event(self, name) def c_error(self, name): @@ -2880,7 +3268,7 @@ output = {'open' : c_open, # Check for the argument that specifies path to the xcbgen python package. try: - opts, args = getopt.getopt(sys.argv[1:], 'c:l:s:p:m') + opts, args = getopt.getopt(sys.argv[1:], 'c:l:s:p:m', ["server-side"]) except getopt.GetoptError as err: print(err) print('Usage: c_client.py -c center_footer -l left_footer -s section [-p path] file.xml') @@ -2895,6 +3283,8 @@ for (opt, arg) in opts: section=arg if opt == '-p': sys.path.insert(1, arg) + if opt == '--server-side': + config_server_side=True elif opt == '-m': manpaths = True sys.stdout.write('man_MANS = ') diff --git a/dist/libxcb/src/config.h.in b/dist/libxcb/src/config.h.in index 4e64f822c..f75d8497b 100644 --- a/dist/libxcb/src/config.h.in +++ b/dist/libxcb/src/config.h.in @@ -24,6 +24,9 @@ /* launchd support available */ #undef HAVE_LAUNCHD +/* Define to 1 if you have the `ws2_32' library (-lws2_32). */ +#undef HAVE_LIBWS2_32 + /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H @@ -60,8 +63,7 @@ /* Define if not provided by */ #undef IOV_MAX -/* Define to the sub-directory in which libtool stores uninstalled libraries. - */ +/* Define to the sub-directory where libtool stores uninstalled libraries. */ #undef LT_OBJDIR /* Name of package */ diff --git a/dist/libxcb/src/xcb_conn.c b/dist/libxcb/src/xcb_conn.c index fa5098586..7d0963716 100644 --- a/dist/libxcb/src/xcb_conn.c +++ b/dist/libxcb/src/xcb_conn.c @@ -64,6 +64,26 @@ typedef struct { uint16_t length; } xcb_setup_generic_t; +static const xcb_setup_t xcb_error_setup = { + 0, /* status: failed (but we wouldn't have a xcb_setup_t in this case) */ + 0, /* pad0 */ + 0, 0, /* protocol version, should be 11.0, but isn't */ + 0, /* length, invalid value */ + 0, /* release_number */ + 0, 0, /* resource_id_{base,mask} */ + 0, /* motion_buffer_size */ + 0, /* vendor_len */ + 0, /* maximum_request_length */ + 0, /* roots_len */ + 0, /* pixmap_formats_len */ + 0, /* image_byte_order */ + 0, /* bitmap_format_bit_order */ + 0, /* bitmap_format_scanline_unit */ + 0, /* bitmap_format_scanline_pad */ + 0, 0, /* {min,max}_keycode */ + { 0, 0, 0, 0 } /* pad1 */ +}; + /* Keep this list in sync with is_static_error_conn()! */ static const int xcb_con_error = XCB_CONN_ERROR; static const int xcb_con_closed_mem_er = XCB_CONN_CLOSED_MEM_INSUFFICIENT; @@ -288,15 +308,15 @@ static int write_vec(xcb_connection_t *c, struct iovec **vector, int *count) const xcb_setup_t *xcb_get_setup(xcb_connection_t *c) { - if(c->has_error) - return 0; + if(is_static_error_conn(c)) + return &xcb_error_setup; /* doesn't need locking because it's never written to. */ return c->setup; } int xcb_get_file_descriptor(xcb_connection_t *c) { - if(c->has_error) + if(is_static_error_conn(c)) return -1; /* doesn't need locking because it's never written to. */ return c->fd; diff --git a/dist/libxcb/src/xcb_out.c b/dist/libxcb/src/xcb_out.c index 8cc5be868..3601a5fa4 100644 --- a/dist/libxcb/src/xcb_out.c +++ b/dist/libxcb/src/xcb_out.c @@ -177,15 +177,59 @@ uint32_t xcb_get_maximum_request_length(xcb_connection_t *c) return c->out.maximum_request_length.value; } -uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector, const xcb_protocol_request_t *req) +static void close_fds(int *fds, unsigned int num_fds) +{ + for (unsigned int index = 0; index < num_fds; index++) + close(fds[index]); +} + +static void send_fds(xcb_connection_t *c, int *fds, unsigned int num_fds) +{ +#if HAVE_SENDMSG + /* Calling _xcb_out_flush_to() can drop the iolock and wait on a condition + * variable if another thread is currently writing (c->out.writing > 0). + * This call waits for writers to be done and thus _xcb_out_flush_to() will + * do the work itself (in which case we are a writer and + * prepare_socket_request() will wait for us to be done if another threads + * tries to send fds, too). Thanks to this, we can atomically write out FDs. + */ + prepare_socket_request(c); + + while (num_fds > 0) { + while (c->out.out_fd.nfd == XCB_MAX_PASS_FD && !c->has_error) { + /* XXX: if c->out.writing > 0, this releases the iolock and + * potentially allows other threads to interfere with their own fds. + */ + _xcb_out_flush_to(c, c->out.request); + + if (c->out.out_fd.nfd == XCB_MAX_PASS_FD) { + /* We need some request to send FDs with */ + _xcb_out_send_sync(c); + } + } + if (c->has_error) + break; + + c->out.out_fd.fd[c->out.out_fd.nfd++] = fds[0]; + fds++; + num_fds--; + } +#endif + close_fds(fds, num_fds); +} + +uint64_t xcb_send_request_with_fds64(xcb_connection_t *c, int flags, struct iovec *vector, + const xcb_protocol_request_t *req, unsigned int num_fds, int *fds) { uint64_t request; uint32_t prefix[2]; int veclen = req->count; enum workarounds workaround = WORKAROUND_NONE; - if(c->has_error) + if(c->has_error) { + close_fds(fds, num_fds); return 0; + } assert(c != 0); assert(vector != 0); @@ -204,6 +248,7 @@ uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector const xcb_query_extension_reply_t *extension = xcb_get_extension_data(c, req->ext); if(!(extension && extension->present)) { + close_fds(fds, num_fds); _xcb_conn_shutdown(c, XCB_CONN_CLOSED_EXT_NOTSUPPORTED); return 0; } @@ -234,6 +279,7 @@ uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector } else if(longlen > xcb_get_maximum_request_length(c)) { + close_fds(fds, num_fds); _xcb_conn_shutdown(c, XCB_CONN_CLOSED_REQ_LEN_EXCEED); return 0; /* server can't take this; maybe need BIGREQUESTS? */ } @@ -264,6 +310,11 @@ uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector /* get a sequence number and arrange for delivery. */ pthread_mutex_lock(&c->iolock); + /* send FDs before establishing a good request number, because this might + * call send_sync(), too + */ + send_fds(c, fds, num_fds); + prepare_socket_request(c); /* send GetInputFocus (sync_req) when 64k-2 requests have been sent without @@ -272,7 +323,7 @@ uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector * applications see sequence 0 as that is used to indicate * an error in sending the request */ - + while ((req->isvoid && c->out.request == c->in.request_expected + (1 << 16) - 2) || (unsigned int) (c->out.request + 1) == 0) { @@ -286,6 +337,18 @@ uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector return request; } +/* request number are actually uint64_t internally but keep API compat with unsigned int */ +unsigned int xcb_send_request_with_fds(xcb_connection_t *c, int flags, struct iovec *vector, + const xcb_protocol_request_t *req, unsigned int num_fds, int *fds) +{ + return xcb_send_request_with_fds64(c, flags, vector, req, num_fds, fds); +} + +uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector, const xcb_protocol_request_t *req) +{ + return xcb_send_request_with_fds64(c, flags, vector, req, 0, NULL); +} + /* request number are actually uint64_t internally but keep API compat with unsigned int */ unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vector, const xcb_protocol_request_t *req) { @@ -295,19 +358,15 @@ unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vect void xcb_send_fd(xcb_connection_t *c, int fd) { -#if HAVE_SENDMSG - if (c->has_error) + int fds[1] = { fd }; + + if (c->has_error) { + close(fd); return; - pthread_mutex_lock(&c->iolock); - while (c->out.out_fd.nfd == XCB_MAX_PASS_FD) { - _xcb_out_flush_to(c, c->out.request); - if (c->has_error) - break; } - if (!c->has_error) - c->out.out_fd.fd[c->out.out_fd.nfd++] = fd; + pthread_mutex_lock(&c->iolock); + send_fds(c, &fds[0], 1); pthread_mutex_unlock(&c->iolock); -#endif } int xcb_take_socket(xcb_connection_t *c, void (*return_socket)(void *closure), void *closure, int flags, uint64_t *sent) diff --git a/dist/libxcb/src/xcbext.h b/dist/libxcb/src/xcbext.h index b2575f7e3..44d789eee 100644 --- a/dist/libxcb/src/xcbext.h +++ b/dist/libxcb/src/xcbext.h @@ -68,13 +68,13 @@ enum xcb_send_request_flags_t { * * This function sends a new request to the X server. The data of the request is * given as an array of @c iovecs in the @p vector argument. The length of that - * array and the neccessary management information are given in the @p request + * array and the necessary management information are given in the @p request * argument. * * When this function returns, the request might or might not be sent already. * Use xcb_flush() to make sure that it really was sent. * - * Please note that this function is not the prefered way for sending requests. + * Please note that this function is not the preferred way for sending requests. * It's better to use the generated wrapper functions. * * Please note that xcb might use index -1 and -2 of the @p vector array internally, @@ -82,6 +82,37 @@ enum xcb_send_request_flags_t { */ unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vector, const xcb_protocol_request_t *request); +/** + * @brief Send a request to the server. + * @param c: The connection to the X server. + * @param flags: A combination of flags from the xcb_send_request_flags_t enumeration. + * @param vector: Data to send; must have two iovecs before start for internal use. + * @param request: Information about the request to be sent. + * @param num_fds: Number of additional file descriptors to send to the server + * @param fds: Additional file descriptors that should be send to the server. + * @return The request's sequence number on success, 0 otherwise. + * + * This function sends a new request to the X server. The data of the request is + * given as an array of @c iovecs in the @p vector argument. The length of that + * array and the necessary management information are given in the @p request + * argument. + * + * If @p num_fds is non-zero, @p fds points to an array of file descriptors that + * will be sent to the X server along with this request. After this function + * returns, all file descriptors sent are owned by xcb and will be closed + * eventually. + * + * When this function returns, the request might or might not be sent already. + * Use xcb_flush() to make sure that it really was sent. + * + * Please note that this function is not the preferred way for sending requests. + * + * Please note that xcb might use index -1 and -2 of the @p vector array internally, + * so they must be valid! + */ +unsigned int xcb_send_request_with_fds(xcb_connection_t *c, int flags, struct iovec *vector, + const xcb_protocol_request_t *request, unsigned int num_fds, int *fds); + /** * @brief Send a request to the server, with 64-bit sequence number returned. * @param c: The connection to the X server. @@ -92,13 +123,13 @@ unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vect * * This function sends a new request to the X server. The data of the request is * given as an array of @c iovecs in the @p vector argument. The length of that - * array and the neccessary management information are given in the @p request + * array and the necessary management information are given in the @p request * argument. * * When this function returns, the request might or might not be sent already. * Use xcb_flush() to make sure that it really was sent. * - * Please note that this function is not the prefered way for sending requests. + * Please note that this function is not the preferred way for sending requests. * It's better to use the generated wrapper functions. * * Please note that xcb might use index -1 and -2 of the @p vector array internally, @@ -106,6 +137,38 @@ unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vect */ uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector, const xcb_protocol_request_t *request); +/** + * @brief Send a request to the server, with 64-bit sequence number returned. + * @param c: The connection to the X server. + * @param flags: A combination of flags from the xcb_send_request_flags_t enumeration. + * @param vector: Data to send; must have two iovecs before start for internal use. + * @param request: Information about the request to be sent. + * @param num_fds: Number of additional file descriptors to send to the server + * @param fds: Additional file descriptors that should be send to the server. + * @return The request's sequence number on success, 0 otherwise. + * + * This function sends a new request to the X server. The data of the request is + * given as an array of @c iovecs in the @p vector argument. The length of that + * array and the necessary management information are given in the @p request + * argument. + * + * If @p num_fds is non-zero, @p fds points to an array of file descriptors that + * will be sent to the X server along with this request. After this function + * returns, all file descriptors sent are owned by xcb and will be closed + * eventually. + * + * When this function returns, the request might or might not be sent already. + * Use xcb_flush() to make sure that it really was sent. + * + * Please note that this function is not the preferred way for sending requests. + * It's better to use the generated wrapper functions. + * + * Please note that xcb might use index -1 and -2 of the @p vector array internally, + * so they must be valid! + */ +uint64_t xcb_send_request_with_fds64(xcb_connection_t *c, int flags, struct iovec *vector, + const xcb_protocol_request_t *request, unsigned int num_fds, int *fds); + /** * @brief Send a file descriptor to the server in the next call to xcb_send_request. * @param c: The connection to the X server. @@ -114,9 +177,9 @@ uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector * After this function returns, the file descriptor given is owned by xcb and * will be closed eventually. * - * FIXME: How the heck is this supposed to work in a thread-safe way? There is a - * race between two threads doing xcb_send_fd(); xcb_send_request(); at the same - * time. + * @deprecated This function cannot be used in a thread-safe way. Two threads + * that run xcb_send_fd(); xcb_send_request(); could mix up their file + * descriptors. Instead, xcb_send_request_with_fds() should be used. */ void xcb_send_fd(xcb_connection_t *c, int fd); diff --git a/dist/libxcb/tests/Makefile.in b/dist/libxcb/tests/Makefile.in index 619749b6f..b7be43f81 100644 --- a/dist/libxcb/tests/Makefile.in +++ b/dist/libxcb/tests/Makefile.in @@ -482,6 +482,7 @@ LIB_MAN_SUFFIX = @LIB_MAN_SUFFIX@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ +LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ MAKEINFO = @MAKEINFO@ MANIFEST_TOOL = @MANIFEST_TOOL@ MAN_SUBSTS = @MAN_SUBSTS@ diff --git a/dist/libxcb/xcb-composite.pc.in b/dist/libxcb/xcb-composite.pc.in index 02d49b0c2..b9b74c207 100644 --- a/dist/libxcb/xcb-composite.pc.in +++ b/dist/libxcb/xcb-composite.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Composite Description: XCB Composite Extension Version: @PACKAGE_VERSION@ -Requires: xcb xcb-xfixes +Requires.private: xcb xcb-xfixes Libs: -L${libdir} -lxcb-composite Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-damage.pc.in b/dist/libxcb/xcb-damage.pc.in index c4bc59986..3fb46b7f6 100644 --- a/dist/libxcb/xcb-damage.pc.in +++ b/dist/libxcb/xcb-damage.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Damage Description: XCB Damage Extension Version: @PACKAGE_VERSION@ -Requires: xcb xcb-xfixes +Requires.private: xcb xcb-xfixes Libs: -L${libdir} -lxcb-damage Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-dpms.pc.in b/dist/libxcb/xcb-dpms.pc.in index 838a054be..281861cff 100644 --- a/dist/libxcb/xcb-dpms.pc.in +++ b/dist/libxcb/xcb-dpms.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB DPMS Description: XCB DPMS Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-dpms Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-dri2.pc.in b/dist/libxcb/xcb-dri2.pc.in index a9944dfa2..fdb188b00 100644 --- a/dist/libxcb/xcb-dri2.pc.in +++ b/dist/libxcb/xcb-dri2.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB DRI2 Description: XCB DRI2 Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-dri2 Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-dri3.pc.in b/dist/libxcb/xcb-dri3.pc.in index 0eb73908a..befe11ea6 100644 --- a/dist/libxcb/xcb-dri3.pc.in +++ b/dist/libxcb/xcb-dri3.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB DRI3 Description: XCB DRI3 Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-dri3 Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-glx.pc.in b/dist/libxcb/xcb-glx.pc.in index bbd412675..79805efe9 100644 --- a/dist/libxcb/xcb-glx.pc.in +++ b/dist/libxcb/xcb-glx.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB GLX Description: XCB GLX Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-glx Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-present.pc.in b/dist/libxcb/xcb-present.pc.in index e2eccc489..2e0cff8e7 100644 --- a/dist/libxcb/xcb-present.pc.in +++ b/dist/libxcb/xcb-present.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Present Description: XCB Present Extension Version: @PACKAGE_VERSION@ -Requires: xcb xcb-randr xcb-xfixes xcb-sync +Requires.private: xcb xcb-randr xcb-xfixes xcb-sync Libs: -L${libdir} -lxcb-present Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-randr.pc.in b/dist/libxcb/xcb-randr.pc.in index 09c3d12e2..4c0de13f6 100644 --- a/dist/libxcb/xcb-randr.pc.in +++ b/dist/libxcb/xcb-randr.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB RandR Description: XCB RandR Extension Version: @PACKAGE_VERSION@ -Requires: xcb xcb-render +Requires.private: xcb xcb-render Libs: -L${libdir} -lxcb-randr Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-record.pc.in b/dist/libxcb/xcb-record.pc.in index 689f098fc..b441c9a82 100644 --- a/dist/libxcb/xcb-record.pc.in +++ b/dist/libxcb/xcb-record.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Record Description: XCB Record Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-record Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-render.pc.in b/dist/libxcb/xcb-render.pc.in index c3b050ab6..9ad543e89 100644 --- a/dist/libxcb/xcb-render.pc.in +++ b/dist/libxcb/xcb-render.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Render Description: XCB Render Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-render Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-res.pc.in b/dist/libxcb/xcb-res.pc.in index 62dbab63e..1f2889de8 100644 --- a/dist/libxcb/xcb-res.pc.in +++ b/dist/libxcb/xcb-res.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Res Description: XCB X-Resource Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-res Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-screensaver.pc.in b/dist/libxcb/xcb-screensaver.pc.in index ba3f8ecf3..1209b20ab 100644 --- a/dist/libxcb/xcb-screensaver.pc.in +++ b/dist/libxcb/xcb-screensaver.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Screensaver Description: XCB Screensaver Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-screensaver Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-shape.pc.in b/dist/libxcb/xcb-shape.pc.in index 880204d8a..09637b4a1 100644 --- a/dist/libxcb/xcb-shape.pc.in +++ b/dist/libxcb/xcb-shape.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Shape Description: XCB Shape Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-shape Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-shm.pc.in b/dist/libxcb/xcb-shm.pc.in index 9256bf015..47c193b8f 100644 --- a/dist/libxcb/xcb-shm.pc.in +++ b/dist/libxcb/xcb-shm.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Shm Description: XCB Shm Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-shm Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-sync.pc.in b/dist/libxcb/xcb-sync.pc.in index ead76d166..7a4c31511 100644 --- a/dist/libxcb/xcb-sync.pc.in +++ b/dist/libxcb/xcb-sync.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Sync Description: XCB Sync Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-sync Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xevie.pc.in b/dist/libxcb/xcb-xevie.pc.in index 0aa3e02ac..dc4fee4e2 100644 --- a/dist/libxcb/xcb-xevie.pc.in +++ b/dist/libxcb/xcb-xevie.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Xevie Description: XCB Xevie Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-xevie Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xf86dri.pc.in b/dist/libxcb/xcb-xf86dri.pc.in index f3f29806d..87c93d56f 100644 --- a/dist/libxcb/xcb-xf86dri.pc.in +++ b/dist/libxcb/xcb-xf86dri.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB XFree86-DRI Description: XCB XFree86-DRI Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-xf86dri Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xfixes.pc.in b/dist/libxcb/xcb-xfixes.pc.in index 93eafda30..2ebb9cfb2 100644 --- a/dist/libxcb/xcb-xfixes.pc.in +++ b/dist/libxcb/xcb-xfixes.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB XFixes Description: XCB XFixes Extension Version: @PACKAGE_VERSION@ -Requires: xcb xcb-render xcb-shape +Requires.private: xcb xcb-render xcb-shape Libs: -L${libdir} -lxcb-xfixes Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xinerama.pc.in b/dist/libxcb/xcb-xinerama.pc.in index c4775f9b5..abc3012c8 100644 --- a/dist/libxcb/xcb-xinerama.pc.in +++ b/dist/libxcb/xcb-xinerama.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Xinerama Description: XCB Xinerama Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-xinerama Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xinput.pc.in b/dist/libxcb/xcb-xinput.pc.in index ff34ab470..1f1bb2725 100644 --- a/dist/libxcb/xcb-xinput.pc.in +++ b/dist/libxcb/xcb-xinput.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB XInput Description: XCB XInput Extension (EXPERIMENTAL) Version: @PACKAGE_VERSION@ -Requires: xcb xcb-xfixes +Requires.private: xcb xcb-xfixes Libs: -L${libdir} -lxcb-xinput Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xkb.pc.in b/dist/libxcb/xcb-xkb.pc.in index 6ed003581..d5b1bad7e 100644 --- a/dist/libxcb/xcb-xkb.pc.in +++ b/dist/libxcb/xcb-xkb.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB XKB Description: XCB Keyboard Extension (EXPERIMENTAL) Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-xkb Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xprint.pc.in b/dist/libxcb/xcb-xprint.pc.in index b5275d5d5..7ac65f66c 100644 --- a/dist/libxcb/xcb-xprint.pc.in +++ b/dist/libxcb/xcb-xprint.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Xprint Description: XCB Xprint Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-xprint Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xselinux.pc.in b/dist/libxcb/xcb-xselinux.pc.in index 6a71f733a..0f86a9351 100644 --- a/dist/libxcb/xcb-xselinux.pc.in +++ b/dist/libxcb/xcb-xselinux.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB SELinux Description: XCB SELinux Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-xselinux Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xtest.pc.in b/dist/libxcb/xcb-xtest.pc.in index 886c4dc2f..996115210 100644 --- a/dist/libxcb/xcb-xtest.pc.in +++ b/dist/libxcb/xcb-xtest.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB XTEST Description: XCB XTEST Extension Version: @PACKAGE_VERSION@ -Requires: xcb +Requires.private: xcb Libs: -L${libdir} -lxcb-xtest Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xv.pc.in b/dist/libxcb/xcb-xv.pc.in index f4476135f..f31de1ab9 100644 --- a/dist/libxcb/xcb-xv.pc.in +++ b/dist/libxcb/xcb-xv.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB Xv Description: XCB Xv Extension Version: @PACKAGE_VERSION@ -Requires: xcb xcb-shm +Requires.private: xcb xcb-shm Libs: -L${libdir} -lxcb-xv Cflags: -I${includedir} diff --git a/dist/libxcb/xcb-xvmc.pc.in b/dist/libxcb/xcb-xvmc.pc.in index 95bf4effc..93c51a933 100644 --- a/dist/libxcb/xcb-xvmc.pc.in +++ b/dist/libxcb/xcb-xvmc.pc.in @@ -6,6 +6,6 @@ includedir=@includedir@ Name: XCB XvMC Description: XCB XvMC Extension Version: @PACKAGE_VERSION@ -Requires: xcb xcb-xv +Requires.private: xcb xcb-xv Libs: -L${libdir} -lxcb-xvmc Cflags: -I${includedir} diff --git a/lib/libxcb/libxcb-glx/shlib_version b/lib/libxcb/libxcb-glx/shlib_version index 1edea46de..893819d18 100644 --- a/lib/libxcb/libxcb-glx/shlib_version +++ b/lib/libxcb/libxcb-glx/shlib_version @@ -1,2 +1,2 @@ major=1 -minor=0 +minor=1 diff --git a/lib/libxcb/libxcb-present/shlib_version b/lib/libxcb/libxcb-present/shlib_version index 97c9f92d6..3d7c908e4 100644 --- a/lib/libxcb/libxcb-present/shlib_version +++ b/lib/libxcb/libxcb-present/shlib_version @@ -1,2 +1,2 @@ major=0 -minor=0 +minor=1 diff --git a/lib/libxcb/libxcb-randr/shlib_version b/lib/libxcb/libxcb-randr/shlib_version index c6e3f4d3f..ba5a3fee5 100644 --- a/lib/libxcb/libxcb-randr/shlib_version +++ b/lib/libxcb/libxcb-randr/shlib_version @@ -1,2 +1,2 @@ major=2 -minor=1 +minor=2 diff --git a/lib/libxcb/libxcb-record/shlib_version b/lib/libxcb/libxcb-record/shlib_version index 1edea46de..893819d18 100644 --- a/lib/libxcb/libxcb-record/shlib_version +++ b/lib/libxcb/libxcb-record/shlib_version @@ -1,2 +1,2 @@ major=1 -minor=0 +minor=1 diff --git a/lib/libxcb/libxcb-render/shlib_version b/lib/libxcb/libxcb-render/shlib_version index 1edea46de..893819d18 100644 --- a/lib/libxcb/libxcb-render/shlib_version +++ b/lib/libxcb/libxcb-render/shlib_version @@ -1,2 +1,2 @@ major=1 -minor=0 +minor=1 diff --git a/lib/libxcb/libxcb-screensaver/shlib_version b/lib/libxcb/libxcb-screensaver/shlib_version index 1edea46de..893819d18 100644 --- a/lib/libxcb/libxcb-screensaver/shlib_version +++ b/lib/libxcb/libxcb-screensaver/shlib_version @@ -1,2 +1,2 @@ major=1 -minor=0 +minor=1 diff --git a/lib/libxcb/libxcb-shape/shlib_version b/lib/libxcb/libxcb-shape/shlib_version index 1edea46de..893819d18 100644 --- a/lib/libxcb/libxcb-shape/shlib_version +++ b/lib/libxcb/libxcb-shape/shlib_version @@ -1,2 +1,2 @@ major=1 -minor=0 +minor=1 diff --git a/lib/libxcb/libxcb-sync/shlib_version b/lib/libxcb/libxcb-sync/shlib_version index 893819d18..c8860078e 100644 --- a/lib/libxcb/libxcb-sync/shlib_version +++ b/lib/libxcb/libxcb-sync/shlib_version @@ -1,2 +1,2 @@ major=1 -minor=1 +minor=2 diff --git a/lib/libxcb/libxcb-xfixes/shlib_version b/lib/libxcb/libxcb-xfixes/shlib_version index 893819d18..c8860078e 100644 --- a/lib/libxcb/libxcb-xfixes/shlib_version +++ b/lib/libxcb/libxcb-xfixes/shlib_version @@ -1,2 +1,2 @@ major=1 -minor=1 +minor=2 diff --git a/lib/libxcb/libxcb-xkb/shlib_version b/lib/libxcb/libxcb-xkb/shlib_version index 97c9f92d6..3d7c908e4 100644 --- a/lib/libxcb/libxcb-xkb/shlib_version +++ b/lib/libxcb/libxcb-xkb/shlib_version @@ -1,2 +1,2 @@ major=0 -minor=0 +minor=1 diff --git a/lib/libxcb/libxcb-xprint/shlib_version b/lib/libxcb/libxcb-xprint/shlib_version index b52599a16..012c14171 100644 --- a/lib/libxcb/libxcb-xprint/shlib_version +++ b/lib/libxcb/libxcb-xprint/shlib_version @@ -1,2 +1,2 @@ -major=2 +major=3 minor=0 diff --git a/lib/libxcb/libxcb-xv/shlib_version b/lib/libxcb/libxcb-xv/shlib_version index 1edea46de..893819d18 100644 --- a/lib/libxcb/libxcb-xv/shlib_version +++ b/lib/libxcb/libxcb-xv/shlib_version @@ -1,2 +1,2 @@ major=1 -minor=0 +minor=1 diff --git a/lib/libxcb/libxcb/Makefile b/lib/libxcb/libxcb/Makefile index 9e83e1b5e..a4b6e67dd 100644 --- a/lib/libxcb/libxcb/Makefile +++ b/lib/libxcb/libxcb/Makefile @@ -1,4 +1,4 @@ -# $OpenBSD: Makefile,v 1.6 2009/07/18 20:06:46 matthieu Exp $ +# $OpenBSD: Makefile,v 1.7 2016/09/02 10:09:43 matthieu Exp $ LIB= xcb @@ -28,6 +28,8 @@ PKGCONFIG= xcb.pc NEEDED= pthread-stubs xau >= 0.99.2 xdmcp +CFLAGS+= --std=c99 + XCBPROTO_VERSION!= pkg-config --modversion xcb-proto EXTRA_PKGCONFIG_SUBST= '-e s,@NEEDED@,${NEEDED},g' \ diff --git a/lib/libxcb/libxcb/shlib_version b/lib/libxcb/libxcb/shlib_version index 83a67c373..d9961ea9f 100644 --- a/lib/libxcb/libxcb/shlib_version +++ b/lib/libxcb/libxcb/shlib_version @@ -1,2 +1,2 @@ -major=3 -minor=2 +major=4 +minor=0 diff --git a/lib/libxcb/src/Makefile b/lib/libxcb/src/Makefile index bc79888a2..360fe0f1b 100644 --- a/lib/libxcb/src/Makefile +++ b/lib/libxcb/src/Makefile @@ -1,10 +1,10 @@ -# $OpenBSD: Makefile,v 1.6 2015/01/26 21:32:11 matthieu Exp $ +# $OpenBSD: Makefile,v 1.7 2016/09/02 10:09:44 matthieu Exp $ DATADIR= ${X11BASE}/share PYTHON= python${PYTHON_VERSION} PYTHONDIR= ${X11BASE}/lib/python${PYTHON_VERSION}/site-packages -MANOPTIONS= -c 'libxcb 1.11' -l 'X Version 11' -s 3 +MANOPTIONS= -c 'libxcb 1.12' -l 'X Version 11' -s 3 SRCS= \ bigreq.c \ @@ -42,11 +42,11 @@ HDRS= ${SRCS:.c=.h} all: ${SRCS} ${HDRS} -test: - @echo ${SRCS} - clean: +force-clean: + rm -f ${SRCS} ${HDRS} + .SUFFIXES: .xml .c .h .xml.c: diff --git a/lib/libxcb/src/bigreq.c b/lib/libxcb/src/bigreq.c index 9926f6146..46f66ca07 100644 --- a/lib/libxcb/src/bigreq.c +++ b/lib/libxcb/src/bigreq.c @@ -18,13 +18,13 @@ xcb_extension_t xcb_big_requests_id = { "BIG-REQUESTS", 0 }; xcb_big_requests_enable_cookie_t -xcb_big_requests_enable (xcb_connection_t *c /**< */) +xcb_big_requests_enable (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_big_requests_id, - /* opcode */ XCB_BIG_REQUESTS_ENABLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_big_requests_id, + .opcode = XCB_BIG_REQUESTS_ENABLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -42,13 +42,13 @@ xcb_big_requests_enable (xcb_connection_t *c /**< */) } xcb_big_requests_enable_cookie_t -xcb_big_requests_enable_unchecked (xcb_connection_t *c /**< */) +xcb_big_requests_enable_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_big_requests_id, - /* opcode */ XCB_BIG_REQUESTS_ENABLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_big_requests_id, + .opcode = XCB_BIG_REQUESTS_ENABLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -66,9 +66,9 @@ xcb_big_requests_enable_unchecked (xcb_connection_t *c /**< */) } xcb_big_requests_enable_reply_t * -xcb_big_requests_enable_reply (xcb_connection_t *c /**< */, +xcb_big_requests_enable_reply (xcb_connection_t *c, xcb_big_requests_enable_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_big_requests_enable_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/bigreq.h b/lib/libxcb/src/bigreq.h index 88401e0d5..bfb9527ba 100644 --- a/lib/libxcb/src/bigreq.h +++ b/lib/libxcb/src/bigreq.h @@ -27,7 +27,7 @@ extern xcb_extension_t xcb_big_requests_id; * @brief xcb_big_requests_enable_cookie_t **/ typedef struct xcb_big_requests_enable_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_big_requests_enable_cookie_t; /** Opcode for xcb_big_requests_enable. */ @@ -37,20 +37,20 @@ typedef struct xcb_big_requests_enable_cookie_t { * @brief xcb_big_requests_enable_request_t **/ typedef struct xcb_big_requests_enable_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_big_requests_enable_request_t; /** * @brief xcb_big_requests_enable_reply_t **/ typedef struct xcb_big_requests_enable_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t maximum_request_length; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t maximum_request_length; } xcb_big_requests_enable_reply_t; /** @@ -62,7 +62,7 @@ typedef struct xcb_big_requests_enable_reply_t { * */ xcb_big_requests_enable_cookie_t -xcb_big_requests_enable (xcb_connection_t *c /**< */); +xcb_big_requests_enable (xcb_connection_t *c); /** * @@ -76,7 +76,7 @@ xcb_big_requests_enable (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_big_requests_enable_cookie_t -xcb_big_requests_enable_unchecked (xcb_connection_t *c /**< */); +xcb_big_requests_enable_unchecked (xcb_connection_t *c); /** * Return the reply @@ -93,9 +93,9 @@ xcb_big_requests_enable_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_big_requests_enable_reply_t * -xcb_big_requests_enable_reply (xcb_connection_t *c /**< */, +xcb_big_requests_enable_reply (xcb_connection_t *c, xcb_big_requests_enable_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/composite.c b/lib/libxcb/src/composite.c index b79e9ac46..db3efbd63 100644 --- a/lib/libxcb/src/composite.c +++ b/lib/libxcb/src/composite.c @@ -20,15 +20,15 @@ xcb_extension_t xcb_composite_id = { "Composite", 0 }; xcb_composite_query_version_cookie_t -xcb_composite_query_version (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */) +xcb_composite_query_version (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -48,15 +48,15 @@ xcb_composite_query_version (xcb_connection_t *c /**< */, } xcb_composite_query_version_cookie_t -xcb_composite_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */) +xcb_composite_query_version_unchecked (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -76,23 +76,23 @@ xcb_composite_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_composite_query_version_reply_t * -xcb_composite_query_version_reply (xcb_connection_t *c /**< */, +xcb_composite_query_version_reply (xcb_connection_t *c, xcb_composite_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_composite_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_composite_redirect_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */) +xcb_composite_redirect_window_checked (xcb_connection_t *c, + xcb_window_t window, + uint8_t update) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_REDIRECT_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_REDIRECT_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -113,15 +113,15 @@ xcb_composite_redirect_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_redirect_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */) +xcb_composite_redirect_window (xcb_connection_t *c, + xcb_window_t window, + uint8_t update) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_REDIRECT_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_REDIRECT_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -142,15 +142,15 @@ xcb_composite_redirect_window (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_redirect_subwindows_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */) +xcb_composite_redirect_subwindows_checked (xcb_connection_t *c, + xcb_window_t window, + uint8_t update) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_REDIRECT_SUBWINDOWS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_REDIRECT_SUBWINDOWS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -171,15 +171,15 @@ xcb_composite_redirect_subwindows_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_redirect_subwindows (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */) +xcb_composite_redirect_subwindows (xcb_connection_t *c, + xcb_window_t window, + uint8_t update) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_REDIRECT_SUBWINDOWS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_REDIRECT_SUBWINDOWS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -200,15 +200,15 @@ xcb_composite_redirect_subwindows (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_unredirect_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */) +xcb_composite_unredirect_window_checked (xcb_connection_t *c, + xcb_window_t window, + uint8_t update) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_UNREDIRECT_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_UNREDIRECT_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -229,15 +229,15 @@ xcb_composite_unredirect_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_unredirect_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */) +xcb_composite_unredirect_window (xcb_connection_t *c, + xcb_window_t window, + uint8_t update) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_UNREDIRECT_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_UNREDIRECT_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -258,15 +258,15 @@ xcb_composite_unredirect_window (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_unredirect_subwindows_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */) +xcb_composite_unredirect_subwindows_checked (xcb_connection_t *c, + xcb_window_t window, + uint8_t update) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_UNREDIRECT_SUBWINDOWS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_UNREDIRECT_SUBWINDOWS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -287,15 +287,15 @@ xcb_composite_unredirect_subwindows_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_unredirect_subwindows (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */) +xcb_composite_unredirect_subwindows (xcb_connection_t *c, + xcb_window_t window, + uint8_t update) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_UNREDIRECT_SUBWINDOWS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_UNREDIRECT_SUBWINDOWS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -316,15 +316,15 @@ xcb_composite_unredirect_subwindows (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_create_region_from_border_clip_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_window_t window /**< */) +xcb_composite_create_region_from_border_clip_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_CREATE_REGION_FROM_BORDER_CLIP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_CREATE_REGION_FROM_BORDER_CLIP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -344,15 +344,15 @@ xcb_composite_create_region_from_border_clip_checked (xcb_connection_t *c /* } xcb_void_cookie_t -xcb_composite_create_region_from_border_clip (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_window_t window /**< */) +xcb_composite_create_region_from_border_clip (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_CREATE_REGION_FROM_BORDER_CLIP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_CREATE_REGION_FROM_BORDER_CLIP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -372,15 +372,15 @@ xcb_composite_create_region_from_border_clip (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_name_window_pixmap_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_pixmap_t pixmap /**< */) +xcb_composite_name_window_pixmap_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_pixmap_t pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_NAME_WINDOW_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_NAME_WINDOW_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -400,15 +400,15 @@ xcb_composite_name_window_pixmap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_name_window_pixmap (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_pixmap_t pixmap /**< */) +xcb_composite_name_window_pixmap (xcb_connection_t *c, + xcb_window_t window, + xcb_pixmap_t pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_NAME_WINDOW_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_NAME_WINDOW_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -428,14 +428,14 @@ xcb_composite_name_window_pixmap (xcb_connection_t *c /**< */, } xcb_composite_get_overlay_window_cookie_t -xcb_composite_get_overlay_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_composite_get_overlay_window (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_GET_OVERLAY_WINDOW, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_GET_OVERLAY_WINDOW, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -454,14 +454,14 @@ xcb_composite_get_overlay_window (xcb_connection_t *c /**< */, } xcb_composite_get_overlay_window_cookie_t -xcb_composite_get_overlay_window_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_composite_get_overlay_window_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_GET_OVERLAY_WINDOW, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_GET_OVERLAY_WINDOW, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -480,22 +480,22 @@ xcb_composite_get_overlay_window_unchecked (xcb_connection_t *c /**< */, } xcb_composite_get_overlay_window_reply_t * -xcb_composite_get_overlay_window_reply (xcb_connection_t *c /**< */, +xcb_composite_get_overlay_window_reply (xcb_connection_t *c, xcb_composite_get_overlay_window_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_composite_get_overlay_window_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_composite_release_overlay_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_composite_release_overlay_window_checked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_RELEASE_OVERLAY_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_RELEASE_OVERLAY_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -514,14 +514,14 @@ xcb_composite_release_overlay_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_composite_release_overlay_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_composite_release_overlay_window (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_composite_id, - /* opcode */ XCB_COMPOSITE_RELEASE_OVERLAY_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_composite_id, + .opcode = XCB_COMPOSITE_RELEASE_OVERLAY_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; diff --git a/lib/libxcb/src/composite.h b/lib/libxcb/src/composite.h index 112d53348..6daddeab8 100644 --- a/lib/libxcb/src/composite.h +++ b/lib/libxcb/src/composite.h @@ -34,7 +34,7 @@ typedef enum xcb_composite_redirect_t { * @brief xcb_composite_query_version_cookie_t **/ typedef struct xcb_composite_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_composite_query_version_cookie_t; /** Opcode for xcb_composite_query_version. */ @@ -44,24 +44,24 @@ typedef struct xcb_composite_query_version_cookie_t { * @brief xcb_composite_query_version_request_t **/ typedef struct xcb_composite_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t client_major_version; /**< */ - uint32_t client_minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t client_major_version; + uint32_t client_minor_version; } xcb_composite_query_version_request_t; /** * @brief xcb_composite_query_version_reply_t **/ typedef struct xcb_composite_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t major_version; + uint32_t minor_version; + uint8_t pad1[16]; } xcb_composite_query_version_reply_t; /** Opcode for xcb_composite_redirect_window. */ @@ -71,12 +71,12 @@ typedef struct xcb_composite_query_version_reply_t { * @brief xcb_composite_redirect_window_request_t **/ typedef struct xcb_composite_redirect_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint8_t update; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint8_t update; + uint8_t pad0[3]; } xcb_composite_redirect_window_request_t; /** Opcode for xcb_composite_redirect_subwindows. */ @@ -86,12 +86,12 @@ typedef struct xcb_composite_redirect_window_request_t { * @brief xcb_composite_redirect_subwindows_request_t **/ typedef struct xcb_composite_redirect_subwindows_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint8_t update; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint8_t update; + uint8_t pad0[3]; } xcb_composite_redirect_subwindows_request_t; /** Opcode for xcb_composite_unredirect_window. */ @@ -101,12 +101,12 @@ typedef struct xcb_composite_redirect_subwindows_request_t { * @brief xcb_composite_unredirect_window_request_t **/ typedef struct xcb_composite_unredirect_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint8_t update; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint8_t update; + uint8_t pad0[3]; } xcb_composite_unredirect_window_request_t; /** Opcode for xcb_composite_unredirect_subwindows. */ @@ -116,12 +116,12 @@ typedef struct xcb_composite_unredirect_window_request_t { * @brief xcb_composite_unredirect_subwindows_request_t **/ typedef struct xcb_composite_unredirect_subwindows_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint8_t update; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint8_t update; + uint8_t pad0[3]; } xcb_composite_unredirect_subwindows_request_t; /** Opcode for xcb_composite_create_region_from_border_clip. */ @@ -131,11 +131,11 @@ typedef struct xcb_composite_unredirect_subwindows_request_t { * @brief xcb_composite_create_region_from_border_clip_request_t **/ typedef struct xcb_composite_create_region_from_border_clip_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t region; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t region; + xcb_window_t window; } xcb_composite_create_region_from_border_clip_request_t; /** Opcode for xcb_composite_name_window_pixmap. */ @@ -145,18 +145,18 @@ typedef struct xcb_composite_create_region_from_border_clip_request_t { * @brief xcb_composite_name_window_pixmap_request_t **/ typedef struct xcb_composite_name_window_pixmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_pixmap_t pixmap; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_pixmap_t pixmap; } xcb_composite_name_window_pixmap_request_t; /** * @brief xcb_composite_get_overlay_window_cookie_t **/ typedef struct xcb_composite_get_overlay_window_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_composite_get_overlay_window_cookie_t; /** Opcode for xcb_composite_get_overlay_window. */ @@ -166,22 +166,22 @@ typedef struct xcb_composite_get_overlay_window_cookie_t { * @brief xcb_composite_get_overlay_window_request_t **/ typedef struct xcb_composite_get_overlay_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_composite_get_overlay_window_request_t; /** * @brief xcb_composite_get_overlay_window_reply_t **/ typedef struct xcb_composite_get_overlay_window_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t overlay_win; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_window_t overlay_win; + uint8_t pad1[20]; } xcb_composite_get_overlay_window_reply_t; /** Opcode for xcb_composite_release_overlay_window. */ @@ -191,10 +191,10 @@ typedef struct xcb_composite_get_overlay_window_reply_t { * @brief xcb_composite_release_overlay_window_request_t **/ typedef struct xcb_composite_release_overlay_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_composite_release_overlay_window_request_t; /** @@ -206,9 +206,9 @@ typedef struct xcb_composite_release_overlay_window_request_t { * */ xcb_composite_query_version_cookie_t -xcb_composite_query_version (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */); +xcb_composite_query_version (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version); /** * @@ -222,9 +222,9 @@ xcb_composite_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_composite_query_version_cookie_t -xcb_composite_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */); +xcb_composite_query_version_unchecked (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version); /** * Return the reply @@ -241,9 +241,9 @@ xcb_composite_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_composite_query_version_reply_t * -xcb_composite_query_version_reply (xcb_connection_t *c /**< */, +xcb_composite_query_version_reply (xcb_connection_t *c, xcb_composite_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -257,9 +257,9 @@ xcb_composite_query_version_reply (xcb_connection_t *c /** * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_composite_redirect_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */); +xcb_composite_redirect_window_checked (xcb_connection_t *c, + xcb_window_t window, + uint8_t update); /** * @@ -270,9 +270,9 @@ xcb_composite_redirect_window_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_composite_redirect_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */); +xcb_composite_redirect_window (xcb_connection_t *c, + xcb_window_t window, + uint8_t update); /** * @@ -286,9 +286,9 @@ xcb_composite_redirect_window (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_composite_redirect_subwindows_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */); +xcb_composite_redirect_subwindows_checked (xcb_connection_t *c, + xcb_window_t window, + uint8_t update); /** * @@ -299,9 +299,9 @@ xcb_composite_redirect_subwindows_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_composite_redirect_subwindows (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */); +xcb_composite_redirect_subwindows (xcb_connection_t *c, + xcb_window_t window, + uint8_t update); /** * @@ -315,9 +315,9 @@ xcb_composite_redirect_subwindows (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_composite_unredirect_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */); +xcb_composite_unredirect_window_checked (xcb_connection_t *c, + xcb_window_t window, + uint8_t update); /** * @@ -328,9 +328,9 @@ xcb_composite_unredirect_window_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_composite_unredirect_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */); +xcb_composite_unredirect_window (xcb_connection_t *c, + xcb_window_t window, + uint8_t update); /** * @@ -344,9 +344,9 @@ xcb_composite_unredirect_window (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_composite_unredirect_subwindows_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */); +xcb_composite_unredirect_subwindows_checked (xcb_connection_t *c, + xcb_window_t window, + uint8_t update); /** * @@ -357,9 +357,9 @@ xcb_composite_unredirect_subwindows_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_composite_unredirect_subwindows (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint8_t update /**< */); +xcb_composite_unredirect_subwindows (xcb_connection_t *c, + xcb_window_t window, + uint8_t update); /** * @@ -373,9 +373,9 @@ xcb_composite_unredirect_subwindows (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_composite_create_region_from_border_clip_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_window_t window /**< */); +xcb_composite_create_region_from_border_clip_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_window_t window); /** * @@ -386,9 +386,9 @@ xcb_composite_create_region_from_border_clip_checked (xcb_connection_t *c /* * */ xcb_void_cookie_t -xcb_composite_create_region_from_border_clip (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_window_t window /**< */); +xcb_composite_create_region_from_border_clip (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_window_t window); /** * @@ -402,9 +402,9 @@ xcb_composite_create_region_from_border_clip (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_composite_name_window_pixmap_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_pixmap_t pixmap /**< */); +xcb_composite_name_window_pixmap_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_pixmap_t pixmap); /** * @@ -415,9 +415,9 @@ xcb_composite_name_window_pixmap_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_composite_name_window_pixmap (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_pixmap_t pixmap /**< */); +xcb_composite_name_window_pixmap (xcb_connection_t *c, + xcb_window_t window, + xcb_pixmap_t pixmap); /** * @@ -428,8 +428,8 @@ xcb_composite_name_window_pixmap (xcb_connection_t *c /**< */, * */ xcb_composite_get_overlay_window_cookie_t -xcb_composite_get_overlay_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_composite_get_overlay_window (xcb_connection_t *c, + xcb_window_t window); /** * @@ -443,8 +443,8 @@ xcb_composite_get_overlay_window (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_composite_get_overlay_window_cookie_t -xcb_composite_get_overlay_window_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_composite_get_overlay_window_unchecked (xcb_connection_t *c, + xcb_window_t window); /** * Return the reply @@ -461,9 +461,9 @@ xcb_composite_get_overlay_window_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_composite_get_overlay_window_reply_t * -xcb_composite_get_overlay_window_reply (xcb_connection_t *c /**< */, +xcb_composite_get_overlay_window_reply (xcb_connection_t *c, xcb_composite_get_overlay_window_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -477,8 +477,8 @@ xcb_composite_get_overlay_window_reply (xcb_connection_t * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_composite_release_overlay_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_composite_release_overlay_window_checked (xcb_connection_t *c, + xcb_window_t window); /** * @@ -489,8 +489,8 @@ xcb_composite_release_overlay_window_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_composite_release_overlay_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_composite_release_overlay_window (xcb_connection_t *c, + xcb_window_t window); #ifdef __cplusplus diff --git a/lib/libxcb/src/config.h b/lib/libxcb/src/config.h index a848d0b32..030b6ef4e 100644 --- a/lib/libxcb/src/config.h +++ b/lib/libxcb/src/config.h @@ -2,7 +2,7 @@ /* src/config.h.in. Generated from configure.ac by autoheader. */ /* Defined if GCC supports the visibility feature */ -/* #undef GCC_HAS_VISIBILITY */ +#define GCC_HAS_VISIBILITY /**/ /* Has Wraphelp.c needed for XDM AUTH protocols */ #define HASXDMAUTH 1 @@ -25,6 +25,9 @@ /* launchd support available */ /* #undef HAVE_LAUNCHD */ +/* Define to 1 if you have the `ws2_32' library (-lws2_32). */ +/* #undef HAVE_LIBWS2_32 */ + /* Define to 1 if you have the header file. */ #define HAVE_MEMORY_H 1 @@ -61,21 +64,20 @@ /* Define if not provided by */ /* #undef IOV_MAX */ -/* Define to the sub-directory in which libtool stores uninstalled libraries. - */ +/* Define to the sub-directory where libtool stores uninstalled libraries. */ #define LT_OBJDIR ".libs/" /* Name of package */ #define PACKAGE "libxcb" /* Define to the address where bug reports for this package should be sent. */ -#define PACKAGE_BUGREPORT "xcb@lists.freedesktop.org" +#define PACKAGE_BUGREPORT "https://bugs.freedesktop.org/enter_bug.cgi?product=xcb" /* Define to the full name of this package. */ #define PACKAGE_NAME "libxcb" /* Define to the full name and version of this package. */ -#define PACKAGE_STRING "libxcb 1.10" +#define PACKAGE_STRING "libxcb 1.12" /* Define to the one symbol short name of this package. */ #define PACKAGE_TARNAME "libxcb" @@ -84,7 +86,16 @@ #define PACKAGE_URL "" /* Define to the version of this package. */ -#define PACKAGE_VERSION "1.10" +#define PACKAGE_VERSION "1.12" + +/* Major version of this package */ +#define PACKAGE_VERSION_MAJOR 1 + +/* Minor version of this package */ +#define PACKAGE_VERSION_MINOR 12 + +/* Patch version of this package */ +#define PACKAGE_VERSION_PATCHLEVEL 0 /* Define to 1 if you have the ANSI C header files. */ #define STDC_HEADERS 1 @@ -115,7 +126,7 @@ /* Version number of package */ -#define VERSION "1.10" +#define VERSION "1.12" /* XCB buffer queue size */ #define XCB_QUEUE_BUFFER_SIZE 16384 diff --git a/lib/libxcb/src/damage.c b/lib/libxcb/src/damage.c index 8c57e6d6f..e84a5b9da 100644 --- a/lib/libxcb/src/damage.c +++ b/lib/libxcb/src/damage.c @@ -20,7 +20,7 @@ xcb_extension_t xcb_damage_id = { "DAMAGE", 0 }; void -xcb_damage_damage_next (xcb_damage_damage_iterator_t *i /**< */) +xcb_damage_damage_next (xcb_damage_damage_iterator_t *i) { --i->rem; ++i->data; @@ -28,7 +28,7 @@ xcb_damage_damage_next (xcb_damage_damage_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_damage_damage_end (xcb_damage_damage_iterator_t i /**< */) +xcb_damage_damage_end (xcb_damage_damage_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -38,15 +38,15 @@ xcb_damage_damage_end (xcb_damage_damage_iterator_t i /**< */) } xcb_damage_query_version_cookie_t -xcb_damage_query_version (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */) +xcb_damage_query_version (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_damage_id, - /* opcode */ XCB_DAMAGE_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_damage_id, + .opcode = XCB_DAMAGE_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -66,15 +66,15 @@ xcb_damage_query_version (xcb_connection_t *c /**< */, } xcb_damage_query_version_cookie_t -xcb_damage_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */) +xcb_damage_query_version_unchecked (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_damage_id, - /* opcode */ XCB_DAMAGE_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_damage_id, + .opcode = XCB_DAMAGE_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -94,24 +94,24 @@ xcb_damage_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_damage_query_version_reply_t * -xcb_damage_query_version_reply (xcb_connection_t *c /**< */, +xcb_damage_query_version_reply (xcb_connection_t *c, xcb_damage_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_damage_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_damage_create_checked (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */, - xcb_drawable_t drawable /**< */, - uint8_t level /**< */) +xcb_damage_create_checked (xcb_connection_t *c, + xcb_damage_damage_t damage, + xcb_drawable_t drawable, + uint8_t level) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_damage_id, - /* opcode */ XCB_DAMAGE_CREATE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_damage_id, + .opcode = XCB_DAMAGE_CREATE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -133,16 +133,16 @@ xcb_damage_create_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_damage_create (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */, - xcb_drawable_t drawable /**< */, - uint8_t level /**< */) +xcb_damage_create (xcb_connection_t *c, + xcb_damage_damage_t damage, + xcb_drawable_t drawable, + uint8_t level) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_damage_id, - /* opcode */ XCB_DAMAGE_CREATE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_damage_id, + .opcode = XCB_DAMAGE_CREATE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -164,14 +164,14 @@ xcb_damage_create (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_damage_destroy_checked (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */) +xcb_damage_destroy_checked (xcb_connection_t *c, + xcb_damage_damage_t damage) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_damage_id, - /* opcode */ XCB_DAMAGE_DESTROY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_damage_id, + .opcode = XCB_DAMAGE_DESTROY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -190,14 +190,14 @@ xcb_damage_destroy_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_damage_destroy (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */) +xcb_damage_destroy (xcb_connection_t *c, + xcb_damage_damage_t damage) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_damage_id, - /* opcode */ XCB_DAMAGE_DESTROY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_damage_id, + .opcode = XCB_DAMAGE_DESTROY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -216,16 +216,16 @@ xcb_damage_destroy (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_damage_subtract_checked (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */, - xcb_xfixes_region_t repair /**< */, - xcb_xfixes_region_t parts /**< */) +xcb_damage_subtract_checked (xcb_connection_t *c, + xcb_damage_damage_t damage, + xcb_xfixes_region_t repair, + xcb_xfixes_region_t parts) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_damage_id, - /* opcode */ XCB_DAMAGE_SUBTRACT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_damage_id, + .opcode = XCB_DAMAGE_SUBTRACT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -246,16 +246,16 @@ xcb_damage_subtract_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_damage_subtract (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */, - xcb_xfixes_region_t repair /**< */, - xcb_xfixes_region_t parts /**< */) +xcb_damage_subtract (xcb_connection_t *c, + xcb_damage_damage_t damage, + xcb_xfixes_region_t repair, + xcb_xfixes_region_t parts) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_damage_id, - /* opcode */ XCB_DAMAGE_SUBTRACT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_damage_id, + .opcode = XCB_DAMAGE_SUBTRACT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -276,15 +276,15 @@ xcb_damage_subtract (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_damage_add_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_xfixes_region_t region /**< */) +xcb_damage_add_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_xfixes_region_t region) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_damage_id, - /* opcode */ XCB_DAMAGE_ADD, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_damage_id, + .opcode = XCB_DAMAGE_ADD, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -304,15 +304,15 @@ xcb_damage_add_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_damage_add (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_xfixes_region_t region /**< */) +xcb_damage_add (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_xfixes_region_t region) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_damage_id, - /* opcode */ XCB_DAMAGE_ADD, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_damage_id, + .opcode = XCB_DAMAGE_ADD, + .isvoid = 1 }; struct iovec xcb_parts[4]; diff --git a/lib/libxcb/src/damage.h b/lib/libxcb/src/damage.h index 1884dd62f..213517f2a 100644 --- a/lib/libxcb/src/damage.h +++ b/lib/libxcb/src/damage.h @@ -31,9 +31,9 @@ typedef uint32_t xcb_damage_damage_t; * @brief xcb_damage_damage_iterator_t **/ typedef struct xcb_damage_damage_iterator_t { - xcb_damage_damage_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_damage_damage_t *data; + int rem; + int index; } xcb_damage_damage_iterator_t; typedef enum xcb_damage_report_level_t { @@ -50,16 +50,16 @@ typedef enum xcb_damage_report_level_t { * @brief xcb_damage_bad_damage_error_t **/ typedef struct xcb_damage_bad_damage_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_damage_bad_damage_error_t; /** * @brief xcb_damage_query_version_cookie_t **/ typedef struct xcb_damage_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_damage_query_version_cookie_t; /** Opcode for xcb_damage_query_version. */ @@ -69,24 +69,24 @@ typedef struct xcb_damage_query_version_cookie_t { * @brief xcb_damage_query_version_request_t **/ typedef struct xcb_damage_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t client_major_version; /**< */ - uint32_t client_minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t client_major_version; + uint32_t client_minor_version; } xcb_damage_query_version_request_t; /** * @brief xcb_damage_query_version_reply_t **/ typedef struct xcb_damage_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t major_version; + uint32_t minor_version; + uint8_t pad1[16]; } xcb_damage_query_version_reply_t; /** Opcode for xcb_damage_create. */ @@ -96,13 +96,13 @@ typedef struct xcb_damage_query_version_reply_t { * @brief xcb_damage_create_request_t **/ typedef struct xcb_damage_create_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_damage_damage_t damage; /**< */ - xcb_drawable_t drawable; /**< */ - uint8_t level; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_damage_damage_t damage; + xcb_drawable_t drawable; + uint8_t level; + uint8_t pad0[3]; } xcb_damage_create_request_t; /** Opcode for xcb_damage_destroy. */ @@ -112,10 +112,10 @@ typedef struct xcb_damage_create_request_t { * @brief xcb_damage_destroy_request_t **/ typedef struct xcb_damage_destroy_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_damage_damage_t damage; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_damage_damage_t damage; } xcb_damage_destroy_request_t; /** Opcode for xcb_damage_subtract. */ @@ -125,12 +125,12 @@ typedef struct xcb_damage_destroy_request_t { * @brief xcb_damage_subtract_request_t **/ typedef struct xcb_damage_subtract_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_damage_damage_t damage; /**< */ - xcb_xfixes_region_t repair; /**< */ - xcb_xfixes_region_t parts; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_damage_damage_t damage; + xcb_xfixes_region_t repair; + xcb_xfixes_region_t parts; } xcb_damage_subtract_request_t; /** Opcode for xcb_damage_add. */ @@ -140,11 +140,11 @@ typedef struct xcb_damage_subtract_request_t { * @brief xcb_damage_add_request_t **/ typedef struct xcb_damage_add_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_xfixes_region_t region; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + xcb_xfixes_region_t region; } xcb_damage_add_request_t; /** Opcode for xcb_damage_notify. */ @@ -154,14 +154,14 @@ typedef struct xcb_damage_add_request_t { * @brief xcb_damage_notify_event_t **/ typedef struct xcb_damage_notify_event_t { - uint8_t response_type; /**< */ - uint8_t level; /**< */ - uint16_t sequence; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_damage_damage_t damage; /**< */ - xcb_timestamp_t timestamp; /**< */ - xcb_rectangle_t area; /**< */ - xcb_rectangle_t geometry; /**< */ + uint8_t response_type; + uint8_t level; + uint16_t sequence; + xcb_drawable_t drawable; + xcb_damage_damage_t damage; + xcb_timestamp_t timestamp; + xcb_rectangle_t area; + xcb_rectangle_t geometry; } xcb_damage_notify_event_t; /** @@ -173,7 +173,7 @@ typedef struct xcb_damage_notify_event_t { * element. The member index is increased by sizeof(xcb_damage_damage_t) */ void -xcb_damage_damage_next (xcb_damage_damage_iterator_t *i /**< */); +xcb_damage_damage_next (xcb_damage_damage_iterator_t *i); /** * Return the iterator pointing to the last element @@ -185,7 +185,7 @@ xcb_damage_damage_next (xcb_damage_damage_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_damage_damage_end (xcb_damage_damage_iterator_t i /**< */); +xcb_damage_damage_end (xcb_damage_damage_iterator_t i); /** * @@ -196,9 +196,9 @@ xcb_damage_damage_end (xcb_damage_damage_iterator_t i /**< */); * */ xcb_damage_query_version_cookie_t -xcb_damage_query_version (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */); +xcb_damage_query_version (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version); /** * @@ -212,9 +212,9 @@ xcb_damage_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_damage_query_version_cookie_t -xcb_damage_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */); +xcb_damage_query_version_unchecked (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version); /** * Return the reply @@ -231,9 +231,9 @@ xcb_damage_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_damage_query_version_reply_t * -xcb_damage_query_version_reply (xcb_connection_t *c /**< */, +xcb_damage_query_version_reply (xcb_connection_t *c, xcb_damage_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -247,10 +247,10 @@ xcb_damage_query_version_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_damage_create_checked (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */, - xcb_drawable_t drawable /**< */, - uint8_t level /**< */); +xcb_damage_create_checked (xcb_connection_t *c, + xcb_damage_damage_t damage, + xcb_drawable_t drawable, + uint8_t level); /** * @@ -261,10 +261,10 @@ xcb_damage_create_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_damage_create (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */, - xcb_drawable_t drawable /**< */, - uint8_t level /**< */); +xcb_damage_create (xcb_connection_t *c, + xcb_damage_damage_t damage, + xcb_drawable_t drawable, + uint8_t level); /** * @@ -278,8 +278,8 @@ xcb_damage_create (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_damage_destroy_checked (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */); +xcb_damage_destroy_checked (xcb_connection_t *c, + xcb_damage_damage_t damage); /** * @@ -290,8 +290,8 @@ xcb_damage_destroy_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_damage_destroy (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */); +xcb_damage_destroy (xcb_connection_t *c, + xcb_damage_damage_t damage); /** * @@ -305,10 +305,10 @@ xcb_damage_destroy (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_damage_subtract_checked (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */, - xcb_xfixes_region_t repair /**< */, - xcb_xfixes_region_t parts /**< */); +xcb_damage_subtract_checked (xcb_connection_t *c, + xcb_damage_damage_t damage, + xcb_xfixes_region_t repair, + xcb_xfixes_region_t parts); /** * @@ -319,10 +319,10 @@ xcb_damage_subtract_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_damage_subtract (xcb_connection_t *c /**< */, - xcb_damage_damage_t damage /**< */, - xcb_xfixes_region_t repair /**< */, - xcb_xfixes_region_t parts /**< */); +xcb_damage_subtract (xcb_connection_t *c, + xcb_damage_damage_t damage, + xcb_xfixes_region_t repair, + xcb_xfixes_region_t parts); /** * @@ -336,9 +336,9 @@ xcb_damage_subtract (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_damage_add_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_xfixes_region_t region /**< */); +xcb_damage_add_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_xfixes_region_t region); /** * @@ -349,9 +349,9 @@ xcb_damage_add_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_damage_add (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_xfixes_region_t region /**< */); +xcb_damage_add (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_xfixes_region_t region); #ifdef __cplusplus diff --git a/lib/libxcb/src/dpms.c b/lib/libxcb/src/dpms.c index 66af6bec7..e1020d4df 100644 --- a/lib/libxcb/src/dpms.c +++ b/lib/libxcb/src/dpms.c @@ -18,15 +18,15 @@ xcb_extension_t xcb_dpms_id = { "DPMS", 0 }; xcb_dpms_get_version_cookie_t -xcb_dpms_get_version (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */) +xcb_dpms_get_version (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_GET_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_GET_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -46,15 +46,15 @@ xcb_dpms_get_version (xcb_connection_t *c /**< */, } xcb_dpms_get_version_cookie_t -xcb_dpms_get_version_unchecked (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */) +xcb_dpms_get_version_unchecked (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_GET_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_GET_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -74,21 +74,21 @@ xcb_dpms_get_version_unchecked (xcb_connection_t *c /**< */, } xcb_dpms_get_version_reply_t * -xcb_dpms_get_version_reply (xcb_connection_t *c /**< */, +xcb_dpms_get_version_reply (xcb_connection_t *c, xcb_dpms_get_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dpms_get_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_dpms_capable_cookie_t -xcb_dpms_capable (xcb_connection_t *c /**< */) +xcb_dpms_capable (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_CAPABLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_CAPABLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -106,13 +106,13 @@ xcb_dpms_capable (xcb_connection_t *c /**< */) } xcb_dpms_capable_cookie_t -xcb_dpms_capable_unchecked (xcb_connection_t *c /**< */) +xcb_dpms_capable_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_CAPABLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_CAPABLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -130,21 +130,21 @@ xcb_dpms_capable_unchecked (xcb_connection_t *c /**< */) } xcb_dpms_capable_reply_t * -xcb_dpms_capable_reply (xcb_connection_t *c /**< */, +xcb_dpms_capable_reply (xcb_connection_t *c, xcb_dpms_capable_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dpms_capable_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_dpms_get_timeouts_cookie_t -xcb_dpms_get_timeouts (xcb_connection_t *c /**< */) +xcb_dpms_get_timeouts (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_GET_TIMEOUTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_GET_TIMEOUTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -162,13 +162,13 @@ xcb_dpms_get_timeouts (xcb_connection_t *c /**< */) } xcb_dpms_get_timeouts_cookie_t -xcb_dpms_get_timeouts_unchecked (xcb_connection_t *c /**< */) +xcb_dpms_get_timeouts_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_GET_TIMEOUTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_GET_TIMEOUTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -186,24 +186,24 @@ xcb_dpms_get_timeouts_unchecked (xcb_connection_t *c /**< */) } xcb_dpms_get_timeouts_reply_t * -xcb_dpms_get_timeouts_reply (xcb_connection_t *c /**< */, +xcb_dpms_get_timeouts_reply (xcb_connection_t *c, xcb_dpms_get_timeouts_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dpms_get_timeouts_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_dpms_set_timeouts_checked (xcb_connection_t *c /**< */, - uint16_t standby_timeout /**< */, - uint16_t suspend_timeout /**< */, - uint16_t off_timeout /**< */) +xcb_dpms_set_timeouts_checked (xcb_connection_t *c, + uint16_t standby_timeout, + uint16_t suspend_timeout, + uint16_t off_timeout) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_SET_TIMEOUTS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_SET_TIMEOUTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -224,16 +224,16 @@ xcb_dpms_set_timeouts_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_dpms_set_timeouts (xcb_connection_t *c /**< */, - uint16_t standby_timeout /**< */, - uint16_t suspend_timeout /**< */, - uint16_t off_timeout /**< */) +xcb_dpms_set_timeouts (xcb_connection_t *c, + uint16_t standby_timeout, + uint16_t suspend_timeout, + uint16_t off_timeout) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_SET_TIMEOUTS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_SET_TIMEOUTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -254,13 +254,13 @@ xcb_dpms_set_timeouts (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_dpms_enable_checked (xcb_connection_t *c /**< */) +xcb_dpms_enable_checked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_ENABLE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_ENABLE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -278,13 +278,13 @@ xcb_dpms_enable_checked (xcb_connection_t *c /**< */) } xcb_void_cookie_t -xcb_dpms_enable (xcb_connection_t *c /**< */) +xcb_dpms_enable (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_ENABLE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_ENABLE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -302,13 +302,13 @@ xcb_dpms_enable (xcb_connection_t *c /**< */) } xcb_void_cookie_t -xcb_dpms_disable_checked (xcb_connection_t *c /**< */) +xcb_dpms_disable_checked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_DISABLE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_DISABLE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -326,13 +326,13 @@ xcb_dpms_disable_checked (xcb_connection_t *c /**< */) } xcb_void_cookie_t -xcb_dpms_disable (xcb_connection_t *c /**< */) +xcb_dpms_disable (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_DISABLE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_DISABLE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -350,14 +350,14 @@ xcb_dpms_disable (xcb_connection_t *c /**< */) } xcb_void_cookie_t -xcb_dpms_force_level_checked (xcb_connection_t *c /**< */, - uint16_t power_level /**< */) +xcb_dpms_force_level_checked (xcb_connection_t *c, + uint16_t power_level) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_FORCE_LEVEL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_FORCE_LEVEL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -376,14 +376,14 @@ xcb_dpms_force_level_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_dpms_force_level (xcb_connection_t *c /**< */, - uint16_t power_level /**< */) +xcb_dpms_force_level (xcb_connection_t *c, + uint16_t power_level) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_FORCE_LEVEL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_FORCE_LEVEL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -402,13 +402,13 @@ xcb_dpms_force_level (xcb_connection_t *c /**< */, } xcb_dpms_info_cookie_t -xcb_dpms_info (xcb_connection_t *c /**< */) +xcb_dpms_info (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -426,13 +426,13 @@ xcb_dpms_info (xcb_connection_t *c /**< */) } xcb_dpms_info_cookie_t -xcb_dpms_info_unchecked (xcb_connection_t *c /**< */) +xcb_dpms_info_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dpms_id, - /* opcode */ XCB_DPMS_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dpms_id, + .opcode = XCB_DPMS_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -450,9 +450,9 @@ xcb_dpms_info_unchecked (xcb_connection_t *c /**< */) } xcb_dpms_info_reply_t * -xcb_dpms_info_reply (xcb_connection_t *c /**< */, +xcb_dpms_info_reply (xcb_connection_t *c, xcb_dpms_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dpms_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/dpms.h b/lib/libxcb/src/dpms.h index fb2df9dc3..95aa91d78 100644 --- a/lib/libxcb/src/dpms.h +++ b/lib/libxcb/src/dpms.h @@ -27,7 +27,7 @@ extern xcb_extension_t xcb_dpms_id; * @brief xcb_dpms_get_version_cookie_t **/ typedef struct xcb_dpms_get_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dpms_get_version_cookie_t; /** Opcode for xcb_dpms_get_version. */ @@ -37,30 +37,30 @@ typedef struct xcb_dpms_get_version_cookie_t { * @brief xcb_dpms_get_version_request_t **/ typedef struct xcb_dpms_get_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t client_major_version; /**< */ - uint16_t client_minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t client_major_version; + uint16_t client_minor_version; } xcb_dpms_get_version_request_t; /** * @brief xcb_dpms_get_version_reply_t **/ typedef struct xcb_dpms_get_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t server_major_version; /**< */ - uint16_t server_minor_version; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t server_major_version; + uint16_t server_minor_version; } xcb_dpms_get_version_reply_t; /** * @brief xcb_dpms_capable_cookie_t **/ typedef struct xcb_dpms_capable_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dpms_capable_cookie_t; /** Opcode for xcb_dpms_capable. */ @@ -70,28 +70,28 @@ typedef struct xcb_dpms_capable_cookie_t { * @brief xcb_dpms_capable_request_t **/ typedef struct xcb_dpms_capable_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_dpms_capable_request_t; /** * @brief xcb_dpms_capable_reply_t **/ typedef struct xcb_dpms_capable_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t capable; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t capable; + uint8_t pad1[23]; } xcb_dpms_capable_reply_t; /** * @brief xcb_dpms_get_timeouts_cookie_t **/ typedef struct xcb_dpms_get_timeouts_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dpms_get_timeouts_cookie_t; /** Opcode for xcb_dpms_get_timeouts. */ @@ -101,23 +101,23 @@ typedef struct xcb_dpms_get_timeouts_cookie_t { * @brief xcb_dpms_get_timeouts_request_t **/ typedef struct xcb_dpms_get_timeouts_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_dpms_get_timeouts_request_t; /** * @brief xcb_dpms_get_timeouts_reply_t **/ typedef struct xcb_dpms_get_timeouts_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t standby_timeout; /**< */ - uint16_t suspend_timeout; /**< */ - uint16_t off_timeout; /**< */ - uint8_t pad1[18]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t standby_timeout; + uint16_t suspend_timeout; + uint16_t off_timeout; + uint8_t pad1[18]; } xcb_dpms_get_timeouts_reply_t; /** Opcode for xcb_dpms_set_timeouts. */ @@ -127,12 +127,12 @@ typedef struct xcb_dpms_get_timeouts_reply_t { * @brief xcb_dpms_set_timeouts_request_t **/ typedef struct xcb_dpms_set_timeouts_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t standby_timeout; /**< */ - uint16_t suspend_timeout; /**< */ - uint16_t off_timeout; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t standby_timeout; + uint16_t suspend_timeout; + uint16_t off_timeout; } xcb_dpms_set_timeouts_request_t; /** Opcode for xcb_dpms_enable. */ @@ -142,9 +142,9 @@ typedef struct xcb_dpms_set_timeouts_request_t { * @brief xcb_dpms_enable_request_t **/ typedef struct xcb_dpms_enable_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_dpms_enable_request_t; /** Opcode for xcb_dpms_disable. */ @@ -154,9 +154,9 @@ typedef struct xcb_dpms_enable_request_t { * @brief xcb_dpms_disable_request_t **/ typedef struct xcb_dpms_disable_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_dpms_disable_request_t; typedef enum xcb_dpms_dpms_mode_t { @@ -173,17 +173,17 @@ typedef enum xcb_dpms_dpms_mode_t { * @brief xcb_dpms_force_level_request_t **/ typedef struct xcb_dpms_force_level_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t power_level; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t power_level; } xcb_dpms_force_level_request_t; /** * @brief xcb_dpms_info_cookie_t **/ typedef struct xcb_dpms_info_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dpms_info_cookie_t; /** Opcode for xcb_dpms_info. */ @@ -193,22 +193,22 @@ typedef struct xcb_dpms_info_cookie_t { * @brief xcb_dpms_info_request_t **/ typedef struct xcb_dpms_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_dpms_info_request_t; /** * @brief xcb_dpms_info_reply_t **/ typedef struct xcb_dpms_info_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t power_level; /**< */ - uint8_t state; /**< */ - uint8_t pad1[21]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t power_level; + uint8_t state; + uint8_t pad1[21]; } xcb_dpms_info_reply_t; /** @@ -220,9 +220,9 @@ typedef struct xcb_dpms_info_reply_t { * */ xcb_dpms_get_version_cookie_t -xcb_dpms_get_version (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */); +xcb_dpms_get_version (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version); /** * @@ -236,9 +236,9 @@ xcb_dpms_get_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dpms_get_version_cookie_t -xcb_dpms_get_version_unchecked (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */); +xcb_dpms_get_version_unchecked (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version); /** * Return the reply @@ -255,9 +255,9 @@ xcb_dpms_get_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dpms_get_version_reply_t * -xcb_dpms_get_version_reply (xcb_connection_t *c /**< */, +xcb_dpms_get_version_reply (xcb_connection_t *c, xcb_dpms_get_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -268,7 +268,7 @@ xcb_dpms_get_version_reply (xcb_connection_t *c /**< */, * */ xcb_dpms_capable_cookie_t -xcb_dpms_capable (xcb_connection_t *c /**< */); +xcb_dpms_capable (xcb_connection_t *c); /** * @@ -282,7 +282,7 @@ xcb_dpms_capable (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_dpms_capable_cookie_t -xcb_dpms_capable_unchecked (xcb_connection_t *c /**< */); +xcb_dpms_capable_unchecked (xcb_connection_t *c); /** * Return the reply @@ -299,9 +299,9 @@ xcb_dpms_capable_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_dpms_capable_reply_t * -xcb_dpms_capable_reply (xcb_connection_t *c /**< */, +xcb_dpms_capable_reply (xcb_connection_t *c, xcb_dpms_capable_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -312,7 +312,7 @@ xcb_dpms_capable_reply (xcb_connection_t *c /**< */, * */ xcb_dpms_get_timeouts_cookie_t -xcb_dpms_get_timeouts (xcb_connection_t *c /**< */); +xcb_dpms_get_timeouts (xcb_connection_t *c); /** * @@ -326,7 +326,7 @@ xcb_dpms_get_timeouts (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_dpms_get_timeouts_cookie_t -xcb_dpms_get_timeouts_unchecked (xcb_connection_t *c /**< */); +xcb_dpms_get_timeouts_unchecked (xcb_connection_t *c); /** * Return the reply @@ -343,9 +343,9 @@ xcb_dpms_get_timeouts_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_dpms_get_timeouts_reply_t * -xcb_dpms_get_timeouts_reply (xcb_connection_t *c /**< */, +xcb_dpms_get_timeouts_reply (xcb_connection_t *c, xcb_dpms_get_timeouts_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -359,10 +359,10 @@ xcb_dpms_get_timeouts_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_dpms_set_timeouts_checked (xcb_connection_t *c /**< */, - uint16_t standby_timeout /**< */, - uint16_t suspend_timeout /**< */, - uint16_t off_timeout /**< */); +xcb_dpms_set_timeouts_checked (xcb_connection_t *c, + uint16_t standby_timeout, + uint16_t suspend_timeout, + uint16_t off_timeout); /** * @@ -373,10 +373,10 @@ xcb_dpms_set_timeouts_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_dpms_set_timeouts (xcb_connection_t *c /**< */, - uint16_t standby_timeout /**< */, - uint16_t suspend_timeout /**< */, - uint16_t off_timeout /**< */); +xcb_dpms_set_timeouts (xcb_connection_t *c, + uint16_t standby_timeout, + uint16_t suspend_timeout, + uint16_t off_timeout); /** * @@ -390,7 +390,7 @@ xcb_dpms_set_timeouts (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_dpms_enable_checked (xcb_connection_t *c /**< */); +xcb_dpms_enable_checked (xcb_connection_t *c); /** * @@ -401,7 +401,7 @@ xcb_dpms_enable_checked (xcb_connection_t *c /**< */); * */ xcb_void_cookie_t -xcb_dpms_enable (xcb_connection_t *c /**< */); +xcb_dpms_enable (xcb_connection_t *c); /** * @@ -415,7 +415,7 @@ xcb_dpms_enable (xcb_connection_t *c /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_dpms_disable_checked (xcb_connection_t *c /**< */); +xcb_dpms_disable_checked (xcb_connection_t *c); /** * @@ -426,7 +426,7 @@ xcb_dpms_disable_checked (xcb_connection_t *c /**< */); * */ xcb_void_cookie_t -xcb_dpms_disable (xcb_connection_t *c /**< */); +xcb_dpms_disable (xcb_connection_t *c); /** * @@ -440,8 +440,8 @@ xcb_dpms_disable (xcb_connection_t *c /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_dpms_force_level_checked (xcb_connection_t *c /**< */, - uint16_t power_level /**< */); +xcb_dpms_force_level_checked (xcb_connection_t *c, + uint16_t power_level); /** * @@ -452,8 +452,8 @@ xcb_dpms_force_level_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_dpms_force_level (xcb_connection_t *c /**< */, - uint16_t power_level /**< */); +xcb_dpms_force_level (xcb_connection_t *c, + uint16_t power_level); /** * @@ -464,7 +464,7 @@ xcb_dpms_force_level (xcb_connection_t *c /**< */, * */ xcb_dpms_info_cookie_t -xcb_dpms_info (xcb_connection_t *c /**< */); +xcb_dpms_info (xcb_connection_t *c); /** * @@ -478,7 +478,7 @@ xcb_dpms_info (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_dpms_info_cookie_t -xcb_dpms_info_unchecked (xcb_connection_t *c /**< */); +xcb_dpms_info_unchecked (xcb_connection_t *c); /** * Return the reply @@ -495,9 +495,9 @@ xcb_dpms_info_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_dpms_info_reply_t * -xcb_dpms_info_reply (xcb_connection_t *c /**< */, +xcb_dpms_info_reply (xcb_connection_t *c, xcb_dpms_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/dri2.c b/lib/libxcb/src/dri2.c index 9554520eb..a8bcf6ac7 100644 --- a/lib/libxcb/src/dri2.c +++ b/lib/libxcb/src/dri2.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_dri2_id = { "DRI2", 0 }; void -xcb_dri2_dri2_buffer_next (xcb_dri2_dri2_buffer_iterator_t *i /**< */) +xcb_dri2_dri2_buffer_next (xcb_dri2_dri2_buffer_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_dri2_dri2_buffer_next (xcb_dri2_dri2_buffer_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_dri2_dri2_buffer_end (xcb_dri2_dri2_buffer_iterator_t i /**< */) +xcb_dri2_dri2_buffer_end (xcb_dri2_dri2_buffer_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,7 +37,7 @@ xcb_dri2_dri2_buffer_end (xcb_dri2_dri2_buffer_iterator_t i /**< */) } void -xcb_dri2_attach_format_next (xcb_dri2_attach_format_iterator_t *i /**< */) +xcb_dri2_attach_format_next (xcb_dri2_attach_format_iterator_t *i) { --i->rem; ++i->data; @@ -45,7 +45,7 @@ xcb_dri2_attach_format_next (xcb_dri2_attach_format_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_dri2_attach_format_end (xcb_dri2_attach_format_iterator_t i /**< */) +xcb_dri2_attach_format_end (xcb_dri2_attach_format_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -55,15 +55,15 @@ xcb_dri2_attach_format_end (xcb_dri2_attach_format_iterator_t i /**< */) } xcb_dri2_query_version_cookie_t -xcb_dri2_query_version (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */) +xcb_dri2_query_version (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -83,15 +83,15 @@ xcb_dri2_query_version (xcb_connection_t *c /**< */, } xcb_dri2_query_version_cookie_t -xcb_dri2_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */) +xcb_dri2_query_version_unchecked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -111,15 +111,15 @@ xcb_dri2_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_dri2_query_version_reply_t * -xcb_dri2_query_version_reply (xcb_connection_t *c /**< */, +xcb_dri2_query_version_reply (xcb_connection_t *c, xcb_dri2_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_dri2_connect_sizeof (const void *_buffer /**< */) +xcb_dri2_connect_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_dri2_connect_reply_t *_aux = (xcb_dri2_connect_reply_t *)_buffer; @@ -174,15 +174,15 @@ xcb_dri2_connect_sizeof (const void *_buffer /**< */) } xcb_dri2_connect_cookie_t -xcb_dri2_connect (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t driver_type /**< */) +xcb_dri2_connect (xcb_connection_t *c, + xcb_window_t window, + uint32_t driver_type) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_CONNECT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_CONNECT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -202,15 +202,15 @@ xcb_dri2_connect (xcb_connection_t *c /**< */, } xcb_dri2_connect_cookie_t -xcb_dri2_connect_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t driver_type /**< */) +xcb_dri2_connect_unchecked (xcb_connection_t *c, + xcb_window_t window, + uint32_t driver_type) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_CONNECT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_CONNECT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -230,19 +230,19 @@ xcb_dri2_connect_unchecked (xcb_connection_t *c /**< */, } char * -xcb_dri2_connect_driver_name (const xcb_dri2_connect_reply_t *R /**< */) +xcb_dri2_connect_driver_name (const xcb_dri2_connect_reply_t *R) { return (char *) (R + 1); } int -xcb_dri2_connect_driver_name_length (const xcb_dri2_connect_reply_t *R /**< */) +xcb_dri2_connect_driver_name_length (const xcb_dri2_connect_reply_t *R) { return R->driver_name_length; } xcb_generic_iterator_t -xcb_dri2_connect_driver_name_end (const xcb_dri2_connect_reply_t *R /**< */) +xcb_dri2_connect_driver_name_end (const xcb_dri2_connect_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->driver_name_length); @@ -252,71 +252,71 @@ xcb_dri2_connect_driver_name_end (const xcb_dri2_connect_reply_t *R /**< */) } void * -xcb_dri2_connect_alignment_pad (const xcb_dri2_connect_reply_t *R /**< */) +xcb_dri2_connect_alignment_pad (const xcb_dri2_connect_reply_t *R) { xcb_generic_iterator_t prev = xcb_dri2_connect_driver_name_end(R); return (void *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); } int -xcb_dri2_connect_alignment_pad_length (const xcb_dri2_connect_reply_t *R /**< */) +xcb_dri2_connect_alignment_pad_length (const xcb_dri2_connect_reply_t *R) { return (((R->driver_name_length + 3) & (~3)) - R->driver_name_length); } xcb_generic_iterator_t -xcb_dri2_connect_alignment_pad_end (const xcb_dri2_connect_reply_t *R /**< */) +xcb_dri2_connect_alignment_pad_end (const xcb_dri2_connect_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_dri2_connect_driver_name_end(R); - i.data = ((char *) child.data) + ((((R->driver_name_length + 3) & (~3)) - R->driver_name_length)); + xcb_generic_iterator_t prev = xcb_dri2_connect_driver_name_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + ((((R->driver_name_length + 3) & (~3)) - R->driver_name_length)); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } char * -xcb_dri2_connect_device_name (const xcb_dri2_connect_reply_t *R /**< */) +xcb_dri2_connect_device_name (const xcb_dri2_connect_reply_t *R) { xcb_generic_iterator_t prev = xcb_dri2_connect_alignment_pad_end(R); return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); } int -xcb_dri2_connect_device_name_length (const xcb_dri2_connect_reply_t *R /**< */) +xcb_dri2_connect_device_name_length (const xcb_dri2_connect_reply_t *R) { return R->device_name_length; } xcb_generic_iterator_t -xcb_dri2_connect_device_name_end (const xcb_dri2_connect_reply_t *R /**< */) +xcb_dri2_connect_device_name_end (const xcb_dri2_connect_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_dri2_connect_alignment_pad_end(R); - i.data = ((char *) child.data) + (R->device_name_length); + xcb_generic_iterator_t prev = xcb_dri2_connect_alignment_pad_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->device_name_length); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_dri2_connect_reply_t * -xcb_dri2_connect_reply (xcb_connection_t *c /**< */, +xcb_dri2_connect_reply (xcb_connection_t *c, xcb_dri2_connect_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_connect_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_dri2_authenticate_cookie_t -xcb_dri2_authenticate (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t magic /**< */) +xcb_dri2_authenticate (xcb_connection_t *c, + xcb_window_t window, + uint32_t magic) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_AUTHENTICATE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_AUTHENTICATE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -336,15 +336,15 @@ xcb_dri2_authenticate (xcb_connection_t *c /**< */, } xcb_dri2_authenticate_cookie_t -xcb_dri2_authenticate_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t magic /**< */) +xcb_dri2_authenticate_unchecked (xcb_connection_t *c, + xcb_window_t window, + uint32_t magic) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_AUTHENTICATE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_AUTHENTICATE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -364,22 +364,22 @@ xcb_dri2_authenticate_unchecked (xcb_connection_t *c /**< */, } xcb_dri2_authenticate_reply_t * -xcb_dri2_authenticate_reply (xcb_connection_t *c /**< */, +xcb_dri2_authenticate_reply (xcb_connection_t *c, xcb_dri2_authenticate_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_authenticate_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_dri2_create_drawable_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_dri2_create_drawable_checked (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_CREATE_DRAWABLE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_CREATE_DRAWABLE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -398,14 +398,14 @@ xcb_dri2_create_drawable_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_dri2_create_drawable (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_dri2_create_drawable (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_CREATE_DRAWABLE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_CREATE_DRAWABLE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -424,14 +424,14 @@ xcb_dri2_create_drawable (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_dri2_destroy_drawable_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_dri2_destroy_drawable_checked (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_DESTROY_DRAWABLE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_DESTROY_DRAWABLE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -450,14 +450,14 @@ xcb_dri2_destroy_drawable_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_dri2_destroy_drawable (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_dri2_destroy_drawable (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_DESTROY_DRAWABLE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_DESTROY_DRAWABLE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -476,8 +476,8 @@ xcb_dri2_destroy_drawable (xcb_connection_t *c /**< */, } int -xcb_dri2_get_buffers_sizeof (const void *_buffer /**< */, - uint32_t attachments_len /**< */) +xcb_dri2_get_buffers_sizeof (const void *_buffer, + uint32_t attachments_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -507,17 +507,17 @@ xcb_dri2_get_buffers_sizeof (const void *_buffer /**< */, } xcb_dri2_get_buffers_cookie_t -xcb_dri2_get_buffers (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t count /**< */, - uint32_t attachments_len /**< */, - const uint32_t *attachments /**< */) +xcb_dri2_get_buffers (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t count, + uint32_t attachments_len, + const uint32_t *attachments) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_GET_BUFFERS, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_GET_BUFFERS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -542,17 +542,17 @@ xcb_dri2_get_buffers (xcb_connection_t *c /**< */, } xcb_dri2_get_buffers_cookie_t -xcb_dri2_get_buffers_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t count /**< */, - uint32_t attachments_len /**< */, - const uint32_t *attachments /**< */) +xcb_dri2_get_buffers_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t count, + uint32_t attachments_len, + const uint32_t *attachments) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_GET_BUFFERS, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_GET_BUFFERS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -577,19 +577,19 @@ xcb_dri2_get_buffers_unchecked (xcb_connection_t *c /**< */, } xcb_dri2_dri2_buffer_t * -xcb_dri2_get_buffers_buffers (const xcb_dri2_get_buffers_reply_t *R /**< */) +xcb_dri2_get_buffers_buffers (const xcb_dri2_get_buffers_reply_t *R) { return (xcb_dri2_dri2_buffer_t *) (R + 1); } int -xcb_dri2_get_buffers_buffers_length (const xcb_dri2_get_buffers_reply_t *R /**< */) +xcb_dri2_get_buffers_buffers_length (const xcb_dri2_get_buffers_reply_t *R) { return R->count; } xcb_dri2_dri2_buffer_iterator_t -xcb_dri2_get_buffers_buffers_iterator (const xcb_dri2_get_buffers_reply_t *R /**< */) +xcb_dri2_get_buffers_buffers_iterator (const xcb_dri2_get_buffers_reply_t *R) { xcb_dri2_dri2_buffer_iterator_t i; i.data = (xcb_dri2_dri2_buffer_t *) (R + 1); @@ -599,25 +599,25 @@ xcb_dri2_get_buffers_buffers_iterator (const xcb_dri2_get_buffers_reply_t *R /* } xcb_dri2_get_buffers_reply_t * -xcb_dri2_get_buffers_reply (xcb_connection_t *c /**< */, +xcb_dri2_get_buffers_reply (xcb_connection_t *c, xcb_dri2_get_buffers_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_get_buffers_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_dri2_copy_region_cookie_t -xcb_dri2_copy_region (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t region /**< */, - uint32_t dest /**< */, - uint32_t src /**< */) +xcb_dri2_copy_region (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t region, + uint32_t dest, + uint32_t src) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_COPY_REGION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_COPY_REGION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -639,17 +639,17 @@ xcb_dri2_copy_region (xcb_connection_t *c /**< */, } xcb_dri2_copy_region_cookie_t -xcb_dri2_copy_region_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t region /**< */, - uint32_t dest /**< */, - uint32_t src /**< */) +xcb_dri2_copy_region_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t region, + uint32_t dest, + uint32_t src) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_COPY_REGION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_COPY_REGION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -671,16 +671,16 @@ xcb_dri2_copy_region_unchecked (xcb_connection_t *c /**< */, } xcb_dri2_copy_region_reply_t * -xcb_dri2_copy_region_reply (xcb_connection_t *c /**< */, +xcb_dri2_copy_region_reply (xcb_connection_t *c, xcb_dri2_copy_region_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_copy_region_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_dri2_get_buffers_with_format_sizeof (const void *_buffer /**< */, - uint32_t attachments_len /**< */) +xcb_dri2_get_buffers_with_format_sizeof (const void *_buffer, + uint32_t attachments_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -710,17 +710,17 @@ xcb_dri2_get_buffers_with_format_sizeof (const void *_buffer /**< */, } xcb_dri2_get_buffers_with_format_cookie_t -xcb_dri2_get_buffers_with_format (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t count /**< */, - uint32_t attachments_len /**< */, - const xcb_dri2_attach_format_t *attachments /**< */) +xcb_dri2_get_buffers_with_format (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t count, + uint32_t attachments_len, + const xcb_dri2_attach_format_t *attachments) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_GET_BUFFERS_WITH_FORMAT, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_GET_BUFFERS_WITH_FORMAT, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -745,17 +745,17 @@ xcb_dri2_get_buffers_with_format (xcb_connection_t *c /**< */, } xcb_dri2_get_buffers_with_format_cookie_t -xcb_dri2_get_buffers_with_format_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t count /**< */, - uint32_t attachments_len /**< */, - const xcb_dri2_attach_format_t *attachments /**< */) +xcb_dri2_get_buffers_with_format_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t count, + uint32_t attachments_len, + const xcb_dri2_attach_format_t *attachments) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_GET_BUFFERS_WITH_FORMAT, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_GET_BUFFERS_WITH_FORMAT, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -780,19 +780,19 @@ xcb_dri2_get_buffers_with_format_unchecked (xcb_connection_t *c / } xcb_dri2_dri2_buffer_t * -xcb_dri2_get_buffers_with_format_buffers (const xcb_dri2_get_buffers_with_format_reply_t *R /**< */) +xcb_dri2_get_buffers_with_format_buffers (const xcb_dri2_get_buffers_with_format_reply_t *R) { return (xcb_dri2_dri2_buffer_t *) (R + 1); } int -xcb_dri2_get_buffers_with_format_buffers_length (const xcb_dri2_get_buffers_with_format_reply_t *R /**< */) +xcb_dri2_get_buffers_with_format_buffers_length (const xcb_dri2_get_buffers_with_format_reply_t *R) { return R->count; } xcb_dri2_dri2_buffer_iterator_t -xcb_dri2_get_buffers_with_format_buffers_iterator (const xcb_dri2_get_buffers_with_format_reply_t *R /**< */) +xcb_dri2_get_buffers_with_format_buffers_iterator (const xcb_dri2_get_buffers_with_format_reply_t *R) { xcb_dri2_dri2_buffer_iterator_t i; i.data = (xcb_dri2_dri2_buffer_t *) (R + 1); @@ -802,28 +802,28 @@ xcb_dri2_get_buffers_with_format_buffers_iterator (const xcb_dri2_get_buffers_wi } xcb_dri2_get_buffers_with_format_reply_t * -xcb_dri2_get_buffers_with_format_reply (xcb_connection_t *c /**< */, +xcb_dri2_get_buffers_with_format_reply (xcb_connection_t *c, xcb_dri2_get_buffers_with_format_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_get_buffers_with_format_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_dri2_swap_buffers_cookie_t -xcb_dri2_swap_buffers (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_msc_hi /**< */, - uint32_t target_msc_lo /**< */, - uint32_t divisor_hi /**< */, - uint32_t divisor_lo /**< */, - uint32_t remainder_hi /**< */, - uint32_t remainder_lo /**< */) +xcb_dri2_swap_buffers (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_msc_hi, + uint32_t target_msc_lo, + uint32_t divisor_hi, + uint32_t divisor_lo, + uint32_t remainder_hi, + uint32_t remainder_lo) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_SWAP_BUFFERS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_SWAP_BUFFERS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -848,20 +848,20 @@ xcb_dri2_swap_buffers (xcb_connection_t *c /**< */, } xcb_dri2_swap_buffers_cookie_t -xcb_dri2_swap_buffers_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_msc_hi /**< */, - uint32_t target_msc_lo /**< */, - uint32_t divisor_hi /**< */, - uint32_t divisor_lo /**< */, - uint32_t remainder_hi /**< */, - uint32_t remainder_lo /**< */) +xcb_dri2_swap_buffers_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_msc_hi, + uint32_t target_msc_lo, + uint32_t divisor_hi, + uint32_t divisor_lo, + uint32_t remainder_hi, + uint32_t remainder_lo) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_SWAP_BUFFERS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_SWAP_BUFFERS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -886,22 +886,22 @@ xcb_dri2_swap_buffers_unchecked (xcb_connection_t *c /**< */, } xcb_dri2_swap_buffers_reply_t * -xcb_dri2_swap_buffers_reply (xcb_connection_t *c /**< */, +xcb_dri2_swap_buffers_reply (xcb_connection_t *c, xcb_dri2_swap_buffers_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_swap_buffers_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_dri2_get_msc_cookie_t -xcb_dri2_get_msc (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_dri2_get_msc (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_GET_MSC, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_GET_MSC, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -920,14 +920,14 @@ xcb_dri2_get_msc (xcb_connection_t *c /**< */, } xcb_dri2_get_msc_cookie_t -xcb_dri2_get_msc_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_dri2_get_msc_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_GET_MSC, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_GET_MSC, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -946,28 +946,28 @@ xcb_dri2_get_msc_unchecked (xcb_connection_t *c /**< */, } xcb_dri2_get_msc_reply_t * -xcb_dri2_get_msc_reply (xcb_connection_t *c /**< */, +xcb_dri2_get_msc_reply (xcb_connection_t *c, xcb_dri2_get_msc_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_get_msc_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_dri2_wait_msc_cookie_t -xcb_dri2_wait_msc (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_msc_hi /**< */, - uint32_t target_msc_lo /**< */, - uint32_t divisor_hi /**< */, - uint32_t divisor_lo /**< */, - uint32_t remainder_hi /**< */, - uint32_t remainder_lo /**< */) +xcb_dri2_wait_msc (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_msc_hi, + uint32_t target_msc_lo, + uint32_t divisor_hi, + uint32_t divisor_lo, + uint32_t remainder_hi, + uint32_t remainder_lo) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_WAIT_MSC, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_WAIT_MSC, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -992,20 +992,20 @@ xcb_dri2_wait_msc (xcb_connection_t *c /**< */, } xcb_dri2_wait_msc_cookie_t -xcb_dri2_wait_msc_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_msc_hi /**< */, - uint32_t target_msc_lo /**< */, - uint32_t divisor_hi /**< */, - uint32_t divisor_lo /**< */, - uint32_t remainder_hi /**< */, - uint32_t remainder_lo /**< */) +xcb_dri2_wait_msc_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_msc_hi, + uint32_t target_msc_lo, + uint32_t divisor_hi, + uint32_t divisor_lo, + uint32_t remainder_hi, + uint32_t remainder_lo) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_WAIT_MSC, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_WAIT_MSC, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1030,24 +1030,24 @@ xcb_dri2_wait_msc_unchecked (xcb_connection_t *c /**< */, } xcb_dri2_wait_msc_reply_t * -xcb_dri2_wait_msc_reply (xcb_connection_t *c /**< */, +xcb_dri2_wait_msc_reply (xcb_connection_t *c, xcb_dri2_wait_msc_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_wait_msc_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_dri2_wait_sbc_cookie_t -xcb_dri2_wait_sbc (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_sbc_hi /**< */, - uint32_t target_sbc_lo /**< */) +xcb_dri2_wait_sbc (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_sbc_hi, + uint32_t target_sbc_lo) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_WAIT_SBC, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_WAIT_SBC, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1068,16 +1068,16 @@ xcb_dri2_wait_sbc (xcb_connection_t *c /**< */, } xcb_dri2_wait_sbc_cookie_t -xcb_dri2_wait_sbc_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_sbc_hi /**< */, - uint32_t target_sbc_lo /**< */) +xcb_dri2_wait_sbc_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_sbc_hi, + uint32_t target_sbc_lo) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_WAIT_SBC, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_WAIT_SBC, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1098,23 +1098,23 @@ xcb_dri2_wait_sbc_unchecked (xcb_connection_t *c /**< */, } xcb_dri2_wait_sbc_reply_t * -xcb_dri2_wait_sbc_reply (xcb_connection_t *c /**< */, +xcb_dri2_wait_sbc_reply (xcb_connection_t *c, xcb_dri2_wait_sbc_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_wait_sbc_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_dri2_swap_interval_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t interval /**< */) +xcb_dri2_swap_interval_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t interval) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_SWAP_INTERVAL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_SWAP_INTERVAL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1134,15 +1134,15 @@ xcb_dri2_swap_interval_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_dri2_swap_interval (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t interval /**< */) +xcb_dri2_swap_interval (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t interval) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_SWAP_INTERVAL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_SWAP_INTERVAL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1162,15 +1162,15 @@ xcb_dri2_swap_interval (xcb_connection_t *c /**< */, } xcb_dri2_get_param_cookie_t -xcb_dri2_get_param (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t param /**< */) +xcb_dri2_get_param (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t param) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_GET_PARAM, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_GET_PARAM, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1190,15 +1190,15 @@ xcb_dri2_get_param (xcb_connection_t *c /**< */, } xcb_dri2_get_param_cookie_t -xcb_dri2_get_param_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t param /**< */) +xcb_dri2_get_param_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t param) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri2_id, - /* opcode */ XCB_DRI2_GET_PARAM, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri2_id, + .opcode = XCB_DRI2_GET_PARAM, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1218,9 +1218,9 @@ xcb_dri2_get_param_unchecked (xcb_connection_t *c /**< */, } xcb_dri2_get_param_reply_t * -xcb_dri2_get_param_reply (xcb_connection_t *c /**< */, +xcb_dri2_get_param_reply (xcb_connection_t *c, xcb_dri2_get_param_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri2_get_param_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/dri2.h b/lib/libxcb/src/dri2.h index f7977705c..4ec2f40c6 100644 --- a/lib/libxcb/src/dri2.h +++ b/lib/libxcb/src/dri2.h @@ -53,44 +53,44 @@ typedef enum xcb_dri2_event_type_t { * @brief xcb_dri2_dri2_buffer_t **/ typedef struct xcb_dri2_dri2_buffer_t { - uint32_t attachment; /**< */ - uint32_t name; /**< */ - uint32_t pitch; /**< */ - uint32_t cpp; /**< */ - uint32_t flags; /**< */ + uint32_t attachment; + uint32_t name; + uint32_t pitch; + uint32_t cpp; + uint32_t flags; } xcb_dri2_dri2_buffer_t; /** * @brief xcb_dri2_dri2_buffer_iterator_t **/ typedef struct xcb_dri2_dri2_buffer_iterator_t { - xcb_dri2_dri2_buffer_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_dri2_dri2_buffer_t *data; + int rem; + int index; } xcb_dri2_dri2_buffer_iterator_t; /** * @brief xcb_dri2_attach_format_t **/ typedef struct xcb_dri2_attach_format_t { - uint32_t attachment; /**< */ - uint32_t format; /**< */ + uint32_t attachment; + uint32_t format; } xcb_dri2_attach_format_t; /** * @brief xcb_dri2_attach_format_iterator_t **/ typedef struct xcb_dri2_attach_format_iterator_t { - xcb_dri2_attach_format_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_dri2_attach_format_t *data; + int rem; + int index; } xcb_dri2_attach_format_iterator_t; /** * @brief xcb_dri2_query_version_cookie_t **/ typedef struct xcb_dri2_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_query_version_cookie_t; /** Opcode for xcb_dri2_query_version. */ @@ -100,30 +100,30 @@ typedef struct xcb_dri2_query_version_cookie_t { * @brief xcb_dri2_query_version_request_t **/ typedef struct xcb_dri2_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t major_version; + uint32_t minor_version; } xcb_dri2_query_version_request_t; /** * @brief xcb_dri2_query_version_reply_t **/ typedef struct xcb_dri2_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t major_version; + uint32_t minor_version; } xcb_dri2_query_version_reply_t; /** * @brief xcb_dri2_connect_cookie_t **/ typedef struct xcb_dri2_connect_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_connect_cookie_t; /** Opcode for xcb_dri2_connect. */ @@ -133,31 +133,31 @@ typedef struct xcb_dri2_connect_cookie_t { * @brief xcb_dri2_connect_request_t **/ typedef struct xcb_dri2_connect_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint32_t driver_type; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint32_t driver_type; } xcb_dri2_connect_request_t; /** * @brief xcb_dri2_connect_reply_t **/ typedef struct xcb_dri2_connect_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t driver_name_length; /**< */ - uint32_t device_name_length; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t driver_name_length; + uint32_t device_name_length; + uint8_t pad1[16]; } xcb_dri2_connect_reply_t; /** * @brief xcb_dri2_authenticate_cookie_t **/ typedef struct xcb_dri2_authenticate_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_authenticate_cookie_t; /** Opcode for xcb_dri2_authenticate. */ @@ -167,22 +167,22 @@ typedef struct xcb_dri2_authenticate_cookie_t { * @brief xcb_dri2_authenticate_request_t **/ typedef struct xcb_dri2_authenticate_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint32_t magic; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint32_t magic; } xcb_dri2_authenticate_request_t; /** * @brief xcb_dri2_authenticate_reply_t **/ typedef struct xcb_dri2_authenticate_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t authenticated; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t authenticated; } xcb_dri2_authenticate_reply_t; /** Opcode for xcb_dri2_create_drawable. */ @@ -192,10 +192,10 @@ typedef struct xcb_dri2_authenticate_reply_t { * @brief xcb_dri2_create_drawable_request_t **/ typedef struct xcb_dri2_create_drawable_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; } xcb_dri2_create_drawable_request_t; /** Opcode for xcb_dri2_destroy_drawable. */ @@ -205,17 +205,17 @@ typedef struct xcb_dri2_create_drawable_request_t { * @brief xcb_dri2_destroy_drawable_request_t **/ typedef struct xcb_dri2_destroy_drawable_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; } xcb_dri2_destroy_drawable_request_t; /** * @brief xcb_dri2_get_buffers_cookie_t **/ typedef struct xcb_dri2_get_buffers_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_get_buffers_cookie_t; /** Opcode for xcb_dri2_get_buffers. */ @@ -225,32 +225,32 @@ typedef struct xcb_dri2_get_buffers_cookie_t { * @brief xcb_dri2_get_buffers_request_t **/ typedef struct xcb_dri2_get_buffers_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t count; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t count; } xcb_dri2_get_buffers_request_t; /** * @brief xcb_dri2_get_buffers_reply_t **/ typedef struct xcb_dri2_get_buffers_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t width; /**< */ - uint32_t height; /**< */ - uint32_t count; /**< */ - uint8_t pad1[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t width; + uint32_t height; + uint32_t count; + uint8_t pad1[12]; } xcb_dri2_get_buffers_reply_t; /** * @brief xcb_dri2_copy_region_cookie_t **/ typedef struct xcb_dri2_copy_region_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_copy_region_cookie_t; /** Opcode for xcb_dri2_copy_region. */ @@ -260,30 +260,30 @@ typedef struct xcb_dri2_copy_region_cookie_t { * @brief xcb_dri2_copy_region_request_t **/ typedef struct xcb_dri2_copy_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t region; /**< */ - uint32_t dest; /**< */ - uint32_t src; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t region; + uint32_t dest; + uint32_t src; } xcb_dri2_copy_region_request_t; /** * @brief xcb_dri2_copy_region_reply_t **/ typedef struct xcb_dri2_copy_region_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; } xcb_dri2_copy_region_reply_t; /** * @brief xcb_dri2_get_buffers_with_format_cookie_t **/ typedef struct xcb_dri2_get_buffers_with_format_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_get_buffers_with_format_cookie_t; /** Opcode for xcb_dri2_get_buffers_with_format. */ @@ -293,32 +293,32 @@ typedef struct xcb_dri2_get_buffers_with_format_cookie_t { * @brief xcb_dri2_get_buffers_with_format_request_t **/ typedef struct xcb_dri2_get_buffers_with_format_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t count; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t count; } xcb_dri2_get_buffers_with_format_request_t; /** * @brief xcb_dri2_get_buffers_with_format_reply_t **/ typedef struct xcb_dri2_get_buffers_with_format_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t width; /**< */ - uint32_t height; /**< */ - uint32_t count; /**< */ - uint8_t pad1[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t width; + uint32_t height; + uint32_t count; + uint8_t pad1[12]; } xcb_dri2_get_buffers_with_format_reply_t; /** * @brief xcb_dri2_swap_buffers_cookie_t **/ typedef struct xcb_dri2_swap_buffers_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_swap_buffers_cookie_t; /** Opcode for xcb_dri2_swap_buffers. */ @@ -328,35 +328,35 @@ typedef struct xcb_dri2_swap_buffers_cookie_t { * @brief xcb_dri2_swap_buffers_request_t **/ typedef struct xcb_dri2_swap_buffers_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t target_msc_hi; /**< */ - uint32_t target_msc_lo; /**< */ - uint32_t divisor_hi; /**< */ - uint32_t divisor_lo; /**< */ - uint32_t remainder_hi; /**< */ - uint32_t remainder_lo; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t target_msc_hi; + uint32_t target_msc_lo; + uint32_t divisor_hi; + uint32_t divisor_lo; + uint32_t remainder_hi; + uint32_t remainder_lo; } xcb_dri2_swap_buffers_request_t; /** * @brief xcb_dri2_swap_buffers_reply_t **/ typedef struct xcb_dri2_swap_buffers_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t swap_hi; /**< */ - uint32_t swap_lo; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t swap_hi; + uint32_t swap_lo; } xcb_dri2_swap_buffers_reply_t; /** * @brief xcb_dri2_get_msc_cookie_t **/ typedef struct xcb_dri2_get_msc_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_get_msc_cookie_t; /** Opcode for xcb_dri2_get_msc. */ @@ -366,33 +366,33 @@ typedef struct xcb_dri2_get_msc_cookie_t { * @brief xcb_dri2_get_msc_request_t **/ typedef struct xcb_dri2_get_msc_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; } xcb_dri2_get_msc_request_t; /** * @brief xcb_dri2_get_msc_reply_t **/ typedef struct xcb_dri2_get_msc_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t ust_hi; /**< */ - uint32_t ust_lo; /**< */ - uint32_t msc_hi; /**< */ - uint32_t msc_lo; /**< */ - uint32_t sbc_hi; /**< */ - uint32_t sbc_lo; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t ust_hi; + uint32_t ust_lo; + uint32_t msc_hi; + uint32_t msc_lo; + uint32_t sbc_hi; + uint32_t sbc_lo; } xcb_dri2_get_msc_reply_t; /** * @brief xcb_dri2_wait_msc_cookie_t **/ typedef struct xcb_dri2_wait_msc_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_wait_msc_cookie_t; /** Opcode for xcb_dri2_wait_msc. */ @@ -402,39 +402,39 @@ typedef struct xcb_dri2_wait_msc_cookie_t { * @brief xcb_dri2_wait_msc_request_t **/ typedef struct xcb_dri2_wait_msc_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t target_msc_hi; /**< */ - uint32_t target_msc_lo; /**< */ - uint32_t divisor_hi; /**< */ - uint32_t divisor_lo; /**< */ - uint32_t remainder_hi; /**< */ - uint32_t remainder_lo; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t target_msc_hi; + uint32_t target_msc_lo; + uint32_t divisor_hi; + uint32_t divisor_lo; + uint32_t remainder_hi; + uint32_t remainder_lo; } xcb_dri2_wait_msc_request_t; /** * @brief xcb_dri2_wait_msc_reply_t **/ typedef struct xcb_dri2_wait_msc_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t ust_hi; /**< */ - uint32_t ust_lo; /**< */ - uint32_t msc_hi; /**< */ - uint32_t msc_lo; /**< */ - uint32_t sbc_hi; /**< */ - uint32_t sbc_lo; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t ust_hi; + uint32_t ust_lo; + uint32_t msc_hi; + uint32_t msc_lo; + uint32_t sbc_hi; + uint32_t sbc_lo; } xcb_dri2_wait_msc_reply_t; /** * @brief xcb_dri2_wait_sbc_cookie_t **/ typedef struct xcb_dri2_wait_sbc_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_wait_sbc_cookie_t; /** Opcode for xcb_dri2_wait_sbc. */ @@ -444,28 +444,28 @@ typedef struct xcb_dri2_wait_sbc_cookie_t { * @brief xcb_dri2_wait_sbc_request_t **/ typedef struct xcb_dri2_wait_sbc_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t target_sbc_hi; /**< */ - uint32_t target_sbc_lo; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t target_sbc_hi; + uint32_t target_sbc_lo; } xcb_dri2_wait_sbc_request_t; /** * @brief xcb_dri2_wait_sbc_reply_t **/ typedef struct xcb_dri2_wait_sbc_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t ust_hi; /**< */ - uint32_t ust_lo; /**< */ - uint32_t msc_hi; /**< */ - uint32_t msc_lo; /**< */ - uint32_t sbc_hi; /**< */ - uint32_t sbc_lo; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t ust_hi; + uint32_t ust_lo; + uint32_t msc_hi; + uint32_t msc_lo; + uint32_t sbc_hi; + uint32_t sbc_lo; } xcb_dri2_wait_sbc_reply_t; /** Opcode for xcb_dri2_swap_interval. */ @@ -475,18 +475,18 @@ typedef struct xcb_dri2_wait_sbc_reply_t { * @brief xcb_dri2_swap_interval_request_t **/ typedef struct xcb_dri2_swap_interval_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t interval; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t interval; } xcb_dri2_swap_interval_request_t; /** * @brief xcb_dri2_get_param_cookie_t **/ typedef struct xcb_dri2_get_param_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri2_get_param_cookie_t; /** Opcode for xcb_dri2_get_param. */ @@ -496,23 +496,23 @@ typedef struct xcb_dri2_get_param_cookie_t { * @brief xcb_dri2_get_param_request_t **/ typedef struct xcb_dri2_get_param_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t param; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t param; } xcb_dri2_get_param_request_t; /** * @brief xcb_dri2_get_param_reply_t **/ typedef struct xcb_dri2_get_param_reply_t { - uint8_t response_type; /**< */ - uint8_t is_param_recognized; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t value_hi; /**< */ - uint32_t value_lo; /**< */ + uint8_t response_type; + uint8_t is_param_recognized; + uint16_t sequence; + uint32_t length; + uint32_t value_hi; + uint32_t value_lo; } xcb_dri2_get_param_reply_t; /** Opcode for xcb_dri2_buffer_swap_complete. */ @@ -522,17 +522,17 @@ typedef struct xcb_dri2_get_param_reply_t { * @brief xcb_dri2_buffer_swap_complete_event_t **/ typedef struct xcb_dri2_buffer_swap_complete_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint16_t event_type; /**< */ - uint8_t pad1[2]; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t ust_hi; /**< */ - uint32_t ust_lo; /**< */ - uint32_t msc_hi; /**< */ - uint32_t msc_lo; /**< */ - uint32_t sbc; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint16_t event_type; + uint8_t pad1[2]; + xcb_drawable_t drawable; + uint32_t ust_hi; + uint32_t ust_lo; + uint32_t msc_hi; + uint32_t msc_lo; + uint32_t sbc; } xcb_dri2_buffer_swap_complete_event_t; /** Opcode for xcb_dri2_invalidate_buffers. */ @@ -542,10 +542,10 @@ typedef struct xcb_dri2_buffer_swap_complete_event_t { * @brief xcb_dri2_invalidate_buffers_event_t **/ typedef struct xcb_dri2_invalidate_buffers_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_drawable_t drawable; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_drawable_t drawable; } xcb_dri2_invalidate_buffers_event_t; /** @@ -557,7 +557,7 @@ typedef struct xcb_dri2_invalidate_buffers_event_t { * element. The member index is increased by sizeof(xcb_dri2_dri2_buffer_t) */ void -xcb_dri2_dri2_buffer_next (xcb_dri2_dri2_buffer_iterator_t *i /**< */); +xcb_dri2_dri2_buffer_next (xcb_dri2_dri2_buffer_iterator_t *i); /** * Return the iterator pointing to the last element @@ -569,7 +569,7 @@ xcb_dri2_dri2_buffer_next (xcb_dri2_dri2_buffer_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_dri2_dri2_buffer_end (xcb_dri2_dri2_buffer_iterator_t i /**< */); +xcb_dri2_dri2_buffer_end (xcb_dri2_dri2_buffer_iterator_t i); /** * Get the next element of the iterator @@ -580,7 +580,7 @@ xcb_dri2_dri2_buffer_end (xcb_dri2_dri2_buffer_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_dri2_attach_format_t) */ void -xcb_dri2_attach_format_next (xcb_dri2_attach_format_iterator_t *i /**< */); +xcb_dri2_attach_format_next (xcb_dri2_attach_format_iterator_t *i); /** * Return the iterator pointing to the last element @@ -592,7 +592,7 @@ xcb_dri2_attach_format_next (xcb_dri2_attach_format_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_dri2_attach_format_end (xcb_dri2_attach_format_iterator_t i /**< */); +xcb_dri2_attach_format_end (xcb_dri2_attach_format_iterator_t i); /** * @@ -603,9 +603,9 @@ xcb_dri2_attach_format_end (xcb_dri2_attach_format_iterator_t i /**< */); * */ xcb_dri2_query_version_cookie_t -xcb_dri2_query_version (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */); +xcb_dri2_query_version (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version); /** * @@ -619,9 +619,9 @@ xcb_dri2_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_query_version_cookie_t -xcb_dri2_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */); +xcb_dri2_query_version_unchecked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version); /** * Return the reply @@ -638,12 +638,12 @@ xcb_dri2_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri2_query_version_reply_t * -xcb_dri2_query_version_reply (xcb_connection_t *c /**< */, +xcb_dri2_query_version_reply (xcb_connection_t *c, xcb_dri2_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_dri2_connect_sizeof (const void *_buffer /**< */); +xcb_dri2_connect_sizeof (const void *_buffer); /** * @@ -654,9 +654,9 @@ xcb_dri2_connect_sizeof (const void *_buffer /**< */); * */ xcb_dri2_connect_cookie_t -xcb_dri2_connect (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t driver_type /**< */); +xcb_dri2_connect (xcb_connection_t *c, + xcb_window_t window, + uint32_t driver_type); /** * @@ -670,36 +670,36 @@ xcb_dri2_connect (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_connect_cookie_t -xcb_dri2_connect_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t driver_type /**< */); +xcb_dri2_connect_unchecked (xcb_connection_t *c, + xcb_window_t window, + uint32_t driver_type); char * -xcb_dri2_connect_driver_name (const xcb_dri2_connect_reply_t *R /**< */); +xcb_dri2_connect_driver_name (const xcb_dri2_connect_reply_t *R); int -xcb_dri2_connect_driver_name_length (const xcb_dri2_connect_reply_t *R /**< */); +xcb_dri2_connect_driver_name_length (const xcb_dri2_connect_reply_t *R); xcb_generic_iterator_t -xcb_dri2_connect_driver_name_end (const xcb_dri2_connect_reply_t *R /**< */); +xcb_dri2_connect_driver_name_end (const xcb_dri2_connect_reply_t *R); void * -xcb_dri2_connect_alignment_pad (const xcb_dri2_connect_reply_t *R /**< */); +xcb_dri2_connect_alignment_pad (const xcb_dri2_connect_reply_t *R); int -xcb_dri2_connect_alignment_pad_length (const xcb_dri2_connect_reply_t *R /**< */); +xcb_dri2_connect_alignment_pad_length (const xcb_dri2_connect_reply_t *R); xcb_generic_iterator_t -xcb_dri2_connect_alignment_pad_end (const xcb_dri2_connect_reply_t *R /**< */); +xcb_dri2_connect_alignment_pad_end (const xcb_dri2_connect_reply_t *R); char * -xcb_dri2_connect_device_name (const xcb_dri2_connect_reply_t *R /**< */); +xcb_dri2_connect_device_name (const xcb_dri2_connect_reply_t *R); int -xcb_dri2_connect_device_name_length (const xcb_dri2_connect_reply_t *R /**< */); +xcb_dri2_connect_device_name_length (const xcb_dri2_connect_reply_t *R); xcb_generic_iterator_t -xcb_dri2_connect_device_name_end (const xcb_dri2_connect_reply_t *R /**< */); +xcb_dri2_connect_device_name_end (const xcb_dri2_connect_reply_t *R); /** * Return the reply @@ -716,9 +716,9 @@ xcb_dri2_connect_device_name_end (const xcb_dri2_connect_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_dri2_connect_reply_t * -xcb_dri2_connect_reply (xcb_connection_t *c /**< */, +xcb_dri2_connect_reply (xcb_connection_t *c, xcb_dri2_connect_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -729,9 +729,9 @@ xcb_dri2_connect_reply (xcb_connection_t *c /**< */, * */ xcb_dri2_authenticate_cookie_t -xcb_dri2_authenticate (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t magic /**< */); +xcb_dri2_authenticate (xcb_connection_t *c, + xcb_window_t window, + uint32_t magic); /** * @@ -745,9 +745,9 @@ xcb_dri2_authenticate (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_authenticate_cookie_t -xcb_dri2_authenticate_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t magic /**< */); +xcb_dri2_authenticate_unchecked (xcb_connection_t *c, + xcb_window_t window, + uint32_t magic); /** * Return the reply @@ -764,9 +764,9 @@ xcb_dri2_authenticate_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri2_authenticate_reply_t * -xcb_dri2_authenticate_reply (xcb_connection_t *c /**< */, +xcb_dri2_authenticate_reply (xcb_connection_t *c, xcb_dri2_authenticate_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -780,8 +780,8 @@ xcb_dri2_authenticate_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_dri2_create_drawable_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_dri2_create_drawable_checked (xcb_connection_t *c, + xcb_drawable_t drawable); /** * @@ -792,8 +792,8 @@ xcb_dri2_create_drawable_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_dri2_create_drawable (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_dri2_create_drawable (xcb_connection_t *c, + xcb_drawable_t drawable); /** * @@ -807,8 +807,8 @@ xcb_dri2_create_drawable (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_dri2_destroy_drawable_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_dri2_destroy_drawable_checked (xcb_connection_t *c, + xcb_drawable_t drawable); /** * @@ -819,12 +819,12 @@ xcb_dri2_destroy_drawable_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_dri2_destroy_drawable (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_dri2_destroy_drawable (xcb_connection_t *c, + xcb_drawable_t drawable); int -xcb_dri2_get_buffers_sizeof (const void *_buffer /**< */, - uint32_t attachments_len /**< */); +xcb_dri2_get_buffers_sizeof (const void *_buffer, + uint32_t attachments_len); /** * @@ -835,11 +835,11 @@ xcb_dri2_get_buffers_sizeof (const void *_buffer /**< */, * */ xcb_dri2_get_buffers_cookie_t -xcb_dri2_get_buffers (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t count /**< */, - uint32_t attachments_len /**< */, - const uint32_t *attachments /**< */); +xcb_dri2_get_buffers (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t count, + uint32_t attachments_len, + const uint32_t *attachments); /** * @@ -853,20 +853,20 @@ xcb_dri2_get_buffers (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_get_buffers_cookie_t -xcb_dri2_get_buffers_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t count /**< */, - uint32_t attachments_len /**< */, - const uint32_t *attachments /**< */); +xcb_dri2_get_buffers_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t count, + uint32_t attachments_len, + const uint32_t *attachments); xcb_dri2_dri2_buffer_t * -xcb_dri2_get_buffers_buffers (const xcb_dri2_get_buffers_reply_t *R /**< */); +xcb_dri2_get_buffers_buffers (const xcb_dri2_get_buffers_reply_t *R); int -xcb_dri2_get_buffers_buffers_length (const xcb_dri2_get_buffers_reply_t *R /**< */); +xcb_dri2_get_buffers_buffers_length (const xcb_dri2_get_buffers_reply_t *R); xcb_dri2_dri2_buffer_iterator_t -xcb_dri2_get_buffers_buffers_iterator (const xcb_dri2_get_buffers_reply_t *R /**< */); +xcb_dri2_get_buffers_buffers_iterator (const xcb_dri2_get_buffers_reply_t *R); /** * Return the reply @@ -883,9 +883,9 @@ xcb_dri2_get_buffers_buffers_iterator (const xcb_dri2_get_buffers_reply_t *R /* * The returned value must be freed by the caller using free(). */ xcb_dri2_get_buffers_reply_t * -xcb_dri2_get_buffers_reply (xcb_connection_t *c /**< */, +xcb_dri2_get_buffers_reply (xcb_connection_t *c, xcb_dri2_get_buffers_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -896,11 +896,11 @@ xcb_dri2_get_buffers_reply (xcb_connection_t *c /**< */, * */ xcb_dri2_copy_region_cookie_t -xcb_dri2_copy_region (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t region /**< */, - uint32_t dest /**< */, - uint32_t src /**< */); +xcb_dri2_copy_region (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t region, + uint32_t dest, + uint32_t src); /** * @@ -914,11 +914,11 @@ xcb_dri2_copy_region (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_copy_region_cookie_t -xcb_dri2_copy_region_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t region /**< */, - uint32_t dest /**< */, - uint32_t src /**< */); +xcb_dri2_copy_region_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t region, + uint32_t dest, + uint32_t src); /** * Return the reply @@ -935,13 +935,13 @@ xcb_dri2_copy_region_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri2_copy_region_reply_t * -xcb_dri2_copy_region_reply (xcb_connection_t *c /**< */, +xcb_dri2_copy_region_reply (xcb_connection_t *c, xcb_dri2_copy_region_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_dri2_get_buffers_with_format_sizeof (const void *_buffer /**< */, - uint32_t attachments_len /**< */); +xcb_dri2_get_buffers_with_format_sizeof (const void *_buffer, + uint32_t attachments_len); /** * @@ -952,11 +952,11 @@ xcb_dri2_get_buffers_with_format_sizeof (const void *_buffer /**< */, * */ xcb_dri2_get_buffers_with_format_cookie_t -xcb_dri2_get_buffers_with_format (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t count /**< */, - uint32_t attachments_len /**< */, - const xcb_dri2_attach_format_t *attachments /**< */); +xcb_dri2_get_buffers_with_format (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t count, + uint32_t attachments_len, + const xcb_dri2_attach_format_t *attachments); /** * @@ -970,20 +970,20 @@ xcb_dri2_get_buffers_with_format (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_get_buffers_with_format_cookie_t -xcb_dri2_get_buffers_with_format_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t count /**< */, - uint32_t attachments_len /**< */, - const xcb_dri2_attach_format_t *attachments /**< */); +xcb_dri2_get_buffers_with_format_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t count, + uint32_t attachments_len, + const xcb_dri2_attach_format_t *attachments); xcb_dri2_dri2_buffer_t * -xcb_dri2_get_buffers_with_format_buffers (const xcb_dri2_get_buffers_with_format_reply_t *R /**< */); +xcb_dri2_get_buffers_with_format_buffers (const xcb_dri2_get_buffers_with_format_reply_t *R); int -xcb_dri2_get_buffers_with_format_buffers_length (const xcb_dri2_get_buffers_with_format_reply_t *R /**< */); +xcb_dri2_get_buffers_with_format_buffers_length (const xcb_dri2_get_buffers_with_format_reply_t *R); xcb_dri2_dri2_buffer_iterator_t -xcb_dri2_get_buffers_with_format_buffers_iterator (const xcb_dri2_get_buffers_with_format_reply_t *R /**< */); +xcb_dri2_get_buffers_with_format_buffers_iterator (const xcb_dri2_get_buffers_with_format_reply_t *R); /** * Return the reply @@ -1000,9 +1000,9 @@ xcb_dri2_get_buffers_with_format_buffers_iterator (const xcb_dri2_get_buffers_wi * The returned value must be freed by the caller using free(). */ xcb_dri2_get_buffers_with_format_reply_t * -xcb_dri2_get_buffers_with_format_reply (xcb_connection_t *c /**< */, +xcb_dri2_get_buffers_with_format_reply (xcb_connection_t *c, xcb_dri2_get_buffers_with_format_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1013,14 +1013,14 @@ xcb_dri2_get_buffers_with_format_reply (xcb_connection_t * */ xcb_dri2_swap_buffers_cookie_t -xcb_dri2_swap_buffers (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_msc_hi /**< */, - uint32_t target_msc_lo /**< */, - uint32_t divisor_hi /**< */, - uint32_t divisor_lo /**< */, - uint32_t remainder_hi /**< */, - uint32_t remainder_lo /**< */); +xcb_dri2_swap_buffers (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_msc_hi, + uint32_t target_msc_lo, + uint32_t divisor_hi, + uint32_t divisor_lo, + uint32_t remainder_hi, + uint32_t remainder_lo); /** * @@ -1034,14 +1034,14 @@ xcb_dri2_swap_buffers (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_swap_buffers_cookie_t -xcb_dri2_swap_buffers_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_msc_hi /**< */, - uint32_t target_msc_lo /**< */, - uint32_t divisor_hi /**< */, - uint32_t divisor_lo /**< */, - uint32_t remainder_hi /**< */, - uint32_t remainder_lo /**< */); +xcb_dri2_swap_buffers_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_msc_hi, + uint32_t target_msc_lo, + uint32_t divisor_hi, + uint32_t divisor_lo, + uint32_t remainder_hi, + uint32_t remainder_lo); /** * Return the reply @@ -1058,9 +1058,9 @@ xcb_dri2_swap_buffers_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri2_swap_buffers_reply_t * -xcb_dri2_swap_buffers_reply (xcb_connection_t *c /**< */, +xcb_dri2_swap_buffers_reply (xcb_connection_t *c, xcb_dri2_swap_buffers_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1071,8 +1071,8 @@ xcb_dri2_swap_buffers_reply (xcb_connection_t *c /**< */, * */ xcb_dri2_get_msc_cookie_t -xcb_dri2_get_msc (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_dri2_get_msc (xcb_connection_t *c, + xcb_drawable_t drawable); /** * @@ -1086,8 +1086,8 @@ xcb_dri2_get_msc (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_get_msc_cookie_t -xcb_dri2_get_msc_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_dri2_get_msc_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable); /** * Return the reply @@ -1104,9 +1104,9 @@ xcb_dri2_get_msc_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri2_get_msc_reply_t * -xcb_dri2_get_msc_reply (xcb_connection_t *c /**< */, +xcb_dri2_get_msc_reply (xcb_connection_t *c, xcb_dri2_get_msc_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1117,14 +1117,14 @@ xcb_dri2_get_msc_reply (xcb_connection_t *c /**< */, * */ xcb_dri2_wait_msc_cookie_t -xcb_dri2_wait_msc (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_msc_hi /**< */, - uint32_t target_msc_lo /**< */, - uint32_t divisor_hi /**< */, - uint32_t divisor_lo /**< */, - uint32_t remainder_hi /**< */, - uint32_t remainder_lo /**< */); +xcb_dri2_wait_msc (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_msc_hi, + uint32_t target_msc_lo, + uint32_t divisor_hi, + uint32_t divisor_lo, + uint32_t remainder_hi, + uint32_t remainder_lo); /** * @@ -1138,14 +1138,14 @@ xcb_dri2_wait_msc (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_wait_msc_cookie_t -xcb_dri2_wait_msc_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_msc_hi /**< */, - uint32_t target_msc_lo /**< */, - uint32_t divisor_hi /**< */, - uint32_t divisor_lo /**< */, - uint32_t remainder_hi /**< */, - uint32_t remainder_lo /**< */); +xcb_dri2_wait_msc_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_msc_hi, + uint32_t target_msc_lo, + uint32_t divisor_hi, + uint32_t divisor_lo, + uint32_t remainder_hi, + uint32_t remainder_lo); /** * Return the reply @@ -1162,9 +1162,9 @@ xcb_dri2_wait_msc_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri2_wait_msc_reply_t * -xcb_dri2_wait_msc_reply (xcb_connection_t *c /**< */, +xcb_dri2_wait_msc_reply (xcb_connection_t *c, xcb_dri2_wait_msc_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1175,10 +1175,10 @@ xcb_dri2_wait_msc_reply (xcb_connection_t *c /**< */, * */ xcb_dri2_wait_sbc_cookie_t -xcb_dri2_wait_sbc (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_sbc_hi /**< */, - uint32_t target_sbc_lo /**< */); +xcb_dri2_wait_sbc (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_sbc_hi, + uint32_t target_sbc_lo); /** * @@ -1192,10 +1192,10 @@ xcb_dri2_wait_sbc (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_wait_sbc_cookie_t -xcb_dri2_wait_sbc_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t target_sbc_hi /**< */, - uint32_t target_sbc_lo /**< */); +xcb_dri2_wait_sbc_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t target_sbc_hi, + uint32_t target_sbc_lo); /** * Return the reply @@ -1212,9 +1212,9 @@ xcb_dri2_wait_sbc_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri2_wait_sbc_reply_t * -xcb_dri2_wait_sbc_reply (xcb_connection_t *c /**< */, +xcb_dri2_wait_sbc_reply (xcb_connection_t *c, xcb_dri2_wait_sbc_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1228,9 +1228,9 @@ xcb_dri2_wait_sbc_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_dri2_swap_interval_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t interval /**< */); +xcb_dri2_swap_interval_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t interval); /** * @@ -1241,9 +1241,9 @@ xcb_dri2_swap_interval_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_dri2_swap_interval (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t interval /**< */); +xcb_dri2_swap_interval (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t interval); /** * @@ -1254,9 +1254,9 @@ xcb_dri2_swap_interval (xcb_connection_t *c /**< */, * */ xcb_dri2_get_param_cookie_t -xcb_dri2_get_param (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t param /**< */); +xcb_dri2_get_param (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t param); /** * @@ -1270,9 +1270,9 @@ xcb_dri2_get_param (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri2_get_param_cookie_t -xcb_dri2_get_param_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t param /**< */); +xcb_dri2_get_param_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t param); /** * Return the reply @@ -1289,9 +1289,9 @@ xcb_dri2_get_param_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri2_get_param_reply_t * -xcb_dri2_get_param_reply (xcb_connection_t *c /**< */, +xcb_dri2_get_param_reply (xcb_connection_t *c, xcb_dri2_get_param_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/dri3.c b/lib/libxcb/src/dri3.c index 10f2df409..255f5c634 100644 --- a/lib/libxcb/src/dri3.c +++ b/lib/libxcb/src/dri3.c @@ -19,15 +19,15 @@ xcb_extension_t xcb_dri3_id = { "DRI3", 0 }; xcb_dri3_query_version_cookie_t -xcb_dri3_query_version (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */) +xcb_dri3_query_version (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -47,15 +47,15 @@ xcb_dri3_query_version (xcb_connection_t *c /**< */, } xcb_dri3_query_version_cookie_t -xcb_dri3_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */) +xcb_dri3_query_version_unchecked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -75,23 +75,23 @@ xcb_dri3_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_dri3_query_version_reply_t * -xcb_dri3_query_version_reply (xcb_connection_t *c /**< */, +xcb_dri3_query_version_reply (xcb_connection_t *c, xcb_dri3_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri3_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_dri3_open_cookie_t -xcb_dri3_open (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t provider /**< */) +xcb_dri3_open (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t provider) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_OPEN, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_OPEN, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -111,15 +111,15 @@ xcb_dri3_open (xcb_connection_t *c /**< */, } xcb_dri3_open_cookie_t -xcb_dri3_open_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t provider /**< */) +xcb_dri3_open_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t provider) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_OPEN, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_OPEN, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -139,42 +139,43 @@ xcb_dri3_open_unchecked (xcb_connection_t *c /**< */, } xcb_dri3_open_reply_t * -xcb_dri3_open_reply (xcb_connection_t *c /**< */, +xcb_dri3_open_reply (xcb_connection_t *c, xcb_dri3_open_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri3_open_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int * xcb_dri3_open_reply_fds (xcb_connection_t *c /**< */, - xcb_dri3_open_reply_t *reply /**< */) + xcb_dri3_open_reply_t *reply) { return xcb_get_reply_fds(c, reply, sizeof(xcb_dri3_open_reply_t) + 4 * reply->length); } xcb_void_cookie_t -xcb_dri3_pixmap_from_buffer_checked (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_drawable_t drawable /**< */, - uint32_t size /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t stride /**< */, - uint8_t depth /**< */, - uint8_t bpp /**< */, - int32_t pixmap_fd /**< */) +xcb_dri3_pixmap_from_buffer_checked (xcb_connection_t *c, + xcb_pixmap_t pixmap, + xcb_drawable_t drawable, + uint32_t size, + uint16_t width, + uint16_t height, + uint16_t stride, + uint8_t depth, + uint8_t bpp, + int32_t pixmap_fd) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_PIXMAP_FROM_BUFFER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_PIXMAP_FROM_BUFFER, + .isvoid = 1 }; struct iovec xcb_parts[4]; xcb_void_cookie_t xcb_ret; xcb_dri3_pixmap_from_buffer_request_t xcb_out; + int fds[1]; xcb_out.pixmap = pixmap; xcb_out.drawable = drawable; @@ -190,33 +191,34 @@ xcb_dri3_pixmap_from_buffer_checked (xcb_connection_t *c /**< */, xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - xcb_send_fd(c, pixmap_fd); - xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + fds[0] = pixmap_fd; + xcb_ret.sequence = xcb_send_request_with_fds(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req, 1, fds); return xcb_ret; } xcb_void_cookie_t -xcb_dri3_pixmap_from_buffer (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_drawable_t drawable /**< */, - uint32_t size /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t stride /**< */, - uint8_t depth /**< */, - uint8_t bpp /**< */, - int32_t pixmap_fd /**< */) +xcb_dri3_pixmap_from_buffer (xcb_connection_t *c, + xcb_pixmap_t pixmap, + xcb_drawable_t drawable, + uint32_t size, + uint16_t width, + uint16_t height, + uint16_t stride, + uint8_t depth, + uint8_t bpp, + int32_t pixmap_fd) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_PIXMAP_FROM_BUFFER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_PIXMAP_FROM_BUFFER, + .isvoid = 1 }; struct iovec xcb_parts[4]; xcb_void_cookie_t xcb_ret; xcb_dri3_pixmap_from_buffer_request_t xcb_out; + int fds[1]; xcb_out.pixmap = pixmap; xcb_out.drawable = drawable; @@ -232,20 +234,20 @@ xcb_dri3_pixmap_from_buffer (xcb_connection_t *c /**< */, xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - xcb_send_fd(c, pixmap_fd); - xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + fds[0] = pixmap_fd; + xcb_ret.sequence = xcb_send_request_with_fds(c, 0, xcb_parts + 2, &xcb_req, 1, fds); return xcb_ret; } xcb_dri3_buffer_from_pixmap_cookie_t -xcb_dri3_buffer_from_pixmap (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */) +xcb_dri3_buffer_from_pixmap (xcb_connection_t *c, + xcb_pixmap_t pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_BUFFER_FROM_PIXMAP, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_BUFFER_FROM_PIXMAP, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -264,14 +266,14 @@ xcb_dri3_buffer_from_pixmap (xcb_connection_t *c /**< */, } xcb_dri3_buffer_from_pixmap_cookie_t -xcb_dri3_buffer_from_pixmap_unchecked (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */) +xcb_dri3_buffer_from_pixmap_unchecked (xcb_connection_t *c, + xcb_pixmap_t pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_BUFFER_FROM_PIXMAP, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_BUFFER_FROM_PIXMAP, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -290,37 +292,38 @@ xcb_dri3_buffer_from_pixmap_unchecked (xcb_connection_t *c /**< */, } xcb_dri3_buffer_from_pixmap_reply_t * -xcb_dri3_buffer_from_pixmap_reply (xcb_connection_t *c /**< */, +xcb_dri3_buffer_from_pixmap_reply (xcb_connection_t *c, xcb_dri3_buffer_from_pixmap_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri3_buffer_from_pixmap_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int * xcb_dri3_buffer_from_pixmap_reply_fds (xcb_connection_t *c /**< */, - xcb_dri3_buffer_from_pixmap_reply_t *reply /**< */) + xcb_dri3_buffer_from_pixmap_reply_t *reply) { return xcb_get_reply_fds(c, reply, sizeof(xcb_dri3_buffer_from_pixmap_reply_t) + 4 * reply->length); } xcb_void_cookie_t -xcb_dri3_fence_from_fd_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t fence /**< */, - uint8_t initially_triggered /**< */, - int32_t fence_fd /**< */) +xcb_dri3_fence_from_fd_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t fence, + uint8_t initially_triggered, + int32_t fence_fd) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_FENCE_FROM_FD, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_FENCE_FROM_FD, + .isvoid = 1 }; struct iovec xcb_parts[4]; xcb_void_cookie_t xcb_ret; xcb_dri3_fence_from_fd_request_t xcb_out; + int fds[1]; xcb_out.drawable = drawable; xcb_out.fence = fence; @@ -332,28 +335,29 @@ xcb_dri3_fence_from_fd_checked (xcb_connection_t *c /**< */, xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - xcb_send_fd(c, fence_fd); - xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + fds[0] = fence_fd; + xcb_ret.sequence = xcb_send_request_with_fds(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req, 1, fds); return xcb_ret; } xcb_void_cookie_t -xcb_dri3_fence_from_fd (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t fence /**< */, - uint8_t initially_triggered /**< */, - int32_t fence_fd /**< */) +xcb_dri3_fence_from_fd (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t fence, + uint8_t initially_triggered, + int32_t fence_fd) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_FENCE_FROM_FD, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_FENCE_FROM_FD, + .isvoid = 1 }; struct iovec xcb_parts[4]; xcb_void_cookie_t xcb_ret; xcb_dri3_fence_from_fd_request_t xcb_out; + int fds[1]; xcb_out.drawable = drawable; xcb_out.fence = fence; @@ -365,21 +369,21 @@ xcb_dri3_fence_from_fd (xcb_connection_t *c /**< */, xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - xcb_send_fd(c, fence_fd); - xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + fds[0] = fence_fd; + xcb_ret.sequence = xcb_send_request_with_fds(c, 0, xcb_parts + 2, &xcb_req, 1, fds); return xcb_ret; } xcb_dri3_fd_from_fence_cookie_t -xcb_dri3_fd_from_fence (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t fence /**< */) +xcb_dri3_fd_from_fence (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t fence) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_FD_FROM_FENCE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_FD_FROM_FENCE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -399,15 +403,15 @@ xcb_dri3_fd_from_fence (xcb_connection_t *c /**< */, } xcb_dri3_fd_from_fence_cookie_t -xcb_dri3_fd_from_fence_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t fence /**< */) +xcb_dri3_fd_from_fence_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t fence) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_dri3_id, - /* opcode */ XCB_DRI3_FD_FROM_FENCE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_dri3_id, + .opcode = XCB_DRI3_FD_FROM_FENCE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -427,16 +431,16 @@ xcb_dri3_fd_from_fence_unchecked (xcb_connection_t *c /**< */, } xcb_dri3_fd_from_fence_reply_t * -xcb_dri3_fd_from_fence_reply (xcb_connection_t *c /**< */, +xcb_dri3_fd_from_fence_reply (xcb_connection_t *c, xcb_dri3_fd_from_fence_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_dri3_fd_from_fence_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int * xcb_dri3_fd_from_fence_reply_fds (xcb_connection_t *c /**< */, - xcb_dri3_fd_from_fence_reply_t *reply /**< */) + xcb_dri3_fd_from_fence_reply_t *reply) { return xcb_get_reply_fds(c, reply, sizeof(xcb_dri3_fd_from_fence_reply_t) + 4 * reply->length); } diff --git a/lib/libxcb/src/dri3.h b/lib/libxcb/src/dri3.h index 6ca7822d9..bfc2ea54d 100644 --- a/lib/libxcb/src/dri3.h +++ b/lib/libxcb/src/dri3.h @@ -28,7 +28,7 @@ extern xcb_extension_t xcb_dri3_id; * @brief xcb_dri3_query_version_cookie_t **/ typedef struct xcb_dri3_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri3_query_version_cookie_t; /** Opcode for xcb_dri3_query_version. */ @@ -38,30 +38,30 @@ typedef struct xcb_dri3_query_version_cookie_t { * @brief xcb_dri3_query_version_request_t **/ typedef struct xcb_dri3_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t major_version; + uint32_t minor_version; } xcb_dri3_query_version_request_t; /** * @brief xcb_dri3_query_version_reply_t **/ typedef struct xcb_dri3_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t major_version; + uint32_t minor_version; } xcb_dri3_query_version_reply_t; /** * @brief xcb_dri3_open_cookie_t **/ typedef struct xcb_dri3_open_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri3_open_cookie_t; /** Opcode for xcb_dri3_open. */ @@ -71,22 +71,22 @@ typedef struct xcb_dri3_open_cookie_t { * @brief xcb_dri3_open_request_t **/ typedef struct xcb_dri3_open_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t provider; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t provider; } xcb_dri3_open_request_t; /** * @brief xcb_dri3_open_reply_t **/ typedef struct xcb_dri3_open_reply_t { - uint8_t response_type; /**< */ - uint8_t nfd; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad0[24]; /**< */ + uint8_t response_type; + uint8_t nfd; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; } xcb_dri3_open_reply_t; /** Opcode for xcb_dri3_pixmap_from_buffer. */ @@ -96,24 +96,24 @@ typedef struct xcb_dri3_open_reply_t { * @brief xcb_dri3_pixmap_from_buffer_request_t **/ typedef struct xcb_dri3_pixmap_from_buffer_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_pixmap_t pixmap; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t size; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t stride; /**< */ - uint8_t depth; /**< */ - uint8_t bpp; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_pixmap_t pixmap; + xcb_drawable_t drawable; + uint32_t size; + uint16_t width; + uint16_t height; + uint16_t stride; + uint8_t depth; + uint8_t bpp; } xcb_dri3_pixmap_from_buffer_request_t; /** * @brief xcb_dri3_buffer_from_pixmap_cookie_t **/ typedef struct xcb_dri3_buffer_from_pixmap_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri3_buffer_from_pixmap_cookie_t; /** Opcode for xcb_dri3_buffer_from_pixmap. */ @@ -123,27 +123,27 @@ typedef struct xcb_dri3_buffer_from_pixmap_cookie_t { * @brief xcb_dri3_buffer_from_pixmap_request_t **/ typedef struct xcb_dri3_buffer_from_pixmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_pixmap_t pixmap; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_pixmap_t pixmap; } xcb_dri3_buffer_from_pixmap_request_t; /** * @brief xcb_dri3_buffer_from_pixmap_reply_t **/ typedef struct xcb_dri3_buffer_from_pixmap_reply_t { - uint8_t response_type; /**< */ - uint8_t nfd; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t size; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t stride; /**< */ - uint8_t depth; /**< */ - uint8_t bpp; /**< */ - uint8_t pad0[12]; /**< */ + uint8_t response_type; + uint8_t nfd; + uint16_t sequence; + uint32_t length; + uint32_t size; + uint16_t width; + uint16_t height; + uint16_t stride; + uint8_t depth; + uint8_t bpp; + uint8_t pad0[12]; } xcb_dri3_buffer_from_pixmap_reply_t; /** Opcode for xcb_dri3_fence_from_fd. */ @@ -153,20 +153,20 @@ typedef struct xcb_dri3_buffer_from_pixmap_reply_t { * @brief xcb_dri3_fence_from_fd_request_t **/ typedef struct xcb_dri3_fence_from_fd_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t fence; /**< */ - uint8_t initially_triggered; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t fence; + uint8_t initially_triggered; + uint8_t pad0[3]; } xcb_dri3_fence_from_fd_request_t; /** * @brief xcb_dri3_fd_from_fence_cookie_t **/ typedef struct xcb_dri3_fd_from_fence_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_dri3_fd_from_fence_cookie_t; /** Opcode for xcb_dri3_fd_from_fence. */ @@ -176,22 +176,22 @@ typedef struct xcb_dri3_fd_from_fence_cookie_t { * @brief xcb_dri3_fd_from_fence_request_t **/ typedef struct xcb_dri3_fd_from_fence_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t fence; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t fence; } xcb_dri3_fd_from_fence_request_t; /** * @brief xcb_dri3_fd_from_fence_reply_t **/ typedef struct xcb_dri3_fd_from_fence_reply_t { - uint8_t response_type; /**< */ - uint8_t nfd; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad0[24]; /**< */ + uint8_t response_type; + uint8_t nfd; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; } xcb_dri3_fd_from_fence_reply_t; /** @@ -203,9 +203,9 @@ typedef struct xcb_dri3_fd_from_fence_reply_t { * */ xcb_dri3_query_version_cookie_t -xcb_dri3_query_version (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */); +xcb_dri3_query_version (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version); /** * @@ -219,9 +219,9 @@ xcb_dri3_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri3_query_version_cookie_t -xcb_dri3_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */); +xcb_dri3_query_version_unchecked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version); /** * Return the reply @@ -238,9 +238,9 @@ xcb_dri3_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri3_query_version_reply_t * -xcb_dri3_query_version_reply (xcb_connection_t *c /**< */, +xcb_dri3_query_version_reply (xcb_connection_t *c, xcb_dri3_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -251,9 +251,9 @@ xcb_dri3_query_version_reply (xcb_connection_t *c /**< */, * */ xcb_dri3_open_cookie_t -xcb_dri3_open (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t provider /**< */); +xcb_dri3_open (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t provider); /** * @@ -267,9 +267,9 @@ xcb_dri3_open (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri3_open_cookie_t -xcb_dri3_open_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t provider /**< */); +xcb_dri3_open_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t provider); /** * Return the reply @@ -286,9 +286,9 @@ xcb_dri3_open_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri3_open_reply_t * -xcb_dri3_open_reply (xcb_connection_t *c /**< */, +xcb_dri3_open_reply (xcb_connection_t *c, xcb_dri3_open_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Return the reply fds @@ -301,7 +301,7 @@ xcb_dri3_open_reply (xcb_connection_t *c /**< */, */ int * xcb_dri3_open_reply_fds (xcb_connection_t *c /**< */, - xcb_dri3_open_reply_t *reply /**< */); + xcb_dri3_open_reply_t *reply); /** * @@ -315,16 +315,16 @@ xcb_dri3_open_reply_fds (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_dri3_pixmap_from_buffer_checked (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_drawable_t drawable /**< */, - uint32_t size /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t stride /**< */, - uint8_t depth /**< */, - uint8_t bpp /**< */, - int32_t pixmap_fd /**< */); +xcb_dri3_pixmap_from_buffer_checked (xcb_connection_t *c, + xcb_pixmap_t pixmap, + xcb_drawable_t drawable, + uint32_t size, + uint16_t width, + uint16_t height, + uint16_t stride, + uint8_t depth, + uint8_t bpp, + int32_t pixmap_fd); /** * @@ -335,16 +335,16 @@ xcb_dri3_pixmap_from_buffer_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_dri3_pixmap_from_buffer (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_drawable_t drawable /**< */, - uint32_t size /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t stride /**< */, - uint8_t depth /**< */, - uint8_t bpp /**< */, - int32_t pixmap_fd /**< */); +xcb_dri3_pixmap_from_buffer (xcb_connection_t *c, + xcb_pixmap_t pixmap, + xcb_drawable_t drawable, + uint32_t size, + uint16_t width, + uint16_t height, + uint16_t stride, + uint8_t depth, + uint8_t bpp, + int32_t pixmap_fd); /** * @@ -355,8 +355,8 @@ xcb_dri3_pixmap_from_buffer (xcb_connection_t *c /**< */, * */ xcb_dri3_buffer_from_pixmap_cookie_t -xcb_dri3_buffer_from_pixmap (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */); +xcb_dri3_buffer_from_pixmap (xcb_connection_t *c, + xcb_pixmap_t pixmap); /** * @@ -370,8 +370,8 @@ xcb_dri3_buffer_from_pixmap (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri3_buffer_from_pixmap_cookie_t -xcb_dri3_buffer_from_pixmap_unchecked (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */); +xcb_dri3_buffer_from_pixmap_unchecked (xcb_connection_t *c, + xcb_pixmap_t pixmap); /** * Return the reply @@ -388,9 +388,9 @@ xcb_dri3_buffer_from_pixmap_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri3_buffer_from_pixmap_reply_t * -xcb_dri3_buffer_from_pixmap_reply (xcb_connection_t *c /**< */, +xcb_dri3_buffer_from_pixmap_reply (xcb_connection_t *c, xcb_dri3_buffer_from_pixmap_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Return the reply fds @@ -403,7 +403,7 @@ xcb_dri3_buffer_from_pixmap_reply (xcb_connection_t *c /** */ int * xcb_dri3_buffer_from_pixmap_reply_fds (xcb_connection_t *c /**< */, - xcb_dri3_buffer_from_pixmap_reply_t *reply /**< */); + xcb_dri3_buffer_from_pixmap_reply_t *reply); /** * @@ -417,11 +417,11 @@ xcb_dri3_buffer_from_pixmap_reply_fds (xcb_connection_t *c * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_dri3_fence_from_fd_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t fence /**< */, - uint8_t initially_triggered /**< */, - int32_t fence_fd /**< */); +xcb_dri3_fence_from_fd_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t fence, + uint8_t initially_triggered, + int32_t fence_fd); /** * @@ -432,11 +432,11 @@ xcb_dri3_fence_from_fd_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_dri3_fence_from_fd (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t fence /**< */, - uint8_t initially_triggered /**< */, - int32_t fence_fd /**< */); +xcb_dri3_fence_from_fd (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t fence, + uint8_t initially_triggered, + int32_t fence_fd); /** * @@ -447,9 +447,9 @@ xcb_dri3_fence_from_fd (xcb_connection_t *c /**< */, * */ xcb_dri3_fd_from_fence_cookie_t -xcb_dri3_fd_from_fence (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t fence /**< */); +xcb_dri3_fd_from_fence (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t fence); /** * @@ -463,9 +463,9 @@ xcb_dri3_fd_from_fence (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_dri3_fd_from_fence_cookie_t -xcb_dri3_fd_from_fence_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t fence /**< */); +xcb_dri3_fd_from_fence_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t fence); /** * Return the reply @@ -482,9 +482,9 @@ xcb_dri3_fd_from_fence_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_dri3_fd_from_fence_reply_t * -xcb_dri3_fd_from_fence_reply (xcb_connection_t *c /**< */, +xcb_dri3_fd_from_fence_reply (xcb_connection_t *c, xcb_dri3_fd_from_fence_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Return the reply fds @@ -497,7 +497,7 @@ xcb_dri3_fd_from_fence_reply (xcb_connection_t *c /**< */, */ int * xcb_dri3_fd_from_fence_reply_fds (xcb_connection_t *c /**< */, - xcb_dri3_fd_from_fence_reply_t *reply /**< */); + xcb_dri3_fd_from_fence_reply_t *reply); #ifdef __cplusplus diff --git a/lib/libxcb/src/glx.c b/lib/libxcb/src/glx.c index 33db8d48b..2446817ca 100644 --- a/lib/libxcb/src/glx.c +++ b/lib/libxcb/src/glx.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_glx_id = { "GLX", 0 }; void -xcb_glx_pixmap_next (xcb_glx_pixmap_iterator_t *i /**< */) +xcb_glx_pixmap_next (xcb_glx_pixmap_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_glx_pixmap_next (xcb_glx_pixmap_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_glx_pixmap_end (xcb_glx_pixmap_iterator_t i /**< */) +xcb_glx_pixmap_end (xcb_glx_pixmap_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,7 +37,7 @@ xcb_glx_pixmap_end (xcb_glx_pixmap_iterator_t i /**< */) } void -xcb_glx_context_next (xcb_glx_context_iterator_t *i /**< */) +xcb_glx_context_next (xcb_glx_context_iterator_t *i) { --i->rem; ++i->data; @@ -45,7 +45,7 @@ xcb_glx_context_next (xcb_glx_context_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_glx_context_end (xcb_glx_context_iterator_t i /**< */) +xcb_glx_context_end (xcb_glx_context_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -55,7 +55,7 @@ xcb_glx_context_end (xcb_glx_context_iterator_t i /**< */) } void -xcb_glx_pbuffer_next (xcb_glx_pbuffer_iterator_t *i /**< */) +xcb_glx_pbuffer_next (xcb_glx_pbuffer_iterator_t *i) { --i->rem; ++i->data; @@ -63,7 +63,7 @@ xcb_glx_pbuffer_next (xcb_glx_pbuffer_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_glx_pbuffer_end (xcb_glx_pbuffer_iterator_t i /**< */) +xcb_glx_pbuffer_end (xcb_glx_pbuffer_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -73,7 +73,7 @@ xcb_glx_pbuffer_end (xcb_glx_pbuffer_iterator_t i /**< */) } void -xcb_glx_window_next (xcb_glx_window_iterator_t *i /**< */) +xcb_glx_window_next (xcb_glx_window_iterator_t *i) { --i->rem; ++i->data; @@ -81,7 +81,7 @@ xcb_glx_window_next (xcb_glx_window_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_glx_window_end (xcb_glx_window_iterator_t i /**< */) +xcb_glx_window_end (xcb_glx_window_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -91,7 +91,7 @@ xcb_glx_window_end (xcb_glx_window_iterator_t i /**< */) } void -xcb_glx_fbconfig_next (xcb_glx_fbconfig_iterator_t *i /**< */) +xcb_glx_fbconfig_next (xcb_glx_fbconfig_iterator_t *i) { --i->rem; ++i->data; @@ -99,7 +99,7 @@ xcb_glx_fbconfig_next (xcb_glx_fbconfig_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_glx_fbconfig_end (xcb_glx_fbconfig_iterator_t i /**< */) +xcb_glx_fbconfig_end (xcb_glx_fbconfig_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -109,7 +109,7 @@ xcb_glx_fbconfig_end (xcb_glx_fbconfig_iterator_t i /**< */) } void -xcb_glx_drawable_next (xcb_glx_drawable_iterator_t *i /**< */) +xcb_glx_drawable_next (xcb_glx_drawable_iterator_t *i) { --i->rem; ++i->data; @@ -117,7 +117,7 @@ xcb_glx_drawable_next (xcb_glx_drawable_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_glx_drawable_end (xcb_glx_drawable_iterator_t i /**< */) +xcb_glx_drawable_end (xcb_glx_drawable_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -127,7 +127,7 @@ xcb_glx_drawable_end (xcb_glx_drawable_iterator_t i /**< */) } void -xcb_glx_float32_next (xcb_glx_float32_iterator_t *i /**< */) +xcb_glx_float32_next (xcb_glx_float32_iterator_t *i) { --i->rem; ++i->data; @@ -135,7 +135,7 @@ xcb_glx_float32_next (xcb_glx_float32_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_glx_float32_end (xcb_glx_float32_iterator_t i /**< */) +xcb_glx_float32_end (xcb_glx_float32_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -145,7 +145,7 @@ xcb_glx_float32_end (xcb_glx_float32_iterator_t i /**< */) } void -xcb_glx_float64_next (xcb_glx_float64_iterator_t *i /**< */) +xcb_glx_float64_next (xcb_glx_float64_iterator_t *i) { --i->rem; ++i->data; @@ -153,7 +153,7 @@ xcb_glx_float64_next (xcb_glx_float64_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_glx_float64_end (xcb_glx_float64_iterator_t i /**< */) +xcb_glx_float64_end (xcb_glx_float64_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -163,7 +163,7 @@ xcb_glx_float64_end (xcb_glx_float64_iterator_t i /**< */) } void -xcb_glx_bool32_next (xcb_glx_bool32_iterator_t *i /**< */) +xcb_glx_bool32_next (xcb_glx_bool32_iterator_t *i) { --i->rem; ++i->data; @@ -171,7 +171,7 @@ xcb_glx_bool32_next (xcb_glx_bool32_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_glx_bool32_end (xcb_glx_bool32_iterator_t i /**< */) +xcb_glx_bool32_end (xcb_glx_bool32_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -181,7 +181,7 @@ xcb_glx_bool32_end (xcb_glx_bool32_iterator_t i /**< */) } void -xcb_glx_context_tag_next (xcb_glx_context_tag_iterator_t *i /**< */) +xcb_glx_context_tag_next (xcb_glx_context_tag_iterator_t *i) { --i->rem; ++i->data; @@ -189,7 +189,7 @@ xcb_glx_context_tag_next (xcb_glx_context_tag_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_glx_context_tag_end (xcb_glx_context_tag_iterator_t i /**< */) +xcb_glx_context_tag_end (xcb_glx_context_tag_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -199,8 +199,8 @@ xcb_glx_context_tag_end (xcb_glx_context_tag_iterator_t i /**< */) } int -xcb_glx_render_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */) +xcb_glx_render_sizeof (const void *_buffer, + uint32_t data_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -230,16 +230,16 @@ xcb_glx_render_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_glx_render_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_glx_render_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_RENDER, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_RENDER, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -263,16 +263,16 @@ xcb_glx_render_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_render (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_glx_render (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_RENDER, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_RENDER, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -295,8 +295,30 @@ xcb_glx_render (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_glx_render_data (const xcb_glx_render_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_glx_render_large_sizeof (const void *_buffer /**< */) +xcb_glx_render_data_length (const xcb_glx_render_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_glx_render_request_t))/sizeof(uint8_t)); +} + +xcb_generic_iterator_t +xcb_glx_render_data_end (const xcb_glx_render_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_glx_render_request_t))/sizeof(uint8_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_glx_render_large_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_render_large_request_t *_aux = (xcb_glx_render_large_request_t *)_buffer; @@ -327,18 +349,18 @@ xcb_glx_render_large_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_render_large_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint16_t request_num /**< */, - uint16_t request_total /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_glx_render_large_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint16_t request_num, + uint16_t request_total, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_RENDER_LARGE, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_RENDER_LARGE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -365,18 +387,18 @@ xcb_glx_render_large_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_render_large (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint16_t request_num /**< */, - uint16_t request_total /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_glx_render_large (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint16_t request_num, + uint16_t request_total, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_RENDER_LARGE, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_RENDER_LARGE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -402,19 +424,41 @@ xcb_glx_render_large (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_glx_render_large_data (const xcb_glx_render_large_request_t *R) +{ + return (uint8_t *) (R + 1); +} + +int +xcb_glx_render_large_data_length (const xcb_glx_render_large_request_t *R) +{ + return R->data_len; +} + +xcb_generic_iterator_t +xcb_glx_render_large_data_end (const xcb_glx_render_large_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + (R->data_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_glx_create_context_checked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_visualid_t visual /**< */, - uint32_t screen /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */) +xcb_glx_create_context_checked (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_visualid_t visual, + uint32_t screen, + xcb_glx_context_t share_list, + uint8_t is_direct) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -438,18 +482,18 @@ xcb_glx_create_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_create_context (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_visualid_t visual /**< */, - uint32_t screen /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */) +xcb_glx_create_context (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_visualid_t visual, + uint32_t screen, + xcb_glx_context_t share_list, + uint8_t is_direct) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -473,14 +517,14 @@ xcb_glx_create_context (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_destroy_context_checked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */) +xcb_glx_destroy_context_checked (xcb_connection_t *c, + xcb_glx_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DESTROY_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DESTROY_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -499,14 +543,14 @@ xcb_glx_destroy_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_destroy_context (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */) +xcb_glx_destroy_context (xcb_connection_t *c, + xcb_glx_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DESTROY_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DESTROY_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -525,16 +569,16 @@ xcb_glx_destroy_context (xcb_connection_t *c /**< */, } xcb_glx_make_current_cookie_t -xcb_glx_make_current (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_context_tag_t old_context_tag /**< */) +xcb_glx_make_current (xcb_connection_t *c, + xcb_glx_drawable_t drawable, + xcb_glx_context_t context, + xcb_glx_context_tag_t old_context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_MAKE_CURRENT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_MAKE_CURRENT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -555,16 +599,16 @@ xcb_glx_make_current (xcb_connection_t *c /**< */, } xcb_glx_make_current_cookie_t -xcb_glx_make_current_unchecked (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_context_tag_t old_context_tag /**< */) +xcb_glx_make_current_unchecked (xcb_connection_t *c, + xcb_glx_drawable_t drawable, + xcb_glx_context_t context, + xcb_glx_context_tag_t old_context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_MAKE_CURRENT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_MAKE_CURRENT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -585,22 +629,22 @@ xcb_glx_make_current_unchecked (xcb_connection_t *c /**< */, } xcb_glx_make_current_reply_t * -xcb_glx_make_current_reply (xcb_connection_t *c /**< */, +xcb_glx_make_current_reply (xcb_connection_t *c, xcb_glx_make_current_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_make_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_glx_is_direct_cookie_t -xcb_glx_is_direct (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */) +xcb_glx_is_direct (xcb_connection_t *c, + xcb_glx_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_IS_DIRECT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_IS_DIRECT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -619,14 +663,14 @@ xcb_glx_is_direct (xcb_connection_t *c /**< */, } xcb_glx_is_direct_cookie_t -xcb_glx_is_direct_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */) +xcb_glx_is_direct_unchecked (xcb_connection_t *c, + xcb_glx_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_IS_DIRECT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_IS_DIRECT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -645,23 +689,23 @@ xcb_glx_is_direct_unchecked (xcb_connection_t *c /**< */, } xcb_glx_is_direct_reply_t * -xcb_glx_is_direct_reply (xcb_connection_t *c /**< */, +xcb_glx_is_direct_reply (xcb_connection_t *c, xcb_glx_is_direct_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_is_direct_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_glx_query_version_cookie_t -xcb_glx_query_version (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */) +xcb_glx_query_version (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -681,15 +725,15 @@ xcb_glx_query_version (xcb_connection_t *c /**< */, } xcb_glx_query_version_cookie_t -xcb_glx_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */) +xcb_glx_query_version_unchecked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -709,22 +753,22 @@ xcb_glx_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_glx_query_version_reply_t * -xcb_glx_query_version_reply (xcb_connection_t *c /**< */, +xcb_glx_query_version_reply (xcb_connection_t *c, xcb_glx_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_glx_wait_gl_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_wait_gl_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_WAIT_GL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_WAIT_GL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -743,14 +787,14 @@ xcb_glx_wait_gl_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_wait_gl (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_wait_gl (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_WAIT_GL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_WAIT_GL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -769,14 +813,14 @@ xcb_glx_wait_gl (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_wait_x_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_wait_x_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_WAIT_X, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_WAIT_X, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -795,14 +839,14 @@ xcb_glx_wait_x_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_wait_x (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_wait_x (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_WAIT_X, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_WAIT_X, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -821,17 +865,17 @@ xcb_glx_wait_x (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_copy_context_checked (xcb_connection_t *c /**< */, - xcb_glx_context_t src /**< */, - xcb_glx_context_t dest /**< */, - uint32_t mask /**< */, - xcb_glx_context_tag_t src_context_tag /**< */) +xcb_glx_copy_context_checked (xcb_connection_t *c, + xcb_glx_context_t src, + xcb_glx_context_t dest, + uint32_t mask, + xcb_glx_context_tag_t src_context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_COPY_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_COPY_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -853,17 +897,17 @@ xcb_glx_copy_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_copy_context (xcb_connection_t *c /**< */, - xcb_glx_context_t src /**< */, - xcb_glx_context_t dest /**< */, - uint32_t mask /**< */, - xcb_glx_context_tag_t src_context_tag /**< */) +xcb_glx_copy_context (xcb_connection_t *c, + xcb_glx_context_t src, + xcb_glx_context_t dest, + uint32_t mask, + xcb_glx_context_tag_t src_context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_COPY_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_COPY_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -885,15 +929,15 @@ xcb_glx_copy_context (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_swap_buffers_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - xcb_glx_drawable_t drawable /**< */) +xcb_glx_swap_buffers_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + xcb_glx_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_SWAP_BUFFERS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_SWAP_BUFFERS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -913,15 +957,15 @@ xcb_glx_swap_buffers_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_swap_buffers (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - xcb_glx_drawable_t drawable /**< */) +xcb_glx_swap_buffers (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + xcb_glx_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_SWAP_BUFFERS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_SWAP_BUFFERS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -941,18 +985,18 @@ xcb_glx_swap_buffers (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_use_x_font_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - xcb_font_t font /**< */, - uint32_t first /**< */, - uint32_t count /**< */, - uint32_t list_base /**< */) +xcb_glx_use_x_font_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + xcb_font_t font, + uint32_t first, + uint32_t count, + uint32_t list_base) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_USE_X_FONT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_USE_X_FONT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -975,18 +1019,18 @@ xcb_glx_use_x_font_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_use_x_font (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - xcb_font_t font /**< */, - uint32_t first /**< */, - uint32_t count /**< */, - uint32_t list_base /**< */) +xcb_glx_use_x_font (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + xcb_font_t font, + uint32_t first, + uint32_t count, + uint32_t list_base) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_USE_X_FONT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_USE_X_FONT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1009,17 +1053,17 @@ xcb_glx_use_x_font (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_visualid_t visual /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */) +xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c, + uint32_t screen, + xcb_visualid_t visual, + xcb_pixmap_t pixmap, + xcb_glx_pixmap_t glx_pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_GLX_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_GLX_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1041,17 +1085,17 @@ xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_create_glx_pixmap (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_visualid_t visual /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */) +xcb_glx_create_glx_pixmap (xcb_connection_t *c, + uint32_t screen, + xcb_visualid_t visual, + xcb_pixmap_t pixmap, + xcb_glx_pixmap_t glx_pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_GLX_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_GLX_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1073,7 +1117,7 @@ xcb_glx_create_glx_pixmap (xcb_connection_t *c /**< */, } int -xcb_glx_get_visual_configs_sizeof (const void *_buffer /**< */) +xcb_glx_get_visual_configs_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_visual_configs_reply_t *_aux = (xcb_glx_get_visual_configs_reply_t *)_buffer; @@ -1104,14 +1148,14 @@ xcb_glx_get_visual_configs_sizeof (const void *_buffer /**< */) } xcb_glx_get_visual_configs_cookie_t -xcb_glx_get_visual_configs (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_glx_get_visual_configs (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_VISUAL_CONFIGS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_VISUAL_CONFIGS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1130,14 +1174,14 @@ xcb_glx_get_visual_configs (xcb_connection_t *c /**< */, } xcb_glx_get_visual_configs_cookie_t -xcb_glx_get_visual_configs_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_glx_get_visual_configs_unchecked (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_VISUAL_CONFIGS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_VISUAL_CONFIGS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1156,19 +1200,19 @@ xcb_glx_get_visual_configs_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_glx_get_visual_configs_property_list (const xcb_glx_get_visual_configs_reply_t *R /**< */) +xcb_glx_get_visual_configs_property_list (const xcb_glx_get_visual_configs_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_glx_get_visual_configs_property_list_length (const xcb_glx_get_visual_configs_reply_t *R /**< */) +xcb_glx_get_visual_configs_property_list_length (const xcb_glx_get_visual_configs_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_reply_t *R /**< */) +xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->length); @@ -1178,22 +1222,22 @@ xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_r } xcb_glx_get_visual_configs_reply_t * -xcb_glx_get_visual_configs_reply (xcb_connection_t *c /**< */, +xcb_glx_get_visual_configs_reply (xcb_connection_t *c, xcb_glx_get_visual_configs_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_visual_configs_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */) +xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c, + xcb_glx_pixmap_t glx_pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DESTROY_GLX_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DESTROY_GLX_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1212,14 +1256,14 @@ xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_destroy_glx_pixmap (xcb_connection_t *c /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */) +xcb_glx_destroy_glx_pixmap (xcb_connection_t *c, + xcb_glx_pixmap_t glx_pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DESTROY_GLX_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DESTROY_GLX_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1238,8 +1282,8 @@ xcb_glx_destroy_glx_pixmap (xcb_connection_t *c /**< */, } int -xcb_glx_vendor_private_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */) +xcb_glx_vendor_private_sizeof (const void *_buffer, + uint32_t data_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -1269,17 +1313,17 @@ xcb_glx_vendor_private_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_glx_vendor_private_checked (xcb_connection_t *c /**< */, - uint32_t vendor_code /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_glx_vendor_private_checked (xcb_connection_t *c, + uint32_t vendor_code, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_VENDOR_PRIVATE, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_VENDOR_PRIVATE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1304,17 +1348,17 @@ xcb_glx_vendor_private_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_vendor_private (xcb_connection_t *c /**< */, - uint32_t vendor_code /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_glx_vendor_private (xcb_connection_t *c, + uint32_t vendor_code, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_VENDOR_PRIVATE, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_VENDOR_PRIVATE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1338,9 +1382,31 @@ xcb_glx_vendor_private (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_glx_vendor_private_data (const xcb_glx_vendor_private_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_glx_vendor_private_with_reply_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */) +xcb_glx_vendor_private_data_length (const xcb_glx_vendor_private_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_glx_vendor_private_request_t))/sizeof(uint8_t)); +} + +xcb_generic_iterator_t +xcb_glx_vendor_private_data_end (const xcb_glx_vendor_private_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_glx_vendor_private_request_t))/sizeof(uint8_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_glx_vendor_private_with_reply_sizeof (const void *_buffer, + uint32_t data_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -1370,17 +1436,17 @@ xcb_glx_vendor_private_with_reply_sizeof (const void *_buffer /**< */, } xcb_glx_vendor_private_with_reply_cookie_t -xcb_glx_vendor_private_with_reply (xcb_connection_t *c /**< */, - uint32_t vendor_code /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_glx_vendor_private_with_reply (xcb_connection_t *c, + uint32_t vendor_code, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_VENDOR_PRIVATE_WITH_REPLY, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_VENDOR_PRIVATE_WITH_REPLY, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -1405,17 +1471,17 @@ xcb_glx_vendor_private_with_reply (xcb_connection_t *c /**< */, } xcb_glx_vendor_private_with_reply_cookie_t -xcb_glx_vendor_private_with_reply_unchecked (xcb_connection_t *c /**< */, - uint32_t vendor_code /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_glx_vendor_private_with_reply_unchecked (xcb_connection_t *c, + uint32_t vendor_code, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_VENDOR_PRIVATE_WITH_REPLY, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_VENDOR_PRIVATE_WITH_REPLY, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -1440,19 +1506,19 @@ xcb_glx_vendor_private_with_reply_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_vendor_private_with_reply_data_2 (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */) +xcb_glx_vendor_private_with_reply_data_2 (const xcb_glx_vendor_private_with_reply_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_vendor_private_with_reply_data_2_length (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */) +xcb_glx_vendor_private_with_reply_data_2_length (const xcb_glx_vendor_private_with_reply_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */) +xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_reply_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -1462,22 +1528,22 @@ xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_ } xcb_glx_vendor_private_with_reply_reply_t * -xcb_glx_vendor_private_with_reply_reply (xcb_connection_t *c /**< */, +xcb_glx_vendor_private_with_reply_reply (xcb_connection_t *c, xcb_glx_vendor_private_with_reply_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_vendor_private_with_reply_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_glx_query_extensions_string_cookie_t -xcb_glx_query_extensions_string (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_glx_query_extensions_string (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_QUERY_EXTENSIONS_STRING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_QUERY_EXTENSIONS_STRING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1496,14 +1562,14 @@ xcb_glx_query_extensions_string (xcb_connection_t *c /**< */, } xcb_glx_query_extensions_string_cookie_t -xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_QUERY_EXTENSIONS_STRING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_QUERY_EXTENSIONS_STRING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1522,15 +1588,15 @@ xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c /**< */, } xcb_glx_query_extensions_string_reply_t * -xcb_glx_query_extensions_string_reply (xcb_connection_t *c /**< */, +xcb_glx_query_extensions_string_reply (xcb_connection_t *c, xcb_glx_query_extensions_string_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_query_extensions_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_query_server_string_sizeof (const void *_buffer /**< */) +xcb_glx_query_server_string_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_query_server_string_reply_t *_aux = (xcb_glx_query_server_string_reply_t *)_buffer; @@ -1561,15 +1627,15 @@ xcb_glx_query_server_string_sizeof (const void *_buffer /**< */) } xcb_glx_query_server_string_cookie_t -xcb_glx_query_server_string (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t name /**< */) +xcb_glx_query_server_string (xcb_connection_t *c, + uint32_t screen, + uint32_t name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_QUERY_SERVER_STRING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_QUERY_SERVER_STRING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1589,15 +1655,15 @@ xcb_glx_query_server_string (xcb_connection_t *c /**< */, } xcb_glx_query_server_string_cookie_t -xcb_glx_query_server_string_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t name /**< */) +xcb_glx_query_server_string_unchecked (xcb_connection_t *c, + uint32_t screen, + uint32_t name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_QUERY_SERVER_STRING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_QUERY_SERVER_STRING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1617,19 +1683,19 @@ xcb_glx_query_server_string_unchecked (xcb_connection_t *c /**< */, } char * -xcb_glx_query_server_string_string (const xcb_glx_query_server_string_reply_t *R /**< */) +xcb_glx_query_server_string_string (const xcb_glx_query_server_string_reply_t *R) { return (char *) (R + 1); } int -xcb_glx_query_server_string_string_length (const xcb_glx_query_server_string_reply_t *R /**< */) +xcb_glx_query_server_string_string_length (const xcb_glx_query_server_string_reply_t *R) { return R->str_len; } xcb_generic_iterator_t -xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_t *R /**< */) +xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->str_len); @@ -1639,15 +1705,15 @@ xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_ } xcb_glx_query_server_string_reply_t * -xcb_glx_query_server_string_reply (xcb_connection_t *c /**< */, +xcb_glx_query_server_string_reply (xcb_connection_t *c, xcb_glx_query_server_string_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_query_server_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_client_info_sizeof (const void *_buffer /**< */) +xcb_glx_client_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_client_info_request_t *_aux = (xcb_glx_client_info_request_t *)_buffer; @@ -1678,17 +1744,17 @@ xcb_glx_client_info_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_client_info_checked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t str_len /**< */, - const char *string /**< */) +xcb_glx_client_info_checked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t str_len, + const char *string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CLIENT_INFO, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CLIENT_INFO, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1714,17 +1780,17 @@ xcb_glx_client_info_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_client_info (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t str_len /**< */, - const char *string /**< */) +xcb_glx_client_info (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t str_len, + const char *string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CLIENT_INFO, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CLIENT_INFO, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1749,8 +1815,30 @@ xcb_glx_client_info (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_glx_client_info_string (const xcb_glx_client_info_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_glx_get_fb_configs_sizeof (const void *_buffer /**< */) +xcb_glx_client_info_string_length (const xcb_glx_client_info_request_t *R) +{ + return R->str_len; +} + +xcb_generic_iterator_t +xcb_glx_client_info_string_end (const xcb_glx_client_info_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->str_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_glx_get_fb_configs_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_fb_configs_reply_t *_aux = (xcb_glx_get_fb_configs_reply_t *)_buffer; @@ -1781,14 +1869,14 @@ xcb_glx_get_fb_configs_sizeof (const void *_buffer /**< */) } xcb_glx_get_fb_configs_cookie_t -xcb_glx_get_fb_configs (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_glx_get_fb_configs (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_FB_CONFIGS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_FB_CONFIGS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1807,14 +1895,14 @@ xcb_glx_get_fb_configs (xcb_connection_t *c /**< */, } xcb_glx_get_fb_configs_cookie_t -xcb_glx_get_fb_configs_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_glx_get_fb_configs_unchecked (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_FB_CONFIGS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_FB_CONFIGS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1833,19 +1921,19 @@ xcb_glx_get_fb_configs_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_glx_get_fb_configs_property_list (const xcb_glx_get_fb_configs_reply_t *R /**< */) +xcb_glx_get_fb_configs_property_list (const xcb_glx_get_fb_configs_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_glx_get_fb_configs_property_list_length (const xcb_glx_get_fb_configs_reply_t *R /**< */) +xcb_glx_get_fb_configs_property_list_length (const xcb_glx_get_fb_configs_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t *R /**< */) +xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->length); @@ -1855,15 +1943,15 @@ xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t * } xcb_glx_get_fb_configs_reply_t * -xcb_glx_get_fb_configs_reply (xcb_connection_t *c /**< */, +xcb_glx_get_fb_configs_reply (xcb_connection_t *c, xcb_glx_get_fb_configs_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_fb_configs_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_create_pixmap_sizeof (const void *_buffer /**< */) +xcb_glx_create_pixmap_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_create_pixmap_request_t *_aux = (xcb_glx_create_pixmap_request_t *)_buffer; @@ -1894,19 +1982,19 @@ xcb_glx_create_pixmap_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_create_pixmap_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */) +xcb_glx_create_pixmap_checked (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_pixmap_t pixmap, + xcb_glx_pixmap_t glx_pixmap, + uint32_t num_attribs, + const uint32_t *attribs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_PIXMAP, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1934,19 +2022,19 @@ xcb_glx_create_pixmap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_create_pixmap (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */) +xcb_glx_create_pixmap (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_pixmap_t pixmap, + xcb_glx_pixmap_t glx_pixmap, + uint32_t num_attribs, + const uint32_t *attribs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_PIXMAP, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1973,15 +2061,37 @@ xcb_glx_create_pixmap (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_glx_create_pixmap_attribs (const xcb_glx_create_pixmap_request_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_glx_create_pixmap_attribs_length (const xcb_glx_create_pixmap_request_t *R) +{ + return (R->num_attribs * 2); +} + +xcb_generic_iterator_t +xcb_glx_create_pixmap_attribs_end (const xcb_glx_create_pixmap_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_glx_destroy_pixmap_checked (xcb_connection_t *c /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */) +xcb_glx_destroy_pixmap_checked (xcb_connection_t *c, + xcb_glx_pixmap_t glx_pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DESTROY_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DESTROY_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2000,14 +2110,14 @@ xcb_glx_destroy_pixmap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_destroy_pixmap (xcb_connection_t *c /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */) +xcb_glx_destroy_pixmap (xcb_connection_t *c, + xcb_glx_pixmap_t glx_pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DESTROY_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DESTROY_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2026,19 +2136,19 @@ xcb_glx_destroy_pixmap (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_create_new_context_checked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - uint32_t screen /**< */, - uint32_t render_type /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */) +xcb_glx_create_new_context_checked (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_glx_fbconfig_t fbconfig, + uint32_t screen, + uint32_t render_type, + xcb_glx_context_t share_list, + uint8_t is_direct) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_NEW_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_NEW_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2063,19 +2173,19 @@ xcb_glx_create_new_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_create_new_context (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - uint32_t screen /**< */, - uint32_t render_type /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */) +xcb_glx_create_new_context (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_glx_fbconfig_t fbconfig, + uint32_t screen, + uint32_t render_type, + xcb_glx_context_t share_list, + uint8_t is_direct) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_NEW_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_NEW_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2100,7 +2210,7 @@ xcb_glx_create_new_context (xcb_connection_t *c /**< */, } int -xcb_glx_query_context_sizeof (const void *_buffer /**< */) +xcb_glx_query_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_query_context_reply_t *_aux = (xcb_glx_query_context_reply_t *)_buffer; @@ -2131,14 +2241,14 @@ xcb_glx_query_context_sizeof (const void *_buffer /**< */) } xcb_glx_query_context_cookie_t -xcb_glx_query_context (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */) +xcb_glx_query_context (xcb_connection_t *c, + xcb_glx_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_QUERY_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_QUERY_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2157,14 +2267,14 @@ xcb_glx_query_context (xcb_connection_t *c /**< */, } xcb_glx_query_context_cookie_t -xcb_glx_query_context_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */) +xcb_glx_query_context_unchecked (xcb_connection_t *c, + xcb_glx_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_QUERY_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_QUERY_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2183,19 +2293,19 @@ xcb_glx_query_context_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_glx_query_context_attribs (const xcb_glx_query_context_reply_t *R /**< */) +xcb_glx_query_context_attribs (const xcb_glx_query_context_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_glx_query_context_attribs_length (const xcb_glx_query_context_reply_t *R /**< */) +xcb_glx_query_context_attribs_length (const xcb_glx_query_context_reply_t *R) { return (R->num_attribs * 2); } xcb_generic_iterator_t -xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R /**< */) +xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); @@ -2205,25 +2315,25 @@ xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R /**< } xcb_glx_query_context_reply_t * -xcb_glx_query_context_reply (xcb_connection_t *c /**< */, +xcb_glx_query_context_reply (xcb_connection_t *c, xcb_glx_query_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_query_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_glx_make_context_current_cookie_t -xcb_glx_make_context_current (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t old_context_tag /**< */, - xcb_glx_drawable_t drawable /**< */, - xcb_glx_drawable_t read_drawable /**< */, - xcb_glx_context_t context /**< */) +xcb_glx_make_context_current (xcb_connection_t *c, + xcb_glx_context_tag_t old_context_tag, + xcb_glx_drawable_t drawable, + xcb_glx_drawable_t read_drawable, + xcb_glx_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_MAKE_CONTEXT_CURRENT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_MAKE_CONTEXT_CURRENT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2245,17 +2355,17 @@ xcb_glx_make_context_current (xcb_connection_t *c /**< */, } xcb_glx_make_context_current_cookie_t -xcb_glx_make_context_current_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t old_context_tag /**< */, - xcb_glx_drawable_t drawable /**< */, - xcb_glx_drawable_t read_drawable /**< */, - xcb_glx_context_t context /**< */) +xcb_glx_make_context_current_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t old_context_tag, + xcb_glx_drawable_t drawable, + xcb_glx_drawable_t read_drawable, + xcb_glx_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_MAKE_CONTEXT_CURRENT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_MAKE_CONTEXT_CURRENT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2277,15 +2387,15 @@ xcb_glx_make_context_current_unchecked (xcb_connection_t *c /**< */, } xcb_glx_make_context_current_reply_t * -xcb_glx_make_context_current_reply (xcb_connection_t *c /**< */, +xcb_glx_make_context_current_reply (xcb_connection_t *c, xcb_glx_make_context_current_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_make_context_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_create_pbuffer_sizeof (const void *_buffer /**< */) +xcb_glx_create_pbuffer_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_create_pbuffer_request_t *_aux = (xcb_glx_create_pbuffer_request_t *)_buffer; @@ -2316,18 +2426,18 @@ xcb_glx_create_pbuffer_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_create_pbuffer_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_glx_pbuffer_t pbuffer /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */) +xcb_glx_create_pbuffer_checked (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_glx_pbuffer_t pbuffer, + uint32_t num_attribs, + const uint32_t *attribs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_PBUFFER, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_PBUFFER, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2354,18 +2464,18 @@ xcb_glx_create_pbuffer_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_create_pbuffer (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_glx_pbuffer_t pbuffer /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */) +xcb_glx_create_pbuffer (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_glx_pbuffer_t pbuffer, + uint32_t num_attribs, + const uint32_t *attribs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_PBUFFER, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_PBUFFER, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2391,15 +2501,37 @@ xcb_glx_create_pbuffer (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_glx_create_pbuffer_attribs (const xcb_glx_create_pbuffer_request_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_glx_create_pbuffer_attribs_length (const xcb_glx_create_pbuffer_request_t *R) +{ + return (R->num_attribs * 2); +} + +xcb_generic_iterator_t +xcb_glx_create_pbuffer_attribs_end (const xcb_glx_create_pbuffer_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_glx_destroy_pbuffer_checked (xcb_connection_t *c /**< */, - xcb_glx_pbuffer_t pbuffer /**< */) +xcb_glx_destroy_pbuffer_checked (xcb_connection_t *c, + xcb_glx_pbuffer_t pbuffer) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DESTROY_PBUFFER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DESTROY_PBUFFER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2418,14 +2550,14 @@ xcb_glx_destroy_pbuffer_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_destroy_pbuffer (xcb_connection_t *c /**< */, - xcb_glx_pbuffer_t pbuffer /**< */) +xcb_glx_destroy_pbuffer (xcb_connection_t *c, + xcb_glx_pbuffer_t pbuffer) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DESTROY_PBUFFER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DESTROY_PBUFFER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2444,7 +2576,7 @@ xcb_glx_destroy_pbuffer (xcb_connection_t *c /**< */, } int -xcb_glx_get_drawable_attributes_sizeof (const void *_buffer /**< */) +xcb_glx_get_drawable_attributes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_drawable_attributes_reply_t *_aux = (xcb_glx_get_drawable_attributes_reply_t *)_buffer; @@ -2475,14 +2607,14 @@ xcb_glx_get_drawable_attributes_sizeof (const void *_buffer /**< */) } xcb_glx_get_drawable_attributes_cookie_t -xcb_glx_get_drawable_attributes (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */) +xcb_glx_get_drawable_attributes (xcb_connection_t *c, + xcb_glx_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_DRAWABLE_ATTRIBUTES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_DRAWABLE_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2501,14 +2633,14 @@ xcb_glx_get_drawable_attributes (xcb_connection_t *c /**< */, } xcb_glx_get_drawable_attributes_cookie_t -xcb_glx_get_drawable_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */) +xcb_glx_get_drawable_attributes_unchecked (xcb_connection_t *c, + xcb_glx_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_DRAWABLE_ATTRIBUTES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_DRAWABLE_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2527,19 +2659,19 @@ xcb_glx_get_drawable_attributes_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_glx_get_drawable_attributes_attribs (const xcb_glx_get_drawable_attributes_reply_t *R /**< */) +xcb_glx_get_drawable_attributes_attribs (const xcb_glx_get_drawable_attributes_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_glx_get_drawable_attributes_attribs_length (const xcb_glx_get_drawable_attributes_reply_t *R /**< */) +xcb_glx_get_drawable_attributes_attribs_length (const xcb_glx_get_drawable_attributes_reply_t *R) { return (R->num_attribs * 2); } xcb_generic_iterator_t -xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attributes_reply_t *R /**< */) +xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attributes_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); @@ -2549,15 +2681,15 @@ xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attribut } xcb_glx_get_drawable_attributes_reply_t * -xcb_glx_get_drawable_attributes_reply (xcb_connection_t *c /**< */, +xcb_glx_get_drawable_attributes_reply (xcb_connection_t *c, xcb_glx_get_drawable_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_drawable_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_change_drawable_attributes_sizeof (const void *_buffer /**< */) +xcb_glx_change_drawable_attributes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_change_drawable_attributes_request_t *_aux = (xcb_glx_change_drawable_attributes_request_t *)_buffer; @@ -2588,16 +2720,16 @@ xcb_glx_change_drawable_attributes_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_change_drawable_attributes_checked (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */) +xcb_glx_change_drawable_attributes_checked (xcb_connection_t *c, + xcb_glx_drawable_t drawable, + uint32_t num_attribs, + const uint32_t *attribs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2622,16 +2754,16 @@ xcb_glx_change_drawable_attributes_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_change_drawable_attributes (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */) +xcb_glx_change_drawable_attributes (xcb_connection_t *c, + xcb_glx_drawable_t drawable, + uint32_t num_attribs, + const uint32_t *attribs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2655,8 +2787,30 @@ xcb_glx_change_drawable_attributes (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_glx_change_drawable_attributes_attribs (const xcb_glx_change_drawable_attributes_request_t *R) +{ + return (uint32_t *) (R + 1); +} + int -xcb_glx_create_window_sizeof (const void *_buffer /**< */) +xcb_glx_change_drawable_attributes_attribs_length (const xcb_glx_change_drawable_attributes_request_t *R) +{ + return (R->num_attribs * 2); +} + +xcb_generic_iterator_t +xcb_glx_change_drawable_attributes_attribs_end (const xcb_glx_change_drawable_attributes_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_glx_create_window_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_create_window_request_t *_aux = (xcb_glx_create_window_request_t *)_buffer; @@ -2687,19 +2841,19 @@ xcb_glx_create_window_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_create_window_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_window_t window /**< */, - xcb_glx_window_t glx_window /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */) +xcb_glx_create_window_checked (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_window_t window, + xcb_glx_window_t glx_window, + uint32_t num_attribs, + const uint32_t *attribs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_WINDOW, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2727,19 +2881,19 @@ xcb_glx_create_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_create_window (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_window_t window /**< */, - xcb_glx_window_t glx_window /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */) +xcb_glx_create_window (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_window_t window, + xcb_glx_window_t glx_window, + uint32_t num_attribs, + const uint32_t *attribs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_WINDOW, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2766,15 +2920,37 @@ xcb_glx_create_window (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_glx_create_window_attribs (const xcb_glx_create_window_request_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_glx_create_window_attribs_length (const xcb_glx_create_window_request_t *R) +{ + return (R->num_attribs * 2); +} + +xcb_generic_iterator_t +xcb_glx_create_window_attribs_end (const xcb_glx_create_window_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_glx_delete_window_checked (xcb_connection_t *c /**< */, - xcb_glx_window_t glxwindow /**< */) +xcb_glx_delete_window_checked (xcb_connection_t *c, + xcb_glx_window_t glxwindow) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DELETE_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DELETE_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2793,14 +2969,14 @@ xcb_glx_delete_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_delete_window (xcb_connection_t *c /**< */, - xcb_glx_window_t glxwindow /**< */) +xcb_glx_delete_window (xcb_connection_t *c, + xcb_glx_window_t glxwindow) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DELETE_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DELETE_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2819,7 +2995,7 @@ xcb_glx_delete_window (xcb_connection_t *c /**< */, } int -xcb_glx_set_client_info_arb_sizeof (const void *_buffer /**< */) +xcb_glx_set_client_info_arb_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_set_client_info_arb_request_t *_aux = (xcb_glx_set_client_info_arb_request_t *)_buffer; @@ -2874,21 +3050,21 @@ xcb_glx_set_client_info_arb_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_set_client_info_arb_checked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t num_versions /**< */, - uint32_t gl_str_len /**< */, - uint32_t glx_str_len /**< */, - const uint32_t *gl_versions /**< */, - const char *gl_extension_string /**< */, - const char *glx_extension_string /**< */) +xcb_glx_set_client_info_arb_checked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t num_versions, + uint32_t gl_str_len, + uint32_t glx_str_len, + const uint32_t *gl_versions, + const char *gl_extension_string, + const char *glx_extension_string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 8, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_SET_CLIENT_INFO_ARB, - /* isvoid */ 1 + .count = 8, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_SET_CLIENT_INFO_ARB, + .isvoid = 1 }; struct iovec xcb_parts[10]; @@ -2926,21 +3102,21 @@ xcb_glx_set_client_info_arb_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_set_client_info_arb (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t num_versions /**< */, - uint32_t gl_str_len /**< */, - uint32_t glx_str_len /**< */, - const uint32_t *gl_versions /**< */, - const char *gl_extension_string /**< */, - const char *glx_extension_string /**< */) +xcb_glx_set_client_info_arb (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t num_versions, + uint32_t gl_str_len, + uint32_t glx_str_len, + const uint32_t *gl_versions, + const char *gl_extension_string, + const char *glx_extension_string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 8, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_SET_CLIENT_INFO_ARB, - /* isvoid */ 1 + .count = 8, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_SET_CLIENT_INFO_ARB, + .isvoid = 1 }; struct iovec xcb_parts[10]; @@ -2977,8 +3153,78 @@ xcb_glx_set_client_info_arb (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_glx_set_client_info_arb_gl_versions (const xcb_glx_set_client_info_arb_request_t *R) +{ + return (uint32_t *) (R + 1); +} + int -xcb_glx_create_context_attribs_arb_sizeof (const void *_buffer /**< */) +xcb_glx_set_client_info_arb_gl_versions_length (const xcb_glx_set_client_info_arb_request_t *R) +{ + return (R->num_versions * 2); +} + +xcb_generic_iterator_t +xcb_glx_set_client_info_arb_gl_versions_end (const xcb_glx_set_client_info_arb_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + ((R->num_versions * 2)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +char * +xcb_glx_set_client_info_arb_gl_extension_string (const xcb_glx_set_client_info_arb_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_versions_end(R); + return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); +} + +int +xcb_glx_set_client_info_arb_gl_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R) +{ + return R->gl_str_len; +} + +xcb_generic_iterator_t +xcb_glx_set_client_info_arb_gl_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_versions_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->gl_str_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +char * +xcb_glx_set_client_info_arb_glx_extension_string (const xcb_glx_set_client_info_arb_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_extension_string_end(R); + return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); +} + +int +xcb_glx_set_client_info_arb_glx_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R) +{ + return R->glx_str_len; +} + +xcb_generic_iterator_t +xcb_glx_set_client_info_arb_glx_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_extension_string_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->glx_str_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_glx_create_context_attribs_arb_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_create_context_attribs_arb_request_t *_aux = (xcb_glx_create_context_attribs_arb_request_t *)_buffer; @@ -3009,20 +3255,20 @@ xcb_glx_create_context_attribs_arb_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_create_context_attribs_arb_checked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - uint32_t screen /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */) +xcb_glx_create_context_attribs_arb_checked (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_glx_fbconfig_t fbconfig, + uint32_t screen, + xcb_glx_context_t share_list, + uint8_t is_direct, + uint32_t num_attribs, + const uint32_t *attribs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -3052,20 +3298,20 @@ xcb_glx_create_context_attribs_arb_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_create_context_attribs_arb (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - uint32_t screen /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */) +xcb_glx_create_context_attribs_arb (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_glx_fbconfig_t fbconfig, + uint32_t screen, + xcb_glx_context_t share_list, + uint8_t is_direct, + uint32_t num_attribs, + const uint32_t *attribs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -3094,8 +3340,30 @@ xcb_glx_create_context_attribs_arb (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_glx_create_context_attribs_arb_attribs (const xcb_glx_create_context_attribs_arb_request_t *R) +{ + return (uint32_t *) (R + 1); +} + int -xcb_glx_set_client_info_2arb_sizeof (const void *_buffer /**< */) +xcb_glx_create_context_attribs_arb_attribs_length (const xcb_glx_create_context_attribs_arb_request_t *R) +{ + return (R->num_attribs * 2); +} + +xcb_generic_iterator_t +xcb_glx_create_context_attribs_arb_attribs_end (const xcb_glx_create_context_attribs_arb_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_glx_set_client_info_2arb_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_set_client_info_2arb_request_t *_aux = (xcb_glx_set_client_info_2arb_request_t *)_buffer; @@ -3150,21 +3418,21 @@ xcb_glx_set_client_info_2arb_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t num_versions /**< */, - uint32_t gl_str_len /**< */, - uint32_t glx_str_len /**< */, - const uint32_t *gl_versions /**< */, - const char *gl_extension_string /**< */, - const char *glx_extension_string /**< */) +xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t num_versions, + uint32_t gl_str_len, + uint32_t glx_str_len, + const uint32_t *gl_versions, + const char *gl_extension_string, + const char *glx_extension_string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 8, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_SET_CLIENT_INFO_2ARB, - /* isvoid */ 1 + .count = 8, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_SET_CLIENT_INFO_2ARB, + .isvoid = 1 }; struct iovec xcb_parts[10]; @@ -3202,21 +3470,21 @@ xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_set_client_info_2arb (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t num_versions /**< */, - uint32_t gl_str_len /**< */, - uint32_t glx_str_len /**< */, - const uint32_t *gl_versions /**< */, - const char *gl_extension_string /**< */, - const char *glx_extension_string /**< */) +xcb_glx_set_client_info_2arb (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t num_versions, + uint32_t gl_str_len, + uint32_t glx_str_len, + const uint32_t *gl_versions, + const char *gl_extension_string, + const char *glx_extension_string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 8, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_SET_CLIENT_INFO_2ARB, - /* isvoid */ 1 + .count = 8, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_SET_CLIENT_INFO_2ARB, + .isvoid = 1 }; struct iovec xcb_parts[10]; @@ -3253,17 +3521,87 @@ xcb_glx_set_client_info_2arb (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_glx_set_client_info_2arb_gl_versions (const xcb_glx_set_client_info_2arb_request_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_glx_set_client_info_2arb_gl_versions_length (const xcb_glx_set_client_info_2arb_request_t *R) +{ + return (R->num_versions * 3); +} + +xcb_generic_iterator_t +xcb_glx_set_client_info_2arb_gl_versions_end (const xcb_glx_set_client_info_2arb_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + ((R->num_versions * 3)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +char * +xcb_glx_set_client_info_2arb_gl_extension_string (const xcb_glx_set_client_info_2arb_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_versions_end(R); + return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); +} + +int +xcb_glx_set_client_info_2arb_gl_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R) +{ + return R->gl_str_len; +} + +xcb_generic_iterator_t +xcb_glx_set_client_info_2arb_gl_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_versions_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->gl_str_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +char * +xcb_glx_set_client_info_2arb_glx_extension_string (const xcb_glx_set_client_info_2arb_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_extension_string_end(R); + return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); +} + +int +xcb_glx_set_client_info_2arb_glx_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R) +{ + return R->glx_str_len; +} + +xcb_generic_iterator_t +xcb_glx_set_client_info_2arb_glx_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_extension_string_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->glx_str_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_glx_new_list_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */, - uint32_t mode /**< */) +xcb_glx_new_list_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list, + uint32_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_NEW_LIST, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_NEW_LIST, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3284,16 +3622,16 @@ xcb_glx_new_list_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_new_list (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */, - uint32_t mode /**< */) +xcb_glx_new_list (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list, + uint32_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_NEW_LIST, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_NEW_LIST, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3314,14 +3652,14 @@ xcb_glx_new_list (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_end_list_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_end_list_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_END_LIST, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_END_LIST, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3340,14 +3678,14 @@ xcb_glx_end_list_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_end_list (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_end_list (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_END_LIST, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_END_LIST, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3366,16 +3704,16 @@ xcb_glx_end_list (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_delete_lists_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */, - int32_t range /**< */) +xcb_glx_delete_lists_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list, + int32_t range) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DELETE_LISTS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DELETE_LISTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3396,16 +3734,16 @@ xcb_glx_delete_lists_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_delete_lists (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */, - int32_t range /**< */) +xcb_glx_delete_lists (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list, + int32_t range) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DELETE_LISTS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DELETE_LISTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3426,15 +3764,15 @@ xcb_glx_delete_lists (xcb_connection_t *c /**< */, } xcb_glx_gen_lists_cookie_t -xcb_glx_gen_lists (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t range /**< */) +xcb_glx_gen_lists (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t range) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GEN_LISTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GEN_LISTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3454,15 +3792,15 @@ xcb_glx_gen_lists (xcb_connection_t *c /**< */, } xcb_glx_gen_lists_cookie_t -xcb_glx_gen_lists_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t range /**< */) +xcb_glx_gen_lists_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t range) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GEN_LISTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GEN_LISTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3482,24 +3820,24 @@ xcb_glx_gen_lists_unchecked (xcb_connection_t *c /**< */, } xcb_glx_gen_lists_reply_t * -xcb_glx_gen_lists_reply (xcb_connection_t *c /**< */, +xcb_glx_gen_lists_reply (xcb_connection_t *c, xcb_glx_gen_lists_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_gen_lists_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_glx_feedback_buffer_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t size /**< */, - int32_t type /**< */) +xcb_glx_feedback_buffer_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t size, + int32_t type) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_FEEDBACK_BUFFER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_FEEDBACK_BUFFER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3520,16 +3858,16 @@ xcb_glx_feedback_buffer_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_feedback_buffer (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t size /**< */, - int32_t type /**< */) +xcb_glx_feedback_buffer (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t size, + int32_t type) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_FEEDBACK_BUFFER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_FEEDBACK_BUFFER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3550,15 +3888,15 @@ xcb_glx_feedback_buffer (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_select_buffer_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t size /**< */) +xcb_glx_select_buffer_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t size) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_SELECT_BUFFER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_SELECT_BUFFER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3578,15 +3916,15 @@ xcb_glx_select_buffer_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_select_buffer (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t size /**< */) +xcb_glx_select_buffer (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t size) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_SELECT_BUFFER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_SELECT_BUFFER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3606,7 +3944,7 @@ xcb_glx_select_buffer (xcb_connection_t *c /**< */, } int -xcb_glx_render_mode_sizeof (const void *_buffer /**< */) +xcb_glx_render_mode_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_render_mode_reply_t *_aux = (xcb_glx_render_mode_reply_t *)_buffer; @@ -3637,15 +3975,15 @@ xcb_glx_render_mode_sizeof (const void *_buffer /**< */) } xcb_glx_render_mode_cookie_t -xcb_glx_render_mode (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t mode /**< */) +xcb_glx_render_mode (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_RENDER_MODE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_RENDER_MODE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3665,15 +4003,15 @@ xcb_glx_render_mode (xcb_connection_t *c /**< */, } xcb_glx_render_mode_cookie_t -xcb_glx_render_mode_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t mode /**< */) +xcb_glx_render_mode_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_RENDER_MODE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_RENDER_MODE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3693,19 +4031,19 @@ xcb_glx_render_mode_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_glx_render_mode_data (const xcb_glx_render_mode_reply_t *R /**< */) +xcb_glx_render_mode_data (const xcb_glx_render_mode_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_glx_render_mode_data_length (const xcb_glx_render_mode_reply_t *R /**< */) +xcb_glx_render_mode_data_length (const xcb_glx_render_mode_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R /**< */) +xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->n); @@ -3715,22 +4053,22 @@ xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R /**< */) } xcb_glx_render_mode_reply_t * -xcb_glx_render_mode_reply (xcb_connection_t *c /**< */, +xcb_glx_render_mode_reply (xcb_connection_t *c, xcb_glx_render_mode_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_render_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_glx_finish_cookie_t -xcb_glx_finish (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_finish (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_FINISH, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_FINISH, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3749,14 +4087,14 @@ xcb_glx_finish (xcb_connection_t *c /**< */, } xcb_glx_finish_cookie_t -xcb_glx_finish_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_finish_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_FINISH, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_FINISH, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3775,24 +4113,24 @@ xcb_glx_finish_unchecked (xcb_connection_t *c /**< */, } xcb_glx_finish_reply_t * -xcb_glx_finish_reply (xcb_connection_t *c /**< */, +xcb_glx_finish_reply (xcb_connection_t *c, xcb_glx_finish_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_finish_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_glx_pixel_storef_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */, - xcb_glx_float32_t datum /**< */) +xcb_glx_pixel_storef_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname, + xcb_glx_float32_t datum) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_PIXEL_STOREF, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_PIXEL_STOREF, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3813,16 +4151,16 @@ xcb_glx_pixel_storef_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_pixel_storef (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */, - xcb_glx_float32_t datum /**< */) +xcb_glx_pixel_storef (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname, + xcb_glx_float32_t datum) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_PIXEL_STOREF, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_PIXEL_STOREF, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3843,16 +4181,16 @@ xcb_glx_pixel_storef (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_pixel_storei_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */, - int32_t datum /**< */) +xcb_glx_pixel_storei_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname, + int32_t datum) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_PIXEL_STOREI, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_PIXEL_STOREI, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3873,16 +4211,16 @@ xcb_glx_pixel_storei_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_pixel_storei (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */, - int32_t datum /**< */) +xcb_glx_pixel_storei (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname, + int32_t datum) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_PIXEL_STOREI, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_PIXEL_STOREI, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3903,7 +4241,7 @@ xcb_glx_pixel_storei (xcb_connection_t *c /**< */, } int -xcb_glx_read_pixels_sizeof (const void *_buffer /**< */) +xcb_glx_read_pixels_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_read_pixels_reply_t *_aux = (xcb_glx_read_pixels_reply_t *)_buffer; @@ -3934,22 +4272,22 @@ xcb_glx_read_pixels_sizeof (const void *_buffer /**< */) } xcb_glx_read_pixels_cookie_t -xcb_glx_read_pixels (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t x /**< */, - int32_t y /**< */, - int32_t width /**< */, - int32_t height /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t lsb_first /**< */) +xcb_glx_read_pixels (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t x, + int32_t y, + int32_t width, + int32_t height, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t lsb_first) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_READ_PIXELS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_READ_PIXELS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3976,22 +4314,22 @@ xcb_glx_read_pixels (xcb_connection_t *c /**< */, } xcb_glx_read_pixels_cookie_t -xcb_glx_read_pixels_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t x /**< */, - int32_t y /**< */, - int32_t width /**< */, - int32_t height /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t lsb_first /**< */) +xcb_glx_read_pixels_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t x, + int32_t y, + int32_t width, + int32_t height, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t lsb_first) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_READ_PIXELS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_READ_PIXELS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4018,19 +4356,19 @@ xcb_glx_read_pixels_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_read_pixels_data (const xcb_glx_read_pixels_reply_t *R /**< */) +xcb_glx_read_pixels_data (const xcb_glx_read_pixels_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_read_pixels_data_length (const xcb_glx_read_pixels_reply_t *R /**< */) +xcb_glx_read_pixels_data_length (const xcb_glx_read_pixels_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R /**< */) +xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -4040,15 +4378,15 @@ xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R /**< */) } xcb_glx_read_pixels_reply_t * -xcb_glx_read_pixels_reply (xcb_connection_t *c /**< */, +xcb_glx_read_pixels_reply (xcb_connection_t *c, xcb_glx_read_pixels_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_read_pixels_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_booleanv_sizeof (const void *_buffer /**< */) +xcb_glx_get_booleanv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_booleanv_reply_t *_aux = (xcb_glx_get_booleanv_reply_t *)_buffer; @@ -4079,15 +4417,15 @@ xcb_glx_get_booleanv_sizeof (const void *_buffer /**< */) } xcb_glx_get_booleanv_cookie_t -xcb_glx_get_booleanv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t pname /**< */) +xcb_glx_get_booleanv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_BOOLEANV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_BOOLEANV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4107,15 +4445,15 @@ xcb_glx_get_booleanv (xcb_connection_t *c /**< */, } xcb_glx_get_booleanv_cookie_t -xcb_glx_get_booleanv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t pname /**< */) +xcb_glx_get_booleanv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_BOOLEANV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_BOOLEANV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4135,19 +4473,19 @@ xcb_glx_get_booleanv_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_get_booleanv_data (const xcb_glx_get_booleanv_reply_t *R /**< */) +xcb_glx_get_booleanv_data (const xcb_glx_get_booleanv_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_get_booleanv_data_length (const xcb_glx_get_booleanv_reply_t *R /**< */) +xcb_glx_get_booleanv_data_length (const xcb_glx_get_booleanv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R /**< */) +xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + (R->n); @@ -4157,15 +4495,15 @@ xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R /**< */) } xcb_glx_get_booleanv_reply_t * -xcb_glx_get_booleanv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_booleanv_reply (xcb_connection_t *c, xcb_glx_get_booleanv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_booleanv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_clip_plane_sizeof (const void *_buffer /**< */) +xcb_glx_get_clip_plane_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_clip_plane_reply_t *_aux = (xcb_glx_get_clip_plane_reply_t *)_buffer; @@ -4196,15 +4534,15 @@ xcb_glx_get_clip_plane_sizeof (const void *_buffer /**< */) } xcb_glx_get_clip_plane_cookie_t -xcb_glx_get_clip_plane (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t plane /**< */) +xcb_glx_get_clip_plane (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t plane) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_CLIP_PLANE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_CLIP_PLANE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4224,15 +4562,15 @@ xcb_glx_get_clip_plane (xcb_connection_t *c /**< */, } xcb_glx_get_clip_plane_cookie_t -xcb_glx_get_clip_plane_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t plane /**< */) +xcb_glx_get_clip_plane_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t plane) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_CLIP_PLANE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_CLIP_PLANE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4252,19 +4590,19 @@ xcb_glx_get_clip_plane_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float64_t * -xcb_glx_get_clip_plane_data (const xcb_glx_get_clip_plane_reply_t *R /**< */) +xcb_glx_get_clip_plane_data (const xcb_glx_get_clip_plane_reply_t *R) { return (xcb_glx_float64_t *) (R + 1); } int -xcb_glx_get_clip_plane_data_length (const xcb_glx_get_clip_plane_reply_t *R /**< */) +xcb_glx_get_clip_plane_data_length (const xcb_glx_get_clip_plane_reply_t *R) { return (R->length / 2); } xcb_generic_iterator_t -xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R /**< */) +xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float64_t *) (R + 1)) + ((R->length / 2)); @@ -4274,15 +4612,15 @@ xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R /**< * } xcb_glx_get_clip_plane_reply_t * -xcb_glx_get_clip_plane_reply (xcb_connection_t *c /**< */, +xcb_glx_get_clip_plane_reply (xcb_connection_t *c, xcb_glx_get_clip_plane_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_clip_plane_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_doublev_sizeof (const void *_buffer /**< */) +xcb_glx_get_doublev_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_doublev_reply_t *_aux = (xcb_glx_get_doublev_reply_t *)_buffer; @@ -4313,15 +4651,15 @@ xcb_glx_get_doublev_sizeof (const void *_buffer /**< */) } xcb_glx_get_doublev_cookie_t -xcb_glx_get_doublev (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */) +xcb_glx_get_doublev (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_DOUBLEV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_DOUBLEV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4341,15 +4679,15 @@ xcb_glx_get_doublev (xcb_connection_t *c /**< */, } xcb_glx_get_doublev_cookie_t -xcb_glx_get_doublev_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */) +xcb_glx_get_doublev_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_DOUBLEV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_DOUBLEV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4369,19 +4707,19 @@ xcb_glx_get_doublev_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float64_t * -xcb_glx_get_doublev_data (const xcb_glx_get_doublev_reply_t *R /**< */) +xcb_glx_get_doublev_data (const xcb_glx_get_doublev_reply_t *R) { return (xcb_glx_float64_t *) (R + 1); } int -xcb_glx_get_doublev_data_length (const xcb_glx_get_doublev_reply_t *R /**< */) +xcb_glx_get_doublev_data_length (const xcb_glx_get_doublev_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R /**< */) +xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); @@ -4391,22 +4729,22 @@ xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R /**< */) } xcb_glx_get_doublev_reply_t * -xcb_glx_get_doublev_reply (xcb_connection_t *c /**< */, +xcb_glx_get_doublev_reply (xcb_connection_t *c, xcb_glx_get_doublev_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_doublev_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_glx_get_error_cookie_t -xcb_glx_get_error (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_get_error (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_ERROR, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_ERROR, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4425,14 +4763,14 @@ xcb_glx_get_error (xcb_connection_t *c /**< */, } xcb_glx_get_error_cookie_t -xcb_glx_get_error_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_get_error_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_ERROR, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_ERROR, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4451,15 +4789,15 @@ xcb_glx_get_error_unchecked (xcb_connection_t *c /**< */, } xcb_glx_get_error_reply_t * -xcb_glx_get_error_reply (xcb_connection_t *c /**< */, +xcb_glx_get_error_reply (xcb_connection_t *c, xcb_glx_get_error_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_error_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_floatv_sizeof (const void *_buffer /**< */) +xcb_glx_get_floatv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_floatv_reply_t *_aux = (xcb_glx_get_floatv_reply_t *)_buffer; @@ -4490,15 +4828,15 @@ xcb_glx_get_floatv_sizeof (const void *_buffer /**< */) } xcb_glx_get_floatv_cookie_t -xcb_glx_get_floatv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */) +xcb_glx_get_floatv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_FLOATV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_FLOATV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4518,15 +4856,15 @@ xcb_glx_get_floatv (xcb_connection_t *c /**< */, } xcb_glx_get_floatv_cookie_t -xcb_glx_get_floatv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */) +xcb_glx_get_floatv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_FLOATV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_FLOATV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4546,19 +4884,19 @@ xcb_glx_get_floatv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_floatv_data (const xcb_glx_get_floatv_reply_t *R /**< */) +xcb_glx_get_floatv_data (const xcb_glx_get_floatv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_floatv_data_length (const xcb_glx_get_floatv_reply_t *R /**< */) +xcb_glx_get_floatv_data_length (const xcb_glx_get_floatv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R /**< */) +xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -4568,15 +4906,15 @@ xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R /**< */) } xcb_glx_get_floatv_reply_t * -xcb_glx_get_floatv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_floatv_reply (xcb_connection_t *c, xcb_glx_get_floatv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_floatv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_integerv_sizeof (const void *_buffer /**< */) +xcb_glx_get_integerv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_integerv_reply_t *_aux = (xcb_glx_get_integerv_reply_t *)_buffer; @@ -4607,15 +4945,15 @@ xcb_glx_get_integerv_sizeof (const void *_buffer /**< */) } xcb_glx_get_integerv_cookie_t -xcb_glx_get_integerv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */) +xcb_glx_get_integerv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_INTEGERV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_INTEGERV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4635,15 +4973,15 @@ xcb_glx_get_integerv (xcb_connection_t *c /**< */, } xcb_glx_get_integerv_cookie_t -xcb_glx_get_integerv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */) +xcb_glx_get_integerv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_INTEGERV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_INTEGERV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4663,19 +5001,19 @@ xcb_glx_get_integerv_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_integerv_data (const xcb_glx_get_integerv_reply_t *R /**< */) +xcb_glx_get_integerv_data (const xcb_glx_get_integerv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_integerv_data_length (const xcb_glx_get_integerv_reply_t *R /**< */) +xcb_glx_get_integerv_data_length (const xcb_glx_get_integerv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R /**< */) +xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -4685,15 +5023,15 @@ xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R /**< */) } xcb_glx_get_integerv_reply_t * -xcb_glx_get_integerv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_integerv_reply (xcb_connection_t *c, xcb_glx_get_integerv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_integerv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_lightfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_lightfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_lightfv_reply_t *_aux = (xcb_glx_get_lightfv_reply_t *)_buffer; @@ -4724,16 +5062,16 @@ xcb_glx_get_lightfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_lightfv_cookie_t -xcb_glx_get_lightfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t light /**< */, - uint32_t pname /**< */) +xcb_glx_get_lightfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t light, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_LIGHTFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_LIGHTFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4754,16 +5092,16 @@ xcb_glx_get_lightfv (xcb_connection_t *c /**< */, } xcb_glx_get_lightfv_cookie_t -xcb_glx_get_lightfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t light /**< */, - uint32_t pname /**< */) +xcb_glx_get_lightfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t light, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_LIGHTFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_LIGHTFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4784,19 +5122,19 @@ xcb_glx_get_lightfv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_lightfv_data (const xcb_glx_get_lightfv_reply_t *R /**< */) +xcb_glx_get_lightfv_data (const xcb_glx_get_lightfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_lightfv_data_length (const xcb_glx_get_lightfv_reply_t *R /**< */) +xcb_glx_get_lightfv_data_length (const xcb_glx_get_lightfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R /**< */) +xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -4806,15 +5144,15 @@ xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R /**< */) } xcb_glx_get_lightfv_reply_t * -xcb_glx_get_lightfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_lightfv_reply (xcb_connection_t *c, xcb_glx_get_lightfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_lightfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_lightiv_sizeof (const void *_buffer /**< */) +xcb_glx_get_lightiv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_lightiv_reply_t *_aux = (xcb_glx_get_lightiv_reply_t *)_buffer; @@ -4845,16 +5183,16 @@ xcb_glx_get_lightiv_sizeof (const void *_buffer /**< */) } xcb_glx_get_lightiv_cookie_t -xcb_glx_get_lightiv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t light /**< */, - uint32_t pname /**< */) +xcb_glx_get_lightiv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t light, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_LIGHTIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_LIGHTIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4875,16 +5213,16 @@ xcb_glx_get_lightiv (xcb_connection_t *c /**< */, } xcb_glx_get_lightiv_cookie_t -xcb_glx_get_lightiv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t light /**< */, - uint32_t pname /**< */) +xcb_glx_get_lightiv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t light, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_LIGHTIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_LIGHTIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4905,19 +5243,19 @@ xcb_glx_get_lightiv_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_lightiv_data (const xcb_glx_get_lightiv_reply_t *R /**< */) +xcb_glx_get_lightiv_data (const xcb_glx_get_lightiv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_lightiv_data_length (const xcb_glx_get_lightiv_reply_t *R /**< */) +xcb_glx_get_lightiv_data_length (const xcb_glx_get_lightiv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R /**< */) +xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -4927,15 +5265,15 @@ xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R /**< */) } xcb_glx_get_lightiv_reply_t * -xcb_glx_get_lightiv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_lightiv_reply (xcb_connection_t *c, xcb_glx_get_lightiv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_lightiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_mapdv_sizeof (const void *_buffer /**< */) +xcb_glx_get_mapdv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_mapdv_reply_t *_aux = (xcb_glx_get_mapdv_reply_t *)_buffer; @@ -4966,16 +5304,16 @@ xcb_glx_get_mapdv_sizeof (const void *_buffer /**< */) } xcb_glx_get_mapdv_cookie_t -xcb_glx_get_mapdv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */) +xcb_glx_get_mapdv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MAPDV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MAPDV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4996,16 +5334,16 @@ xcb_glx_get_mapdv (xcb_connection_t *c /**< */, } xcb_glx_get_mapdv_cookie_t -xcb_glx_get_mapdv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */) +xcb_glx_get_mapdv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MAPDV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MAPDV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5026,19 +5364,19 @@ xcb_glx_get_mapdv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float64_t * -xcb_glx_get_mapdv_data (const xcb_glx_get_mapdv_reply_t *R /**< */) +xcb_glx_get_mapdv_data (const xcb_glx_get_mapdv_reply_t *R) { return (xcb_glx_float64_t *) (R + 1); } int -xcb_glx_get_mapdv_data_length (const xcb_glx_get_mapdv_reply_t *R /**< */) +xcb_glx_get_mapdv_data_length (const xcb_glx_get_mapdv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R /**< */) +xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); @@ -5048,15 +5386,15 @@ xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R /**< */) } xcb_glx_get_mapdv_reply_t * -xcb_glx_get_mapdv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_mapdv_reply (xcb_connection_t *c, xcb_glx_get_mapdv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_mapdv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_mapfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_mapfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_mapfv_reply_t *_aux = (xcb_glx_get_mapfv_reply_t *)_buffer; @@ -5087,16 +5425,16 @@ xcb_glx_get_mapfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_mapfv_cookie_t -xcb_glx_get_mapfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */) +xcb_glx_get_mapfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MAPFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MAPFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5117,16 +5455,16 @@ xcb_glx_get_mapfv (xcb_connection_t *c /**< */, } xcb_glx_get_mapfv_cookie_t -xcb_glx_get_mapfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */) +xcb_glx_get_mapfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MAPFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MAPFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5147,19 +5485,19 @@ xcb_glx_get_mapfv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_mapfv_data (const xcb_glx_get_mapfv_reply_t *R /**< */) +xcb_glx_get_mapfv_data (const xcb_glx_get_mapfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_mapfv_data_length (const xcb_glx_get_mapfv_reply_t *R /**< */) +xcb_glx_get_mapfv_data_length (const xcb_glx_get_mapfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R /**< */) +xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -5169,15 +5507,15 @@ xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R /**< */) } xcb_glx_get_mapfv_reply_t * -xcb_glx_get_mapfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_mapfv_reply (xcb_connection_t *c, xcb_glx_get_mapfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_mapiv_sizeof (const void *_buffer /**< */) +xcb_glx_get_mapiv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_mapiv_reply_t *_aux = (xcb_glx_get_mapiv_reply_t *)_buffer; @@ -5208,16 +5546,16 @@ xcb_glx_get_mapiv_sizeof (const void *_buffer /**< */) } xcb_glx_get_mapiv_cookie_t -xcb_glx_get_mapiv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */) +xcb_glx_get_mapiv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MAPIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MAPIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5238,16 +5576,16 @@ xcb_glx_get_mapiv (xcb_connection_t *c /**< */, } xcb_glx_get_mapiv_cookie_t -xcb_glx_get_mapiv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */) +xcb_glx_get_mapiv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MAPIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MAPIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5268,19 +5606,19 @@ xcb_glx_get_mapiv_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_mapiv_data (const xcb_glx_get_mapiv_reply_t *R /**< */) +xcb_glx_get_mapiv_data (const xcb_glx_get_mapiv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_mapiv_data_length (const xcb_glx_get_mapiv_reply_t *R /**< */) +xcb_glx_get_mapiv_data_length (const xcb_glx_get_mapiv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R /**< */) +xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -5290,15 +5628,15 @@ xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R /**< */) } xcb_glx_get_mapiv_reply_t * -xcb_glx_get_mapiv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_mapiv_reply (xcb_connection_t *c, xcb_glx_get_mapiv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_mapiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_materialfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_materialfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_materialfv_reply_t *_aux = (xcb_glx_get_materialfv_reply_t *)_buffer; @@ -5329,16 +5667,16 @@ xcb_glx_get_materialfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_materialfv_cookie_t -xcb_glx_get_materialfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t face /**< */, - uint32_t pname /**< */) +xcb_glx_get_materialfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t face, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MATERIALFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MATERIALFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5359,16 +5697,16 @@ xcb_glx_get_materialfv (xcb_connection_t *c /**< */, } xcb_glx_get_materialfv_cookie_t -xcb_glx_get_materialfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t face /**< */, - uint32_t pname /**< */) +xcb_glx_get_materialfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t face, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MATERIALFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MATERIALFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5389,19 +5727,19 @@ xcb_glx_get_materialfv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_materialfv_data (const xcb_glx_get_materialfv_reply_t *R /**< */) +xcb_glx_get_materialfv_data (const xcb_glx_get_materialfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_materialfv_data_length (const xcb_glx_get_materialfv_reply_t *R /**< */) +xcb_glx_get_materialfv_data_length (const xcb_glx_get_materialfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R /**< */) +xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -5411,15 +5749,15 @@ xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R /**< * } xcb_glx_get_materialfv_reply_t * -xcb_glx_get_materialfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_materialfv_reply (xcb_connection_t *c, xcb_glx_get_materialfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_materialfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_materialiv_sizeof (const void *_buffer /**< */) +xcb_glx_get_materialiv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_materialiv_reply_t *_aux = (xcb_glx_get_materialiv_reply_t *)_buffer; @@ -5450,16 +5788,16 @@ xcb_glx_get_materialiv_sizeof (const void *_buffer /**< */) } xcb_glx_get_materialiv_cookie_t -xcb_glx_get_materialiv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t face /**< */, - uint32_t pname /**< */) +xcb_glx_get_materialiv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t face, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MATERIALIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MATERIALIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5480,16 +5818,16 @@ xcb_glx_get_materialiv (xcb_connection_t *c /**< */, } xcb_glx_get_materialiv_cookie_t -xcb_glx_get_materialiv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t face /**< */, - uint32_t pname /**< */) +xcb_glx_get_materialiv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t face, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MATERIALIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MATERIALIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5510,19 +5848,19 @@ xcb_glx_get_materialiv_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_materialiv_data (const xcb_glx_get_materialiv_reply_t *R /**< */) +xcb_glx_get_materialiv_data (const xcb_glx_get_materialiv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_materialiv_data_length (const xcb_glx_get_materialiv_reply_t *R /**< */) +xcb_glx_get_materialiv_data_length (const xcb_glx_get_materialiv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R /**< */) +xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -5532,15 +5870,15 @@ xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R /**< * } xcb_glx_get_materialiv_reply_t * -xcb_glx_get_materialiv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_materialiv_reply (xcb_connection_t *c, xcb_glx_get_materialiv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_materialiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_pixel_mapfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_pixel_mapfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_pixel_mapfv_reply_t *_aux = (xcb_glx_get_pixel_mapfv_reply_t *)_buffer; @@ -5571,15 +5909,15 @@ xcb_glx_get_pixel_mapfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_pixel_mapfv_cookie_t -xcb_glx_get_pixel_mapfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */) +xcb_glx_get_pixel_mapfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_PIXEL_MAPFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_PIXEL_MAPFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5599,15 +5937,15 @@ xcb_glx_get_pixel_mapfv (xcb_connection_t *c /**< */, } xcb_glx_get_pixel_mapfv_cookie_t -xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */) +xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_PIXEL_MAPFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_PIXEL_MAPFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5627,19 +5965,19 @@ xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_pixel_mapfv_data (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */) +xcb_glx_get_pixel_mapfv_data (const xcb_glx_get_pixel_mapfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_pixel_mapfv_data_length (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */) +xcb_glx_get_pixel_mapfv_data_length (const xcb_glx_get_pixel_mapfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */) +xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -5649,15 +5987,15 @@ xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R /**< } xcb_glx_get_pixel_mapfv_reply_t * -xcb_glx_get_pixel_mapfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_pixel_mapfv_reply (xcb_connection_t *c, xcb_glx_get_pixel_mapfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_pixel_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_pixel_mapuiv_sizeof (const void *_buffer /**< */) +xcb_glx_get_pixel_mapuiv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_pixel_mapuiv_reply_t *_aux = (xcb_glx_get_pixel_mapuiv_reply_t *)_buffer; @@ -5688,15 +6026,15 @@ xcb_glx_get_pixel_mapuiv_sizeof (const void *_buffer /**< */) } xcb_glx_get_pixel_mapuiv_cookie_t -xcb_glx_get_pixel_mapuiv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */) +xcb_glx_get_pixel_mapuiv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_PIXEL_MAPUIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_PIXEL_MAPUIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5716,15 +6054,15 @@ xcb_glx_get_pixel_mapuiv (xcb_connection_t *c /**< */, } xcb_glx_get_pixel_mapuiv_cookie_t -xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */) +xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_PIXEL_MAPUIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_PIXEL_MAPUIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5744,19 +6082,19 @@ xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_glx_get_pixel_mapuiv_data (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */) +xcb_glx_get_pixel_mapuiv_data (const xcb_glx_get_pixel_mapuiv_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_glx_get_pixel_mapuiv_data_length (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */) +xcb_glx_get_pixel_mapuiv_data_length (const xcb_glx_get_pixel_mapuiv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */) +xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->n); @@ -5766,15 +6104,15 @@ xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R /* } xcb_glx_get_pixel_mapuiv_reply_t * -xcb_glx_get_pixel_mapuiv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_pixel_mapuiv_reply (xcb_connection_t *c, xcb_glx_get_pixel_mapuiv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_pixel_mapuiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_pixel_mapusv_sizeof (const void *_buffer /**< */) +xcb_glx_get_pixel_mapusv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_pixel_mapusv_reply_t *_aux = (xcb_glx_get_pixel_mapusv_reply_t *)_buffer; @@ -5805,15 +6143,15 @@ xcb_glx_get_pixel_mapusv_sizeof (const void *_buffer /**< */) } xcb_glx_get_pixel_mapusv_cookie_t -xcb_glx_get_pixel_mapusv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */) +xcb_glx_get_pixel_mapusv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_PIXEL_MAPUSV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_PIXEL_MAPUSV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5833,15 +6171,15 @@ xcb_glx_get_pixel_mapusv (xcb_connection_t *c /**< */, } xcb_glx_get_pixel_mapusv_cookie_t -xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */) +xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_PIXEL_MAPUSV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_PIXEL_MAPUSV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5861,19 +6199,19 @@ xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t *c /**< */, } uint16_t * -xcb_glx_get_pixel_mapusv_data (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */) +xcb_glx_get_pixel_mapusv_data (const xcb_glx_get_pixel_mapusv_reply_t *R) { return (uint16_t *) (R + 1); } int -xcb_glx_get_pixel_mapusv_data_length (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */) +xcb_glx_get_pixel_mapusv_data_length (const xcb_glx_get_pixel_mapusv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */) +xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint16_t *) (R + 1)) + (R->n); @@ -5883,15 +6221,15 @@ xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R /* } xcb_glx_get_pixel_mapusv_reply_t * -xcb_glx_get_pixel_mapusv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_pixel_mapusv_reply (xcb_connection_t *c, xcb_glx_get_pixel_mapusv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_pixel_mapusv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_polygon_stipple_sizeof (const void *_buffer /**< */) +xcb_glx_get_polygon_stipple_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_polygon_stipple_reply_t *_aux = (xcb_glx_get_polygon_stipple_reply_t *)_buffer; @@ -5922,15 +6260,15 @@ xcb_glx_get_polygon_stipple_sizeof (const void *_buffer /**< */) } xcb_glx_get_polygon_stipple_cookie_t -xcb_glx_get_polygon_stipple (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint8_t lsb_first /**< */) +xcb_glx_get_polygon_stipple (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint8_t lsb_first) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_POLYGON_STIPPLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_POLYGON_STIPPLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5950,15 +6288,15 @@ xcb_glx_get_polygon_stipple (xcb_connection_t *c /**< */, } xcb_glx_get_polygon_stipple_cookie_t -xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint8_t lsb_first /**< */) +xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint8_t lsb_first) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_POLYGON_STIPPLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_POLYGON_STIPPLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5978,19 +6316,19 @@ xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_get_polygon_stipple_data (const xcb_glx_get_polygon_stipple_reply_t *R /**< */) +xcb_glx_get_polygon_stipple_data (const xcb_glx_get_polygon_stipple_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_get_polygon_stipple_data_length (const xcb_glx_get_polygon_stipple_reply_t *R /**< */) +xcb_glx_get_polygon_stipple_data_length (const xcb_glx_get_polygon_stipple_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t *R /**< */) +xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -6000,15 +6338,15 @@ xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t } xcb_glx_get_polygon_stipple_reply_t * -xcb_glx_get_polygon_stipple_reply (xcb_connection_t *c /**< */, +xcb_glx_get_polygon_stipple_reply (xcb_connection_t *c, xcb_glx_get_polygon_stipple_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_polygon_stipple_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_string_sizeof (const void *_buffer /**< */) +xcb_glx_get_string_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_string_reply_t *_aux = (xcb_glx_get_string_reply_t *)_buffer; @@ -6039,15 +6377,15 @@ xcb_glx_get_string_sizeof (const void *_buffer /**< */) } xcb_glx_get_string_cookie_t -xcb_glx_get_string (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t name /**< */) +xcb_glx_get_string (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_STRING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_STRING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6067,15 +6405,15 @@ xcb_glx_get_string (xcb_connection_t *c /**< */, } xcb_glx_get_string_cookie_t -xcb_glx_get_string_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t name /**< */) +xcb_glx_get_string_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_STRING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_STRING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6095,19 +6433,19 @@ xcb_glx_get_string_unchecked (xcb_connection_t *c /**< */, } char * -xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R /**< */) +xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R) { return (char *) (R + 1); } int -xcb_glx_get_string_string_length (const xcb_glx_get_string_reply_t *R /**< */) +xcb_glx_get_string_string_length (const xcb_glx_get_string_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R /**< */) +xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->n); @@ -6117,15 +6455,15 @@ xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R /**< */) } xcb_glx_get_string_reply_t * -xcb_glx_get_string_reply (xcb_connection_t *c /**< */, +xcb_glx_get_string_reply (xcb_connection_t *c, xcb_glx_get_string_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_tex_envfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_tex_envfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_tex_envfv_reply_t *_aux = (xcb_glx_get_tex_envfv_reply_t *)_buffer; @@ -6156,16 +6494,16 @@ xcb_glx_get_tex_envfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_tex_envfv_cookie_t -xcb_glx_get_tex_envfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_envfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_ENVFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_ENVFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6186,16 +6524,16 @@ xcb_glx_get_tex_envfv (xcb_connection_t *c /**< */, } xcb_glx_get_tex_envfv_cookie_t -xcb_glx_get_tex_envfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_envfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_ENVFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_ENVFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6216,19 +6554,19 @@ xcb_glx_get_tex_envfv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_tex_envfv_data (const xcb_glx_get_tex_envfv_reply_t *R /**< */) +xcb_glx_get_tex_envfv_data (const xcb_glx_get_tex_envfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_tex_envfv_data_length (const xcb_glx_get_tex_envfv_reply_t *R /**< */) +xcb_glx_get_tex_envfv_data_length (const xcb_glx_get_tex_envfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R /**< */) +xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -6238,15 +6576,15 @@ xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R /**< */) } xcb_glx_get_tex_envfv_reply_t * -xcb_glx_get_tex_envfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_envfv_reply (xcb_connection_t *c, xcb_glx_get_tex_envfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_tex_envfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_tex_enviv_sizeof (const void *_buffer /**< */) +xcb_glx_get_tex_enviv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_tex_enviv_reply_t *_aux = (xcb_glx_get_tex_enviv_reply_t *)_buffer; @@ -6277,16 +6615,16 @@ xcb_glx_get_tex_enviv_sizeof (const void *_buffer /**< */) } xcb_glx_get_tex_enviv_cookie_t -xcb_glx_get_tex_enviv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_enviv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_ENVIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_ENVIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6307,16 +6645,16 @@ xcb_glx_get_tex_enviv (xcb_connection_t *c /**< */, } xcb_glx_get_tex_enviv_cookie_t -xcb_glx_get_tex_enviv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_enviv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_ENVIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_ENVIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6337,19 +6675,19 @@ xcb_glx_get_tex_enviv_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_tex_enviv_data (const xcb_glx_get_tex_enviv_reply_t *R /**< */) +xcb_glx_get_tex_enviv_data (const xcb_glx_get_tex_enviv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_tex_enviv_data_length (const xcb_glx_get_tex_enviv_reply_t *R /**< */) +xcb_glx_get_tex_enviv_data_length (const xcb_glx_get_tex_enviv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R /**< */) +xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -6359,15 +6697,15 @@ xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R /**< */) } xcb_glx_get_tex_enviv_reply_t * -xcb_glx_get_tex_enviv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_enviv_reply (xcb_connection_t *c, xcb_glx_get_tex_enviv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_tex_enviv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_tex_gendv_sizeof (const void *_buffer /**< */) +xcb_glx_get_tex_gendv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_tex_gendv_reply_t *_aux = (xcb_glx_get_tex_gendv_reply_t *)_buffer; @@ -6398,16 +6736,16 @@ xcb_glx_get_tex_gendv_sizeof (const void *_buffer /**< */) } xcb_glx_get_tex_gendv_cookie_t -xcb_glx_get_tex_gendv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_gendv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_GENDV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_GENDV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6428,16 +6766,16 @@ xcb_glx_get_tex_gendv (xcb_connection_t *c /**< */, } xcb_glx_get_tex_gendv_cookie_t -xcb_glx_get_tex_gendv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_gendv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_GENDV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_GENDV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6458,19 +6796,19 @@ xcb_glx_get_tex_gendv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float64_t * -xcb_glx_get_tex_gendv_data (const xcb_glx_get_tex_gendv_reply_t *R /**< */) +xcb_glx_get_tex_gendv_data (const xcb_glx_get_tex_gendv_reply_t *R) { return (xcb_glx_float64_t *) (R + 1); } int -xcb_glx_get_tex_gendv_data_length (const xcb_glx_get_tex_gendv_reply_t *R /**< */) +xcb_glx_get_tex_gendv_data_length (const xcb_glx_get_tex_gendv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R /**< */) +xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n); @@ -6480,15 +6818,15 @@ xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R /**< */) } xcb_glx_get_tex_gendv_reply_t * -xcb_glx_get_tex_gendv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_gendv_reply (xcb_connection_t *c, xcb_glx_get_tex_gendv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_tex_gendv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_tex_genfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_tex_genfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_tex_genfv_reply_t *_aux = (xcb_glx_get_tex_genfv_reply_t *)_buffer; @@ -6519,16 +6857,16 @@ xcb_glx_get_tex_genfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_tex_genfv_cookie_t -xcb_glx_get_tex_genfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_genfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_GENFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_GENFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6549,16 +6887,16 @@ xcb_glx_get_tex_genfv (xcb_connection_t *c /**< */, } xcb_glx_get_tex_genfv_cookie_t -xcb_glx_get_tex_genfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_genfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_GENFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_GENFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6579,19 +6917,19 @@ xcb_glx_get_tex_genfv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_tex_genfv_data (const xcb_glx_get_tex_genfv_reply_t *R /**< */) +xcb_glx_get_tex_genfv_data (const xcb_glx_get_tex_genfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_tex_genfv_data_length (const xcb_glx_get_tex_genfv_reply_t *R /**< */) +xcb_glx_get_tex_genfv_data_length (const xcb_glx_get_tex_genfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R /**< */) +xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -6601,15 +6939,15 @@ xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R /**< */) } xcb_glx_get_tex_genfv_reply_t * -xcb_glx_get_tex_genfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_genfv_reply (xcb_connection_t *c, xcb_glx_get_tex_genfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_tex_genfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_tex_geniv_sizeof (const void *_buffer /**< */) +xcb_glx_get_tex_geniv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_tex_geniv_reply_t *_aux = (xcb_glx_get_tex_geniv_reply_t *)_buffer; @@ -6640,16 +6978,16 @@ xcb_glx_get_tex_geniv_sizeof (const void *_buffer /**< */) } xcb_glx_get_tex_geniv_cookie_t -xcb_glx_get_tex_geniv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_geniv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_GENIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_GENIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6670,16 +7008,16 @@ xcb_glx_get_tex_geniv (xcb_connection_t *c /**< */, } xcb_glx_get_tex_geniv_cookie_t -xcb_glx_get_tex_geniv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_geniv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_GENIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_GENIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6700,19 +7038,19 @@ xcb_glx_get_tex_geniv_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_tex_geniv_data (const xcb_glx_get_tex_geniv_reply_t *R /**< */) +xcb_glx_get_tex_geniv_data (const xcb_glx_get_tex_geniv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_tex_geniv_data_length (const xcb_glx_get_tex_geniv_reply_t *R /**< */) +xcb_glx_get_tex_geniv_data_length (const xcb_glx_get_tex_geniv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R /**< */) +xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -6722,15 +7060,15 @@ xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R /**< */) } xcb_glx_get_tex_geniv_reply_t * -xcb_glx_get_tex_geniv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_geniv_reply (xcb_connection_t *c, xcb_glx_get_tex_geniv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_tex_geniv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_tex_image_sizeof (const void *_buffer /**< */) +xcb_glx_get_tex_image_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_tex_image_reply_t *_aux = (xcb_glx_get_tex_image_reply_t *)_buffer; @@ -6761,19 +7099,19 @@ xcb_glx_get_tex_image_sizeof (const void *_buffer /**< */) } xcb_glx_get_tex_image_cookie_t -xcb_glx_get_tex_image (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */) +xcb_glx_get_tex_image (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t format, + uint32_t type, + uint8_t swap_bytes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_IMAGE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_IMAGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6797,19 +7135,19 @@ xcb_glx_get_tex_image (xcb_connection_t *c /**< */, } xcb_glx_get_tex_image_cookie_t -xcb_glx_get_tex_image_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */) +xcb_glx_get_tex_image_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t format, + uint32_t type, + uint8_t swap_bytes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_IMAGE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_IMAGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6833,19 +7171,19 @@ xcb_glx_get_tex_image_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_get_tex_image_data (const xcb_glx_get_tex_image_reply_t *R /**< */) +xcb_glx_get_tex_image_data (const xcb_glx_get_tex_image_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_get_tex_image_data_length (const xcb_glx_get_tex_image_reply_t *R /**< */) +xcb_glx_get_tex_image_data_length (const xcb_glx_get_tex_image_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R /**< */) +xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -6855,15 +7193,15 @@ xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R /**< */) } xcb_glx_get_tex_image_reply_t * -xcb_glx_get_tex_image_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_image_reply (xcb_connection_t *c, xcb_glx_get_tex_image_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_tex_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_tex_parameterfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_tex_parameterfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_tex_parameterfv_reply_t *_aux = (xcb_glx_get_tex_parameterfv_reply_t *)_buffer; @@ -6894,16 +7232,16 @@ xcb_glx_get_tex_parameterfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_tex_parameterfv_cookie_t -xcb_glx_get_tex_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6924,16 +7262,16 @@ xcb_glx_get_tex_parameterfv (xcb_connection_t *c /**< */, } xcb_glx_get_tex_parameterfv_cookie_t -xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6954,19 +7292,19 @@ xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_tex_parameterfv_data (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */) +xcb_glx_get_tex_parameterfv_data (const xcb_glx_get_tex_parameterfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_tex_parameterfv_data_length (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */) +xcb_glx_get_tex_parameterfv_data_length (const xcb_glx_get_tex_parameterfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */) +xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -6976,15 +7314,15 @@ xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t } xcb_glx_get_tex_parameterfv_reply_t * -xcb_glx_get_tex_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_tex_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_tex_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_tex_parameteriv_sizeof (const void *_buffer /**< */) +xcb_glx_get_tex_parameteriv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_tex_parameteriv_reply_t *_aux = (xcb_glx_get_tex_parameteriv_reply_t *)_buffer; @@ -7015,16 +7353,16 @@ xcb_glx_get_tex_parameteriv_sizeof (const void *_buffer /**< */) } xcb_glx_get_tex_parameteriv_cookie_t -xcb_glx_get_tex_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7045,16 +7383,16 @@ xcb_glx_get_tex_parameteriv (xcb_connection_t *c /**< */, } xcb_glx_get_tex_parameteriv_cookie_t -xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7075,19 +7413,19 @@ xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_tex_parameteriv_data (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */) +xcb_glx_get_tex_parameteriv_data (const xcb_glx_get_tex_parameteriv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_tex_parameteriv_data_length (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */) +xcb_glx_get_tex_parameteriv_data_length (const xcb_glx_get_tex_parameteriv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */) +xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -7097,15 +7435,15 @@ xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t } xcb_glx_get_tex_parameteriv_reply_t * -xcb_glx_get_tex_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_tex_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_tex_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_tex_level_parameterfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_tex_level_parameterfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_tex_level_parameterfv_reply_t *_aux = (xcb_glx_get_tex_level_parameterfv_reply_t *)_buffer; @@ -7136,17 +7474,17 @@ xcb_glx_get_tex_level_parameterfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_tex_level_parameterfv_cookie_t -xcb_glx_get_tex_level_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_level_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7168,17 +7506,17 @@ xcb_glx_get_tex_level_parameterfv (xcb_connection_t *c /**< */, } xcb_glx_get_tex_level_parameterfv_cookie_t -xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7200,19 +7538,19 @@ xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_tex_level_parameterfv_data (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */) +xcb_glx_get_tex_level_parameterfv_data (const xcb_glx_get_tex_level_parameterfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_tex_level_parameterfv_data_length (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */) +xcb_glx_get_tex_level_parameterfv_data_length (const xcb_glx_get_tex_level_parameterfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */) +xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_parameterfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -7222,15 +7560,15 @@ xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_paramete } xcb_glx_get_tex_level_parameterfv_reply_t * -xcb_glx_get_tex_level_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_level_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_tex_level_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_tex_level_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_tex_level_parameteriv_sizeof (const void *_buffer /**< */) +xcb_glx_get_tex_level_parameteriv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_tex_level_parameteriv_reply_t *_aux = (xcb_glx_get_tex_level_parameteriv_reply_t *)_buffer; @@ -7261,17 +7599,17 @@ xcb_glx_get_tex_level_parameteriv_sizeof (const void *_buffer /**< */) } xcb_glx_get_tex_level_parameteriv_cookie_t -xcb_glx_get_tex_level_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_level_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7293,17 +7631,17 @@ xcb_glx_get_tex_level_parameteriv (xcb_connection_t *c /**< */, } xcb_glx_get_tex_level_parameteriv_cookie_t -xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t pname /**< */) +xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7325,19 +7663,19 @@ xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_tex_level_parameteriv_data (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */) +xcb_glx_get_tex_level_parameteriv_data (const xcb_glx_get_tex_level_parameteriv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_tex_level_parameteriv_data_length (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */) +xcb_glx_get_tex_level_parameteriv_data_length (const xcb_glx_get_tex_level_parameteriv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */) +xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_parameteriv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -7347,23 +7685,87 @@ xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_paramete } xcb_glx_get_tex_level_parameteriv_reply_t * -xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_tex_level_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_tex_level_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } -xcb_glx_is_list_cookie_t -xcb_glx_is_list (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */) +xcb_glx_is_enabled_cookie_t +xcb_glx_is_enabled (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t capability) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_IS_LIST, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_IS_ENABLED, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_glx_is_enabled_cookie_t xcb_ret; + xcb_glx_is_enabled_request_t xcb_out; + + xcb_out.context_tag = context_tag; + xcb_out.capability = capability; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_glx_is_enabled_cookie_t +xcb_glx_is_enabled_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t capability) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_IS_ENABLED, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_glx_is_enabled_cookie_t xcb_ret; + xcb_glx_is_enabled_request_t xcb_out; + + xcb_out.context_tag = context_tag; + xcb_out.capability = capability; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + 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; +} + +xcb_glx_is_enabled_reply_t * +xcb_glx_is_enabled_reply (xcb_connection_t *c, + xcb_glx_is_enabled_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_glx_is_enabled_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_glx_is_list_cookie_t +xcb_glx_is_list (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_IS_LIST, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7383,15 +7785,15 @@ xcb_glx_is_list (xcb_connection_t *c /**< */, } xcb_glx_is_list_cookie_t -xcb_glx_is_list_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */) +xcb_glx_is_list_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_IS_LIST, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_IS_LIST, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7411,22 +7813,22 @@ xcb_glx_is_list_unchecked (xcb_connection_t *c /**< */, } xcb_glx_is_list_reply_t * -xcb_glx_is_list_reply (xcb_connection_t *c /**< */, +xcb_glx_is_list_reply (xcb_connection_t *c, xcb_glx_is_list_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_is_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_glx_flush_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_flush_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_FLUSH, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_FLUSH, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7445,14 +7847,14 @@ xcb_glx_flush_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_flush (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */) +xcb_glx_flush (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_FLUSH, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_FLUSH, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7471,7 +7873,7 @@ xcb_glx_flush (xcb_connection_t *c /**< */, } int -xcb_glx_are_textures_resident_sizeof (const void *_buffer /**< */) +xcb_glx_are_textures_resident_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_are_textures_resident_request_t *_aux = (xcb_glx_are_textures_resident_request_t *)_buffer; @@ -7502,16 +7904,16 @@ xcb_glx_are_textures_resident_sizeof (const void *_buffer /**< */) } xcb_glx_are_textures_resident_cookie_t -xcb_glx_are_textures_resident (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *textures /**< */) +xcb_glx_are_textures_resident (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *textures) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_ARE_TEXTURES_RESIDENT, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_ARE_TEXTURES_RESIDENT, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -7536,16 +7938,16 @@ xcb_glx_are_textures_resident (xcb_connection_t *c /**< */, } xcb_glx_are_textures_resident_cookie_t -xcb_glx_are_textures_resident_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *textures /**< */) +xcb_glx_are_textures_resident_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *textures) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_ARE_TEXTURES_RESIDENT, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_ARE_TEXTURES_RESIDENT, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -7570,19 +7972,19 @@ xcb_glx_are_textures_resident_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_are_textures_resident_data (const xcb_glx_are_textures_resident_reply_t *R /**< */) +xcb_glx_are_textures_resident_data (const xcb_glx_are_textures_resident_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_are_textures_resident_data_length (const xcb_glx_are_textures_resident_reply_t *R /**< */) +xcb_glx_are_textures_resident_data_length (const xcb_glx_are_textures_resident_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_reply_t *R /**< */) +xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -7592,15 +7994,15 @@ xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_repl } xcb_glx_are_textures_resident_reply_t * -xcb_glx_are_textures_resident_reply (xcb_connection_t *c /**< */, +xcb_glx_are_textures_resident_reply (xcb_connection_t *c, xcb_glx_are_textures_resident_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_are_textures_resident_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_delete_textures_sizeof (const void *_buffer /**< */) +xcb_glx_delete_textures_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_delete_textures_request_t *_aux = (xcb_glx_delete_textures_request_t *)_buffer; @@ -7631,16 +8033,16 @@ xcb_glx_delete_textures_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_delete_textures_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *textures /**< */) +xcb_glx_delete_textures_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *textures) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DELETE_TEXTURES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DELETE_TEXTURES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7665,16 +8067,16 @@ xcb_glx_delete_textures_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_delete_textures (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *textures /**< */) +xcb_glx_delete_textures (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *textures) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DELETE_TEXTURES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DELETE_TEXTURES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7698,8 +8100,30 @@ xcb_glx_delete_textures (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_glx_delete_textures_textures (const xcb_glx_delete_textures_request_t *R) +{ + return (uint32_t *) (R + 1); +} + int -xcb_glx_gen_textures_sizeof (const void *_buffer /**< */) +xcb_glx_delete_textures_textures_length (const xcb_glx_delete_textures_request_t *R) +{ + return R->n; +} + +xcb_generic_iterator_t +xcb_glx_delete_textures_textures_end (const xcb_glx_delete_textures_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->n); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_glx_gen_textures_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_gen_textures_reply_t *_aux = (xcb_glx_gen_textures_reply_t *)_buffer; @@ -7730,15 +8154,15 @@ xcb_glx_gen_textures_sizeof (const void *_buffer /**< */) } xcb_glx_gen_textures_cookie_t -xcb_glx_gen_textures (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */) +xcb_glx_gen_textures (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GEN_TEXTURES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GEN_TEXTURES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7758,15 +8182,15 @@ xcb_glx_gen_textures (xcb_connection_t *c /**< */, } xcb_glx_gen_textures_cookie_t -xcb_glx_gen_textures_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */) +xcb_glx_gen_textures_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GEN_TEXTURES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GEN_TEXTURES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7786,19 +8210,19 @@ xcb_glx_gen_textures_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_glx_gen_textures_data (const xcb_glx_gen_textures_reply_t *R /**< */) +xcb_glx_gen_textures_data (const xcb_glx_gen_textures_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_glx_gen_textures_data_length (const xcb_glx_gen_textures_reply_t *R /**< */) +xcb_glx_gen_textures_data_length (const xcb_glx_gen_textures_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R /**< */) +xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->length); @@ -7808,23 +8232,23 @@ xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R /**< */) } xcb_glx_gen_textures_reply_t * -xcb_glx_gen_textures_reply (xcb_connection_t *c /**< */, +xcb_glx_gen_textures_reply (xcb_connection_t *c, xcb_glx_gen_textures_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_gen_textures_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_glx_is_texture_cookie_t -xcb_glx_is_texture (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t texture /**< */) +xcb_glx_is_texture (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t texture) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_IS_TEXTURE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_IS_TEXTURE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7844,15 +8268,15 @@ xcb_glx_is_texture (xcb_connection_t *c /**< */, } xcb_glx_is_texture_cookie_t -xcb_glx_is_texture_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t texture /**< */) +xcb_glx_is_texture_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t texture) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_IS_TEXTURE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_IS_TEXTURE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7872,15 +8296,15 @@ xcb_glx_is_texture_unchecked (xcb_connection_t *c /**< */, } xcb_glx_is_texture_reply_t * -xcb_glx_is_texture_reply (xcb_connection_t *c /**< */, +xcb_glx_is_texture_reply (xcb_connection_t *c, xcb_glx_is_texture_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_is_texture_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_color_table_sizeof (const void *_buffer /**< */) +xcb_glx_get_color_table_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_color_table_reply_t *_aux = (xcb_glx_get_color_table_reply_t *)_buffer; @@ -7911,18 +8335,18 @@ xcb_glx_get_color_table_sizeof (const void *_buffer /**< */) } xcb_glx_get_color_table_cookie_t -xcb_glx_get_color_table (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */) +xcb_glx_get_color_table (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_COLOR_TABLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_COLOR_TABLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7945,18 +8369,18 @@ xcb_glx_get_color_table (xcb_connection_t *c /**< */, } xcb_glx_get_color_table_cookie_t -xcb_glx_get_color_table_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */) +xcb_glx_get_color_table_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_COLOR_TABLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_COLOR_TABLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7979,19 +8403,19 @@ xcb_glx_get_color_table_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_get_color_table_data (const xcb_glx_get_color_table_reply_t *R /**< */) +xcb_glx_get_color_table_data (const xcb_glx_get_color_table_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_get_color_table_data_length (const xcb_glx_get_color_table_reply_t *R /**< */) +xcb_glx_get_color_table_data_length (const xcb_glx_get_color_table_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R /**< */) +xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -8001,15 +8425,15 @@ xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R /**< } xcb_glx_get_color_table_reply_t * -xcb_glx_get_color_table_reply (xcb_connection_t *c /**< */, +xcb_glx_get_color_table_reply (xcb_connection_t *c, xcb_glx_get_color_table_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_color_table_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_color_table_parameterfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_color_table_parameterfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_color_table_parameterfv_reply_t *_aux = (xcb_glx_get_color_table_parameterfv_reply_t *)_buffer; @@ -8040,16 +8464,16 @@ xcb_glx_get_color_table_parameterfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_color_table_parameterfv_cookie_t -xcb_glx_get_color_table_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_color_table_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8070,16 +8494,16 @@ xcb_glx_get_color_table_parameterfv (xcb_connection_t *c /**< */, } xcb_glx_get_color_table_parameterfv_cookie_t -xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8100,19 +8524,19 @@ xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t *c /**< */ } xcb_glx_float32_t * -xcb_glx_get_color_table_parameterfv_data (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */) +xcb_glx_get_color_table_parameterfv_data (const xcb_glx_get_color_table_parameterfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_color_table_parameterfv_data_length (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */) +xcb_glx_get_color_table_parameterfv_data_length (const xcb_glx_get_color_table_parameterfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */) +xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_parameterfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -8122,15 +8546,15 @@ xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_para } xcb_glx_get_color_table_parameterfv_reply_t * -xcb_glx_get_color_table_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_color_table_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_color_table_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_color_table_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_color_table_parameteriv_sizeof (const void *_buffer /**< */) +xcb_glx_get_color_table_parameteriv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_color_table_parameteriv_reply_t *_aux = (xcb_glx_get_color_table_parameteriv_reply_t *)_buffer; @@ -8161,16 +8585,16 @@ xcb_glx_get_color_table_parameteriv_sizeof (const void *_buffer /**< */) } xcb_glx_get_color_table_parameteriv_cookie_t -xcb_glx_get_color_table_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_color_table_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8191,16 +8615,16 @@ xcb_glx_get_color_table_parameteriv (xcb_connection_t *c /**< */, } xcb_glx_get_color_table_parameteriv_cookie_t -xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8221,19 +8645,19 @@ xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t *c /**< */ } int32_t * -xcb_glx_get_color_table_parameteriv_data (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */) +xcb_glx_get_color_table_parameteriv_data (const xcb_glx_get_color_table_parameteriv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_color_table_parameteriv_data_length (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */) +xcb_glx_get_color_table_parameteriv_data_length (const xcb_glx_get_color_table_parameteriv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */) +xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_parameteriv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -8243,15 +8667,15 @@ xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_para } xcb_glx_get_color_table_parameteriv_reply_t * -xcb_glx_get_color_table_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_color_table_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_color_table_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_color_table_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_convolution_filter_sizeof (const void *_buffer /**< */) +xcb_glx_get_convolution_filter_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_convolution_filter_reply_t *_aux = (xcb_glx_get_convolution_filter_reply_t *)_buffer; @@ -8282,18 +8706,18 @@ xcb_glx_get_convolution_filter_sizeof (const void *_buffer /**< */) } xcb_glx_get_convolution_filter_cookie_t -xcb_glx_get_convolution_filter (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */) +xcb_glx_get_convolution_filter (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_CONVOLUTION_FILTER, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_CONVOLUTION_FILTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8316,18 +8740,18 @@ xcb_glx_get_convolution_filter (xcb_connection_t *c /**< */, } xcb_glx_get_convolution_filter_cookie_t -xcb_glx_get_convolution_filter_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */) +xcb_glx_get_convolution_filter_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_CONVOLUTION_FILTER, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_CONVOLUTION_FILTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8350,19 +8774,19 @@ xcb_glx_get_convolution_filter_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_get_convolution_filter_data (const xcb_glx_get_convolution_filter_reply_t *R /**< */) +xcb_glx_get_convolution_filter_data (const xcb_glx_get_convolution_filter_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_get_convolution_filter_data_length (const xcb_glx_get_convolution_filter_reply_t *R /**< */) +xcb_glx_get_convolution_filter_data_length (const xcb_glx_get_convolution_filter_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_reply_t *R /**< */) +xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -8372,15 +8796,15 @@ xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_re } xcb_glx_get_convolution_filter_reply_t * -xcb_glx_get_convolution_filter_reply (xcb_connection_t *c /**< */, +xcb_glx_get_convolution_filter_reply (xcb_connection_t *c, xcb_glx_get_convolution_filter_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_convolution_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_convolution_parameterfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_convolution_parameterfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_convolution_parameterfv_reply_t *_aux = (xcb_glx_get_convolution_parameterfv_reply_t *)_buffer; @@ -8411,16 +8835,16 @@ xcb_glx_get_convolution_parameterfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_convolution_parameterfv_cookie_t -xcb_glx_get_convolution_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_convolution_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8441,16 +8865,16 @@ xcb_glx_get_convolution_parameterfv (xcb_connection_t *c /**< */, } xcb_glx_get_convolution_parameterfv_cookie_t -xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8471,19 +8895,19 @@ xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t *c /**< */ } xcb_glx_float32_t * -xcb_glx_get_convolution_parameterfv_data (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */) +xcb_glx_get_convolution_parameterfv_data (const xcb_glx_get_convolution_parameterfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_convolution_parameterfv_data_length (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */) +xcb_glx_get_convolution_parameterfv_data_length (const xcb_glx_get_convolution_parameterfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */) +xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_parameterfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -8493,15 +8917,15 @@ xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_para } xcb_glx_get_convolution_parameterfv_reply_t * -xcb_glx_get_convolution_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_convolution_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_convolution_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_convolution_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_convolution_parameteriv_sizeof (const void *_buffer /**< */) +xcb_glx_get_convolution_parameteriv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_convolution_parameteriv_reply_t *_aux = (xcb_glx_get_convolution_parameteriv_reply_t *)_buffer; @@ -8532,16 +8956,16 @@ xcb_glx_get_convolution_parameteriv_sizeof (const void *_buffer /**< */) } xcb_glx_get_convolution_parameteriv_cookie_t -xcb_glx_get_convolution_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_convolution_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8562,16 +8986,16 @@ xcb_glx_get_convolution_parameteriv (xcb_connection_t *c /**< */, } xcb_glx_get_convolution_parameteriv_cookie_t -xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_CONVOLUTION_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8592,19 +9016,19 @@ xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t *c /**< */ } int32_t * -xcb_glx_get_convolution_parameteriv_data (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */) +xcb_glx_get_convolution_parameteriv_data (const xcb_glx_get_convolution_parameteriv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_convolution_parameteriv_data_length (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */) +xcb_glx_get_convolution_parameteriv_data_length (const xcb_glx_get_convolution_parameteriv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */) +xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_parameteriv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -8614,15 +9038,15 @@ xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_para } xcb_glx_get_convolution_parameteriv_reply_t * -xcb_glx_get_convolution_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_convolution_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_convolution_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_convolution_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_separable_filter_sizeof (const void *_buffer /**< */) +xcb_glx_get_separable_filter_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_separable_filter_reply_t *_aux = (xcb_glx_get_separable_filter_reply_t *)_buffer; @@ -8653,18 +9077,18 @@ xcb_glx_get_separable_filter_sizeof (const void *_buffer /**< */) } xcb_glx_get_separable_filter_cookie_t -xcb_glx_get_separable_filter (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */) +xcb_glx_get_separable_filter (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_SEPARABLE_FILTER, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_SEPARABLE_FILTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8687,18 +9111,18 @@ xcb_glx_get_separable_filter (xcb_connection_t *c /**< */, } xcb_glx_get_separable_filter_cookie_t -xcb_glx_get_separable_filter_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */) +xcb_glx_get_separable_filter_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_SEPARABLE_FILTER, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_SEPARABLE_FILTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8721,19 +9145,19 @@ xcb_glx_get_separable_filter_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_get_separable_filter_rows_and_cols (const xcb_glx_get_separable_filter_reply_t *R /**< */) +xcb_glx_get_separable_filter_rows_and_cols (const xcb_glx_get_separable_filter_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_get_separable_filter_rows_and_cols_length (const xcb_glx_get_separable_filter_reply_t *R /**< */) +xcb_glx_get_separable_filter_rows_and_cols_length (const xcb_glx_get_separable_filter_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filter_reply_t *R /**< */) +xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filter_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -8743,15 +9167,15 @@ xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filt } xcb_glx_get_separable_filter_reply_t * -xcb_glx_get_separable_filter_reply (xcb_connection_t *c /**< */, +xcb_glx_get_separable_filter_reply (xcb_connection_t *c, xcb_glx_get_separable_filter_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_separable_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_histogram_sizeof (const void *_buffer /**< */) +xcb_glx_get_histogram_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_histogram_reply_t *_aux = (xcb_glx_get_histogram_reply_t *)_buffer; @@ -8782,19 +9206,19 @@ xcb_glx_get_histogram_sizeof (const void *_buffer /**< */) } xcb_glx_get_histogram_cookie_t -xcb_glx_get_histogram (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t reset /**< */) +xcb_glx_get_histogram (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t reset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_HISTOGRAM, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_HISTOGRAM, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8818,19 +9242,19 @@ xcb_glx_get_histogram (xcb_connection_t *c /**< */, } xcb_glx_get_histogram_cookie_t -xcb_glx_get_histogram_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t reset /**< */) +xcb_glx_get_histogram_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t reset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_HISTOGRAM, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_HISTOGRAM, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8854,19 +9278,19 @@ xcb_glx_get_histogram_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_get_histogram_data (const xcb_glx_get_histogram_reply_t *R /**< */) +xcb_glx_get_histogram_data (const xcb_glx_get_histogram_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_get_histogram_data_length (const xcb_glx_get_histogram_reply_t *R /**< */) +xcb_glx_get_histogram_data_length (const xcb_glx_get_histogram_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R /**< */) +xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -8876,15 +9300,15 @@ xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R /**< */) } xcb_glx_get_histogram_reply_t * -xcb_glx_get_histogram_reply (xcb_connection_t *c /**< */, +xcb_glx_get_histogram_reply (xcb_connection_t *c, xcb_glx_get_histogram_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_histogram_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_histogram_parameterfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_histogram_parameterfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_histogram_parameterfv_reply_t *_aux = (xcb_glx_get_histogram_parameterfv_reply_t *)_buffer; @@ -8915,16 +9339,16 @@ xcb_glx_get_histogram_parameterfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_histogram_parameterfv_cookie_t -xcb_glx_get_histogram_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_histogram_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8945,16 +9369,16 @@ xcb_glx_get_histogram_parameterfv (xcb_connection_t *c /**< */, } xcb_glx_get_histogram_parameterfv_cookie_t -xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8975,19 +9399,19 @@ xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_histogram_parameterfv_data (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */) +xcb_glx_get_histogram_parameterfv_data (const xcb_glx_get_histogram_parameterfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_histogram_parameterfv_data_length (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */) +xcb_glx_get_histogram_parameterfv_data_length (const xcb_glx_get_histogram_parameterfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */) +xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_parameterfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -8997,15 +9421,15 @@ xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_paramete } xcb_glx_get_histogram_parameterfv_reply_t * -xcb_glx_get_histogram_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_histogram_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_histogram_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_histogram_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_histogram_parameteriv_sizeof (const void *_buffer /**< */) +xcb_glx_get_histogram_parameteriv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_histogram_parameteriv_reply_t *_aux = (xcb_glx_get_histogram_parameteriv_reply_t *)_buffer; @@ -9036,16 +9460,16 @@ xcb_glx_get_histogram_parameteriv_sizeof (const void *_buffer /**< */) } xcb_glx_get_histogram_parameteriv_cookie_t -xcb_glx_get_histogram_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_histogram_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9066,16 +9490,16 @@ xcb_glx_get_histogram_parameteriv (xcb_connection_t *c /**< */, } xcb_glx_get_histogram_parameteriv_cookie_t -xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_HISTOGRAM_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9096,19 +9520,19 @@ xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_histogram_parameteriv_data (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */) +xcb_glx_get_histogram_parameteriv_data (const xcb_glx_get_histogram_parameteriv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_histogram_parameteriv_data_length (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */) +xcb_glx_get_histogram_parameteriv_data_length (const xcb_glx_get_histogram_parameteriv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */) +xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_parameteriv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -9118,15 +9542,15 @@ xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_paramete } xcb_glx_get_histogram_parameteriv_reply_t * -xcb_glx_get_histogram_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_histogram_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_histogram_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_histogram_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_minmax_sizeof (const void *_buffer /**< */) +xcb_glx_get_minmax_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_minmax_reply_t *_aux = (xcb_glx_get_minmax_reply_t *)_buffer; @@ -9157,19 +9581,19 @@ xcb_glx_get_minmax_sizeof (const void *_buffer /**< */) } xcb_glx_get_minmax_cookie_t -xcb_glx_get_minmax (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t reset /**< */) +xcb_glx_get_minmax (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t reset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MINMAX, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MINMAX, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9193,19 +9617,19 @@ xcb_glx_get_minmax (xcb_connection_t *c /**< */, } xcb_glx_get_minmax_cookie_t -xcb_glx_get_minmax_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t reset /**< */) +xcb_glx_get_minmax_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t reset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MINMAX, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MINMAX, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9229,19 +9653,19 @@ xcb_glx_get_minmax_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_glx_get_minmax_data (const xcb_glx_get_minmax_reply_t *R /**< */) +xcb_glx_get_minmax_data (const xcb_glx_get_minmax_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_get_minmax_data_length (const xcb_glx_get_minmax_reply_t *R /**< */) +xcb_glx_get_minmax_data_length (const xcb_glx_get_minmax_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R /**< */) +xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -9251,15 +9675,15 @@ xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R /**< */) } xcb_glx_get_minmax_reply_t * -xcb_glx_get_minmax_reply (xcb_connection_t *c /**< */, +xcb_glx_get_minmax_reply (xcb_connection_t *c, xcb_glx_get_minmax_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_minmax_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_minmax_parameterfv_sizeof (const void *_buffer /**< */) +xcb_glx_get_minmax_parameterfv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_minmax_parameterfv_reply_t *_aux = (xcb_glx_get_minmax_parameterfv_reply_t *)_buffer; @@ -9290,16 +9714,16 @@ xcb_glx_get_minmax_parameterfv_sizeof (const void *_buffer /**< */) } xcb_glx_get_minmax_parameterfv_cookie_t -xcb_glx_get_minmax_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_minmax_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MINMAX_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9320,16 +9744,16 @@ xcb_glx_get_minmax_parameterfv (xcb_connection_t *c /**< */, } xcb_glx_get_minmax_parameterfv_cookie_t -xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERFV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MINMAX_PARAMETERFV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9350,19 +9774,19 @@ xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t *c /**< */, } xcb_glx_float32_t * -xcb_glx_get_minmax_parameterfv_data (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */) +xcb_glx_get_minmax_parameterfv_data (const xcb_glx_get_minmax_parameterfv_reply_t *R) { return (xcb_glx_float32_t *) (R + 1); } int -xcb_glx_get_minmax_parameterfv_data_length (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */) +xcb_glx_get_minmax_parameterfv_data_length (const xcb_glx_get_minmax_parameterfv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */) +xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n); @@ -9372,15 +9796,15 @@ xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_re } xcb_glx_get_minmax_parameterfv_reply_t * -xcb_glx_get_minmax_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_minmax_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_minmax_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_minmax_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_minmax_parameteriv_sizeof (const void *_buffer /**< */) +xcb_glx_get_minmax_parameteriv_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_minmax_parameteriv_reply_t *_aux = (xcb_glx_get_minmax_parameteriv_reply_t *)_buffer; @@ -9411,16 +9835,16 @@ xcb_glx_get_minmax_parameteriv_sizeof (const void *_buffer /**< */) } xcb_glx_get_minmax_parameteriv_cookie_t -xcb_glx_get_minmax_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_minmax_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MINMAX_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9441,16 +9865,16 @@ xcb_glx_get_minmax_parameteriv (xcb_connection_t *c /**< */, } xcb_glx_get_minmax_parameteriv_cookie_t -xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_MINMAX_PARAMETERIV, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_MINMAX_PARAMETERIV, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9471,19 +9895,19 @@ xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_minmax_parameteriv_data (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */) +xcb_glx_get_minmax_parameteriv_data (const xcb_glx_get_minmax_parameteriv_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_minmax_parameteriv_data_length (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */) +xcb_glx_get_minmax_parameteriv_data_length (const xcb_glx_get_minmax_parameteriv_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */) +xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -9493,15 +9917,15 @@ xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_re } xcb_glx_get_minmax_parameteriv_reply_t * -xcb_glx_get_minmax_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_minmax_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_minmax_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_minmax_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_compressed_tex_image_arb_sizeof (const void *_buffer /**< */) +xcb_glx_get_compressed_tex_image_arb_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_compressed_tex_image_arb_reply_t *_aux = (xcb_glx_get_compressed_tex_image_arb_reply_t *)_buffer; @@ -9532,16 +9956,16 @@ xcb_glx_get_compressed_tex_image_arb_sizeof (const void *_buffer /**< */) } xcb_glx_get_compressed_tex_image_arb_cookie_t -xcb_glx_get_compressed_tex_image_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */) +xcb_glx_get_compressed_tex_image_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9562,16 +9986,16 @@ xcb_glx_get_compressed_tex_image_arb (xcb_connection_t *c /**< */, } xcb_glx_get_compressed_tex_image_arb_cookie_t -xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */) +xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9592,19 +10016,19 @@ xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t *c /**< * } uint8_t * -xcb_glx_get_compressed_tex_image_arb_data (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */) +xcb_glx_get_compressed_tex_image_arb_data (const xcb_glx_get_compressed_tex_image_arb_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_glx_get_compressed_tex_image_arb_data_length (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */) +xcb_glx_get_compressed_tex_image_arb_data_length (const xcb_glx_get_compressed_tex_image_arb_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */) +xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_image_arb_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -9614,15 +10038,15 @@ xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_ } xcb_glx_get_compressed_tex_image_arb_reply_t * -xcb_glx_get_compressed_tex_image_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_get_compressed_tex_image_arb_reply (xcb_connection_t *c, xcb_glx_get_compressed_tex_image_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_compressed_tex_image_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_delete_queries_arb_sizeof (const void *_buffer /**< */) +xcb_glx_delete_queries_arb_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_delete_queries_arb_request_t *_aux = (xcb_glx_delete_queries_arb_request_t *)_buffer; @@ -9653,16 +10077,16 @@ xcb_glx_delete_queries_arb_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_glx_delete_queries_arb_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *ids /**< */) +xcb_glx_delete_queries_arb_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *ids) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DELETE_QUERIES_ARB, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DELETE_QUERIES_ARB, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -9687,16 +10111,16 @@ xcb_glx_delete_queries_arb_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_glx_delete_queries_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *ids /**< */) +xcb_glx_delete_queries_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *ids) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_DELETE_QUERIES_ARB, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_DELETE_QUERIES_ARB, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -9720,8 +10144,30 @@ xcb_glx_delete_queries_arb (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_glx_delete_queries_arb_ids (const xcb_glx_delete_queries_arb_request_t *R) +{ + return (uint32_t *) (R + 1); +} + int -xcb_glx_gen_queries_arb_sizeof (const void *_buffer /**< */) +xcb_glx_delete_queries_arb_ids_length (const xcb_glx_delete_queries_arb_request_t *R) +{ + return R->n; +} + +xcb_generic_iterator_t +xcb_glx_delete_queries_arb_ids_end (const xcb_glx_delete_queries_arb_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->n); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_glx_gen_queries_arb_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_gen_queries_arb_reply_t *_aux = (xcb_glx_gen_queries_arb_reply_t *)_buffer; @@ -9752,15 +10198,15 @@ xcb_glx_gen_queries_arb_sizeof (const void *_buffer /**< */) } xcb_glx_gen_queries_arb_cookie_t -xcb_glx_gen_queries_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */) +xcb_glx_gen_queries_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GEN_QUERIES_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GEN_QUERIES_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9780,15 +10226,15 @@ xcb_glx_gen_queries_arb (xcb_connection_t *c /**< */, } xcb_glx_gen_queries_arb_cookie_t -xcb_glx_gen_queries_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */) +xcb_glx_gen_queries_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GEN_QUERIES_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GEN_QUERIES_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9808,19 +10254,19 @@ xcb_glx_gen_queries_arb_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_glx_gen_queries_arb_data (const xcb_glx_gen_queries_arb_reply_t *R /**< */) +xcb_glx_gen_queries_arb_data (const xcb_glx_gen_queries_arb_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_glx_gen_queries_arb_data_length (const xcb_glx_gen_queries_arb_reply_t *R /**< */) +xcb_glx_gen_queries_arb_data_length (const xcb_glx_gen_queries_arb_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R /**< */) +xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->length); @@ -9830,23 +10276,23 @@ xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R /**< } xcb_glx_gen_queries_arb_reply_t * -xcb_glx_gen_queries_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_gen_queries_arb_reply (xcb_connection_t *c, xcb_glx_gen_queries_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_gen_queries_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_glx_is_query_arb_cookie_t -xcb_glx_is_query_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */) +xcb_glx_is_query_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_IS_QUERY_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_IS_QUERY_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9866,15 +10312,15 @@ xcb_glx_is_query_arb (xcb_connection_t *c /**< */, } xcb_glx_is_query_arb_cookie_t -xcb_glx_is_query_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */) +xcb_glx_is_query_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_IS_QUERY_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_IS_QUERY_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9894,15 +10340,15 @@ xcb_glx_is_query_arb_unchecked (xcb_connection_t *c /**< */, } xcb_glx_is_query_arb_reply_t * -xcb_glx_is_query_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_is_query_arb_reply (xcb_connection_t *c, xcb_glx_is_query_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_is_query_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_queryiv_arb_sizeof (const void *_buffer /**< */) +xcb_glx_get_queryiv_arb_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_queryiv_arb_reply_t *_aux = (xcb_glx_get_queryiv_arb_reply_t *)_buffer; @@ -9933,16 +10379,16 @@ xcb_glx_get_queryiv_arb_sizeof (const void *_buffer /**< */) } xcb_glx_get_queryiv_arb_cookie_t -xcb_glx_get_queryiv_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_queryiv_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_QUERYIV_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_QUERYIV_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9963,16 +10409,16 @@ xcb_glx_get_queryiv_arb (xcb_connection_t *c /**< */, } xcb_glx_get_queryiv_arb_cookie_t -xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */) +xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_QUERYIV_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_QUERYIV_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9993,19 +10439,19 @@ xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_queryiv_arb_data (const xcb_glx_get_queryiv_arb_reply_t *R /**< */) +xcb_glx_get_queryiv_arb_data (const xcb_glx_get_queryiv_arb_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_queryiv_arb_data_length (const xcb_glx_get_queryiv_arb_reply_t *R /**< */) +xcb_glx_get_queryiv_arb_data_length (const xcb_glx_get_queryiv_arb_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R /**< */) +xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -10015,15 +10461,15 @@ xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R /**< } xcb_glx_get_queryiv_arb_reply_t * -xcb_glx_get_queryiv_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_get_queryiv_arb_reply (xcb_connection_t *c, xcb_glx_get_queryiv_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_queryiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_query_objectiv_arb_sizeof (const void *_buffer /**< */) +xcb_glx_get_query_objectiv_arb_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_query_objectiv_arb_reply_t *_aux = (xcb_glx_get_query_objectiv_arb_reply_t *)_buffer; @@ -10054,16 +10500,16 @@ xcb_glx_get_query_objectiv_arb_sizeof (const void *_buffer /**< */) } xcb_glx_get_query_objectiv_arb_cookie_t -xcb_glx_get_query_objectiv_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */, - uint32_t pname /**< */) +xcb_glx_get_query_objectiv_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_QUERY_OBJECTIV_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_QUERY_OBJECTIV_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10084,16 +10530,16 @@ xcb_glx_get_query_objectiv_arb (xcb_connection_t *c /**< */, } xcb_glx_get_query_objectiv_arb_cookie_t -xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */, - uint32_t pname /**< */) +xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_QUERY_OBJECTIV_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_QUERY_OBJECTIV_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10114,19 +10560,19 @@ xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_glx_get_query_objectiv_arb_data (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */) +xcb_glx_get_query_objectiv_arb_data (const xcb_glx_get_query_objectiv_arb_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_glx_get_query_objectiv_arb_data_length (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */) +xcb_glx_get_query_objectiv_arb_data_length (const xcb_glx_get_query_objectiv_arb_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */) +xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->n); @@ -10136,15 +10582,15 @@ xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_re } xcb_glx_get_query_objectiv_arb_reply_t * -xcb_glx_get_query_objectiv_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_get_query_objectiv_arb_reply (xcb_connection_t *c, xcb_glx_get_query_objectiv_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_query_objectiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_glx_get_query_objectuiv_arb_sizeof (const void *_buffer /**< */) +xcb_glx_get_query_objectuiv_arb_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_glx_get_query_objectuiv_arb_reply_t *_aux = (xcb_glx_get_query_objectuiv_arb_reply_t *)_buffer; @@ -10175,16 +10621,16 @@ xcb_glx_get_query_objectuiv_arb_sizeof (const void *_buffer /**< */) } xcb_glx_get_query_objectuiv_arb_cookie_t -xcb_glx_get_query_objectuiv_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */, - uint32_t pname /**< */) +xcb_glx_get_query_objectuiv_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_QUERY_OBJECTUIV_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_QUERY_OBJECTUIV_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10205,16 +10651,16 @@ xcb_glx_get_query_objectuiv_arb (xcb_connection_t *c /**< */, } xcb_glx_get_query_objectuiv_arb_cookie_t -xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */, - uint32_t pname /**< */) +xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id, + uint32_t pname) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_glx_id, - /* opcode */ XCB_GLX_GET_QUERY_OBJECTUIV_ARB, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_glx_id, + .opcode = XCB_GLX_GET_QUERY_OBJECTUIV_ARB, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10235,19 +10681,19 @@ xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_glx_get_query_objectuiv_arb_data (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */) +xcb_glx_get_query_objectuiv_arb_data (const xcb_glx_get_query_objectuiv_arb_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_glx_get_query_objectuiv_arb_data_length (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */) +xcb_glx_get_query_objectuiv_arb_data_length (const xcb_glx_get_query_objectuiv_arb_reply_t *R) { return R->n; } xcb_generic_iterator_t -xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */) +xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->n); @@ -10257,9 +10703,9 @@ xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_ } xcb_glx_get_query_objectuiv_arb_reply_t * -xcb_glx_get_query_objectuiv_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_get_query_objectuiv_arb_reply (xcb_connection_t *c, xcb_glx_get_query_objectuiv_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_glx_get_query_objectuiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/glx.h b/lib/libxcb/src/glx.h index f374632cc..d864bcc0b 100644 --- a/lib/libxcb/src/glx.h +++ b/lib/libxcb/src/glx.h @@ -30,9 +30,9 @@ typedef uint32_t xcb_glx_pixmap_t; * @brief xcb_glx_pixmap_iterator_t **/ typedef struct xcb_glx_pixmap_iterator_t { - xcb_glx_pixmap_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_glx_pixmap_t *data; + int rem; + int index; } xcb_glx_pixmap_iterator_t; typedef uint32_t xcb_glx_context_t; @@ -41,9 +41,9 @@ typedef uint32_t xcb_glx_context_t; * @brief xcb_glx_context_iterator_t **/ typedef struct xcb_glx_context_iterator_t { - xcb_glx_context_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_glx_context_t *data; + int rem; + int index; } xcb_glx_context_iterator_t; typedef uint32_t xcb_glx_pbuffer_t; @@ -52,9 +52,9 @@ typedef uint32_t xcb_glx_pbuffer_t; * @brief xcb_glx_pbuffer_iterator_t **/ typedef struct xcb_glx_pbuffer_iterator_t { - xcb_glx_pbuffer_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_glx_pbuffer_t *data; + int rem; + int index; } xcb_glx_pbuffer_iterator_t; typedef uint32_t xcb_glx_window_t; @@ -63,9 +63,9 @@ typedef uint32_t xcb_glx_window_t; * @brief xcb_glx_window_iterator_t **/ typedef struct xcb_glx_window_iterator_t { - xcb_glx_window_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_glx_window_t *data; + int rem; + int index; } xcb_glx_window_iterator_t; typedef uint32_t xcb_glx_fbconfig_t; @@ -74,9 +74,9 @@ typedef uint32_t xcb_glx_fbconfig_t; * @brief xcb_glx_fbconfig_iterator_t **/ typedef struct xcb_glx_fbconfig_iterator_t { - xcb_glx_fbconfig_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_glx_fbconfig_t *data; + int rem; + int index; } xcb_glx_fbconfig_iterator_t; typedef uint32_t xcb_glx_drawable_t; @@ -85,9 +85,9 @@ typedef uint32_t xcb_glx_drawable_t; * @brief xcb_glx_drawable_iterator_t **/ typedef struct xcb_glx_drawable_iterator_t { - xcb_glx_drawable_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_glx_drawable_t *data; + int rem; + int index; } xcb_glx_drawable_iterator_t; typedef float xcb_glx_float32_t; @@ -96,9 +96,9 @@ typedef float xcb_glx_float32_t; * @brief xcb_glx_float32_iterator_t **/ typedef struct xcb_glx_float32_iterator_t { - xcb_glx_float32_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_glx_float32_t *data; + int rem; + int index; } xcb_glx_float32_iterator_t; typedef double xcb_glx_float64_t; @@ -107,9 +107,9 @@ typedef double xcb_glx_float64_t; * @brief xcb_glx_float64_iterator_t **/ typedef struct xcb_glx_float64_iterator_t { - xcb_glx_float64_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_glx_float64_t *data; + int rem; + int index; } xcb_glx_float64_iterator_t; typedef uint32_t xcb_glx_bool32_t; @@ -118,9 +118,9 @@ typedef uint32_t xcb_glx_bool32_t; * @brief xcb_glx_bool32_iterator_t **/ typedef struct xcb_glx_bool32_iterator_t { - xcb_glx_bool32_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_glx_bool32_t *data; + int rem; + int index; } xcb_glx_bool32_iterator_t; typedef uint32_t xcb_glx_context_tag_t; @@ -129,9 +129,9 @@ typedef uint32_t xcb_glx_context_tag_t; * @brief xcb_glx_context_tag_iterator_t **/ typedef struct xcb_glx_context_tag_iterator_t { - xcb_glx_context_tag_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_glx_context_tag_t *data; + int rem; + int index; } xcb_glx_context_tag_iterator_t; /** Opcode for xcb_glx_generic. */ @@ -141,13 +141,13 @@ typedef struct xcb_glx_context_tag_iterator_t { * @brief xcb_glx_generic_error_t **/ typedef struct xcb_glx_generic_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ - uint32_t bad_value; /**< */ - uint16_t minor_opcode; /**< */ - uint8_t major_opcode; /**< */ - uint8_t pad0[21]; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; + uint32_t bad_value; + uint16_t minor_opcode; + uint8_t major_opcode; + uint8_t pad0[21]; } xcb_glx_generic_error_t; /** Opcode for xcb_glx_bad_context. */ @@ -227,20 +227,20 @@ typedef xcb_glx_generic_error_t xcb_glx_glx_bad_profile_arb_error_t; * @brief xcb_glx_pbuffer_clobber_event_t **/ typedef struct xcb_glx_pbuffer_clobber_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint16_t event_type; /**< */ - uint16_t draw_type; /**< */ - xcb_glx_drawable_t drawable; /**< */ - uint32_t b_mask; /**< */ - uint16_t aux_buffer; /**< */ - uint16_t x; /**< */ - uint16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t count; /**< */ - uint8_t pad1[4]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint16_t event_type; + uint16_t draw_type; + xcb_glx_drawable_t drawable; + uint32_t b_mask; + uint16_t aux_buffer; + uint16_t x; + uint16_t y; + uint16_t width; + uint16_t height; + uint16_t count; + uint8_t pad1[4]; } xcb_glx_pbuffer_clobber_event_t; /** Opcode for xcb_glx_buffer_swap_complete. */ @@ -250,17 +250,17 @@ typedef struct xcb_glx_pbuffer_clobber_event_t { * @brief xcb_glx_buffer_swap_complete_event_t **/ typedef struct xcb_glx_buffer_swap_complete_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint16_t event_type; /**< */ - uint8_t pad1[2]; /**< */ - xcb_glx_drawable_t drawable; /**< */ - uint32_t ust_hi; /**< */ - uint32_t ust_lo; /**< */ - uint32_t msc_hi; /**< */ - uint32_t msc_lo; /**< */ - uint32_t sbc; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint16_t event_type; + uint8_t pad1[2]; + xcb_glx_drawable_t drawable; + uint32_t ust_hi; + uint32_t ust_lo; + uint32_t msc_hi; + uint32_t msc_lo; + uint32_t sbc; } xcb_glx_buffer_swap_complete_event_t; typedef enum xcb_glx_pbcet_t { @@ -280,10 +280,10 @@ typedef enum xcb_glx_pbcdt_t { * @brief xcb_glx_render_request_t **/ typedef struct xcb_glx_render_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; } xcb_glx_render_request_t; /** Opcode for xcb_glx_render_large. */ @@ -293,13 +293,13 @@ typedef struct xcb_glx_render_request_t { * @brief xcb_glx_render_large_request_t **/ typedef struct xcb_glx_render_large_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint16_t request_num; /**< */ - uint16_t request_total; /**< */ - uint32_t data_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint16_t request_num; + uint16_t request_total; + uint32_t data_len; } xcb_glx_render_large_request_t; /** Opcode for xcb_glx_create_context. */ @@ -309,15 +309,15 @@ typedef struct xcb_glx_render_large_request_t { * @brief xcb_glx_create_context_request_t **/ typedef struct xcb_glx_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_t context; /**< */ - xcb_visualid_t visual; /**< */ - uint32_t screen; /**< */ - xcb_glx_context_t share_list; /**< */ - uint8_t is_direct; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_t context; + xcb_visualid_t visual; + uint32_t screen; + xcb_glx_context_t share_list; + uint8_t is_direct; + uint8_t pad0[3]; } xcb_glx_create_context_request_t; /** Opcode for xcb_glx_destroy_context. */ @@ -327,17 +327,17 @@ typedef struct xcb_glx_create_context_request_t { * @brief xcb_glx_destroy_context_request_t **/ typedef struct xcb_glx_destroy_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_t context; } xcb_glx_destroy_context_request_t; /** * @brief xcb_glx_make_current_cookie_t **/ typedef struct xcb_glx_make_current_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_make_current_cookie_t; /** Opcode for xcb_glx_make_current. */ @@ -347,31 +347,31 @@ typedef struct xcb_glx_make_current_cookie_t { * @brief xcb_glx_make_current_request_t **/ typedef struct xcb_glx_make_current_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_drawable_t drawable; /**< */ - xcb_glx_context_t context; /**< */ - xcb_glx_context_tag_t old_context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_drawable_t drawable; + xcb_glx_context_t context; + xcb_glx_context_tag_t old_context_tag; } xcb_glx_make_current_request_t; /** * @brief xcb_glx_make_current_reply_t **/ typedef struct xcb_glx_make_current_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_glx_context_tag_t context_tag; + uint8_t pad1[20]; } xcb_glx_make_current_reply_t; /** * @brief xcb_glx_is_direct_cookie_t **/ typedef struct xcb_glx_is_direct_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_is_direct_cookie_t; /** Opcode for xcb_glx_is_direct. */ @@ -381,29 +381,29 @@ typedef struct xcb_glx_is_direct_cookie_t { * @brief xcb_glx_is_direct_request_t **/ typedef struct xcb_glx_is_direct_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_t context; } xcb_glx_is_direct_request_t; /** * @brief xcb_glx_is_direct_reply_t **/ typedef struct xcb_glx_is_direct_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t is_direct; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t is_direct; + uint8_t pad1[23]; } xcb_glx_is_direct_reply_t; /** * @brief xcb_glx_query_version_cookie_t **/ typedef struct xcb_glx_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_query_version_cookie_t; /** Opcode for xcb_glx_query_version. */ @@ -413,24 +413,24 @@ typedef struct xcb_glx_query_version_cookie_t { * @brief xcb_glx_query_version_request_t **/ typedef struct xcb_glx_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t major_version; + uint32_t minor_version; } xcb_glx_query_version_request_t; /** * @brief xcb_glx_query_version_reply_t **/ typedef struct xcb_glx_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t major_version; + uint32_t minor_version; + uint8_t pad1[16]; } xcb_glx_query_version_reply_t; /** Opcode for xcb_glx_wait_gl. */ @@ -440,10 +440,10 @@ typedef struct xcb_glx_query_version_reply_t { * @brief xcb_glx_wait_gl_request_t **/ typedef struct xcb_glx_wait_gl_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; } xcb_glx_wait_gl_request_t; /** Opcode for xcb_glx_wait_x. */ @@ -453,10 +453,10 @@ typedef struct xcb_glx_wait_gl_request_t { * @brief xcb_glx_wait_x_request_t **/ typedef struct xcb_glx_wait_x_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; } xcb_glx_wait_x_request_t; /** Opcode for xcb_glx_copy_context. */ @@ -466,13 +466,13 @@ typedef struct xcb_glx_wait_x_request_t { * @brief xcb_glx_copy_context_request_t **/ typedef struct xcb_glx_copy_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_t src; /**< */ - xcb_glx_context_t dest; /**< */ - uint32_t mask; /**< */ - xcb_glx_context_tag_t src_context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_t src; + xcb_glx_context_t dest; + uint32_t mask; + xcb_glx_context_tag_t src_context_tag; } xcb_glx_copy_context_request_t; typedef enum xcb_glx_gc_t { @@ -506,11 +506,11 @@ typedef enum xcb_glx_gc_t { * @brief xcb_glx_swap_buffers_request_t **/ typedef struct xcb_glx_swap_buffers_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - xcb_glx_drawable_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + xcb_glx_drawable_t drawable; } xcb_glx_swap_buffers_request_t; /** Opcode for xcb_glx_use_x_font. */ @@ -520,14 +520,14 @@ typedef struct xcb_glx_swap_buffers_request_t { * @brief xcb_glx_use_x_font_request_t **/ typedef struct xcb_glx_use_x_font_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - xcb_font_t font; /**< */ - uint32_t first; /**< */ - uint32_t count; /**< */ - uint32_t list_base; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + xcb_font_t font; + uint32_t first; + uint32_t count; + uint32_t list_base; } xcb_glx_use_x_font_request_t; /** Opcode for xcb_glx_create_glx_pixmap. */ @@ -537,20 +537,20 @@ typedef struct xcb_glx_use_x_font_request_t { * @brief xcb_glx_create_glx_pixmap_request_t **/ typedef struct xcb_glx_create_glx_pixmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - xcb_visualid_t visual; /**< */ - xcb_pixmap_t pixmap; /**< */ - xcb_glx_pixmap_t glx_pixmap; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + xcb_visualid_t visual; + xcb_pixmap_t pixmap; + xcb_glx_pixmap_t glx_pixmap; } xcb_glx_create_glx_pixmap_request_t; /** * @brief xcb_glx_get_visual_configs_cookie_t **/ typedef struct xcb_glx_get_visual_configs_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_visual_configs_cookie_t; /** Opcode for xcb_glx_get_visual_configs. */ @@ -560,23 +560,23 @@ typedef struct xcb_glx_get_visual_configs_cookie_t { * @brief xcb_glx_get_visual_configs_request_t **/ typedef struct xcb_glx_get_visual_configs_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; } xcb_glx_get_visual_configs_request_t; /** * @brief xcb_glx_get_visual_configs_reply_t **/ typedef struct xcb_glx_get_visual_configs_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_visuals; /**< */ - uint32_t num_properties; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_visuals; + uint32_t num_properties; + uint8_t pad1[16]; } xcb_glx_get_visual_configs_reply_t; /** Opcode for xcb_glx_destroy_glx_pixmap. */ @@ -586,10 +586,10 @@ typedef struct xcb_glx_get_visual_configs_reply_t { * @brief xcb_glx_destroy_glx_pixmap_request_t **/ typedef struct xcb_glx_destroy_glx_pixmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_pixmap_t glx_pixmap; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_pixmap_t glx_pixmap; } xcb_glx_destroy_glx_pixmap_request_t; /** Opcode for xcb_glx_vendor_private. */ @@ -599,18 +599,18 @@ typedef struct xcb_glx_destroy_glx_pixmap_request_t { * @brief xcb_glx_vendor_private_request_t **/ typedef struct xcb_glx_vendor_private_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t vendor_code; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t vendor_code; + xcb_glx_context_tag_t context_tag; } xcb_glx_vendor_private_request_t; /** * @brief xcb_glx_vendor_private_with_reply_cookie_t **/ typedef struct xcb_glx_vendor_private_with_reply_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_vendor_private_with_reply_cookie_t; /** Opcode for xcb_glx_vendor_private_with_reply. */ @@ -620,30 +620,30 @@ typedef struct xcb_glx_vendor_private_with_reply_cookie_t { * @brief xcb_glx_vendor_private_with_reply_request_t **/ typedef struct xcb_glx_vendor_private_with_reply_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t vendor_code; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t vendor_code; + xcb_glx_context_tag_t context_tag; } xcb_glx_vendor_private_with_reply_request_t; /** * @brief xcb_glx_vendor_private_with_reply_reply_t **/ typedef struct xcb_glx_vendor_private_with_reply_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t retval; /**< */ - uint8_t data1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t retval; + uint8_t data1[24]; } xcb_glx_vendor_private_with_reply_reply_t; /** * @brief xcb_glx_query_extensions_string_cookie_t **/ typedef struct xcb_glx_query_extensions_string_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_query_extensions_string_cookie_t; /** Opcode for xcb_glx_query_extensions_string. */ @@ -653,30 +653,30 @@ typedef struct xcb_glx_query_extensions_string_cookie_t { * @brief xcb_glx_query_extensions_string_request_t **/ typedef struct xcb_glx_query_extensions_string_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; } xcb_glx_query_extensions_string_request_t; /** * @brief xcb_glx_query_extensions_string_reply_t **/ typedef struct xcb_glx_query_extensions_string_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - uint8_t pad2[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + uint8_t pad2[16]; } xcb_glx_query_extensions_string_reply_t; /** * @brief xcb_glx_query_server_string_cookie_t **/ typedef struct xcb_glx_query_server_string_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_query_server_string_cookie_t; /** Opcode for xcb_glx_query_server_string. */ @@ -686,24 +686,24 @@ typedef struct xcb_glx_query_server_string_cookie_t { * @brief xcb_glx_query_server_string_request_t **/ typedef struct xcb_glx_query_server_string_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - uint32_t name; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + uint32_t name; } xcb_glx_query_server_string_request_t; /** * @brief xcb_glx_query_server_string_reply_t **/ typedef struct xcb_glx_query_server_string_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t str_len; /**< */ - uint8_t pad2[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t str_len; + uint8_t pad2[16]; } xcb_glx_query_server_string_reply_t; /** Opcode for xcb_glx_client_info. */ @@ -713,19 +713,19 @@ typedef struct xcb_glx_query_server_string_reply_t { * @brief xcb_glx_client_info_request_t **/ typedef struct xcb_glx_client_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ - uint32_t str_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t major_version; + uint32_t minor_version; + uint32_t str_len; } xcb_glx_client_info_request_t; /** * @brief xcb_glx_get_fb_configs_cookie_t **/ typedef struct xcb_glx_get_fb_configs_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_fb_configs_cookie_t; /** Opcode for xcb_glx_get_fb_configs. */ @@ -735,23 +735,23 @@ typedef struct xcb_glx_get_fb_configs_cookie_t { * @brief xcb_glx_get_fb_configs_request_t **/ typedef struct xcb_glx_get_fb_configs_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; } xcb_glx_get_fb_configs_request_t; /** * @brief xcb_glx_get_fb_configs_reply_t **/ typedef struct xcb_glx_get_fb_configs_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_FB_configs; /**< */ - uint32_t num_properties; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_FB_configs; + uint32_t num_properties; + uint8_t pad1[16]; } xcb_glx_get_fb_configs_reply_t; /** Opcode for xcb_glx_create_pixmap. */ @@ -761,14 +761,14 @@ typedef struct xcb_glx_get_fb_configs_reply_t { * @brief xcb_glx_create_pixmap_request_t **/ typedef struct xcb_glx_create_pixmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - xcb_glx_fbconfig_t fbconfig; /**< */ - xcb_pixmap_t pixmap; /**< */ - xcb_glx_pixmap_t glx_pixmap; /**< */ - uint32_t num_attribs; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + xcb_glx_fbconfig_t fbconfig; + xcb_pixmap_t pixmap; + xcb_glx_pixmap_t glx_pixmap; + uint32_t num_attribs; } xcb_glx_create_pixmap_request_t; /** Opcode for xcb_glx_destroy_pixmap. */ @@ -778,10 +778,10 @@ typedef struct xcb_glx_create_pixmap_request_t { * @brief xcb_glx_destroy_pixmap_request_t **/ typedef struct xcb_glx_destroy_pixmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_pixmap_t glx_pixmap; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_pixmap_t glx_pixmap; } xcb_glx_destroy_pixmap_request_t; /** Opcode for xcb_glx_create_new_context. */ @@ -791,23 +791,23 @@ typedef struct xcb_glx_destroy_pixmap_request_t { * @brief xcb_glx_create_new_context_request_t **/ typedef struct xcb_glx_create_new_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_t context; /**< */ - xcb_glx_fbconfig_t fbconfig; /**< */ - uint32_t screen; /**< */ - uint32_t render_type; /**< */ - xcb_glx_context_t share_list; /**< */ - uint8_t is_direct; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_t context; + xcb_glx_fbconfig_t fbconfig; + uint32_t screen; + uint32_t render_type; + xcb_glx_context_t share_list; + uint8_t is_direct; + uint8_t pad0[3]; } xcb_glx_create_new_context_request_t; /** * @brief xcb_glx_query_context_cookie_t **/ typedef struct xcb_glx_query_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_query_context_cookie_t; /** Opcode for xcb_glx_query_context. */ @@ -817,29 +817,29 @@ typedef struct xcb_glx_query_context_cookie_t { * @brief xcb_glx_query_context_request_t **/ typedef struct xcb_glx_query_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_t context; } xcb_glx_query_context_request_t; /** * @brief xcb_glx_query_context_reply_t **/ typedef struct xcb_glx_query_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_attribs; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_attribs; + uint8_t pad1[20]; } xcb_glx_query_context_reply_t; /** * @brief xcb_glx_make_context_current_cookie_t **/ typedef struct xcb_glx_make_context_current_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_make_context_current_cookie_t; /** Opcode for xcb_glx_make_context_current. */ @@ -849,25 +849,25 @@ typedef struct xcb_glx_make_context_current_cookie_t { * @brief xcb_glx_make_context_current_request_t **/ typedef struct xcb_glx_make_context_current_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t old_context_tag; /**< */ - xcb_glx_drawable_t drawable; /**< */ - xcb_glx_drawable_t read_drawable; /**< */ - xcb_glx_context_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t old_context_tag; + xcb_glx_drawable_t drawable; + xcb_glx_drawable_t read_drawable; + xcb_glx_context_t context; } xcb_glx_make_context_current_request_t; /** * @brief xcb_glx_make_context_current_reply_t **/ typedef struct xcb_glx_make_context_current_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_glx_context_tag_t context_tag; + uint8_t pad1[20]; } xcb_glx_make_context_current_reply_t; /** Opcode for xcb_glx_create_pbuffer. */ @@ -877,13 +877,13 @@ typedef struct xcb_glx_make_context_current_reply_t { * @brief xcb_glx_create_pbuffer_request_t **/ typedef struct xcb_glx_create_pbuffer_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - xcb_glx_fbconfig_t fbconfig; /**< */ - xcb_glx_pbuffer_t pbuffer; /**< */ - uint32_t num_attribs; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + xcb_glx_fbconfig_t fbconfig; + xcb_glx_pbuffer_t pbuffer; + uint32_t num_attribs; } xcb_glx_create_pbuffer_request_t; /** Opcode for xcb_glx_destroy_pbuffer. */ @@ -893,17 +893,17 @@ typedef struct xcb_glx_create_pbuffer_request_t { * @brief xcb_glx_destroy_pbuffer_request_t **/ typedef struct xcb_glx_destroy_pbuffer_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_pbuffer_t pbuffer; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_pbuffer_t pbuffer; } xcb_glx_destroy_pbuffer_request_t; /** * @brief xcb_glx_get_drawable_attributes_cookie_t **/ typedef struct xcb_glx_get_drawable_attributes_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_drawable_attributes_cookie_t; /** Opcode for xcb_glx_get_drawable_attributes. */ @@ -913,22 +913,22 @@ typedef struct xcb_glx_get_drawable_attributes_cookie_t { * @brief xcb_glx_get_drawable_attributes_request_t **/ typedef struct xcb_glx_get_drawable_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_drawable_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_drawable_t drawable; } xcb_glx_get_drawable_attributes_request_t; /** * @brief xcb_glx_get_drawable_attributes_reply_t **/ typedef struct xcb_glx_get_drawable_attributes_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_attribs; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_attribs; + uint8_t pad1[20]; } xcb_glx_get_drawable_attributes_reply_t; /** Opcode for xcb_glx_change_drawable_attributes. */ @@ -938,11 +938,11 @@ typedef struct xcb_glx_get_drawable_attributes_reply_t { * @brief xcb_glx_change_drawable_attributes_request_t **/ typedef struct xcb_glx_change_drawable_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_drawable_t drawable; /**< */ - uint32_t num_attribs; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_drawable_t drawable; + uint32_t num_attribs; } xcb_glx_change_drawable_attributes_request_t; /** Opcode for xcb_glx_create_window. */ @@ -952,14 +952,14 @@ typedef struct xcb_glx_change_drawable_attributes_request_t { * @brief xcb_glx_create_window_request_t **/ typedef struct xcb_glx_create_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - xcb_glx_fbconfig_t fbconfig; /**< */ - xcb_window_t window; /**< */ - xcb_glx_window_t glx_window; /**< */ - uint32_t num_attribs; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + xcb_glx_fbconfig_t fbconfig; + xcb_window_t window; + xcb_glx_window_t glx_window; + uint32_t num_attribs; } xcb_glx_create_window_request_t; /** Opcode for xcb_glx_delete_window. */ @@ -969,10 +969,10 @@ typedef struct xcb_glx_create_window_request_t { * @brief xcb_glx_delete_window_request_t **/ typedef struct xcb_glx_delete_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_window_t glxwindow; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_window_t glxwindow; } xcb_glx_delete_window_request_t; /** Opcode for xcb_glx_set_client_info_arb. */ @@ -982,14 +982,14 @@ typedef struct xcb_glx_delete_window_request_t { * @brief xcb_glx_set_client_info_arb_request_t **/ typedef struct xcb_glx_set_client_info_arb_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ - uint32_t num_versions; /**< */ - uint32_t gl_str_len; /**< */ - uint32_t glx_str_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t major_version; + uint32_t minor_version; + uint32_t num_versions; + uint32_t gl_str_len; + uint32_t glx_str_len; } xcb_glx_set_client_info_arb_request_t; /** Opcode for xcb_glx_create_context_attribs_arb. */ @@ -999,16 +999,16 @@ typedef struct xcb_glx_set_client_info_arb_request_t { * @brief xcb_glx_create_context_attribs_arb_request_t **/ typedef struct xcb_glx_create_context_attribs_arb_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_t context; /**< */ - xcb_glx_fbconfig_t fbconfig; /**< */ - uint32_t screen; /**< */ - xcb_glx_context_t share_list; /**< */ - uint8_t is_direct; /**< */ - uint8_t pad0[3]; /**< */ - uint32_t num_attribs; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_t context; + xcb_glx_fbconfig_t fbconfig; + uint32_t screen; + xcb_glx_context_t share_list; + uint8_t is_direct; + uint8_t pad0[3]; + uint32_t num_attribs; } xcb_glx_create_context_attribs_arb_request_t; /** Opcode for xcb_glx_set_client_info_2arb. */ @@ -1018,14 +1018,14 @@ typedef struct xcb_glx_create_context_attribs_arb_request_t { * @brief xcb_glx_set_client_info_2arb_request_t **/ typedef struct xcb_glx_set_client_info_2arb_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ - uint32_t num_versions; /**< */ - uint32_t gl_str_len; /**< */ - uint32_t glx_str_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t major_version; + uint32_t minor_version; + uint32_t num_versions; + uint32_t gl_str_len; + uint32_t glx_str_len; } xcb_glx_set_client_info_2arb_request_t; /** Opcode for xcb_glx_new_list. */ @@ -1035,12 +1035,12 @@ typedef struct xcb_glx_set_client_info_2arb_request_t { * @brief xcb_glx_new_list_request_t **/ typedef struct xcb_glx_new_list_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t list; /**< */ - uint32_t mode; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t list; + uint32_t mode; } xcb_glx_new_list_request_t; /** Opcode for xcb_glx_end_list. */ @@ -1050,10 +1050,10 @@ typedef struct xcb_glx_new_list_request_t { * @brief xcb_glx_end_list_request_t **/ typedef struct xcb_glx_end_list_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; } xcb_glx_end_list_request_t; /** Opcode for xcb_glx_delete_lists. */ @@ -1063,19 +1063,19 @@ typedef struct xcb_glx_end_list_request_t { * @brief xcb_glx_delete_lists_request_t **/ typedef struct xcb_glx_delete_lists_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t list; /**< */ - int32_t range; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t list; + int32_t range; } xcb_glx_delete_lists_request_t; /** * @brief xcb_glx_gen_lists_cookie_t **/ typedef struct xcb_glx_gen_lists_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_gen_lists_cookie_t; /** Opcode for xcb_glx_gen_lists. */ @@ -1085,22 +1085,22 @@ typedef struct xcb_glx_gen_lists_cookie_t { * @brief xcb_glx_gen_lists_request_t **/ typedef struct xcb_glx_gen_lists_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t range; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t range; } xcb_glx_gen_lists_request_t; /** * @brief xcb_glx_gen_lists_reply_t **/ typedef struct xcb_glx_gen_lists_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t ret_val; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t ret_val; } xcb_glx_gen_lists_reply_t; /** Opcode for xcb_glx_feedback_buffer. */ @@ -1110,12 +1110,12 @@ typedef struct xcb_glx_gen_lists_reply_t { * @brief xcb_glx_feedback_buffer_request_t **/ typedef struct xcb_glx_feedback_buffer_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t size; /**< */ - int32_t type; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t size; + int32_t type; } xcb_glx_feedback_buffer_request_t; /** Opcode for xcb_glx_select_buffer. */ @@ -1125,18 +1125,18 @@ typedef struct xcb_glx_feedback_buffer_request_t { * @brief xcb_glx_select_buffer_request_t **/ typedef struct xcb_glx_select_buffer_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t size; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t size; } xcb_glx_select_buffer_request_t; /** * @brief xcb_glx_render_mode_cookie_t **/ typedef struct xcb_glx_render_mode_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_render_mode_cookie_t; /** Opcode for xcb_glx_render_mode. */ @@ -1146,25 +1146,25 @@ typedef struct xcb_glx_render_mode_cookie_t { * @brief xcb_glx_render_mode_request_t **/ typedef struct xcb_glx_render_mode_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t mode; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t mode; } xcb_glx_render_mode_request_t; /** * @brief xcb_glx_render_mode_reply_t **/ typedef struct xcb_glx_render_mode_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t ret_val; /**< */ - uint32_t n; /**< */ - uint32_t new_mode; /**< */ - uint8_t pad1[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t ret_val; + uint32_t n; + uint32_t new_mode; + uint8_t pad1[12]; } xcb_glx_render_mode_reply_t; typedef enum xcb_glx_rm_t { @@ -1177,7 +1177,7 @@ typedef enum xcb_glx_rm_t { * @brief xcb_glx_finish_cookie_t **/ typedef struct xcb_glx_finish_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_finish_cookie_t; /** Opcode for xcb_glx_finish. */ @@ -1187,20 +1187,20 @@ typedef struct xcb_glx_finish_cookie_t { * @brief xcb_glx_finish_request_t **/ typedef struct xcb_glx_finish_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; } xcb_glx_finish_request_t; /** * @brief xcb_glx_finish_reply_t **/ typedef struct xcb_glx_finish_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; } xcb_glx_finish_reply_t; /** Opcode for xcb_glx_pixel_storef. */ @@ -1210,12 +1210,12 @@ typedef struct xcb_glx_finish_reply_t { * @brief xcb_glx_pixel_storef_request_t **/ typedef struct xcb_glx_pixel_storef_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t pname; /**< */ - xcb_glx_float32_t datum; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t pname; + xcb_glx_float32_t datum; } xcb_glx_pixel_storef_request_t; /** Opcode for xcb_glx_pixel_storei. */ @@ -1225,19 +1225,19 @@ typedef struct xcb_glx_pixel_storef_request_t { * @brief xcb_glx_pixel_storei_request_t **/ typedef struct xcb_glx_pixel_storei_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t pname; /**< */ - int32_t datum; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t pname; + int32_t datum; } xcb_glx_pixel_storei_request_t; /** * @brief xcb_glx_read_pixels_cookie_t **/ typedef struct xcb_glx_read_pixels_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_read_pixels_cookie_t; /** Opcode for xcb_glx_read_pixels. */ @@ -1247,36 +1247,36 @@ typedef struct xcb_glx_read_pixels_cookie_t { * @brief xcb_glx_read_pixels_request_t **/ typedef struct xcb_glx_read_pixels_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t x; /**< */ - int32_t y; /**< */ - int32_t width; /**< */ - int32_t height; /**< */ - uint32_t format; /**< */ - uint32_t type; /**< */ - uint8_t swap_bytes; /**< */ - uint8_t lsb_first; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t x; + int32_t y; + int32_t width; + int32_t height; + uint32_t format; + uint32_t type; + uint8_t swap_bytes; + uint8_t lsb_first; } xcb_glx_read_pixels_request_t; /** * @brief xcb_glx_read_pixels_reply_t **/ typedef struct xcb_glx_read_pixels_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_glx_read_pixels_reply_t; /** * @brief xcb_glx_get_booleanv_cookie_t **/ typedef struct xcb_glx_get_booleanv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_booleanv_cookie_t; /** Opcode for xcb_glx_get_booleanv. */ @@ -1286,32 +1286,32 @@ typedef struct xcb_glx_get_booleanv_cookie_t { * @brief xcb_glx_get_booleanv_request_t **/ typedef struct xcb_glx_get_booleanv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t pname; } xcb_glx_get_booleanv_request_t; /** * @brief xcb_glx_get_booleanv_reply_t **/ typedef struct xcb_glx_get_booleanv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - uint8_t datum; /**< */ - uint8_t pad2[15]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + uint8_t datum; + uint8_t pad2[15]; } xcb_glx_get_booleanv_reply_t; /** * @brief xcb_glx_get_clip_plane_cookie_t **/ typedef struct xcb_glx_get_clip_plane_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_clip_plane_cookie_t; /** Opcode for xcb_glx_get_clip_plane. */ @@ -1321,29 +1321,29 @@ typedef struct xcb_glx_get_clip_plane_cookie_t { * @brief xcb_glx_get_clip_plane_request_t **/ typedef struct xcb_glx_get_clip_plane_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t plane; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t plane; } xcb_glx_get_clip_plane_request_t; /** * @brief xcb_glx_get_clip_plane_reply_t **/ typedef struct xcb_glx_get_clip_plane_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_glx_get_clip_plane_reply_t; /** * @brief xcb_glx_get_doublev_cookie_t **/ typedef struct xcb_glx_get_doublev_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_doublev_cookie_t; /** Opcode for xcb_glx_get_doublev. */ @@ -1353,32 +1353,32 @@ typedef struct xcb_glx_get_doublev_cookie_t { * @brief xcb_glx_get_doublev_request_t **/ typedef struct xcb_glx_get_doublev_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t pname; } xcb_glx_get_doublev_request_t; /** * @brief xcb_glx_get_doublev_reply_t **/ typedef struct xcb_glx_get_doublev_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float64_t datum; /**< */ - uint8_t pad2[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float64_t datum; + uint8_t pad2[8]; } xcb_glx_get_doublev_reply_t; /** * @brief xcb_glx_get_error_cookie_t **/ typedef struct xcb_glx_get_error_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_error_cookie_t; /** Opcode for xcb_glx_get_error. */ @@ -1388,28 +1388,28 @@ typedef struct xcb_glx_get_error_cookie_t { * @brief xcb_glx_get_error_request_t **/ typedef struct xcb_glx_get_error_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; } xcb_glx_get_error_request_t; /** * @brief xcb_glx_get_error_reply_t **/ typedef struct xcb_glx_get_error_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - int32_t error; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + int32_t error; } xcb_glx_get_error_reply_t; /** * @brief xcb_glx_get_floatv_cookie_t **/ typedef struct xcb_glx_get_floatv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_floatv_cookie_t; /** Opcode for xcb_glx_get_floatv. */ @@ -1419,32 +1419,32 @@ typedef struct xcb_glx_get_floatv_cookie_t { * @brief xcb_glx_get_floatv_request_t **/ typedef struct xcb_glx_get_floatv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t pname; } xcb_glx_get_floatv_request_t; /** * @brief xcb_glx_get_floatv_reply_t **/ typedef struct xcb_glx_get_floatv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_floatv_reply_t; /** * @brief xcb_glx_get_integerv_cookie_t **/ typedef struct xcb_glx_get_integerv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_integerv_cookie_t; /** Opcode for xcb_glx_get_integerv. */ @@ -1454,32 +1454,32 @@ typedef struct xcb_glx_get_integerv_cookie_t { * @brief xcb_glx_get_integerv_request_t **/ typedef struct xcb_glx_get_integerv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t pname; } xcb_glx_get_integerv_request_t; /** * @brief xcb_glx_get_integerv_reply_t **/ typedef struct xcb_glx_get_integerv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_integerv_reply_t; /** * @brief xcb_glx_get_lightfv_cookie_t **/ typedef struct xcb_glx_get_lightfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_lightfv_cookie_t; /** Opcode for xcb_glx_get_lightfv. */ @@ -1489,33 +1489,33 @@ typedef struct xcb_glx_get_lightfv_cookie_t { * @brief xcb_glx_get_lightfv_request_t **/ typedef struct xcb_glx_get_lightfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t light; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t light; + uint32_t pname; } xcb_glx_get_lightfv_request_t; /** * @brief xcb_glx_get_lightfv_reply_t **/ typedef struct xcb_glx_get_lightfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_lightfv_reply_t; /** * @brief xcb_glx_get_lightiv_cookie_t **/ typedef struct xcb_glx_get_lightiv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_lightiv_cookie_t; /** Opcode for xcb_glx_get_lightiv. */ @@ -1525,33 +1525,33 @@ typedef struct xcb_glx_get_lightiv_cookie_t { * @brief xcb_glx_get_lightiv_request_t **/ typedef struct xcb_glx_get_lightiv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t light; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t light; + uint32_t pname; } xcb_glx_get_lightiv_request_t; /** * @brief xcb_glx_get_lightiv_reply_t **/ typedef struct xcb_glx_get_lightiv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_lightiv_reply_t; /** * @brief xcb_glx_get_mapdv_cookie_t **/ typedef struct xcb_glx_get_mapdv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_mapdv_cookie_t; /** Opcode for xcb_glx_get_mapdv. */ @@ -1561,33 +1561,33 @@ typedef struct xcb_glx_get_mapdv_cookie_t { * @brief xcb_glx_get_mapdv_request_t **/ typedef struct xcb_glx_get_mapdv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t query; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t query; } xcb_glx_get_mapdv_request_t; /** * @brief xcb_glx_get_mapdv_reply_t **/ typedef struct xcb_glx_get_mapdv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float64_t datum; /**< */ - uint8_t pad2[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float64_t datum; + uint8_t pad2[8]; } xcb_glx_get_mapdv_reply_t; /** * @brief xcb_glx_get_mapfv_cookie_t **/ typedef struct xcb_glx_get_mapfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_mapfv_cookie_t; /** Opcode for xcb_glx_get_mapfv. */ @@ -1597,33 +1597,33 @@ typedef struct xcb_glx_get_mapfv_cookie_t { * @brief xcb_glx_get_mapfv_request_t **/ typedef struct xcb_glx_get_mapfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t query; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t query; } xcb_glx_get_mapfv_request_t; /** * @brief xcb_glx_get_mapfv_reply_t **/ typedef struct xcb_glx_get_mapfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_mapfv_reply_t; /** * @brief xcb_glx_get_mapiv_cookie_t **/ typedef struct xcb_glx_get_mapiv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_mapiv_cookie_t; /** Opcode for xcb_glx_get_mapiv. */ @@ -1633,33 +1633,33 @@ typedef struct xcb_glx_get_mapiv_cookie_t { * @brief xcb_glx_get_mapiv_request_t **/ typedef struct xcb_glx_get_mapiv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t query; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t query; } xcb_glx_get_mapiv_request_t; /** * @brief xcb_glx_get_mapiv_reply_t **/ typedef struct xcb_glx_get_mapiv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_mapiv_reply_t; /** * @brief xcb_glx_get_materialfv_cookie_t **/ typedef struct xcb_glx_get_materialfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_materialfv_cookie_t; /** Opcode for xcb_glx_get_materialfv. */ @@ -1669,33 +1669,33 @@ typedef struct xcb_glx_get_materialfv_cookie_t { * @brief xcb_glx_get_materialfv_request_t **/ typedef struct xcb_glx_get_materialfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t face; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t face; + uint32_t pname; } xcb_glx_get_materialfv_request_t; /** * @brief xcb_glx_get_materialfv_reply_t **/ typedef struct xcb_glx_get_materialfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_materialfv_reply_t; /** * @brief xcb_glx_get_materialiv_cookie_t **/ typedef struct xcb_glx_get_materialiv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_materialiv_cookie_t; /** Opcode for xcb_glx_get_materialiv. */ @@ -1705,33 +1705,33 @@ typedef struct xcb_glx_get_materialiv_cookie_t { * @brief xcb_glx_get_materialiv_request_t **/ typedef struct xcb_glx_get_materialiv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t face; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t face; + uint32_t pname; } xcb_glx_get_materialiv_request_t; /** * @brief xcb_glx_get_materialiv_reply_t **/ typedef struct xcb_glx_get_materialiv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_materialiv_reply_t; /** * @brief xcb_glx_get_pixel_mapfv_cookie_t **/ typedef struct xcb_glx_get_pixel_mapfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_pixel_mapfv_cookie_t; /** Opcode for xcb_glx_get_pixel_mapfv. */ @@ -1741,32 +1741,32 @@ typedef struct xcb_glx_get_pixel_mapfv_cookie_t { * @brief xcb_glx_get_pixel_mapfv_request_t **/ typedef struct xcb_glx_get_pixel_mapfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t map; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t map; } xcb_glx_get_pixel_mapfv_request_t; /** * @brief xcb_glx_get_pixel_mapfv_reply_t **/ typedef struct xcb_glx_get_pixel_mapfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_pixel_mapfv_reply_t; /** * @brief xcb_glx_get_pixel_mapuiv_cookie_t **/ typedef struct xcb_glx_get_pixel_mapuiv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_pixel_mapuiv_cookie_t; /** Opcode for xcb_glx_get_pixel_mapuiv. */ @@ -1776,32 +1776,32 @@ typedef struct xcb_glx_get_pixel_mapuiv_cookie_t { * @brief xcb_glx_get_pixel_mapuiv_request_t **/ typedef struct xcb_glx_get_pixel_mapuiv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t map; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t map; } xcb_glx_get_pixel_mapuiv_request_t; /** * @brief xcb_glx_get_pixel_mapuiv_reply_t **/ typedef struct xcb_glx_get_pixel_mapuiv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - uint32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + uint32_t datum; + uint8_t pad2[12]; } xcb_glx_get_pixel_mapuiv_reply_t; /** * @brief xcb_glx_get_pixel_mapusv_cookie_t **/ typedef struct xcb_glx_get_pixel_mapusv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_pixel_mapusv_cookie_t; /** Opcode for xcb_glx_get_pixel_mapusv. */ @@ -1811,32 +1811,32 @@ typedef struct xcb_glx_get_pixel_mapusv_cookie_t { * @brief xcb_glx_get_pixel_mapusv_request_t **/ typedef struct xcb_glx_get_pixel_mapusv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t map; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t map; } xcb_glx_get_pixel_mapusv_request_t; /** * @brief xcb_glx_get_pixel_mapusv_reply_t **/ typedef struct xcb_glx_get_pixel_mapusv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - uint16_t datum; /**< */ - uint8_t pad2[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + uint16_t datum; + uint8_t pad2[16]; } xcb_glx_get_pixel_mapusv_reply_t; /** * @brief xcb_glx_get_polygon_stipple_cookie_t **/ typedef struct xcb_glx_get_polygon_stipple_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_polygon_stipple_cookie_t; /** Opcode for xcb_glx_get_polygon_stipple. */ @@ -1846,29 +1846,29 @@ typedef struct xcb_glx_get_polygon_stipple_cookie_t { * @brief xcb_glx_get_polygon_stipple_request_t **/ typedef struct xcb_glx_get_polygon_stipple_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint8_t lsb_first; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint8_t lsb_first; } xcb_glx_get_polygon_stipple_request_t; /** * @brief xcb_glx_get_polygon_stipple_reply_t **/ typedef struct xcb_glx_get_polygon_stipple_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_glx_get_polygon_stipple_reply_t; /** * @brief xcb_glx_get_string_cookie_t **/ typedef struct xcb_glx_get_string_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_string_cookie_t; /** Opcode for xcb_glx_get_string. */ @@ -1878,31 +1878,31 @@ typedef struct xcb_glx_get_string_cookie_t { * @brief xcb_glx_get_string_request_t **/ typedef struct xcb_glx_get_string_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t name; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t name; } xcb_glx_get_string_request_t; /** * @brief xcb_glx_get_string_reply_t **/ typedef struct xcb_glx_get_string_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - uint8_t pad2[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + uint8_t pad2[16]; } xcb_glx_get_string_reply_t; /** * @brief xcb_glx_get_tex_envfv_cookie_t **/ typedef struct xcb_glx_get_tex_envfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_tex_envfv_cookie_t; /** Opcode for xcb_glx_get_tex_envfv. */ @@ -1912,33 +1912,33 @@ typedef struct xcb_glx_get_tex_envfv_cookie_t { * @brief xcb_glx_get_tex_envfv_request_t **/ typedef struct xcb_glx_get_tex_envfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_tex_envfv_request_t; /** * @brief xcb_glx_get_tex_envfv_reply_t **/ typedef struct xcb_glx_get_tex_envfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_tex_envfv_reply_t; /** * @brief xcb_glx_get_tex_enviv_cookie_t **/ typedef struct xcb_glx_get_tex_enviv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_tex_enviv_cookie_t; /** Opcode for xcb_glx_get_tex_enviv. */ @@ -1948,33 +1948,33 @@ typedef struct xcb_glx_get_tex_enviv_cookie_t { * @brief xcb_glx_get_tex_enviv_request_t **/ typedef struct xcb_glx_get_tex_enviv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_tex_enviv_request_t; /** * @brief xcb_glx_get_tex_enviv_reply_t **/ typedef struct xcb_glx_get_tex_enviv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_tex_enviv_reply_t; /** * @brief xcb_glx_get_tex_gendv_cookie_t **/ typedef struct xcb_glx_get_tex_gendv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_tex_gendv_cookie_t; /** Opcode for xcb_glx_get_tex_gendv. */ @@ -1984,33 +1984,33 @@ typedef struct xcb_glx_get_tex_gendv_cookie_t { * @brief xcb_glx_get_tex_gendv_request_t **/ typedef struct xcb_glx_get_tex_gendv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t coord; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t coord; + uint32_t pname; } xcb_glx_get_tex_gendv_request_t; /** * @brief xcb_glx_get_tex_gendv_reply_t **/ typedef struct xcb_glx_get_tex_gendv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float64_t datum; /**< */ - uint8_t pad2[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float64_t datum; + uint8_t pad2[8]; } xcb_glx_get_tex_gendv_reply_t; /** * @brief xcb_glx_get_tex_genfv_cookie_t **/ typedef struct xcb_glx_get_tex_genfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_tex_genfv_cookie_t; /** Opcode for xcb_glx_get_tex_genfv. */ @@ -2020,33 +2020,33 @@ typedef struct xcb_glx_get_tex_genfv_cookie_t { * @brief xcb_glx_get_tex_genfv_request_t **/ typedef struct xcb_glx_get_tex_genfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t coord; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t coord; + uint32_t pname; } xcb_glx_get_tex_genfv_request_t; /** * @brief xcb_glx_get_tex_genfv_reply_t **/ typedef struct xcb_glx_get_tex_genfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_tex_genfv_reply_t; /** * @brief xcb_glx_get_tex_geniv_cookie_t **/ typedef struct xcb_glx_get_tex_geniv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_tex_geniv_cookie_t; /** Opcode for xcb_glx_get_tex_geniv. */ @@ -2056,33 +2056,33 @@ typedef struct xcb_glx_get_tex_geniv_cookie_t { * @brief xcb_glx_get_tex_geniv_request_t **/ typedef struct xcb_glx_get_tex_geniv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t coord; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t coord; + uint32_t pname; } xcb_glx_get_tex_geniv_request_t; /** * @brief xcb_glx_get_tex_geniv_reply_t **/ typedef struct xcb_glx_get_tex_geniv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_tex_geniv_reply_t; /** * @brief xcb_glx_get_tex_image_cookie_t **/ typedef struct xcb_glx_get_tex_image_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_tex_image_cookie_t; /** Opcode for xcb_glx_get_tex_image. */ @@ -2092,37 +2092,37 @@ typedef struct xcb_glx_get_tex_image_cookie_t { * @brief xcb_glx_get_tex_image_request_t **/ typedef struct xcb_glx_get_tex_image_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - int32_t level; /**< */ - uint32_t format; /**< */ - uint32_t type; /**< */ - uint8_t swap_bytes; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + int32_t level; + uint32_t format; + uint32_t type; + uint8_t swap_bytes; } xcb_glx_get_tex_image_request_t; /** * @brief xcb_glx_get_tex_image_reply_t **/ typedef struct xcb_glx_get_tex_image_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[8]; /**< */ - int32_t width; /**< */ - int32_t height; /**< */ - int32_t depth; /**< */ - uint8_t pad2[4]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[8]; + int32_t width; + int32_t height; + int32_t depth; + uint8_t pad2[4]; } xcb_glx_get_tex_image_reply_t; /** * @brief xcb_glx_get_tex_parameterfv_cookie_t **/ typedef struct xcb_glx_get_tex_parameterfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_tex_parameterfv_cookie_t; /** Opcode for xcb_glx_get_tex_parameterfv. */ @@ -2132,33 +2132,33 @@ typedef struct xcb_glx_get_tex_parameterfv_cookie_t { * @brief xcb_glx_get_tex_parameterfv_request_t **/ typedef struct xcb_glx_get_tex_parameterfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_tex_parameterfv_request_t; /** * @brief xcb_glx_get_tex_parameterfv_reply_t **/ typedef struct xcb_glx_get_tex_parameterfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_tex_parameterfv_reply_t; /** * @brief xcb_glx_get_tex_parameteriv_cookie_t **/ typedef struct xcb_glx_get_tex_parameteriv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_tex_parameteriv_cookie_t; /** Opcode for xcb_glx_get_tex_parameteriv. */ @@ -2168,33 +2168,33 @@ typedef struct xcb_glx_get_tex_parameteriv_cookie_t { * @brief xcb_glx_get_tex_parameteriv_request_t **/ typedef struct xcb_glx_get_tex_parameteriv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_tex_parameteriv_request_t; /** * @brief xcb_glx_get_tex_parameteriv_reply_t **/ typedef struct xcb_glx_get_tex_parameteriv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_tex_parameteriv_reply_t; /** * @brief xcb_glx_get_tex_level_parameterfv_cookie_t **/ typedef struct xcb_glx_get_tex_level_parameterfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_tex_level_parameterfv_cookie_t; /** Opcode for xcb_glx_get_tex_level_parameterfv. */ @@ -2204,34 +2204,34 @@ typedef struct xcb_glx_get_tex_level_parameterfv_cookie_t { * @brief xcb_glx_get_tex_level_parameterfv_request_t **/ typedef struct xcb_glx_get_tex_level_parameterfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - int32_t level; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + int32_t level; + uint32_t pname; } xcb_glx_get_tex_level_parameterfv_request_t; /** * @brief xcb_glx_get_tex_level_parameterfv_reply_t **/ typedef struct xcb_glx_get_tex_level_parameterfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_tex_level_parameterfv_reply_t; /** * @brief xcb_glx_get_tex_level_parameteriv_cookie_t **/ typedef struct xcb_glx_get_tex_level_parameteriv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_tex_level_parameteriv_cookie_t; /** Opcode for xcb_glx_get_tex_level_parameteriv. */ @@ -2241,34 +2241,66 @@ typedef struct xcb_glx_get_tex_level_parameteriv_cookie_t { * @brief xcb_glx_get_tex_level_parameteriv_request_t **/ typedef struct xcb_glx_get_tex_level_parameteriv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - int32_t level; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + int32_t level; + uint32_t pname; } xcb_glx_get_tex_level_parameteriv_request_t; /** * @brief xcb_glx_get_tex_level_parameteriv_reply_t **/ typedef struct xcb_glx_get_tex_level_parameteriv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_tex_level_parameteriv_reply_t; +/** + * @brief xcb_glx_is_enabled_cookie_t + **/ +typedef struct xcb_glx_is_enabled_cookie_t { + unsigned int sequence; +} xcb_glx_is_enabled_cookie_t; + +/** Opcode for xcb_glx_is_enabled. */ +#define XCB_GLX_IS_ENABLED 140 + +/** + * @brief xcb_glx_is_enabled_request_t + **/ +typedef struct xcb_glx_is_enabled_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t capability; +} xcb_glx_is_enabled_request_t; + +/** + * @brief xcb_glx_is_enabled_reply_t + **/ +typedef struct xcb_glx_is_enabled_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_glx_bool32_t ret_val; +} xcb_glx_is_enabled_reply_t; + /** * @brief xcb_glx_is_list_cookie_t **/ typedef struct xcb_glx_is_list_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_is_list_cookie_t; /** Opcode for xcb_glx_is_list. */ @@ -2278,22 +2310,22 @@ typedef struct xcb_glx_is_list_cookie_t { * @brief xcb_glx_is_list_request_t **/ typedef struct xcb_glx_is_list_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t list; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t list; } xcb_glx_is_list_request_t; /** * @brief xcb_glx_is_list_reply_t **/ typedef struct xcb_glx_is_list_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_glx_bool32_t ret_val; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_glx_bool32_t ret_val; } xcb_glx_is_list_reply_t; /** Opcode for xcb_glx_flush. */ @@ -2303,17 +2335,17 @@ typedef struct xcb_glx_is_list_reply_t { * @brief xcb_glx_flush_request_t **/ typedef struct xcb_glx_flush_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; } xcb_glx_flush_request_t; /** * @brief xcb_glx_are_textures_resident_cookie_t **/ typedef struct xcb_glx_are_textures_resident_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_are_textures_resident_cookie_t; /** Opcode for xcb_glx_are_textures_resident. */ @@ -2323,23 +2355,23 @@ typedef struct xcb_glx_are_textures_resident_cookie_t { * @brief xcb_glx_are_textures_resident_request_t **/ typedef struct xcb_glx_are_textures_resident_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t n; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t n; } xcb_glx_are_textures_resident_request_t; /** * @brief xcb_glx_are_textures_resident_reply_t **/ typedef struct xcb_glx_are_textures_resident_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_glx_bool32_t ret_val; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_glx_bool32_t ret_val; + uint8_t pad1[20]; } xcb_glx_are_textures_resident_reply_t; /** Opcode for xcb_glx_delete_textures. */ @@ -2349,18 +2381,18 @@ typedef struct xcb_glx_are_textures_resident_reply_t { * @brief xcb_glx_delete_textures_request_t **/ typedef struct xcb_glx_delete_textures_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t n; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t n; } xcb_glx_delete_textures_request_t; /** * @brief xcb_glx_gen_textures_cookie_t **/ typedef struct xcb_glx_gen_textures_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_gen_textures_cookie_t; /** Opcode for xcb_glx_gen_textures. */ @@ -2370,29 +2402,29 @@ typedef struct xcb_glx_gen_textures_cookie_t { * @brief xcb_glx_gen_textures_request_t **/ typedef struct xcb_glx_gen_textures_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t n; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t n; } xcb_glx_gen_textures_request_t; /** * @brief xcb_glx_gen_textures_reply_t **/ typedef struct xcb_glx_gen_textures_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_glx_gen_textures_reply_t; /** * @brief xcb_glx_is_texture_cookie_t **/ typedef struct xcb_glx_is_texture_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_is_texture_cookie_t; /** Opcode for xcb_glx_is_texture. */ @@ -2402,29 +2434,29 @@ typedef struct xcb_glx_is_texture_cookie_t { * @brief xcb_glx_is_texture_request_t **/ typedef struct xcb_glx_is_texture_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t texture; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t texture; } xcb_glx_is_texture_request_t; /** * @brief xcb_glx_is_texture_reply_t **/ typedef struct xcb_glx_is_texture_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_glx_bool32_t ret_val; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_glx_bool32_t ret_val; } xcb_glx_is_texture_reply_t; /** * @brief xcb_glx_get_color_table_cookie_t **/ typedef struct xcb_glx_get_color_table_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_color_table_cookie_t; /** Opcode for xcb_glx_get_color_table. */ @@ -2434,34 +2466,34 @@ typedef struct xcb_glx_get_color_table_cookie_t { * @brief xcb_glx_get_color_table_request_t **/ typedef struct xcb_glx_get_color_table_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t format; /**< */ - uint32_t type; /**< */ - uint8_t swap_bytes; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t format; + uint32_t type; + uint8_t swap_bytes; } xcb_glx_get_color_table_request_t; /** * @brief xcb_glx_get_color_table_reply_t **/ typedef struct xcb_glx_get_color_table_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[8]; /**< */ - int32_t width; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[8]; + int32_t width; + uint8_t pad2[12]; } xcb_glx_get_color_table_reply_t; /** * @brief xcb_glx_get_color_table_parameterfv_cookie_t **/ typedef struct xcb_glx_get_color_table_parameterfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_color_table_parameterfv_cookie_t; /** Opcode for xcb_glx_get_color_table_parameterfv. */ @@ -2471,33 +2503,33 @@ typedef struct xcb_glx_get_color_table_parameterfv_cookie_t { * @brief xcb_glx_get_color_table_parameterfv_request_t **/ typedef struct xcb_glx_get_color_table_parameterfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_color_table_parameterfv_request_t; /** * @brief xcb_glx_get_color_table_parameterfv_reply_t **/ typedef struct xcb_glx_get_color_table_parameterfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_color_table_parameterfv_reply_t; /** * @brief xcb_glx_get_color_table_parameteriv_cookie_t **/ typedef struct xcb_glx_get_color_table_parameteriv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_color_table_parameteriv_cookie_t; /** Opcode for xcb_glx_get_color_table_parameteriv. */ @@ -2507,33 +2539,33 @@ typedef struct xcb_glx_get_color_table_parameteriv_cookie_t { * @brief xcb_glx_get_color_table_parameteriv_request_t **/ typedef struct xcb_glx_get_color_table_parameteriv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_color_table_parameteriv_request_t; /** * @brief xcb_glx_get_color_table_parameteriv_reply_t **/ typedef struct xcb_glx_get_color_table_parameteriv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_color_table_parameteriv_reply_t; /** * @brief xcb_glx_get_convolution_filter_cookie_t **/ typedef struct xcb_glx_get_convolution_filter_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_convolution_filter_cookie_t; /** Opcode for xcb_glx_get_convolution_filter. */ @@ -2543,35 +2575,35 @@ typedef struct xcb_glx_get_convolution_filter_cookie_t { * @brief xcb_glx_get_convolution_filter_request_t **/ typedef struct xcb_glx_get_convolution_filter_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t format; /**< */ - uint32_t type; /**< */ - uint8_t swap_bytes; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t format; + uint32_t type; + uint8_t swap_bytes; } xcb_glx_get_convolution_filter_request_t; /** * @brief xcb_glx_get_convolution_filter_reply_t **/ typedef struct xcb_glx_get_convolution_filter_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[8]; /**< */ - int32_t width; /**< */ - int32_t height; /**< */ - uint8_t pad2[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[8]; + int32_t width; + int32_t height; + uint8_t pad2[8]; } xcb_glx_get_convolution_filter_reply_t; /** * @brief xcb_glx_get_convolution_parameterfv_cookie_t **/ typedef struct xcb_glx_get_convolution_parameterfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_convolution_parameterfv_cookie_t; /** Opcode for xcb_glx_get_convolution_parameterfv. */ @@ -2581,33 +2613,33 @@ typedef struct xcb_glx_get_convolution_parameterfv_cookie_t { * @brief xcb_glx_get_convolution_parameterfv_request_t **/ typedef struct xcb_glx_get_convolution_parameterfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_convolution_parameterfv_request_t; /** * @brief xcb_glx_get_convolution_parameterfv_reply_t **/ typedef struct xcb_glx_get_convolution_parameterfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_convolution_parameterfv_reply_t; /** * @brief xcb_glx_get_convolution_parameteriv_cookie_t **/ typedef struct xcb_glx_get_convolution_parameteriv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_convolution_parameteriv_cookie_t; /** Opcode for xcb_glx_get_convolution_parameteriv. */ @@ -2617,33 +2649,33 @@ typedef struct xcb_glx_get_convolution_parameteriv_cookie_t { * @brief xcb_glx_get_convolution_parameteriv_request_t **/ typedef struct xcb_glx_get_convolution_parameteriv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_convolution_parameteriv_request_t; /** * @brief xcb_glx_get_convolution_parameteriv_reply_t **/ typedef struct xcb_glx_get_convolution_parameteriv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_convolution_parameteriv_reply_t; /** * @brief xcb_glx_get_separable_filter_cookie_t **/ typedef struct xcb_glx_get_separable_filter_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_separable_filter_cookie_t; /** Opcode for xcb_glx_get_separable_filter. */ @@ -2653,35 +2685,35 @@ typedef struct xcb_glx_get_separable_filter_cookie_t { * @brief xcb_glx_get_separable_filter_request_t **/ typedef struct xcb_glx_get_separable_filter_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t format; /**< */ - uint32_t type; /**< */ - uint8_t swap_bytes; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t format; + uint32_t type; + uint8_t swap_bytes; } xcb_glx_get_separable_filter_request_t; /** * @brief xcb_glx_get_separable_filter_reply_t **/ typedef struct xcb_glx_get_separable_filter_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[8]; /**< */ - int32_t row_w; /**< */ - int32_t col_h; /**< */ - uint8_t pad2[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[8]; + int32_t row_w; + int32_t col_h; + uint8_t pad2[8]; } xcb_glx_get_separable_filter_reply_t; /** * @brief xcb_glx_get_histogram_cookie_t **/ typedef struct xcb_glx_get_histogram_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_histogram_cookie_t; /** Opcode for xcb_glx_get_histogram. */ @@ -2691,35 +2723,35 @@ typedef struct xcb_glx_get_histogram_cookie_t { * @brief xcb_glx_get_histogram_request_t **/ typedef struct xcb_glx_get_histogram_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t format; /**< */ - uint32_t type; /**< */ - uint8_t swap_bytes; /**< */ - uint8_t reset; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t format; + uint32_t type; + uint8_t swap_bytes; + uint8_t reset; } xcb_glx_get_histogram_request_t; /** * @brief xcb_glx_get_histogram_reply_t **/ typedef struct xcb_glx_get_histogram_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[8]; /**< */ - int32_t width; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[8]; + int32_t width; + uint8_t pad2[12]; } xcb_glx_get_histogram_reply_t; /** * @brief xcb_glx_get_histogram_parameterfv_cookie_t **/ typedef struct xcb_glx_get_histogram_parameterfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_histogram_parameterfv_cookie_t; /** Opcode for xcb_glx_get_histogram_parameterfv. */ @@ -2729,33 +2761,33 @@ typedef struct xcb_glx_get_histogram_parameterfv_cookie_t { * @brief xcb_glx_get_histogram_parameterfv_request_t **/ typedef struct xcb_glx_get_histogram_parameterfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_histogram_parameterfv_request_t; /** * @brief xcb_glx_get_histogram_parameterfv_reply_t **/ typedef struct xcb_glx_get_histogram_parameterfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_histogram_parameterfv_reply_t; /** * @brief xcb_glx_get_histogram_parameteriv_cookie_t **/ typedef struct xcb_glx_get_histogram_parameteriv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_histogram_parameteriv_cookie_t; /** Opcode for xcb_glx_get_histogram_parameteriv. */ @@ -2765,33 +2797,33 @@ typedef struct xcb_glx_get_histogram_parameteriv_cookie_t { * @brief xcb_glx_get_histogram_parameteriv_request_t **/ typedef struct xcb_glx_get_histogram_parameteriv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_histogram_parameteriv_request_t; /** * @brief xcb_glx_get_histogram_parameteriv_reply_t **/ typedef struct xcb_glx_get_histogram_parameteriv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_histogram_parameteriv_reply_t; /** * @brief xcb_glx_get_minmax_cookie_t **/ typedef struct xcb_glx_get_minmax_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_minmax_cookie_t; /** Opcode for xcb_glx_get_minmax. */ @@ -2801,33 +2833,33 @@ typedef struct xcb_glx_get_minmax_cookie_t { * @brief xcb_glx_get_minmax_request_t **/ typedef struct xcb_glx_get_minmax_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t format; /**< */ - uint32_t type; /**< */ - uint8_t swap_bytes; /**< */ - uint8_t reset; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t format; + uint32_t type; + uint8_t swap_bytes; + uint8_t reset; } xcb_glx_get_minmax_request_t; /** * @brief xcb_glx_get_minmax_reply_t **/ typedef struct xcb_glx_get_minmax_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_glx_get_minmax_reply_t; /** * @brief xcb_glx_get_minmax_parameterfv_cookie_t **/ typedef struct xcb_glx_get_minmax_parameterfv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_minmax_parameterfv_cookie_t; /** Opcode for xcb_glx_get_minmax_parameterfv. */ @@ -2837,33 +2869,33 @@ typedef struct xcb_glx_get_minmax_parameterfv_cookie_t { * @brief xcb_glx_get_minmax_parameterfv_request_t **/ typedef struct xcb_glx_get_minmax_parameterfv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_minmax_parameterfv_request_t; /** * @brief xcb_glx_get_minmax_parameterfv_reply_t **/ typedef struct xcb_glx_get_minmax_parameterfv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - xcb_glx_float32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + xcb_glx_float32_t datum; + uint8_t pad2[12]; } xcb_glx_get_minmax_parameterfv_reply_t; /** * @brief xcb_glx_get_minmax_parameteriv_cookie_t **/ typedef struct xcb_glx_get_minmax_parameteriv_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_minmax_parameteriv_cookie_t; /** Opcode for xcb_glx_get_minmax_parameteriv. */ @@ -2873,33 +2905,33 @@ typedef struct xcb_glx_get_minmax_parameteriv_cookie_t { * @brief xcb_glx_get_minmax_parameteriv_request_t **/ typedef struct xcb_glx_get_minmax_parameteriv_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_minmax_parameteriv_request_t; /** * @brief xcb_glx_get_minmax_parameteriv_reply_t **/ typedef struct xcb_glx_get_minmax_parameteriv_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_minmax_parameteriv_reply_t; /** * @brief xcb_glx_get_compressed_tex_image_arb_cookie_t **/ typedef struct xcb_glx_get_compressed_tex_image_arb_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_compressed_tex_image_arb_cookie_t; /** Opcode for xcb_glx_get_compressed_tex_image_arb. */ @@ -2909,25 +2941,25 @@ typedef struct xcb_glx_get_compressed_tex_image_arb_cookie_t { * @brief xcb_glx_get_compressed_tex_image_arb_request_t **/ typedef struct xcb_glx_get_compressed_tex_image_arb_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - int32_t level; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + int32_t level; } xcb_glx_get_compressed_tex_image_arb_request_t; /** * @brief xcb_glx_get_compressed_tex_image_arb_reply_t **/ typedef struct xcb_glx_get_compressed_tex_image_arb_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[8]; /**< */ - int32_t size; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[8]; + int32_t size; + uint8_t pad2[12]; } xcb_glx_get_compressed_tex_image_arb_reply_t; /** Opcode for xcb_glx_delete_queries_arb. */ @@ -2937,18 +2969,18 @@ typedef struct xcb_glx_get_compressed_tex_image_arb_reply_t { * @brief xcb_glx_delete_queries_arb_request_t **/ typedef struct xcb_glx_delete_queries_arb_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t n; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t n; } xcb_glx_delete_queries_arb_request_t; /** * @brief xcb_glx_gen_queries_arb_cookie_t **/ typedef struct xcb_glx_gen_queries_arb_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_gen_queries_arb_cookie_t; /** Opcode for xcb_glx_gen_queries_arb. */ @@ -2958,29 +2990,29 @@ typedef struct xcb_glx_gen_queries_arb_cookie_t { * @brief xcb_glx_gen_queries_arb_request_t **/ typedef struct xcb_glx_gen_queries_arb_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - int32_t n; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + int32_t n; } xcb_glx_gen_queries_arb_request_t; /** * @brief xcb_glx_gen_queries_arb_reply_t **/ typedef struct xcb_glx_gen_queries_arb_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_glx_gen_queries_arb_reply_t; /** * @brief xcb_glx_is_query_arb_cookie_t **/ typedef struct xcb_glx_is_query_arb_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_is_query_arb_cookie_t; /** Opcode for xcb_glx_is_query_arb. */ @@ -2990,29 +3022,29 @@ typedef struct xcb_glx_is_query_arb_cookie_t { * @brief xcb_glx_is_query_arb_request_t **/ typedef struct xcb_glx_is_query_arb_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t id; } xcb_glx_is_query_arb_request_t; /** * @brief xcb_glx_is_query_arb_reply_t **/ typedef struct xcb_glx_is_query_arb_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_glx_bool32_t ret_val; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_glx_bool32_t ret_val; } xcb_glx_is_query_arb_reply_t; /** * @brief xcb_glx_get_queryiv_arb_cookie_t **/ typedef struct xcb_glx_get_queryiv_arb_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_queryiv_arb_cookie_t; /** Opcode for xcb_glx_get_queryiv_arb. */ @@ -3022,33 +3054,33 @@ typedef struct xcb_glx_get_queryiv_arb_cookie_t { * @brief xcb_glx_get_queryiv_arb_request_t **/ typedef struct xcb_glx_get_queryiv_arb_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t target; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t target; + uint32_t pname; } xcb_glx_get_queryiv_arb_request_t; /** * @brief xcb_glx_get_queryiv_arb_reply_t **/ typedef struct xcb_glx_get_queryiv_arb_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_queryiv_arb_reply_t; /** * @brief xcb_glx_get_query_objectiv_arb_cookie_t **/ typedef struct xcb_glx_get_query_objectiv_arb_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_query_objectiv_arb_cookie_t; /** Opcode for xcb_glx_get_query_objectiv_arb. */ @@ -3058,33 +3090,33 @@ typedef struct xcb_glx_get_query_objectiv_arb_cookie_t { * @brief xcb_glx_get_query_objectiv_arb_request_t **/ typedef struct xcb_glx_get_query_objectiv_arb_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t id; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t id; + uint32_t pname; } xcb_glx_get_query_objectiv_arb_request_t; /** * @brief xcb_glx_get_query_objectiv_arb_reply_t **/ typedef struct xcb_glx_get_query_objectiv_arb_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - int32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + int32_t datum; + uint8_t pad2[12]; } xcb_glx_get_query_objectiv_arb_reply_t; /** * @brief xcb_glx_get_query_objectuiv_arb_cookie_t **/ typedef struct xcb_glx_get_query_objectuiv_arb_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_glx_get_query_objectuiv_arb_cookie_t; /** Opcode for xcb_glx_get_query_objectuiv_arb. */ @@ -3094,26 +3126,26 @@ typedef struct xcb_glx_get_query_objectuiv_arb_cookie_t { * @brief xcb_glx_get_query_objectuiv_arb_request_t **/ typedef struct xcb_glx_get_query_objectuiv_arb_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_glx_context_tag_t context_tag; /**< */ - uint32_t id; /**< */ - uint32_t pname; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_glx_context_tag_t context_tag; + uint32_t id; + uint32_t pname; } xcb_glx_get_query_objectuiv_arb_request_t; /** * @brief xcb_glx_get_query_objectuiv_arb_reply_t **/ typedef struct xcb_glx_get_query_objectuiv_arb_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[4]; /**< */ - uint32_t n; /**< */ - uint32_t datum; /**< */ - uint8_t pad2[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[4]; + uint32_t n; + uint32_t datum; + uint8_t pad2[12]; } xcb_glx_get_query_objectuiv_arb_reply_t; /** @@ -3125,7 +3157,7 @@ typedef struct xcb_glx_get_query_objectuiv_arb_reply_t { * element. The member index is increased by sizeof(xcb_glx_pixmap_t) */ void -xcb_glx_pixmap_next (xcb_glx_pixmap_iterator_t *i /**< */); +xcb_glx_pixmap_next (xcb_glx_pixmap_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3137,7 +3169,7 @@ xcb_glx_pixmap_next (xcb_glx_pixmap_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_glx_pixmap_end (xcb_glx_pixmap_iterator_t i /**< */); +xcb_glx_pixmap_end (xcb_glx_pixmap_iterator_t i); /** * Get the next element of the iterator @@ -3148,7 +3180,7 @@ xcb_glx_pixmap_end (xcb_glx_pixmap_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_glx_context_t) */ void -xcb_glx_context_next (xcb_glx_context_iterator_t *i /**< */); +xcb_glx_context_next (xcb_glx_context_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3160,7 +3192,7 @@ xcb_glx_context_next (xcb_glx_context_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_glx_context_end (xcb_glx_context_iterator_t i /**< */); +xcb_glx_context_end (xcb_glx_context_iterator_t i); /** * Get the next element of the iterator @@ -3171,7 +3203,7 @@ xcb_glx_context_end (xcb_glx_context_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_glx_pbuffer_t) */ void -xcb_glx_pbuffer_next (xcb_glx_pbuffer_iterator_t *i /**< */); +xcb_glx_pbuffer_next (xcb_glx_pbuffer_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3183,7 +3215,7 @@ xcb_glx_pbuffer_next (xcb_glx_pbuffer_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_glx_pbuffer_end (xcb_glx_pbuffer_iterator_t i /**< */); +xcb_glx_pbuffer_end (xcb_glx_pbuffer_iterator_t i); /** * Get the next element of the iterator @@ -3194,7 +3226,7 @@ xcb_glx_pbuffer_end (xcb_glx_pbuffer_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_glx_window_t) */ void -xcb_glx_window_next (xcb_glx_window_iterator_t *i /**< */); +xcb_glx_window_next (xcb_glx_window_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3206,7 +3238,7 @@ xcb_glx_window_next (xcb_glx_window_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_glx_window_end (xcb_glx_window_iterator_t i /**< */); +xcb_glx_window_end (xcb_glx_window_iterator_t i); /** * Get the next element of the iterator @@ -3217,7 +3249,7 @@ xcb_glx_window_end (xcb_glx_window_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_glx_fbconfig_t) */ void -xcb_glx_fbconfig_next (xcb_glx_fbconfig_iterator_t *i /**< */); +xcb_glx_fbconfig_next (xcb_glx_fbconfig_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3229,7 +3261,7 @@ xcb_glx_fbconfig_next (xcb_glx_fbconfig_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_glx_fbconfig_end (xcb_glx_fbconfig_iterator_t i /**< */); +xcb_glx_fbconfig_end (xcb_glx_fbconfig_iterator_t i); /** * Get the next element of the iterator @@ -3240,7 +3272,7 @@ xcb_glx_fbconfig_end (xcb_glx_fbconfig_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_glx_drawable_t) */ void -xcb_glx_drawable_next (xcb_glx_drawable_iterator_t *i /**< */); +xcb_glx_drawable_next (xcb_glx_drawable_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3252,7 +3284,7 @@ xcb_glx_drawable_next (xcb_glx_drawable_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_glx_drawable_end (xcb_glx_drawable_iterator_t i /**< */); +xcb_glx_drawable_end (xcb_glx_drawable_iterator_t i); /** * Get the next element of the iterator @@ -3263,7 +3295,7 @@ xcb_glx_drawable_end (xcb_glx_drawable_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_glx_float32_t) */ void -xcb_glx_float32_next (xcb_glx_float32_iterator_t *i /**< */); +xcb_glx_float32_next (xcb_glx_float32_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3275,7 +3307,7 @@ xcb_glx_float32_next (xcb_glx_float32_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_glx_float32_end (xcb_glx_float32_iterator_t i /**< */); +xcb_glx_float32_end (xcb_glx_float32_iterator_t i); /** * Get the next element of the iterator @@ -3286,7 +3318,7 @@ xcb_glx_float32_end (xcb_glx_float32_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_glx_float64_t) */ void -xcb_glx_float64_next (xcb_glx_float64_iterator_t *i /**< */); +xcb_glx_float64_next (xcb_glx_float64_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3298,7 +3330,7 @@ xcb_glx_float64_next (xcb_glx_float64_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_glx_float64_end (xcb_glx_float64_iterator_t i /**< */); +xcb_glx_float64_end (xcb_glx_float64_iterator_t i); /** * Get the next element of the iterator @@ -3309,7 +3341,7 @@ xcb_glx_float64_end (xcb_glx_float64_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_glx_bool32_t) */ void -xcb_glx_bool32_next (xcb_glx_bool32_iterator_t *i /**< */); +xcb_glx_bool32_next (xcb_glx_bool32_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3321,7 +3353,7 @@ xcb_glx_bool32_next (xcb_glx_bool32_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_glx_bool32_end (xcb_glx_bool32_iterator_t i /**< */); +xcb_glx_bool32_end (xcb_glx_bool32_iterator_t i); /** * Get the next element of the iterator @@ -3332,7 +3364,7 @@ xcb_glx_bool32_end (xcb_glx_bool32_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_glx_context_tag_t) */ void -xcb_glx_context_tag_next (xcb_glx_context_tag_iterator_t *i /**< */); +xcb_glx_context_tag_next (xcb_glx_context_tag_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3344,11 +3376,11 @@ xcb_glx_context_tag_next (xcb_glx_context_tag_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_glx_context_tag_end (xcb_glx_context_tag_iterator_t i /**< */); +xcb_glx_context_tag_end (xcb_glx_context_tag_iterator_t i); int -xcb_glx_render_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */); +xcb_glx_render_sizeof (const void *_buffer, + uint32_t data_len); /** * @@ -3362,10 +3394,10 @@ xcb_glx_render_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_render_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_glx_render_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data); /** * @@ -3376,13 +3408,22 @@ xcb_glx_render_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_render (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_glx_render (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data); + +uint8_t * +xcb_glx_render_data (const xcb_glx_render_request_t *R); int -xcb_glx_render_large_sizeof (const void *_buffer /**< */); +xcb_glx_render_data_length (const xcb_glx_render_request_t *R); + +xcb_generic_iterator_t +xcb_glx_render_data_end (const xcb_glx_render_request_t *R); + +int +xcb_glx_render_large_sizeof (const void *_buffer); /** * @@ -3396,12 +3437,12 @@ xcb_glx_render_large_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_render_large_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint16_t request_num /**< */, - uint16_t request_total /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_glx_render_large_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint16_t request_num, + uint16_t request_total, + uint32_t data_len, + const uint8_t *data); /** * @@ -3412,12 +3453,21 @@ xcb_glx_render_large_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_render_large (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint16_t request_num /**< */, - uint16_t request_total /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_glx_render_large (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint16_t request_num, + uint16_t request_total, + uint32_t data_len, + const uint8_t *data); + +uint8_t * +xcb_glx_render_large_data (const xcb_glx_render_large_request_t *R); + +int +xcb_glx_render_large_data_length (const xcb_glx_render_large_request_t *R); + +xcb_generic_iterator_t +xcb_glx_render_large_data_end (const xcb_glx_render_large_request_t *R); /** * @@ -3431,12 +3481,12 @@ xcb_glx_render_large (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_create_context_checked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_visualid_t visual /**< */, - uint32_t screen /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */); +xcb_glx_create_context_checked (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_visualid_t visual, + uint32_t screen, + xcb_glx_context_t share_list, + uint8_t is_direct); /** * @@ -3447,12 +3497,12 @@ xcb_glx_create_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_create_context (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_visualid_t visual /**< */, - uint32_t screen /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */); +xcb_glx_create_context (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_visualid_t visual, + uint32_t screen, + xcb_glx_context_t share_list, + uint8_t is_direct); /** * @@ -3466,8 +3516,8 @@ xcb_glx_create_context (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_destroy_context_checked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */); +xcb_glx_destroy_context_checked (xcb_connection_t *c, + xcb_glx_context_t context); /** * @@ -3478,8 +3528,8 @@ xcb_glx_destroy_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_destroy_context (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */); +xcb_glx_destroy_context (xcb_connection_t *c, + xcb_glx_context_t context); /** * @@ -3490,10 +3540,10 @@ xcb_glx_destroy_context (xcb_connection_t *c /**< */, * */ xcb_glx_make_current_cookie_t -xcb_glx_make_current (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_context_tag_t old_context_tag /**< */); +xcb_glx_make_current (xcb_connection_t *c, + xcb_glx_drawable_t drawable, + xcb_glx_context_t context, + xcb_glx_context_tag_t old_context_tag); /** * @@ -3507,10 +3557,10 @@ xcb_glx_make_current (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_make_current_cookie_t -xcb_glx_make_current_unchecked (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_context_tag_t old_context_tag /**< */); +xcb_glx_make_current_unchecked (xcb_connection_t *c, + xcb_glx_drawable_t drawable, + xcb_glx_context_t context, + xcb_glx_context_tag_t old_context_tag); /** * Return the reply @@ -3527,9 +3577,9 @@ xcb_glx_make_current_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_make_current_reply_t * -xcb_glx_make_current_reply (xcb_connection_t *c /**< */, +xcb_glx_make_current_reply (xcb_connection_t *c, xcb_glx_make_current_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -3540,8 +3590,8 @@ xcb_glx_make_current_reply (xcb_connection_t *c /**< */, * */ xcb_glx_is_direct_cookie_t -xcb_glx_is_direct (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */); +xcb_glx_is_direct (xcb_connection_t *c, + xcb_glx_context_t context); /** * @@ -3555,8 +3605,8 @@ xcb_glx_is_direct (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_is_direct_cookie_t -xcb_glx_is_direct_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */); +xcb_glx_is_direct_unchecked (xcb_connection_t *c, + xcb_glx_context_t context); /** * Return the reply @@ -3573,9 +3623,9 @@ xcb_glx_is_direct_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_is_direct_reply_t * -xcb_glx_is_direct_reply (xcb_connection_t *c /**< */, +xcb_glx_is_direct_reply (xcb_connection_t *c, xcb_glx_is_direct_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -3586,9 +3636,9 @@ xcb_glx_is_direct_reply (xcb_connection_t *c /**< */, * */ xcb_glx_query_version_cookie_t -xcb_glx_query_version (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */); +xcb_glx_query_version (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version); /** * @@ -3602,9 +3652,9 @@ xcb_glx_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_query_version_cookie_t -xcb_glx_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */); +xcb_glx_query_version_unchecked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version); /** * Return the reply @@ -3621,9 +3671,9 @@ xcb_glx_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_query_version_reply_t * -xcb_glx_query_version_reply (xcb_connection_t *c /**< */, +xcb_glx_query_version_reply (xcb_connection_t *c, xcb_glx_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -3637,8 +3687,8 @@ xcb_glx_query_version_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_wait_gl_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_wait_gl_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); /** * @@ -3649,8 +3699,8 @@ xcb_glx_wait_gl_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_wait_gl (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_wait_gl (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); /** * @@ -3664,8 +3714,8 @@ xcb_glx_wait_gl (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_wait_x_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_wait_x_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); /** * @@ -3676,8 +3726,8 @@ xcb_glx_wait_x_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_wait_x (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_wait_x (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); /** * @@ -3691,11 +3741,11 @@ xcb_glx_wait_x (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_copy_context_checked (xcb_connection_t *c /**< */, - xcb_glx_context_t src /**< */, - xcb_glx_context_t dest /**< */, - uint32_t mask /**< */, - xcb_glx_context_tag_t src_context_tag /**< */); +xcb_glx_copy_context_checked (xcb_connection_t *c, + xcb_glx_context_t src, + xcb_glx_context_t dest, + uint32_t mask, + xcb_glx_context_tag_t src_context_tag); /** * @@ -3706,11 +3756,11 @@ xcb_glx_copy_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_copy_context (xcb_connection_t *c /**< */, - xcb_glx_context_t src /**< */, - xcb_glx_context_t dest /**< */, - uint32_t mask /**< */, - xcb_glx_context_tag_t src_context_tag /**< */); +xcb_glx_copy_context (xcb_connection_t *c, + xcb_glx_context_t src, + xcb_glx_context_t dest, + uint32_t mask, + xcb_glx_context_tag_t src_context_tag); /** * @@ -3724,9 +3774,9 @@ xcb_glx_copy_context (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_swap_buffers_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - xcb_glx_drawable_t drawable /**< */); +xcb_glx_swap_buffers_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + xcb_glx_drawable_t drawable); /** * @@ -3737,9 +3787,9 @@ xcb_glx_swap_buffers_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_swap_buffers (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - xcb_glx_drawable_t drawable /**< */); +xcb_glx_swap_buffers (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + xcb_glx_drawable_t drawable); /** * @@ -3753,12 +3803,12 @@ xcb_glx_swap_buffers (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_use_x_font_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - xcb_font_t font /**< */, - uint32_t first /**< */, - uint32_t count /**< */, - uint32_t list_base /**< */); +xcb_glx_use_x_font_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + xcb_font_t font, + uint32_t first, + uint32_t count, + uint32_t list_base); /** * @@ -3769,12 +3819,12 @@ xcb_glx_use_x_font_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_use_x_font (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - xcb_font_t font /**< */, - uint32_t first /**< */, - uint32_t count /**< */, - uint32_t list_base /**< */); +xcb_glx_use_x_font (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + xcb_font_t font, + uint32_t first, + uint32_t count, + uint32_t list_base); /** * @@ -3788,11 +3838,11 @@ xcb_glx_use_x_font (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_visualid_t visual /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */); +xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c, + uint32_t screen, + xcb_visualid_t visual, + xcb_pixmap_t pixmap, + xcb_glx_pixmap_t glx_pixmap); /** * @@ -3803,14 +3853,14 @@ xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_create_glx_pixmap (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_visualid_t visual /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */); +xcb_glx_create_glx_pixmap (xcb_connection_t *c, + uint32_t screen, + xcb_visualid_t visual, + xcb_pixmap_t pixmap, + xcb_glx_pixmap_t glx_pixmap); int -xcb_glx_get_visual_configs_sizeof (const void *_buffer /**< */); +xcb_glx_get_visual_configs_sizeof (const void *_buffer); /** * @@ -3821,8 +3871,8 @@ xcb_glx_get_visual_configs_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_visual_configs_cookie_t -xcb_glx_get_visual_configs (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_glx_get_visual_configs (xcb_connection_t *c, + uint32_t screen); /** * @@ -3836,17 +3886,17 @@ xcb_glx_get_visual_configs (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_visual_configs_cookie_t -xcb_glx_get_visual_configs_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_glx_get_visual_configs_unchecked (xcb_connection_t *c, + uint32_t screen); uint32_t * -xcb_glx_get_visual_configs_property_list (const xcb_glx_get_visual_configs_reply_t *R /**< */); +xcb_glx_get_visual_configs_property_list (const xcb_glx_get_visual_configs_reply_t *R); int -xcb_glx_get_visual_configs_property_list_length (const xcb_glx_get_visual_configs_reply_t *R /**< */); +xcb_glx_get_visual_configs_property_list_length (const xcb_glx_get_visual_configs_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_reply_t *R /**< */); +xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_reply_t *R); /** * Return the reply @@ -3863,9 +3913,9 @@ xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_r * The returned value must be freed by the caller using free(). */ xcb_glx_get_visual_configs_reply_t * -xcb_glx_get_visual_configs_reply (xcb_connection_t *c /**< */, +xcb_glx_get_visual_configs_reply (xcb_connection_t *c, xcb_glx_get_visual_configs_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -3879,8 +3929,8 @@ xcb_glx_get_visual_configs_reply (xcb_connection_t *c /**< * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */); +xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c, + xcb_glx_pixmap_t glx_pixmap); /** * @@ -3891,12 +3941,12 @@ xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_destroy_glx_pixmap (xcb_connection_t *c /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */); +xcb_glx_destroy_glx_pixmap (xcb_connection_t *c, + xcb_glx_pixmap_t glx_pixmap); int -xcb_glx_vendor_private_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */); +xcb_glx_vendor_private_sizeof (const void *_buffer, + uint32_t data_len); /** * @@ -3910,11 +3960,11 @@ xcb_glx_vendor_private_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_vendor_private_checked (xcb_connection_t *c /**< */, - uint32_t vendor_code /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_glx_vendor_private_checked (xcb_connection_t *c, + uint32_t vendor_code, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data); /** * @@ -3925,15 +3975,24 @@ xcb_glx_vendor_private_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_vendor_private (xcb_connection_t *c /**< */, - uint32_t vendor_code /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_glx_vendor_private (xcb_connection_t *c, + uint32_t vendor_code, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data); + +uint8_t * +xcb_glx_vendor_private_data (const xcb_glx_vendor_private_request_t *R); int -xcb_glx_vendor_private_with_reply_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */); +xcb_glx_vendor_private_data_length (const xcb_glx_vendor_private_request_t *R); + +xcb_generic_iterator_t +xcb_glx_vendor_private_data_end (const xcb_glx_vendor_private_request_t *R); + +int +xcb_glx_vendor_private_with_reply_sizeof (const void *_buffer, + uint32_t data_len); /** * @@ -3944,11 +4003,11 @@ xcb_glx_vendor_private_with_reply_sizeof (const void *_buffer /**< */, * */ xcb_glx_vendor_private_with_reply_cookie_t -xcb_glx_vendor_private_with_reply (xcb_connection_t *c /**< */, - uint32_t vendor_code /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_glx_vendor_private_with_reply (xcb_connection_t *c, + uint32_t vendor_code, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data); /** * @@ -3962,20 +4021,20 @@ xcb_glx_vendor_private_with_reply (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_vendor_private_with_reply_cookie_t -xcb_glx_vendor_private_with_reply_unchecked (xcb_connection_t *c /**< */, - uint32_t vendor_code /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_glx_vendor_private_with_reply_unchecked (xcb_connection_t *c, + uint32_t vendor_code, + xcb_glx_context_tag_t context_tag, + uint32_t data_len, + const uint8_t *data); uint8_t * -xcb_glx_vendor_private_with_reply_data_2 (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */); +xcb_glx_vendor_private_with_reply_data_2 (const xcb_glx_vendor_private_with_reply_reply_t *R); int -xcb_glx_vendor_private_with_reply_data_2_length (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */); +xcb_glx_vendor_private_with_reply_data_2_length (const xcb_glx_vendor_private_with_reply_reply_t *R); xcb_generic_iterator_t -xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_reply_reply_t *R /**< */); +xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_reply_reply_t *R); /** * Return the reply @@ -3992,9 +4051,9 @@ xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_ * The returned value must be freed by the caller using free(). */ xcb_glx_vendor_private_with_reply_reply_t * -xcb_glx_vendor_private_with_reply_reply (xcb_connection_t *c /**< */, +xcb_glx_vendor_private_with_reply_reply (xcb_connection_t *c, xcb_glx_vendor_private_with_reply_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -4005,8 +4064,8 @@ xcb_glx_vendor_private_with_reply_reply (xcb_connection_t * */ xcb_glx_query_extensions_string_cookie_t -xcb_glx_query_extensions_string (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_glx_query_extensions_string (xcb_connection_t *c, + uint32_t screen); /** * @@ -4020,8 +4079,8 @@ xcb_glx_query_extensions_string (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_query_extensions_string_cookie_t -xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c, + uint32_t screen); /** * Return the reply @@ -4038,12 +4097,12 @@ xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_query_extensions_string_reply_t * -xcb_glx_query_extensions_string_reply (xcb_connection_t *c /**< */, +xcb_glx_query_extensions_string_reply (xcb_connection_t *c, xcb_glx_query_extensions_string_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_query_server_string_sizeof (const void *_buffer /**< */); +xcb_glx_query_server_string_sizeof (const void *_buffer); /** * @@ -4054,9 +4113,9 @@ xcb_glx_query_server_string_sizeof (const void *_buffer /**< */); * */ xcb_glx_query_server_string_cookie_t -xcb_glx_query_server_string (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t name /**< */); +xcb_glx_query_server_string (xcb_connection_t *c, + uint32_t screen, + uint32_t name); /** * @@ -4070,18 +4129,18 @@ xcb_glx_query_server_string (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_query_server_string_cookie_t -xcb_glx_query_server_string_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t name /**< */); +xcb_glx_query_server_string_unchecked (xcb_connection_t *c, + uint32_t screen, + uint32_t name); char * -xcb_glx_query_server_string_string (const xcb_glx_query_server_string_reply_t *R /**< */); +xcb_glx_query_server_string_string (const xcb_glx_query_server_string_reply_t *R); int -xcb_glx_query_server_string_string_length (const xcb_glx_query_server_string_reply_t *R /**< */); +xcb_glx_query_server_string_string_length (const xcb_glx_query_server_string_reply_t *R); xcb_generic_iterator_t -xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_t *R /**< */); +xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_t *R); /** * Return the reply @@ -4098,12 +4157,12 @@ xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_ * The returned value must be freed by the caller using free(). */ xcb_glx_query_server_string_reply_t * -xcb_glx_query_server_string_reply (xcb_connection_t *c /**< */, +xcb_glx_query_server_string_reply (xcb_connection_t *c, xcb_glx_query_server_string_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_client_info_sizeof (const void *_buffer /**< */); +xcb_glx_client_info_sizeof (const void *_buffer); /** * @@ -4117,11 +4176,11 @@ xcb_glx_client_info_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_client_info_checked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t str_len /**< */, - const char *string /**< */); +xcb_glx_client_info_checked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t str_len, + const char *string); /** * @@ -4132,14 +4191,23 @@ xcb_glx_client_info_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_client_info (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t str_len /**< */, - const char *string /**< */); +xcb_glx_client_info (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t str_len, + const char *string); + +char * +xcb_glx_client_info_string (const xcb_glx_client_info_request_t *R); int -xcb_glx_get_fb_configs_sizeof (const void *_buffer /**< */); +xcb_glx_client_info_string_length (const xcb_glx_client_info_request_t *R); + +xcb_generic_iterator_t +xcb_glx_client_info_string_end (const xcb_glx_client_info_request_t *R); + +int +xcb_glx_get_fb_configs_sizeof (const void *_buffer); /** * @@ -4150,8 +4218,8 @@ xcb_glx_get_fb_configs_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_fb_configs_cookie_t -xcb_glx_get_fb_configs (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_glx_get_fb_configs (xcb_connection_t *c, + uint32_t screen); /** * @@ -4165,17 +4233,17 @@ xcb_glx_get_fb_configs (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_fb_configs_cookie_t -xcb_glx_get_fb_configs_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_glx_get_fb_configs_unchecked (xcb_connection_t *c, + uint32_t screen); uint32_t * -xcb_glx_get_fb_configs_property_list (const xcb_glx_get_fb_configs_reply_t *R /**< */); +xcb_glx_get_fb_configs_property_list (const xcb_glx_get_fb_configs_reply_t *R); int -xcb_glx_get_fb_configs_property_list_length (const xcb_glx_get_fb_configs_reply_t *R /**< */); +xcb_glx_get_fb_configs_property_list_length (const xcb_glx_get_fb_configs_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t *R /**< */); +xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t *R); /** * Return the reply @@ -4192,12 +4260,12 @@ xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t * * The returned value must be freed by the caller using free(). */ xcb_glx_get_fb_configs_reply_t * -xcb_glx_get_fb_configs_reply (xcb_connection_t *c /**< */, +xcb_glx_get_fb_configs_reply (xcb_connection_t *c, xcb_glx_get_fb_configs_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_create_pixmap_sizeof (const void *_buffer /**< */); +xcb_glx_create_pixmap_sizeof (const void *_buffer); /** * @@ -4211,13 +4279,13 @@ xcb_glx_create_pixmap_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_create_pixmap_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */); +xcb_glx_create_pixmap_checked (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_pixmap_t pixmap, + xcb_glx_pixmap_t glx_pixmap, + uint32_t num_attribs, + const uint32_t *attribs); /** * @@ -4228,80 +4296,89 @@ xcb_glx_create_pixmap_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_create_pixmap (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_pixmap_t pixmap /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */); +xcb_glx_create_pixmap (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_pixmap_t pixmap, + xcb_glx_pixmap_t glx_pixmap, + uint32_t num_attribs, + const uint32_t *attribs); -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_glx_destroy_pixmap_checked (xcb_connection_t *c /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_glx_destroy_pixmap (xcb_connection_t *c /**< */, - xcb_glx_pixmap_t glx_pixmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_glx_create_new_context_checked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - uint32_t screen /**< */, - uint32_t render_type /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_glx_create_new_context (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - uint32_t screen /**< */, - uint32_t render_type /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */); +uint32_t * +xcb_glx_create_pixmap_attribs (const xcb_glx_create_pixmap_request_t *R); int -xcb_glx_query_context_sizeof (const void *_buffer /**< */); +xcb_glx_create_pixmap_attribs_length (const xcb_glx_create_pixmap_request_t *R); + +xcb_generic_iterator_t +xcb_glx_create_pixmap_attribs_end (const xcb_glx_create_pixmap_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_glx_destroy_pixmap_checked (xcb_connection_t *c, + xcb_glx_pixmap_t glx_pixmap); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_glx_destroy_pixmap (xcb_connection_t *c, + xcb_glx_pixmap_t glx_pixmap); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_glx_create_new_context_checked (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_glx_fbconfig_t fbconfig, + uint32_t screen, + uint32_t render_type, + xcb_glx_context_t share_list, + uint8_t is_direct); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_glx_create_new_context (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_glx_fbconfig_t fbconfig, + uint32_t screen, + uint32_t render_type, + xcb_glx_context_t share_list, + uint8_t is_direct); + +int +xcb_glx_query_context_sizeof (const void *_buffer); /** * @@ -4312,8 +4389,8 @@ xcb_glx_query_context_sizeof (const void *_buffer /**< */); * */ xcb_glx_query_context_cookie_t -xcb_glx_query_context (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */); +xcb_glx_query_context (xcb_connection_t *c, + xcb_glx_context_t context); /** * @@ -4327,17 +4404,17 @@ xcb_glx_query_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_query_context_cookie_t -xcb_glx_query_context_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */); +xcb_glx_query_context_unchecked (xcb_connection_t *c, + xcb_glx_context_t context); uint32_t * -xcb_glx_query_context_attribs (const xcb_glx_query_context_reply_t *R /**< */); +xcb_glx_query_context_attribs (const xcb_glx_query_context_reply_t *R); int -xcb_glx_query_context_attribs_length (const xcb_glx_query_context_reply_t *R /**< */); +xcb_glx_query_context_attribs_length (const xcb_glx_query_context_reply_t *R); xcb_generic_iterator_t -xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R /**< */); +xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R); /** * Return the reply @@ -4354,9 +4431,9 @@ xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R /**< * The returned value must be freed by the caller using free(). */ xcb_glx_query_context_reply_t * -xcb_glx_query_context_reply (xcb_connection_t *c /**< */, +xcb_glx_query_context_reply (xcb_connection_t *c, xcb_glx_query_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -4367,11 +4444,11 @@ xcb_glx_query_context_reply (xcb_connection_t *c /**< */, * */ xcb_glx_make_context_current_cookie_t -xcb_glx_make_context_current (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t old_context_tag /**< */, - xcb_glx_drawable_t drawable /**< */, - xcb_glx_drawable_t read_drawable /**< */, - xcb_glx_context_t context /**< */); +xcb_glx_make_context_current (xcb_connection_t *c, + xcb_glx_context_tag_t old_context_tag, + xcb_glx_drawable_t drawable, + xcb_glx_drawable_t read_drawable, + xcb_glx_context_t context); /** * @@ -4385,11 +4462,11 @@ xcb_glx_make_context_current (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_make_context_current_cookie_t -xcb_glx_make_context_current_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t old_context_tag /**< */, - xcb_glx_drawable_t drawable /**< */, - xcb_glx_drawable_t read_drawable /**< */, - xcb_glx_context_t context /**< */); +xcb_glx_make_context_current_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t old_context_tag, + xcb_glx_drawable_t drawable, + xcb_glx_drawable_t read_drawable, + xcb_glx_context_t context); /** * Return the reply @@ -4406,12 +4483,12 @@ xcb_glx_make_context_current_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_make_context_current_reply_t * -xcb_glx_make_context_current_reply (xcb_connection_t *c /**< */, +xcb_glx_make_context_current_reply (xcb_connection_t *c, xcb_glx_make_context_current_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_create_pbuffer_sizeof (const void *_buffer /**< */); +xcb_glx_create_pbuffer_sizeof (const void *_buffer); /** * @@ -4425,12 +4502,12 @@ xcb_glx_create_pbuffer_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_create_pbuffer_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_glx_pbuffer_t pbuffer /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */); +xcb_glx_create_pbuffer_checked (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_glx_pbuffer_t pbuffer, + uint32_t num_attribs, + const uint32_t *attribs); /** * @@ -4441,12 +4518,21 @@ xcb_glx_create_pbuffer_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_create_pbuffer (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_glx_pbuffer_t pbuffer /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */); +xcb_glx_create_pbuffer (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_glx_pbuffer_t pbuffer, + uint32_t num_attribs, + const uint32_t *attribs); + +uint32_t * +xcb_glx_create_pbuffer_attribs (const xcb_glx_create_pbuffer_request_t *R); + +int +xcb_glx_create_pbuffer_attribs_length (const xcb_glx_create_pbuffer_request_t *R); + +xcb_generic_iterator_t +xcb_glx_create_pbuffer_attribs_end (const xcb_glx_create_pbuffer_request_t *R); /** * @@ -4460,8 +4546,8 @@ xcb_glx_create_pbuffer (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_destroy_pbuffer_checked (xcb_connection_t *c /**< */, - xcb_glx_pbuffer_t pbuffer /**< */); +xcb_glx_destroy_pbuffer_checked (xcb_connection_t *c, + xcb_glx_pbuffer_t pbuffer); /** * @@ -4472,11 +4558,11 @@ xcb_glx_destroy_pbuffer_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_destroy_pbuffer (xcb_connection_t *c /**< */, - xcb_glx_pbuffer_t pbuffer /**< */); +xcb_glx_destroy_pbuffer (xcb_connection_t *c, + xcb_glx_pbuffer_t pbuffer); int -xcb_glx_get_drawable_attributes_sizeof (const void *_buffer /**< */); +xcb_glx_get_drawable_attributes_sizeof (const void *_buffer); /** * @@ -4487,8 +4573,8 @@ xcb_glx_get_drawable_attributes_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_drawable_attributes_cookie_t -xcb_glx_get_drawable_attributes (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */); +xcb_glx_get_drawable_attributes (xcb_connection_t *c, + xcb_glx_drawable_t drawable); /** * @@ -4502,17 +4588,17 @@ xcb_glx_get_drawable_attributes (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_drawable_attributes_cookie_t -xcb_glx_get_drawable_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */); +xcb_glx_get_drawable_attributes_unchecked (xcb_connection_t *c, + xcb_glx_drawable_t drawable); uint32_t * -xcb_glx_get_drawable_attributes_attribs (const xcb_glx_get_drawable_attributes_reply_t *R /**< */); +xcb_glx_get_drawable_attributes_attribs (const xcb_glx_get_drawable_attributes_reply_t *R); int -xcb_glx_get_drawable_attributes_attribs_length (const xcb_glx_get_drawable_attributes_reply_t *R /**< */); +xcb_glx_get_drawable_attributes_attribs_length (const xcb_glx_get_drawable_attributes_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attributes_reply_t *R /**< */); +xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attributes_reply_t *R); /** * Return the reply @@ -4529,12 +4615,12 @@ xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attribut * The returned value must be freed by the caller using free(). */ xcb_glx_get_drawable_attributes_reply_t * -xcb_glx_get_drawable_attributes_reply (xcb_connection_t *c /**< */, +xcb_glx_get_drawable_attributes_reply (xcb_connection_t *c, xcb_glx_get_drawable_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_change_drawable_attributes_sizeof (const void *_buffer /**< */); +xcb_glx_change_drawable_attributes_sizeof (const void *_buffer); /** * @@ -4548,10 +4634,10 @@ xcb_glx_change_drawable_attributes_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_change_drawable_attributes_checked (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */); +xcb_glx_change_drawable_attributes_checked (xcb_connection_t *c, + xcb_glx_drawable_t drawable, + uint32_t num_attribs, + const uint32_t *attribs); /** * @@ -4562,80 +4648,22 @@ xcb_glx_change_drawable_attributes_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_change_drawable_attributes (xcb_connection_t *c /**< */, - xcb_glx_drawable_t drawable /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */); +xcb_glx_change_drawable_attributes (xcb_connection_t *c, + xcb_glx_drawable_t drawable, + uint32_t num_attribs, + const uint32_t *attribs); + +uint32_t * +xcb_glx_change_drawable_attributes_attribs (const xcb_glx_change_drawable_attributes_request_t *R); int -xcb_glx_create_window_sizeof (const void *_buffer /**< */); +xcb_glx_change_drawable_attributes_attribs_length (const xcb_glx_change_drawable_attributes_request_t *R); -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_glx_create_window_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_window_t window /**< */, - xcb_glx_window_t glx_window /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_glx_create_window (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - xcb_window_t window /**< */, - xcb_glx_window_t glx_window /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_glx_delete_window_checked (xcb_connection_t *c /**< */, - xcb_glx_window_t glxwindow /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_glx_delete_window (xcb_connection_t *c /**< */, - xcb_glx_window_t glxwindow /**< */); +xcb_generic_iterator_t +xcb_glx_change_drawable_attributes_attribs_end (const xcb_glx_change_drawable_attributes_request_t *R); int -xcb_glx_set_client_info_arb_sizeof (const void *_buffer /**< */); +xcb_glx_create_window_sizeof (const void *_buffer); /** * @@ -4649,15 +4677,13 @@ xcb_glx_set_client_info_arb_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_set_client_info_arb_checked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t num_versions /**< */, - uint32_t gl_str_len /**< */, - uint32_t glx_str_len /**< */, - const uint32_t *gl_versions /**< */, - const char *gl_extension_string /**< */, - const char *glx_extension_string /**< */); +xcb_glx_create_window_checked (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_window_t window, + xcb_glx_window_t glx_window, + uint32_t num_attribs, + const uint32_t *attribs); /** * @@ -4668,18 +4694,22 @@ xcb_glx_set_client_info_arb_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_set_client_info_arb (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t num_versions /**< */, - uint32_t gl_str_len /**< */, - uint32_t glx_str_len /**< */, - const uint32_t *gl_versions /**< */, - const char *gl_extension_string /**< */, - const char *glx_extension_string /**< */); +xcb_glx_create_window (xcb_connection_t *c, + uint32_t screen, + xcb_glx_fbconfig_t fbconfig, + xcb_window_t window, + xcb_glx_window_t glx_window, + uint32_t num_attribs, + const uint32_t *attribs); + +uint32_t * +xcb_glx_create_window_attribs (const xcb_glx_create_window_request_t *R); int -xcb_glx_create_context_attribs_arb_sizeof (const void *_buffer /**< */); +xcb_glx_create_window_attribs_length (const xcb_glx_create_window_request_t *R); + +xcb_generic_iterator_t +xcb_glx_create_window_attribs_end (const xcb_glx_create_window_request_t *R); /** * @@ -4693,14 +4723,8 @@ xcb_glx_create_context_attribs_arb_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_create_context_attribs_arb_checked (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - uint32_t screen /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */); +xcb_glx_delete_window_checked (xcb_connection_t *c, + xcb_glx_window_t glxwindow); /** * @@ -4711,17 +4735,11 @@ xcb_glx_create_context_attribs_arb_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_create_context_attribs_arb (xcb_connection_t *c /**< */, - xcb_glx_context_t context /**< */, - xcb_glx_fbconfig_t fbconfig /**< */, - uint32_t screen /**< */, - xcb_glx_context_t share_list /**< */, - uint8_t is_direct /**< */, - uint32_t num_attribs /**< */, - const uint32_t *attribs /**< */); +xcb_glx_delete_window (xcb_connection_t *c, + xcb_glx_window_t glxwindow); int -xcb_glx_set_client_info_2arb_sizeof (const void *_buffer /**< */); +xcb_glx_set_client_info_arb_sizeof (const void *_buffer); /** * @@ -4735,15 +4753,15 @@ xcb_glx_set_client_info_2arb_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t num_versions /**< */, - uint32_t gl_str_len /**< */, - uint32_t glx_str_len /**< */, - const uint32_t *gl_versions /**< */, - const char *gl_extension_string /**< */, - const char *glx_extension_string /**< */); +xcb_glx_set_client_info_arb_checked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t num_versions, + uint32_t gl_str_len, + uint32_t glx_str_len, + const uint32_t *gl_versions, + const char *gl_extension_string, + const char *glx_extension_string); /** * @@ -4754,15 +4772,45 @@ xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_set_client_info_2arb (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */, - uint32_t num_versions /**< */, - uint32_t gl_str_len /**< */, - uint32_t glx_str_len /**< */, - const uint32_t *gl_versions /**< */, - const char *gl_extension_string /**< */, - const char *glx_extension_string /**< */); +xcb_glx_set_client_info_arb (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t num_versions, + uint32_t gl_str_len, + uint32_t glx_str_len, + const uint32_t *gl_versions, + const char *gl_extension_string, + const char *glx_extension_string); + +uint32_t * +xcb_glx_set_client_info_arb_gl_versions (const xcb_glx_set_client_info_arb_request_t *R); + +int +xcb_glx_set_client_info_arb_gl_versions_length (const xcb_glx_set_client_info_arb_request_t *R); + +xcb_generic_iterator_t +xcb_glx_set_client_info_arb_gl_versions_end (const xcb_glx_set_client_info_arb_request_t *R); + +char * +xcb_glx_set_client_info_arb_gl_extension_string (const xcb_glx_set_client_info_arb_request_t *R); + +int +xcb_glx_set_client_info_arb_gl_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R); + +xcb_generic_iterator_t +xcb_glx_set_client_info_arb_gl_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R); + +char * +xcb_glx_set_client_info_arb_glx_extension_string (const xcb_glx_set_client_info_arb_request_t *R); + +int +xcb_glx_set_client_info_arb_glx_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R); + +xcb_generic_iterator_t +xcb_glx_set_client_info_arb_glx_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R); + +int +xcb_glx_create_context_attribs_arb_sizeof (const void *_buffer); /** * @@ -4776,10 +4824,14 @@ xcb_glx_set_client_info_2arb (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_new_list_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */, - uint32_t mode /**< */); +xcb_glx_create_context_attribs_arb_checked (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_glx_fbconfig_t fbconfig, + uint32_t screen, + xcb_glx_context_t share_list, + uint8_t is_direct, + uint32_t num_attribs, + const uint32_t *attribs); /** * @@ -4790,10 +4842,26 @@ xcb_glx_new_list_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_new_list (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */, - uint32_t mode /**< */); +xcb_glx_create_context_attribs_arb (xcb_connection_t *c, + xcb_glx_context_t context, + xcb_glx_fbconfig_t fbconfig, + uint32_t screen, + xcb_glx_context_t share_list, + uint8_t is_direct, + uint32_t num_attribs, + const uint32_t *attribs); + +uint32_t * +xcb_glx_create_context_attribs_arb_attribs (const xcb_glx_create_context_attribs_arb_request_t *R); + +int +xcb_glx_create_context_attribs_arb_attribs_length (const xcb_glx_create_context_attribs_arb_request_t *R); + +xcb_generic_iterator_t +xcb_glx_create_context_attribs_arb_attribs_end (const xcb_glx_create_context_attribs_arb_request_t *R); + +int +xcb_glx_set_client_info_2arb_sizeof (const void *_buffer); /** * @@ -4807,8 +4875,15 @@ xcb_glx_new_list (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_end_list_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t num_versions, + uint32_t gl_str_len, + uint32_t glx_str_len, + const uint32_t *gl_versions, + const char *gl_extension_string, + const char *glx_extension_string); /** * @@ -4819,8 +4894,42 @@ xcb_glx_end_list_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_end_list (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_set_client_info_2arb (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version, + uint32_t num_versions, + uint32_t gl_str_len, + uint32_t glx_str_len, + const uint32_t *gl_versions, + const char *gl_extension_string, + const char *glx_extension_string); + +uint32_t * +xcb_glx_set_client_info_2arb_gl_versions (const xcb_glx_set_client_info_2arb_request_t *R); + +int +xcb_glx_set_client_info_2arb_gl_versions_length (const xcb_glx_set_client_info_2arb_request_t *R); + +xcb_generic_iterator_t +xcb_glx_set_client_info_2arb_gl_versions_end (const xcb_glx_set_client_info_2arb_request_t *R); + +char * +xcb_glx_set_client_info_2arb_gl_extension_string (const xcb_glx_set_client_info_2arb_request_t *R); + +int +xcb_glx_set_client_info_2arb_gl_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R); + +xcb_generic_iterator_t +xcb_glx_set_client_info_2arb_gl_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R); + +char * +xcb_glx_set_client_info_2arb_glx_extension_string (const xcb_glx_set_client_info_2arb_request_t *R); + +int +xcb_glx_set_client_info_2arb_glx_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R); + +xcb_generic_iterator_t +xcb_glx_set_client_info_2arb_glx_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R); /** * @@ -4834,10 +4943,10 @@ xcb_glx_end_list (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_delete_lists_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */, - int32_t range /**< */); +xcb_glx_new_list_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list, + uint32_t mode); /** * @@ -4848,10 +4957,68 @@ xcb_glx_delete_lists_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_delete_lists (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */, - int32_t range /**< */); +xcb_glx_new_list (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list, + uint32_t mode); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_glx_end_list_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_glx_end_list (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_glx_delete_lists_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list, + int32_t range); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_glx_delete_lists (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list, + int32_t range); /** * @@ -4862,9 +5029,9 @@ xcb_glx_delete_lists (xcb_connection_t *c /**< */, * */ xcb_glx_gen_lists_cookie_t -xcb_glx_gen_lists (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t range /**< */); +xcb_glx_gen_lists (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t range); /** * @@ -4878,9 +5045,9 @@ xcb_glx_gen_lists (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_gen_lists_cookie_t -xcb_glx_gen_lists_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t range /**< */); +xcb_glx_gen_lists_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t range); /** * Return the reply @@ -4897,9 +5064,9 @@ xcb_glx_gen_lists_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_gen_lists_reply_t * -xcb_glx_gen_lists_reply (xcb_connection_t *c /**< */, +xcb_glx_gen_lists_reply (xcb_connection_t *c, xcb_glx_gen_lists_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -4913,10 +5080,10 @@ xcb_glx_gen_lists_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_feedback_buffer_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t size /**< */, - int32_t type /**< */); +xcb_glx_feedback_buffer_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t size, + int32_t type); /** * @@ -4927,10 +5094,10 @@ xcb_glx_feedback_buffer_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_feedback_buffer (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t size /**< */, - int32_t type /**< */); +xcb_glx_feedback_buffer (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t size, + int32_t type); /** * @@ -4944,9 +5111,9 @@ xcb_glx_feedback_buffer (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_select_buffer_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t size /**< */); +xcb_glx_select_buffer_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t size); /** * @@ -4957,12 +5124,12 @@ xcb_glx_select_buffer_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_select_buffer (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t size /**< */); +xcb_glx_select_buffer (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t size); int -xcb_glx_render_mode_sizeof (const void *_buffer /**< */); +xcb_glx_render_mode_sizeof (const void *_buffer); /** * @@ -4973,9 +5140,9 @@ xcb_glx_render_mode_sizeof (const void *_buffer /**< */); * */ xcb_glx_render_mode_cookie_t -xcb_glx_render_mode (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t mode /**< */); +xcb_glx_render_mode (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t mode); /** * @@ -4989,18 +5156,18 @@ xcb_glx_render_mode (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_render_mode_cookie_t -xcb_glx_render_mode_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t mode /**< */); +xcb_glx_render_mode_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t mode); uint32_t * -xcb_glx_render_mode_data (const xcb_glx_render_mode_reply_t *R /**< */); +xcb_glx_render_mode_data (const xcb_glx_render_mode_reply_t *R); int -xcb_glx_render_mode_data_length (const xcb_glx_render_mode_reply_t *R /**< */); +xcb_glx_render_mode_data_length (const xcb_glx_render_mode_reply_t *R); xcb_generic_iterator_t -xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R /**< */); +xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R); /** * Return the reply @@ -5017,9 +5184,9 @@ xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_render_mode_reply_t * -xcb_glx_render_mode_reply (xcb_connection_t *c /**< */, +xcb_glx_render_mode_reply (xcb_connection_t *c, xcb_glx_render_mode_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -5030,8 +5197,8 @@ xcb_glx_render_mode_reply (xcb_connection_t *c /**< */, * */ xcb_glx_finish_cookie_t -xcb_glx_finish (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_finish (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); /** * @@ -5045,8 +5212,8 @@ xcb_glx_finish (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_finish_cookie_t -xcb_glx_finish_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_finish_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); /** * Return the reply @@ -5063,9 +5230,9 @@ xcb_glx_finish_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_finish_reply_t * -xcb_glx_finish_reply (xcb_connection_t *c /**< */, +xcb_glx_finish_reply (xcb_connection_t *c, xcb_glx_finish_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -5079,10 +5246,10 @@ xcb_glx_finish_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_pixel_storef_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */, - xcb_glx_float32_t datum /**< */); +xcb_glx_pixel_storef_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname, + xcb_glx_float32_t datum); /** * @@ -5093,10 +5260,10 @@ xcb_glx_pixel_storef_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_pixel_storef (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */, - xcb_glx_float32_t datum /**< */); +xcb_glx_pixel_storef (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname, + xcb_glx_float32_t datum); /** * @@ -5110,10 +5277,10 @@ xcb_glx_pixel_storef (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_pixel_storei_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */, - int32_t datum /**< */); +xcb_glx_pixel_storei_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname, + int32_t datum); /** * @@ -5124,13 +5291,13 @@ xcb_glx_pixel_storei_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_pixel_storei (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */, - int32_t datum /**< */); +xcb_glx_pixel_storei (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname, + int32_t datum); int -xcb_glx_read_pixels_sizeof (const void *_buffer /**< */); +xcb_glx_read_pixels_sizeof (const void *_buffer); /** * @@ -5141,16 +5308,16 @@ xcb_glx_read_pixels_sizeof (const void *_buffer /**< */); * */ xcb_glx_read_pixels_cookie_t -xcb_glx_read_pixels (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t x /**< */, - int32_t y /**< */, - int32_t width /**< */, - int32_t height /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t lsb_first /**< */); +xcb_glx_read_pixels (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t x, + int32_t y, + int32_t width, + int32_t height, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t lsb_first); /** * @@ -5164,25 +5331,25 @@ xcb_glx_read_pixels (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_read_pixels_cookie_t -xcb_glx_read_pixels_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t x /**< */, - int32_t y /**< */, - int32_t width /**< */, - int32_t height /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t lsb_first /**< */); +xcb_glx_read_pixels_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t x, + int32_t y, + int32_t width, + int32_t height, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t lsb_first); uint8_t * -xcb_glx_read_pixels_data (const xcb_glx_read_pixels_reply_t *R /**< */); +xcb_glx_read_pixels_data (const xcb_glx_read_pixels_reply_t *R); int -xcb_glx_read_pixels_data_length (const xcb_glx_read_pixels_reply_t *R /**< */); +xcb_glx_read_pixels_data_length (const xcb_glx_read_pixels_reply_t *R); xcb_generic_iterator_t -xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R /**< */); +xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R); /** * Return the reply @@ -5199,12 +5366,12 @@ xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_read_pixels_reply_t * -xcb_glx_read_pixels_reply (xcb_connection_t *c /**< */, +xcb_glx_read_pixels_reply (xcb_connection_t *c, xcb_glx_read_pixels_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_booleanv_sizeof (const void *_buffer /**< */); +xcb_glx_get_booleanv_sizeof (const void *_buffer); /** * @@ -5215,9 +5382,9 @@ xcb_glx_get_booleanv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_booleanv_cookie_t -xcb_glx_get_booleanv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t pname /**< */); +xcb_glx_get_booleanv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t pname); /** * @@ -5231,18 +5398,18 @@ xcb_glx_get_booleanv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_booleanv_cookie_t -xcb_glx_get_booleanv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t pname /**< */); +xcb_glx_get_booleanv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t pname); uint8_t * -xcb_glx_get_booleanv_data (const xcb_glx_get_booleanv_reply_t *R /**< */); +xcb_glx_get_booleanv_data (const xcb_glx_get_booleanv_reply_t *R); int -xcb_glx_get_booleanv_data_length (const xcb_glx_get_booleanv_reply_t *R /**< */); +xcb_glx_get_booleanv_data_length (const xcb_glx_get_booleanv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R /**< */); +xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R); /** * Return the reply @@ -5259,12 +5426,12 @@ xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_booleanv_reply_t * -xcb_glx_get_booleanv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_booleanv_reply (xcb_connection_t *c, xcb_glx_get_booleanv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_clip_plane_sizeof (const void *_buffer /**< */); +xcb_glx_get_clip_plane_sizeof (const void *_buffer); /** * @@ -5275,9 +5442,9 @@ xcb_glx_get_clip_plane_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_clip_plane_cookie_t -xcb_glx_get_clip_plane (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t plane /**< */); +xcb_glx_get_clip_plane (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t plane); /** * @@ -5291,18 +5458,18 @@ xcb_glx_get_clip_plane (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_clip_plane_cookie_t -xcb_glx_get_clip_plane_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t plane /**< */); +xcb_glx_get_clip_plane_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t plane); xcb_glx_float64_t * -xcb_glx_get_clip_plane_data (const xcb_glx_get_clip_plane_reply_t *R /**< */); +xcb_glx_get_clip_plane_data (const xcb_glx_get_clip_plane_reply_t *R); int -xcb_glx_get_clip_plane_data_length (const xcb_glx_get_clip_plane_reply_t *R /**< */); +xcb_glx_get_clip_plane_data_length (const xcb_glx_get_clip_plane_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R /**< */); +xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R); /** * Return the reply @@ -5319,12 +5486,12 @@ xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R /**< * * The returned value must be freed by the caller using free(). */ xcb_glx_get_clip_plane_reply_t * -xcb_glx_get_clip_plane_reply (xcb_connection_t *c /**< */, +xcb_glx_get_clip_plane_reply (xcb_connection_t *c, xcb_glx_get_clip_plane_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_doublev_sizeof (const void *_buffer /**< */); +xcb_glx_get_doublev_sizeof (const void *_buffer); /** * @@ -5335,9 +5502,9 @@ xcb_glx_get_doublev_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_doublev_cookie_t -xcb_glx_get_doublev (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */); +xcb_glx_get_doublev (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname); /** * @@ -5351,18 +5518,18 @@ xcb_glx_get_doublev (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_doublev_cookie_t -xcb_glx_get_doublev_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */); +xcb_glx_get_doublev_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname); xcb_glx_float64_t * -xcb_glx_get_doublev_data (const xcb_glx_get_doublev_reply_t *R /**< */); +xcb_glx_get_doublev_data (const xcb_glx_get_doublev_reply_t *R); int -xcb_glx_get_doublev_data_length (const xcb_glx_get_doublev_reply_t *R /**< */); +xcb_glx_get_doublev_data_length (const xcb_glx_get_doublev_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R /**< */); +xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R); /** * Return the reply @@ -5379,9 +5546,9 @@ xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_doublev_reply_t * -xcb_glx_get_doublev_reply (xcb_connection_t *c /**< */, +xcb_glx_get_doublev_reply (xcb_connection_t *c, xcb_glx_get_doublev_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -5392,8 +5559,8 @@ xcb_glx_get_doublev_reply (xcb_connection_t *c /**< */, * */ xcb_glx_get_error_cookie_t -xcb_glx_get_error (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_get_error (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); /** * @@ -5407,8 +5574,8 @@ xcb_glx_get_error (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_error_cookie_t -xcb_glx_get_error_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_get_error_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); /** * Return the reply @@ -5425,12 +5592,12 @@ xcb_glx_get_error_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_get_error_reply_t * -xcb_glx_get_error_reply (xcb_connection_t *c /**< */, +xcb_glx_get_error_reply (xcb_connection_t *c, xcb_glx_get_error_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_floatv_sizeof (const void *_buffer /**< */); +xcb_glx_get_floatv_sizeof (const void *_buffer); /** * @@ -5441,9 +5608,9 @@ xcb_glx_get_floatv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_floatv_cookie_t -xcb_glx_get_floatv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */); +xcb_glx_get_floatv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname); /** * @@ -5457,18 +5624,18 @@ xcb_glx_get_floatv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_floatv_cookie_t -xcb_glx_get_floatv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */); +xcb_glx_get_floatv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_floatv_data (const xcb_glx_get_floatv_reply_t *R /**< */); +xcb_glx_get_floatv_data (const xcb_glx_get_floatv_reply_t *R); int -xcb_glx_get_floatv_data_length (const xcb_glx_get_floatv_reply_t *R /**< */); +xcb_glx_get_floatv_data_length (const xcb_glx_get_floatv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R /**< */); +xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R); /** * Return the reply @@ -5485,12 +5652,12 @@ xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_floatv_reply_t * -xcb_glx_get_floatv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_floatv_reply (xcb_connection_t *c, xcb_glx_get_floatv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_integerv_sizeof (const void *_buffer /**< */); +xcb_glx_get_integerv_sizeof (const void *_buffer); /** * @@ -5501,9 +5668,9 @@ xcb_glx_get_integerv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_integerv_cookie_t -xcb_glx_get_integerv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */); +xcb_glx_get_integerv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname); /** * @@ -5517,18 +5684,18 @@ xcb_glx_get_integerv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_integerv_cookie_t -xcb_glx_get_integerv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t pname /**< */); +xcb_glx_get_integerv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t pname); int32_t * -xcb_glx_get_integerv_data (const xcb_glx_get_integerv_reply_t *R /**< */); +xcb_glx_get_integerv_data (const xcb_glx_get_integerv_reply_t *R); int -xcb_glx_get_integerv_data_length (const xcb_glx_get_integerv_reply_t *R /**< */); +xcb_glx_get_integerv_data_length (const xcb_glx_get_integerv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R /**< */); +xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R); /** * Return the reply @@ -5545,12 +5712,12 @@ xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_integerv_reply_t * -xcb_glx_get_integerv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_integerv_reply (xcb_connection_t *c, xcb_glx_get_integerv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_lightfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_lightfv_sizeof (const void *_buffer); /** * @@ -5561,10 +5728,10 @@ xcb_glx_get_lightfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_lightfv_cookie_t -xcb_glx_get_lightfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t light /**< */, - uint32_t pname /**< */); +xcb_glx_get_lightfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t light, + uint32_t pname); /** * @@ -5578,19 +5745,19 @@ xcb_glx_get_lightfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_lightfv_cookie_t -xcb_glx_get_lightfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t light /**< */, - uint32_t pname /**< */); +xcb_glx_get_lightfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t light, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_lightfv_data (const xcb_glx_get_lightfv_reply_t *R /**< */); +xcb_glx_get_lightfv_data (const xcb_glx_get_lightfv_reply_t *R); int -xcb_glx_get_lightfv_data_length (const xcb_glx_get_lightfv_reply_t *R /**< */); +xcb_glx_get_lightfv_data_length (const xcb_glx_get_lightfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R /**< */); +xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R); /** * Return the reply @@ -5607,12 +5774,12 @@ xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_lightfv_reply_t * -xcb_glx_get_lightfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_lightfv_reply (xcb_connection_t *c, xcb_glx_get_lightfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_lightiv_sizeof (const void *_buffer /**< */); +xcb_glx_get_lightiv_sizeof (const void *_buffer); /** * @@ -5623,10 +5790,10 @@ xcb_glx_get_lightiv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_lightiv_cookie_t -xcb_glx_get_lightiv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t light /**< */, - uint32_t pname /**< */); +xcb_glx_get_lightiv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t light, + uint32_t pname); /** * @@ -5640,19 +5807,19 @@ xcb_glx_get_lightiv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_lightiv_cookie_t -xcb_glx_get_lightiv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t light /**< */, - uint32_t pname /**< */); +xcb_glx_get_lightiv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t light, + uint32_t pname); int32_t * -xcb_glx_get_lightiv_data (const xcb_glx_get_lightiv_reply_t *R /**< */); +xcb_glx_get_lightiv_data (const xcb_glx_get_lightiv_reply_t *R); int -xcb_glx_get_lightiv_data_length (const xcb_glx_get_lightiv_reply_t *R /**< */); +xcb_glx_get_lightiv_data_length (const xcb_glx_get_lightiv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R /**< */); +xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R); /** * Return the reply @@ -5669,12 +5836,12 @@ xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_lightiv_reply_t * -xcb_glx_get_lightiv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_lightiv_reply (xcb_connection_t *c, xcb_glx_get_lightiv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_mapdv_sizeof (const void *_buffer /**< */); +xcb_glx_get_mapdv_sizeof (const void *_buffer); /** * @@ -5685,10 +5852,10 @@ xcb_glx_get_mapdv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_mapdv_cookie_t -xcb_glx_get_mapdv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */); +xcb_glx_get_mapdv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query); /** * @@ -5702,19 +5869,19 @@ xcb_glx_get_mapdv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_mapdv_cookie_t -xcb_glx_get_mapdv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */); +xcb_glx_get_mapdv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query); xcb_glx_float64_t * -xcb_glx_get_mapdv_data (const xcb_glx_get_mapdv_reply_t *R /**< */); +xcb_glx_get_mapdv_data (const xcb_glx_get_mapdv_reply_t *R); int -xcb_glx_get_mapdv_data_length (const xcb_glx_get_mapdv_reply_t *R /**< */); +xcb_glx_get_mapdv_data_length (const xcb_glx_get_mapdv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R /**< */); +xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R); /** * Return the reply @@ -5731,12 +5898,12 @@ xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_mapdv_reply_t * -xcb_glx_get_mapdv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_mapdv_reply (xcb_connection_t *c, xcb_glx_get_mapdv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_mapfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_mapfv_sizeof (const void *_buffer); /** * @@ -5747,10 +5914,10 @@ xcb_glx_get_mapfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_mapfv_cookie_t -xcb_glx_get_mapfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */); +xcb_glx_get_mapfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query); /** * @@ -5764,19 +5931,19 @@ xcb_glx_get_mapfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_mapfv_cookie_t -xcb_glx_get_mapfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */); +xcb_glx_get_mapfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query); xcb_glx_float32_t * -xcb_glx_get_mapfv_data (const xcb_glx_get_mapfv_reply_t *R /**< */); +xcb_glx_get_mapfv_data (const xcb_glx_get_mapfv_reply_t *R); int -xcb_glx_get_mapfv_data_length (const xcb_glx_get_mapfv_reply_t *R /**< */); +xcb_glx_get_mapfv_data_length (const xcb_glx_get_mapfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R /**< */); +xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R); /** * Return the reply @@ -5793,12 +5960,12 @@ xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_mapfv_reply_t * -xcb_glx_get_mapfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_mapfv_reply (xcb_connection_t *c, xcb_glx_get_mapfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_mapiv_sizeof (const void *_buffer /**< */); +xcb_glx_get_mapiv_sizeof (const void *_buffer); /** * @@ -5809,10 +5976,10 @@ xcb_glx_get_mapiv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_mapiv_cookie_t -xcb_glx_get_mapiv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */); +xcb_glx_get_mapiv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query); /** * @@ -5826,19 +5993,19 @@ xcb_glx_get_mapiv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_mapiv_cookie_t -xcb_glx_get_mapiv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t query /**< */); +xcb_glx_get_mapiv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t query); int32_t * -xcb_glx_get_mapiv_data (const xcb_glx_get_mapiv_reply_t *R /**< */); +xcb_glx_get_mapiv_data (const xcb_glx_get_mapiv_reply_t *R); int -xcb_glx_get_mapiv_data_length (const xcb_glx_get_mapiv_reply_t *R /**< */); +xcb_glx_get_mapiv_data_length (const xcb_glx_get_mapiv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R /**< */); +xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R); /** * Return the reply @@ -5855,12 +6022,12 @@ xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_mapiv_reply_t * -xcb_glx_get_mapiv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_mapiv_reply (xcb_connection_t *c, xcb_glx_get_mapiv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_materialfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_materialfv_sizeof (const void *_buffer); /** * @@ -5871,10 +6038,10 @@ xcb_glx_get_materialfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_materialfv_cookie_t -xcb_glx_get_materialfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t face /**< */, - uint32_t pname /**< */); +xcb_glx_get_materialfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t face, + uint32_t pname); /** * @@ -5888,19 +6055,19 @@ xcb_glx_get_materialfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_materialfv_cookie_t -xcb_glx_get_materialfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t face /**< */, - uint32_t pname /**< */); +xcb_glx_get_materialfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t face, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_materialfv_data (const xcb_glx_get_materialfv_reply_t *R /**< */); +xcb_glx_get_materialfv_data (const xcb_glx_get_materialfv_reply_t *R); int -xcb_glx_get_materialfv_data_length (const xcb_glx_get_materialfv_reply_t *R /**< */); +xcb_glx_get_materialfv_data_length (const xcb_glx_get_materialfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R /**< */); +xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R); /** * Return the reply @@ -5917,12 +6084,12 @@ xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R /**< * * The returned value must be freed by the caller using free(). */ xcb_glx_get_materialfv_reply_t * -xcb_glx_get_materialfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_materialfv_reply (xcb_connection_t *c, xcb_glx_get_materialfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_materialiv_sizeof (const void *_buffer /**< */); +xcb_glx_get_materialiv_sizeof (const void *_buffer); /** * @@ -5933,10 +6100,10 @@ xcb_glx_get_materialiv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_materialiv_cookie_t -xcb_glx_get_materialiv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t face /**< */, - uint32_t pname /**< */); +xcb_glx_get_materialiv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t face, + uint32_t pname); /** * @@ -5950,19 +6117,19 @@ xcb_glx_get_materialiv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_materialiv_cookie_t -xcb_glx_get_materialiv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t face /**< */, - uint32_t pname /**< */); +xcb_glx_get_materialiv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t face, + uint32_t pname); int32_t * -xcb_glx_get_materialiv_data (const xcb_glx_get_materialiv_reply_t *R /**< */); +xcb_glx_get_materialiv_data (const xcb_glx_get_materialiv_reply_t *R); int -xcb_glx_get_materialiv_data_length (const xcb_glx_get_materialiv_reply_t *R /**< */); +xcb_glx_get_materialiv_data_length (const xcb_glx_get_materialiv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R /**< */); +xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R); /** * Return the reply @@ -5979,12 +6146,12 @@ xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R /**< * * The returned value must be freed by the caller using free(). */ xcb_glx_get_materialiv_reply_t * -xcb_glx_get_materialiv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_materialiv_reply (xcb_connection_t *c, xcb_glx_get_materialiv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_pixel_mapfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_pixel_mapfv_sizeof (const void *_buffer); /** * @@ -5995,9 +6162,9 @@ xcb_glx_get_pixel_mapfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_pixel_mapfv_cookie_t -xcb_glx_get_pixel_mapfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */); +xcb_glx_get_pixel_mapfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map); /** * @@ -6011,18 +6178,18 @@ xcb_glx_get_pixel_mapfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_pixel_mapfv_cookie_t -xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */); +xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map); xcb_glx_float32_t * -xcb_glx_get_pixel_mapfv_data (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */); +xcb_glx_get_pixel_mapfv_data (const xcb_glx_get_pixel_mapfv_reply_t *R); int -xcb_glx_get_pixel_mapfv_data_length (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */); +xcb_glx_get_pixel_mapfv_data_length (const xcb_glx_get_pixel_mapfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R /**< */); +xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R); /** * Return the reply @@ -6039,12 +6206,12 @@ xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R /**< * The returned value must be freed by the caller using free(). */ xcb_glx_get_pixel_mapfv_reply_t * -xcb_glx_get_pixel_mapfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_pixel_mapfv_reply (xcb_connection_t *c, xcb_glx_get_pixel_mapfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_pixel_mapuiv_sizeof (const void *_buffer /**< */); +xcb_glx_get_pixel_mapuiv_sizeof (const void *_buffer); /** * @@ -6055,9 +6222,9 @@ xcb_glx_get_pixel_mapuiv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_pixel_mapuiv_cookie_t -xcb_glx_get_pixel_mapuiv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */); +xcb_glx_get_pixel_mapuiv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map); /** * @@ -6071,18 +6238,18 @@ xcb_glx_get_pixel_mapuiv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_pixel_mapuiv_cookie_t -xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */); +xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map); uint32_t * -xcb_glx_get_pixel_mapuiv_data (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */); +xcb_glx_get_pixel_mapuiv_data (const xcb_glx_get_pixel_mapuiv_reply_t *R); int -xcb_glx_get_pixel_mapuiv_data_length (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */); +xcb_glx_get_pixel_mapuiv_data_length (const xcb_glx_get_pixel_mapuiv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R /**< */); +xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R); /** * Return the reply @@ -6099,12 +6266,12 @@ xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R /* * The returned value must be freed by the caller using free(). */ xcb_glx_get_pixel_mapuiv_reply_t * -xcb_glx_get_pixel_mapuiv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_pixel_mapuiv_reply (xcb_connection_t *c, xcb_glx_get_pixel_mapuiv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_pixel_mapusv_sizeof (const void *_buffer /**< */); +xcb_glx_get_pixel_mapusv_sizeof (const void *_buffer); /** * @@ -6115,9 +6282,9 @@ xcb_glx_get_pixel_mapusv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_pixel_mapusv_cookie_t -xcb_glx_get_pixel_mapusv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */); +xcb_glx_get_pixel_mapusv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map); /** * @@ -6131,18 +6298,18 @@ xcb_glx_get_pixel_mapusv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_pixel_mapusv_cookie_t -xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t map /**< */); +xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t map); uint16_t * -xcb_glx_get_pixel_mapusv_data (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */); +xcb_glx_get_pixel_mapusv_data (const xcb_glx_get_pixel_mapusv_reply_t *R); int -xcb_glx_get_pixel_mapusv_data_length (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */); +xcb_glx_get_pixel_mapusv_data_length (const xcb_glx_get_pixel_mapusv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R /**< */); +xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R); /** * Return the reply @@ -6159,12 +6326,12 @@ xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R /* * The returned value must be freed by the caller using free(). */ xcb_glx_get_pixel_mapusv_reply_t * -xcb_glx_get_pixel_mapusv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_pixel_mapusv_reply (xcb_connection_t *c, xcb_glx_get_pixel_mapusv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_polygon_stipple_sizeof (const void *_buffer /**< */); +xcb_glx_get_polygon_stipple_sizeof (const void *_buffer); /** * @@ -6175,9 +6342,9 @@ xcb_glx_get_polygon_stipple_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_polygon_stipple_cookie_t -xcb_glx_get_polygon_stipple (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint8_t lsb_first /**< */); +xcb_glx_get_polygon_stipple (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint8_t lsb_first); /** * @@ -6191,18 +6358,18 @@ xcb_glx_get_polygon_stipple (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_polygon_stipple_cookie_t -xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint8_t lsb_first /**< */); +xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint8_t lsb_first); uint8_t * -xcb_glx_get_polygon_stipple_data (const xcb_glx_get_polygon_stipple_reply_t *R /**< */); +xcb_glx_get_polygon_stipple_data (const xcb_glx_get_polygon_stipple_reply_t *R); int -xcb_glx_get_polygon_stipple_data_length (const xcb_glx_get_polygon_stipple_reply_t *R /**< */); +xcb_glx_get_polygon_stipple_data_length (const xcb_glx_get_polygon_stipple_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t *R /**< */); +xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t *R); /** * Return the reply @@ -6219,12 +6386,12 @@ xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t * The returned value must be freed by the caller using free(). */ xcb_glx_get_polygon_stipple_reply_t * -xcb_glx_get_polygon_stipple_reply (xcb_connection_t *c /**< */, +xcb_glx_get_polygon_stipple_reply (xcb_connection_t *c, xcb_glx_get_polygon_stipple_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_string_sizeof (const void *_buffer /**< */); +xcb_glx_get_string_sizeof (const void *_buffer); /** * @@ -6235,9 +6402,9 @@ xcb_glx_get_string_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_string_cookie_t -xcb_glx_get_string (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t name /**< */); +xcb_glx_get_string (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t name); /** * @@ -6251,18 +6418,18 @@ xcb_glx_get_string (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_string_cookie_t -xcb_glx_get_string_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t name /**< */); +xcb_glx_get_string_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t name); char * -xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R /**< */); +xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R); int -xcb_glx_get_string_string_length (const xcb_glx_get_string_reply_t *R /**< */); +xcb_glx_get_string_string_length (const xcb_glx_get_string_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R /**< */); +xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R); /** * Return the reply @@ -6279,12 +6446,12 @@ xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_string_reply_t * -xcb_glx_get_string_reply (xcb_connection_t *c /**< */, +xcb_glx_get_string_reply (xcb_connection_t *c, xcb_glx_get_string_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_tex_envfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_tex_envfv_sizeof (const void *_buffer); /** * @@ -6295,10 +6462,10 @@ xcb_glx_get_tex_envfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_tex_envfv_cookie_t -xcb_glx_get_tex_envfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_envfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -6312,19 +6479,19 @@ xcb_glx_get_tex_envfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_tex_envfv_cookie_t -xcb_glx_get_tex_envfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_envfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_tex_envfv_data (const xcb_glx_get_tex_envfv_reply_t *R /**< */); +xcb_glx_get_tex_envfv_data (const xcb_glx_get_tex_envfv_reply_t *R); int -xcb_glx_get_tex_envfv_data_length (const xcb_glx_get_tex_envfv_reply_t *R /**< */); +xcb_glx_get_tex_envfv_data_length (const xcb_glx_get_tex_envfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R /**< */); +xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R); /** * Return the reply @@ -6341,12 +6508,12 @@ xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R /**< */) * The returned value must be freed by the caller using free(). */ xcb_glx_get_tex_envfv_reply_t * -xcb_glx_get_tex_envfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_envfv_reply (xcb_connection_t *c, xcb_glx_get_tex_envfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_tex_enviv_sizeof (const void *_buffer /**< */); +xcb_glx_get_tex_enviv_sizeof (const void *_buffer); /** * @@ -6357,10 +6524,10 @@ xcb_glx_get_tex_enviv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_tex_enviv_cookie_t -xcb_glx_get_tex_enviv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_enviv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -6374,19 +6541,19 @@ xcb_glx_get_tex_enviv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_tex_enviv_cookie_t -xcb_glx_get_tex_enviv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_enviv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); int32_t * -xcb_glx_get_tex_enviv_data (const xcb_glx_get_tex_enviv_reply_t *R /**< */); +xcb_glx_get_tex_enviv_data (const xcb_glx_get_tex_enviv_reply_t *R); int -xcb_glx_get_tex_enviv_data_length (const xcb_glx_get_tex_enviv_reply_t *R /**< */); +xcb_glx_get_tex_enviv_data_length (const xcb_glx_get_tex_enviv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R /**< */); +xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R); /** * Return the reply @@ -6403,12 +6570,12 @@ xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R /**< */) * The returned value must be freed by the caller using free(). */ xcb_glx_get_tex_enviv_reply_t * -xcb_glx_get_tex_enviv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_enviv_reply (xcb_connection_t *c, xcb_glx_get_tex_enviv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_tex_gendv_sizeof (const void *_buffer /**< */); +xcb_glx_get_tex_gendv_sizeof (const void *_buffer); /** * @@ -6419,10 +6586,10 @@ xcb_glx_get_tex_gendv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_tex_gendv_cookie_t -xcb_glx_get_tex_gendv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_gendv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname); /** * @@ -6436,19 +6603,19 @@ xcb_glx_get_tex_gendv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_tex_gendv_cookie_t -xcb_glx_get_tex_gendv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_gendv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname); xcb_glx_float64_t * -xcb_glx_get_tex_gendv_data (const xcb_glx_get_tex_gendv_reply_t *R /**< */); +xcb_glx_get_tex_gendv_data (const xcb_glx_get_tex_gendv_reply_t *R); int -xcb_glx_get_tex_gendv_data_length (const xcb_glx_get_tex_gendv_reply_t *R /**< */); +xcb_glx_get_tex_gendv_data_length (const xcb_glx_get_tex_gendv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R /**< */); +xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R); /** * Return the reply @@ -6465,12 +6632,12 @@ xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R /**< */) * The returned value must be freed by the caller using free(). */ xcb_glx_get_tex_gendv_reply_t * -xcb_glx_get_tex_gendv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_gendv_reply (xcb_connection_t *c, xcb_glx_get_tex_gendv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_tex_genfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_tex_genfv_sizeof (const void *_buffer); /** * @@ -6481,10 +6648,10 @@ xcb_glx_get_tex_genfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_tex_genfv_cookie_t -xcb_glx_get_tex_genfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_genfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname); /** * @@ -6498,19 +6665,19 @@ xcb_glx_get_tex_genfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_tex_genfv_cookie_t -xcb_glx_get_tex_genfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_genfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_tex_genfv_data (const xcb_glx_get_tex_genfv_reply_t *R /**< */); +xcb_glx_get_tex_genfv_data (const xcb_glx_get_tex_genfv_reply_t *R); int -xcb_glx_get_tex_genfv_data_length (const xcb_glx_get_tex_genfv_reply_t *R /**< */); +xcb_glx_get_tex_genfv_data_length (const xcb_glx_get_tex_genfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R /**< */); +xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R); /** * Return the reply @@ -6527,12 +6694,12 @@ xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R /**< */) * The returned value must be freed by the caller using free(). */ xcb_glx_get_tex_genfv_reply_t * -xcb_glx_get_tex_genfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_genfv_reply (xcb_connection_t *c, xcb_glx_get_tex_genfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_tex_geniv_sizeof (const void *_buffer /**< */); +xcb_glx_get_tex_geniv_sizeof (const void *_buffer); /** * @@ -6543,10 +6710,10 @@ xcb_glx_get_tex_geniv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_tex_geniv_cookie_t -xcb_glx_get_tex_geniv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_geniv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname); /** * @@ -6560,19 +6727,19 @@ xcb_glx_get_tex_geniv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_tex_geniv_cookie_t -xcb_glx_get_tex_geniv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t coord /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_geniv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t coord, + uint32_t pname); int32_t * -xcb_glx_get_tex_geniv_data (const xcb_glx_get_tex_geniv_reply_t *R /**< */); +xcb_glx_get_tex_geniv_data (const xcb_glx_get_tex_geniv_reply_t *R); int -xcb_glx_get_tex_geniv_data_length (const xcb_glx_get_tex_geniv_reply_t *R /**< */); +xcb_glx_get_tex_geniv_data_length (const xcb_glx_get_tex_geniv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R /**< */); +xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R); /** * Return the reply @@ -6589,12 +6756,12 @@ xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R /**< */) * The returned value must be freed by the caller using free(). */ xcb_glx_get_tex_geniv_reply_t * -xcb_glx_get_tex_geniv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_geniv_reply (xcb_connection_t *c, xcb_glx_get_tex_geniv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_tex_image_sizeof (const void *_buffer /**< */); +xcb_glx_get_tex_image_sizeof (const void *_buffer); /** * @@ -6605,13 +6772,13 @@ xcb_glx_get_tex_image_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_tex_image_cookie_t -xcb_glx_get_tex_image (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */); +xcb_glx_get_tex_image (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t format, + uint32_t type, + uint8_t swap_bytes); /** * @@ -6625,22 +6792,22 @@ xcb_glx_get_tex_image (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_tex_image_cookie_t -xcb_glx_get_tex_image_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */); +xcb_glx_get_tex_image_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t format, + uint32_t type, + uint8_t swap_bytes); uint8_t * -xcb_glx_get_tex_image_data (const xcb_glx_get_tex_image_reply_t *R /**< */); +xcb_glx_get_tex_image_data (const xcb_glx_get_tex_image_reply_t *R); int -xcb_glx_get_tex_image_data_length (const xcb_glx_get_tex_image_reply_t *R /**< */); +xcb_glx_get_tex_image_data_length (const xcb_glx_get_tex_image_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R /**< */); +xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R); /** * Return the reply @@ -6657,12 +6824,12 @@ xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R /**< */) * The returned value must be freed by the caller using free(). */ xcb_glx_get_tex_image_reply_t * -xcb_glx_get_tex_image_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_image_reply (xcb_connection_t *c, xcb_glx_get_tex_image_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_tex_parameterfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_tex_parameterfv_sizeof (const void *_buffer); /** * @@ -6673,10 +6840,10 @@ xcb_glx_get_tex_parameterfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_tex_parameterfv_cookie_t -xcb_glx_get_tex_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -6690,19 +6857,19 @@ xcb_glx_get_tex_parameterfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_tex_parameterfv_cookie_t -xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_tex_parameterfv_data (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */); +xcb_glx_get_tex_parameterfv_data (const xcb_glx_get_tex_parameterfv_reply_t *R); int -xcb_glx_get_tex_parameterfv_data_length (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */); +xcb_glx_get_tex_parameterfv_data_length (const xcb_glx_get_tex_parameterfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t *R /**< */); +xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t *R); /** * Return the reply @@ -6719,12 +6886,12 @@ xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t * The returned value must be freed by the caller using free(). */ xcb_glx_get_tex_parameterfv_reply_t * -xcb_glx_get_tex_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_tex_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_tex_parameteriv_sizeof (const void *_buffer /**< */); +xcb_glx_get_tex_parameteriv_sizeof (const void *_buffer); /** * @@ -6735,10 +6902,10 @@ xcb_glx_get_tex_parameteriv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_tex_parameteriv_cookie_t -xcb_glx_get_tex_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -6752,19 +6919,19 @@ xcb_glx_get_tex_parameteriv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_tex_parameteriv_cookie_t -xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); int32_t * -xcb_glx_get_tex_parameteriv_data (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */); +xcb_glx_get_tex_parameteriv_data (const xcb_glx_get_tex_parameteriv_reply_t *R); int -xcb_glx_get_tex_parameteriv_data_length (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */); +xcb_glx_get_tex_parameteriv_data_length (const xcb_glx_get_tex_parameteriv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t *R /**< */); +xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t *R); /** * Return the reply @@ -6781,12 +6948,12 @@ xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t * The returned value must be freed by the caller using free(). */ xcb_glx_get_tex_parameteriv_reply_t * -xcb_glx_get_tex_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_tex_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_tex_level_parameterfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_tex_level_parameterfv_sizeof (const void *_buffer); /** * @@ -6797,11 +6964,11 @@ xcb_glx_get_tex_level_parameterfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_tex_level_parameterfv_cookie_t -xcb_glx_get_tex_level_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_level_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t pname); /** * @@ -6815,20 +6982,20 @@ xcb_glx_get_tex_level_parameterfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_tex_level_parameterfv_cookie_t -xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_tex_level_parameterfv_data (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */); +xcb_glx_get_tex_level_parameterfv_data (const xcb_glx_get_tex_level_parameterfv_reply_t *R); int -xcb_glx_get_tex_level_parameterfv_data_length (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */); +xcb_glx_get_tex_level_parameterfv_data_length (const xcb_glx_get_tex_level_parameterfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_parameterfv_reply_t *R /**< */); +xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_parameterfv_reply_t *R); /** * Return the reply @@ -6845,12 +7012,12 @@ xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_paramete * The returned value must be freed by the caller using free(). */ xcb_glx_get_tex_level_parameterfv_reply_t * -xcb_glx_get_tex_level_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_level_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_tex_level_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_tex_level_parameteriv_sizeof (const void *_buffer /**< */); +xcb_glx_get_tex_level_parameteriv_sizeof (const void *_buffer); /** * @@ -6861,11 +7028,11 @@ xcb_glx_get_tex_level_parameteriv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_tex_level_parameteriv_cookie_t -xcb_glx_get_tex_level_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_level_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t pname); /** * @@ -6879,20 +7046,20 @@ xcb_glx_get_tex_level_parameteriv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_tex_level_parameteriv_cookie_t -xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */, - uint32_t pname /**< */); +xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level, + uint32_t pname); int32_t * -xcb_glx_get_tex_level_parameteriv_data (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */); +xcb_glx_get_tex_level_parameteriv_data (const xcb_glx_get_tex_level_parameteriv_reply_t *R); int -xcb_glx_get_tex_level_parameteriv_data_length (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */); +xcb_glx_get_tex_level_parameteriv_data_length (const xcb_glx_get_tex_level_parameteriv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_parameteriv_reply_t *R /**< */); +xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_parameteriv_reply_t *R); /** * Return the reply @@ -6909,9 +7076,57 @@ xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_paramete * The returned value must be freed by the caller using free(). */ xcb_glx_get_tex_level_parameteriv_reply_t * -xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_tex_level_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_glx_is_enabled_cookie_t +xcb_glx_is_enabled (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t capability); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_glx_is_enabled_cookie_t +xcb_glx_is_enabled_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t capability); + +/** + * 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 + * + * The parameter @p e supplied to this function must be NULL if + * xcb_glx_is_enabled_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_glx_is_enabled_reply_t * +xcb_glx_is_enabled_reply (xcb_connection_t *c, + xcb_glx_is_enabled_cookie_t cookie /**< */, + xcb_generic_error_t **e); /** * @@ -6922,9 +7137,9 @@ xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t * */ xcb_glx_is_list_cookie_t -xcb_glx_is_list (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */); +xcb_glx_is_list (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list); /** * @@ -6938,9 +7153,9 @@ xcb_glx_is_list (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_is_list_cookie_t -xcb_glx_is_list_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t list /**< */); +xcb_glx_is_list_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t list); /** * Return the reply @@ -6957,9 +7172,9 @@ xcb_glx_is_list_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_is_list_reply_t * -xcb_glx_is_list_reply (xcb_connection_t *c /**< */, +xcb_glx_is_list_reply (xcb_connection_t *c, xcb_glx_is_list_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -6973,8 +7188,8 @@ xcb_glx_is_list_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_flush_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_flush_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); /** * @@ -6985,11 +7200,11 @@ xcb_glx_flush_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_flush (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */); +xcb_glx_flush (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag); int -xcb_glx_are_textures_resident_sizeof (const void *_buffer /**< */); +xcb_glx_are_textures_resident_sizeof (const void *_buffer); /** * @@ -7000,10 +7215,10 @@ xcb_glx_are_textures_resident_sizeof (const void *_buffer /**< */); * */ xcb_glx_are_textures_resident_cookie_t -xcb_glx_are_textures_resident (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *textures /**< */); +xcb_glx_are_textures_resident (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *textures); /** * @@ -7017,19 +7232,19 @@ xcb_glx_are_textures_resident (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_are_textures_resident_cookie_t -xcb_glx_are_textures_resident_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *textures /**< */); +xcb_glx_are_textures_resident_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *textures); uint8_t * -xcb_glx_are_textures_resident_data (const xcb_glx_are_textures_resident_reply_t *R /**< */); +xcb_glx_are_textures_resident_data (const xcb_glx_are_textures_resident_reply_t *R); int -xcb_glx_are_textures_resident_data_length (const xcb_glx_are_textures_resident_reply_t *R /**< */); +xcb_glx_are_textures_resident_data_length (const xcb_glx_are_textures_resident_reply_t *R); xcb_generic_iterator_t -xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_reply_t *R /**< */); +xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_reply_t *R); /** * Return the reply @@ -7046,12 +7261,12 @@ xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_repl * The returned value must be freed by the caller using free(). */ xcb_glx_are_textures_resident_reply_t * -xcb_glx_are_textures_resident_reply (xcb_connection_t *c /**< */, +xcb_glx_are_textures_resident_reply (xcb_connection_t *c, xcb_glx_are_textures_resident_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_delete_textures_sizeof (const void *_buffer /**< */); +xcb_glx_delete_textures_sizeof (const void *_buffer); /** * @@ -7065,10 +7280,10 @@ xcb_glx_delete_textures_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_delete_textures_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *textures /**< */); +xcb_glx_delete_textures_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *textures); /** * @@ -7079,13 +7294,22 @@ xcb_glx_delete_textures_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_delete_textures (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *textures /**< */); +xcb_glx_delete_textures (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *textures); + +uint32_t * +xcb_glx_delete_textures_textures (const xcb_glx_delete_textures_request_t *R); int -xcb_glx_gen_textures_sizeof (const void *_buffer /**< */); +xcb_glx_delete_textures_textures_length (const xcb_glx_delete_textures_request_t *R); + +xcb_generic_iterator_t +xcb_glx_delete_textures_textures_end (const xcb_glx_delete_textures_request_t *R); + +int +xcb_glx_gen_textures_sizeof (const void *_buffer); /** * @@ -7096,9 +7320,9 @@ xcb_glx_gen_textures_sizeof (const void *_buffer /**< */); * */ xcb_glx_gen_textures_cookie_t -xcb_glx_gen_textures (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */); +xcb_glx_gen_textures (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n); /** * @@ -7112,18 +7336,18 @@ xcb_glx_gen_textures (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_gen_textures_cookie_t -xcb_glx_gen_textures_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */); +xcb_glx_gen_textures_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n); uint32_t * -xcb_glx_gen_textures_data (const xcb_glx_gen_textures_reply_t *R /**< */); +xcb_glx_gen_textures_data (const xcb_glx_gen_textures_reply_t *R); int -xcb_glx_gen_textures_data_length (const xcb_glx_gen_textures_reply_t *R /**< */); +xcb_glx_gen_textures_data_length (const xcb_glx_gen_textures_reply_t *R); xcb_generic_iterator_t -xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R /**< */); +xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R); /** * Return the reply @@ -7140,9 +7364,9 @@ xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_gen_textures_reply_t * -xcb_glx_gen_textures_reply (xcb_connection_t *c /**< */, +xcb_glx_gen_textures_reply (xcb_connection_t *c, xcb_glx_gen_textures_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -7153,9 +7377,9 @@ xcb_glx_gen_textures_reply (xcb_connection_t *c /**< */, * */ xcb_glx_is_texture_cookie_t -xcb_glx_is_texture (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t texture /**< */); +xcb_glx_is_texture (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t texture); /** * @@ -7169,9 +7393,9 @@ xcb_glx_is_texture (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_is_texture_cookie_t -xcb_glx_is_texture_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t texture /**< */); +xcb_glx_is_texture_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t texture); /** * Return the reply @@ -7188,12 +7412,12 @@ xcb_glx_is_texture_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_is_texture_reply_t * -xcb_glx_is_texture_reply (xcb_connection_t *c /**< */, +xcb_glx_is_texture_reply (xcb_connection_t *c, xcb_glx_is_texture_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_color_table_sizeof (const void *_buffer /**< */); +xcb_glx_get_color_table_sizeof (const void *_buffer); /** * @@ -7204,12 +7428,12 @@ xcb_glx_get_color_table_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_color_table_cookie_t -xcb_glx_get_color_table (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */); +xcb_glx_get_color_table (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes); /** * @@ -7223,21 +7447,21 @@ xcb_glx_get_color_table (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_color_table_cookie_t -xcb_glx_get_color_table_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */); +xcb_glx_get_color_table_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes); uint8_t * -xcb_glx_get_color_table_data (const xcb_glx_get_color_table_reply_t *R /**< */); +xcb_glx_get_color_table_data (const xcb_glx_get_color_table_reply_t *R); int -xcb_glx_get_color_table_data_length (const xcb_glx_get_color_table_reply_t *R /**< */); +xcb_glx_get_color_table_data_length (const xcb_glx_get_color_table_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R /**< */); +xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R); /** * Return the reply @@ -7254,12 +7478,12 @@ xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R /**< * The returned value must be freed by the caller using free(). */ xcb_glx_get_color_table_reply_t * -xcb_glx_get_color_table_reply (xcb_connection_t *c /**< */, +xcb_glx_get_color_table_reply (xcb_connection_t *c, xcb_glx_get_color_table_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_color_table_parameterfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_color_table_parameterfv_sizeof (const void *_buffer); /** * @@ -7270,10 +7494,10 @@ xcb_glx_get_color_table_parameterfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_color_table_parameterfv_cookie_t -xcb_glx_get_color_table_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_color_table_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -7287,19 +7511,19 @@ xcb_glx_get_color_table_parameterfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_color_table_parameterfv_cookie_t -xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_color_table_parameterfv_data (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */); +xcb_glx_get_color_table_parameterfv_data (const xcb_glx_get_color_table_parameterfv_reply_t *R); int -xcb_glx_get_color_table_parameterfv_data_length (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */); +xcb_glx_get_color_table_parameterfv_data_length (const xcb_glx_get_color_table_parameterfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_parameterfv_reply_t *R /**< */); +xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_parameterfv_reply_t *R); /** * Return the reply @@ -7316,12 +7540,12 @@ xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_para * The returned value must be freed by the caller using free(). */ xcb_glx_get_color_table_parameterfv_reply_t * -xcb_glx_get_color_table_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_color_table_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_color_table_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_color_table_parameteriv_sizeof (const void *_buffer /**< */); +xcb_glx_get_color_table_parameteriv_sizeof (const void *_buffer); /** * @@ -7332,10 +7556,10 @@ xcb_glx_get_color_table_parameteriv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_color_table_parameteriv_cookie_t -xcb_glx_get_color_table_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_color_table_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -7349,19 +7573,19 @@ xcb_glx_get_color_table_parameteriv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_color_table_parameteriv_cookie_t -xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); int32_t * -xcb_glx_get_color_table_parameteriv_data (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */); +xcb_glx_get_color_table_parameteriv_data (const xcb_glx_get_color_table_parameteriv_reply_t *R); int -xcb_glx_get_color_table_parameteriv_data_length (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */); +xcb_glx_get_color_table_parameteriv_data_length (const xcb_glx_get_color_table_parameteriv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_parameteriv_reply_t *R /**< */); +xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_parameteriv_reply_t *R); /** * Return the reply @@ -7378,12 +7602,12 @@ xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_para * The returned value must be freed by the caller using free(). */ xcb_glx_get_color_table_parameteriv_reply_t * -xcb_glx_get_color_table_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_color_table_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_color_table_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_convolution_filter_sizeof (const void *_buffer /**< */); +xcb_glx_get_convolution_filter_sizeof (const void *_buffer); /** * @@ -7394,12 +7618,12 @@ xcb_glx_get_convolution_filter_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_convolution_filter_cookie_t -xcb_glx_get_convolution_filter (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */); +xcb_glx_get_convolution_filter (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes); /** * @@ -7413,21 +7637,21 @@ xcb_glx_get_convolution_filter (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_convolution_filter_cookie_t -xcb_glx_get_convolution_filter_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */); +xcb_glx_get_convolution_filter_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes); uint8_t * -xcb_glx_get_convolution_filter_data (const xcb_glx_get_convolution_filter_reply_t *R /**< */); +xcb_glx_get_convolution_filter_data (const xcb_glx_get_convolution_filter_reply_t *R); int -xcb_glx_get_convolution_filter_data_length (const xcb_glx_get_convolution_filter_reply_t *R /**< */); +xcb_glx_get_convolution_filter_data_length (const xcb_glx_get_convolution_filter_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_reply_t *R /**< */); +xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_reply_t *R); /** * Return the reply @@ -7444,12 +7668,12 @@ xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_re * The returned value must be freed by the caller using free(). */ xcb_glx_get_convolution_filter_reply_t * -xcb_glx_get_convolution_filter_reply (xcb_connection_t *c /**< */, +xcb_glx_get_convolution_filter_reply (xcb_connection_t *c, xcb_glx_get_convolution_filter_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_convolution_parameterfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_convolution_parameterfv_sizeof (const void *_buffer); /** * @@ -7460,10 +7684,10 @@ xcb_glx_get_convolution_parameterfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_convolution_parameterfv_cookie_t -xcb_glx_get_convolution_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_convolution_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -7477,19 +7701,19 @@ xcb_glx_get_convolution_parameterfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_convolution_parameterfv_cookie_t -xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_convolution_parameterfv_data (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */); +xcb_glx_get_convolution_parameterfv_data (const xcb_glx_get_convolution_parameterfv_reply_t *R); int -xcb_glx_get_convolution_parameterfv_data_length (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */); +xcb_glx_get_convolution_parameterfv_data_length (const xcb_glx_get_convolution_parameterfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_parameterfv_reply_t *R /**< */); +xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_parameterfv_reply_t *R); /** * Return the reply @@ -7506,12 +7730,12 @@ xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_para * The returned value must be freed by the caller using free(). */ xcb_glx_get_convolution_parameterfv_reply_t * -xcb_glx_get_convolution_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_convolution_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_convolution_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_convolution_parameteriv_sizeof (const void *_buffer /**< */); +xcb_glx_get_convolution_parameteriv_sizeof (const void *_buffer); /** * @@ -7522,10 +7746,10 @@ xcb_glx_get_convolution_parameteriv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_convolution_parameteriv_cookie_t -xcb_glx_get_convolution_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_convolution_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -7539,19 +7763,19 @@ xcb_glx_get_convolution_parameteriv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_convolution_parameteriv_cookie_t -xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); int32_t * -xcb_glx_get_convolution_parameteriv_data (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */); +xcb_glx_get_convolution_parameteriv_data (const xcb_glx_get_convolution_parameteriv_reply_t *R); int -xcb_glx_get_convolution_parameteriv_data_length (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */); +xcb_glx_get_convolution_parameteriv_data_length (const xcb_glx_get_convolution_parameteriv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_parameteriv_reply_t *R /**< */); +xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_parameteriv_reply_t *R); /** * Return the reply @@ -7568,12 +7792,12 @@ xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_para * The returned value must be freed by the caller using free(). */ xcb_glx_get_convolution_parameteriv_reply_t * -xcb_glx_get_convolution_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_convolution_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_convolution_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_separable_filter_sizeof (const void *_buffer /**< */); +xcb_glx_get_separable_filter_sizeof (const void *_buffer); /** * @@ -7584,12 +7808,12 @@ xcb_glx_get_separable_filter_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_separable_filter_cookie_t -xcb_glx_get_separable_filter (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */); +xcb_glx_get_separable_filter (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes); /** * @@ -7603,21 +7827,21 @@ xcb_glx_get_separable_filter (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_separable_filter_cookie_t -xcb_glx_get_separable_filter_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */); +xcb_glx_get_separable_filter_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes); uint8_t * -xcb_glx_get_separable_filter_rows_and_cols (const xcb_glx_get_separable_filter_reply_t *R /**< */); +xcb_glx_get_separable_filter_rows_and_cols (const xcb_glx_get_separable_filter_reply_t *R); int -xcb_glx_get_separable_filter_rows_and_cols_length (const xcb_glx_get_separable_filter_reply_t *R /**< */); +xcb_glx_get_separable_filter_rows_and_cols_length (const xcb_glx_get_separable_filter_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filter_reply_t *R /**< */); +xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filter_reply_t *R); /** * Return the reply @@ -7634,12 +7858,12 @@ xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filt * The returned value must be freed by the caller using free(). */ xcb_glx_get_separable_filter_reply_t * -xcb_glx_get_separable_filter_reply (xcb_connection_t *c /**< */, +xcb_glx_get_separable_filter_reply (xcb_connection_t *c, xcb_glx_get_separable_filter_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_histogram_sizeof (const void *_buffer /**< */); +xcb_glx_get_histogram_sizeof (const void *_buffer); /** * @@ -7650,13 +7874,13 @@ xcb_glx_get_histogram_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_histogram_cookie_t -xcb_glx_get_histogram (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t reset /**< */); +xcb_glx_get_histogram (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t reset); /** * @@ -7670,22 +7894,22 @@ xcb_glx_get_histogram (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_histogram_cookie_t -xcb_glx_get_histogram_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t reset /**< */); +xcb_glx_get_histogram_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t reset); uint8_t * -xcb_glx_get_histogram_data (const xcb_glx_get_histogram_reply_t *R /**< */); +xcb_glx_get_histogram_data (const xcb_glx_get_histogram_reply_t *R); int -xcb_glx_get_histogram_data_length (const xcb_glx_get_histogram_reply_t *R /**< */); +xcb_glx_get_histogram_data_length (const xcb_glx_get_histogram_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R /**< */); +xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R); /** * Return the reply @@ -7702,12 +7926,12 @@ xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R /**< */) * The returned value must be freed by the caller using free(). */ xcb_glx_get_histogram_reply_t * -xcb_glx_get_histogram_reply (xcb_connection_t *c /**< */, +xcb_glx_get_histogram_reply (xcb_connection_t *c, xcb_glx_get_histogram_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_histogram_parameterfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_histogram_parameterfv_sizeof (const void *_buffer); /** * @@ -7718,10 +7942,10 @@ xcb_glx_get_histogram_parameterfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_histogram_parameterfv_cookie_t -xcb_glx_get_histogram_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_histogram_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -7735,19 +7959,19 @@ xcb_glx_get_histogram_parameterfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_histogram_parameterfv_cookie_t -xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_histogram_parameterfv_data (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */); +xcb_glx_get_histogram_parameterfv_data (const xcb_glx_get_histogram_parameterfv_reply_t *R); int -xcb_glx_get_histogram_parameterfv_data_length (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */); +xcb_glx_get_histogram_parameterfv_data_length (const xcb_glx_get_histogram_parameterfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_parameterfv_reply_t *R /**< */); +xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_parameterfv_reply_t *R); /** * Return the reply @@ -7764,12 +7988,12 @@ xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_paramete * The returned value must be freed by the caller using free(). */ xcb_glx_get_histogram_parameterfv_reply_t * -xcb_glx_get_histogram_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_histogram_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_histogram_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_histogram_parameteriv_sizeof (const void *_buffer /**< */); +xcb_glx_get_histogram_parameteriv_sizeof (const void *_buffer); /** * @@ -7780,10 +8004,10 @@ xcb_glx_get_histogram_parameteriv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_histogram_parameteriv_cookie_t -xcb_glx_get_histogram_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_histogram_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -7797,19 +8021,19 @@ xcb_glx_get_histogram_parameteriv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_histogram_parameteriv_cookie_t -xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); int32_t * -xcb_glx_get_histogram_parameteriv_data (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */); +xcb_glx_get_histogram_parameteriv_data (const xcb_glx_get_histogram_parameteriv_reply_t *R); int -xcb_glx_get_histogram_parameteriv_data_length (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */); +xcb_glx_get_histogram_parameteriv_data_length (const xcb_glx_get_histogram_parameteriv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_parameteriv_reply_t *R /**< */); +xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_parameteriv_reply_t *R); /** * Return the reply @@ -7826,12 +8050,12 @@ xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_paramete * The returned value must be freed by the caller using free(). */ xcb_glx_get_histogram_parameteriv_reply_t * -xcb_glx_get_histogram_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_histogram_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_histogram_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_minmax_sizeof (const void *_buffer /**< */); +xcb_glx_get_minmax_sizeof (const void *_buffer); /** * @@ -7842,13 +8066,13 @@ xcb_glx_get_minmax_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_minmax_cookie_t -xcb_glx_get_minmax (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t reset /**< */); +xcb_glx_get_minmax (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t reset); /** * @@ -7862,22 +8086,22 @@ xcb_glx_get_minmax (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_minmax_cookie_t -xcb_glx_get_minmax_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t format /**< */, - uint32_t type /**< */, - uint8_t swap_bytes /**< */, - uint8_t reset /**< */); +xcb_glx_get_minmax_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t format, + uint32_t type, + uint8_t swap_bytes, + uint8_t reset); uint8_t * -xcb_glx_get_minmax_data (const xcb_glx_get_minmax_reply_t *R /**< */); +xcb_glx_get_minmax_data (const xcb_glx_get_minmax_reply_t *R); int -xcb_glx_get_minmax_data_length (const xcb_glx_get_minmax_reply_t *R /**< */); +xcb_glx_get_minmax_data_length (const xcb_glx_get_minmax_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R /**< */); +xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R); /** * Return the reply @@ -7894,12 +8118,12 @@ xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_glx_get_minmax_reply_t * -xcb_glx_get_minmax_reply (xcb_connection_t *c /**< */, +xcb_glx_get_minmax_reply (xcb_connection_t *c, xcb_glx_get_minmax_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_minmax_parameterfv_sizeof (const void *_buffer /**< */); +xcb_glx_get_minmax_parameterfv_sizeof (const void *_buffer); /** * @@ -7910,10 +8134,10 @@ xcb_glx_get_minmax_parameterfv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_minmax_parameterfv_cookie_t -xcb_glx_get_minmax_parameterfv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_minmax_parameterfv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -7927,19 +8151,19 @@ xcb_glx_get_minmax_parameterfv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_minmax_parameterfv_cookie_t -xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); xcb_glx_float32_t * -xcb_glx_get_minmax_parameterfv_data (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */); +xcb_glx_get_minmax_parameterfv_data (const xcb_glx_get_minmax_parameterfv_reply_t *R); int -xcb_glx_get_minmax_parameterfv_data_length (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */); +xcb_glx_get_minmax_parameterfv_data_length (const xcb_glx_get_minmax_parameterfv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_reply_t *R /**< */); +xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_reply_t *R); /** * Return the reply @@ -7956,12 +8180,12 @@ xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_re * The returned value must be freed by the caller using free(). */ xcb_glx_get_minmax_parameterfv_reply_t * -xcb_glx_get_minmax_parameterfv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_minmax_parameterfv_reply (xcb_connection_t *c, xcb_glx_get_minmax_parameterfv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_minmax_parameteriv_sizeof (const void *_buffer /**< */); +xcb_glx_get_minmax_parameteriv_sizeof (const void *_buffer); /** * @@ -7972,10 +8196,10 @@ xcb_glx_get_minmax_parameteriv_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_minmax_parameteriv_cookie_t -xcb_glx_get_minmax_parameteriv (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_minmax_parameteriv (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -7989,19 +8213,19 @@ xcb_glx_get_minmax_parameteriv (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_minmax_parameteriv_cookie_t -xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); int32_t * -xcb_glx_get_minmax_parameteriv_data (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */); +xcb_glx_get_minmax_parameteriv_data (const xcb_glx_get_minmax_parameteriv_reply_t *R); int -xcb_glx_get_minmax_parameteriv_data_length (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */); +xcb_glx_get_minmax_parameteriv_data_length (const xcb_glx_get_minmax_parameteriv_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_reply_t *R /**< */); +xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_reply_t *R); /** * Return the reply @@ -8018,12 +8242,12 @@ xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_re * The returned value must be freed by the caller using free(). */ xcb_glx_get_minmax_parameteriv_reply_t * -xcb_glx_get_minmax_parameteriv_reply (xcb_connection_t *c /**< */, +xcb_glx_get_minmax_parameteriv_reply (xcb_connection_t *c, xcb_glx_get_minmax_parameteriv_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_compressed_tex_image_arb_sizeof (const void *_buffer /**< */); +xcb_glx_get_compressed_tex_image_arb_sizeof (const void *_buffer); /** * @@ -8034,10 +8258,10 @@ xcb_glx_get_compressed_tex_image_arb_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_compressed_tex_image_arb_cookie_t -xcb_glx_get_compressed_tex_image_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */); +xcb_glx_get_compressed_tex_image_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level); /** * @@ -8051,19 +8275,19 @@ xcb_glx_get_compressed_tex_image_arb (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_compressed_tex_image_arb_cookie_t -xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - int32_t level /**< */); +xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + int32_t level); uint8_t * -xcb_glx_get_compressed_tex_image_arb_data (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */); +xcb_glx_get_compressed_tex_image_arb_data (const xcb_glx_get_compressed_tex_image_arb_reply_t *R); int -xcb_glx_get_compressed_tex_image_arb_data_length (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */); +xcb_glx_get_compressed_tex_image_arb_data_length (const xcb_glx_get_compressed_tex_image_arb_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_image_arb_reply_t *R /**< */); +xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_image_arb_reply_t *R); /** * Return the reply @@ -8080,12 +8304,12 @@ xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_ * The returned value must be freed by the caller using free(). */ xcb_glx_get_compressed_tex_image_arb_reply_t * -xcb_glx_get_compressed_tex_image_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_get_compressed_tex_image_arb_reply (xcb_connection_t *c, xcb_glx_get_compressed_tex_image_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_delete_queries_arb_sizeof (const void *_buffer /**< */); +xcb_glx_delete_queries_arb_sizeof (const void *_buffer); /** * @@ -8099,10 +8323,10 @@ xcb_glx_delete_queries_arb_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_glx_delete_queries_arb_checked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *ids /**< */); +xcb_glx_delete_queries_arb_checked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *ids); /** * @@ -8113,13 +8337,22 @@ xcb_glx_delete_queries_arb_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_glx_delete_queries_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */, - const uint32_t *ids /**< */); +xcb_glx_delete_queries_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n, + const uint32_t *ids); + +uint32_t * +xcb_glx_delete_queries_arb_ids (const xcb_glx_delete_queries_arb_request_t *R); int -xcb_glx_gen_queries_arb_sizeof (const void *_buffer /**< */); +xcb_glx_delete_queries_arb_ids_length (const xcb_glx_delete_queries_arb_request_t *R); + +xcb_generic_iterator_t +xcb_glx_delete_queries_arb_ids_end (const xcb_glx_delete_queries_arb_request_t *R); + +int +xcb_glx_gen_queries_arb_sizeof (const void *_buffer); /** * @@ -8130,9 +8363,9 @@ xcb_glx_gen_queries_arb_sizeof (const void *_buffer /**< */); * */ xcb_glx_gen_queries_arb_cookie_t -xcb_glx_gen_queries_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */); +xcb_glx_gen_queries_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n); /** * @@ -8146,18 +8379,18 @@ xcb_glx_gen_queries_arb (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_gen_queries_arb_cookie_t -xcb_glx_gen_queries_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - int32_t n /**< */); +xcb_glx_gen_queries_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + int32_t n); uint32_t * -xcb_glx_gen_queries_arb_data (const xcb_glx_gen_queries_arb_reply_t *R /**< */); +xcb_glx_gen_queries_arb_data (const xcb_glx_gen_queries_arb_reply_t *R); int -xcb_glx_gen_queries_arb_data_length (const xcb_glx_gen_queries_arb_reply_t *R /**< */); +xcb_glx_gen_queries_arb_data_length (const xcb_glx_gen_queries_arb_reply_t *R); xcb_generic_iterator_t -xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R /**< */); +xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R); /** * Return the reply @@ -8174,9 +8407,9 @@ xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R /**< * The returned value must be freed by the caller using free(). */ xcb_glx_gen_queries_arb_reply_t * -xcb_glx_gen_queries_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_gen_queries_arb_reply (xcb_connection_t *c, xcb_glx_gen_queries_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -8187,9 +8420,9 @@ xcb_glx_gen_queries_arb_reply (xcb_connection_t *c /**< */, * */ xcb_glx_is_query_arb_cookie_t -xcb_glx_is_query_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */); +xcb_glx_is_query_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id); /** * @@ -8203,9 +8436,9 @@ xcb_glx_is_query_arb (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_is_query_arb_cookie_t -xcb_glx_is_query_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */); +xcb_glx_is_query_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id); /** * Return the reply @@ -8222,12 +8455,12 @@ xcb_glx_is_query_arb_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_glx_is_query_arb_reply_t * -xcb_glx_is_query_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_is_query_arb_reply (xcb_connection_t *c, xcb_glx_is_query_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_queryiv_arb_sizeof (const void *_buffer /**< */); +xcb_glx_get_queryiv_arb_sizeof (const void *_buffer); /** * @@ -8238,10 +8471,10 @@ xcb_glx_get_queryiv_arb_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_queryiv_arb_cookie_t -xcb_glx_get_queryiv_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_queryiv_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); /** * @@ -8255,19 +8488,19 @@ xcb_glx_get_queryiv_arb (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_queryiv_arb_cookie_t -xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t target /**< */, - uint32_t pname /**< */); +xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t target, + uint32_t pname); int32_t * -xcb_glx_get_queryiv_arb_data (const xcb_glx_get_queryiv_arb_reply_t *R /**< */); +xcb_glx_get_queryiv_arb_data (const xcb_glx_get_queryiv_arb_reply_t *R); int -xcb_glx_get_queryiv_arb_data_length (const xcb_glx_get_queryiv_arb_reply_t *R /**< */); +xcb_glx_get_queryiv_arb_data_length (const xcb_glx_get_queryiv_arb_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R /**< */); +xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R); /** * Return the reply @@ -8284,12 +8517,12 @@ xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R /**< * The returned value must be freed by the caller using free(). */ xcb_glx_get_queryiv_arb_reply_t * -xcb_glx_get_queryiv_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_get_queryiv_arb_reply (xcb_connection_t *c, xcb_glx_get_queryiv_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_query_objectiv_arb_sizeof (const void *_buffer /**< */); +xcb_glx_get_query_objectiv_arb_sizeof (const void *_buffer); /** * @@ -8300,10 +8533,10 @@ xcb_glx_get_query_objectiv_arb_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_query_objectiv_arb_cookie_t -xcb_glx_get_query_objectiv_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */, - uint32_t pname /**< */); +xcb_glx_get_query_objectiv_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id, + uint32_t pname); /** * @@ -8317,19 +8550,19 @@ xcb_glx_get_query_objectiv_arb (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_query_objectiv_arb_cookie_t -xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */, - uint32_t pname /**< */); +xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id, + uint32_t pname); int32_t * -xcb_glx_get_query_objectiv_arb_data (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */); +xcb_glx_get_query_objectiv_arb_data (const xcb_glx_get_query_objectiv_arb_reply_t *R); int -xcb_glx_get_query_objectiv_arb_data_length (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */); +xcb_glx_get_query_objectiv_arb_data_length (const xcb_glx_get_query_objectiv_arb_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_reply_t *R /**< */); +xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_reply_t *R); /** * Return the reply @@ -8346,12 +8579,12 @@ xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_re * The returned value must be freed by the caller using free(). */ xcb_glx_get_query_objectiv_arb_reply_t * -xcb_glx_get_query_objectiv_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_get_query_objectiv_arb_reply (xcb_connection_t *c, xcb_glx_get_query_objectiv_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_glx_get_query_objectuiv_arb_sizeof (const void *_buffer /**< */); +xcb_glx_get_query_objectuiv_arb_sizeof (const void *_buffer); /** * @@ -8362,10 +8595,10 @@ xcb_glx_get_query_objectuiv_arb_sizeof (const void *_buffer /**< */); * */ xcb_glx_get_query_objectuiv_arb_cookie_t -xcb_glx_get_query_objectuiv_arb (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */, - uint32_t pname /**< */); +xcb_glx_get_query_objectuiv_arb (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id, + uint32_t pname); /** * @@ -8379,19 +8612,19 @@ xcb_glx_get_query_objectuiv_arb (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_glx_get_query_objectuiv_arb_cookie_t -xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t *c /**< */, - xcb_glx_context_tag_t context_tag /**< */, - uint32_t id /**< */, - uint32_t pname /**< */); +xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t *c, + xcb_glx_context_tag_t context_tag, + uint32_t id, + uint32_t pname); uint32_t * -xcb_glx_get_query_objectuiv_arb_data (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */); +xcb_glx_get_query_objectuiv_arb_data (const xcb_glx_get_query_objectuiv_arb_reply_t *R); int -xcb_glx_get_query_objectuiv_arb_data_length (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */); +xcb_glx_get_query_objectuiv_arb_data_length (const xcb_glx_get_query_objectuiv_arb_reply_t *R); xcb_generic_iterator_t -xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_reply_t *R /**< */); +xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_reply_t *R); /** * Return the reply @@ -8408,9 +8641,9 @@ xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_ * The returned value must be freed by the caller using free(). */ xcb_glx_get_query_objectuiv_arb_reply_t * -xcb_glx_get_query_objectuiv_arb_reply (xcb_connection_t *c /**< */, +xcb_glx_get_query_objectuiv_arb_reply (xcb_connection_t *c, xcb_glx_get_query_objectuiv_arb_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/present.c b/lib/libxcb/src/present.c index 12faec693..27aeecc47 100644 --- a/lib/libxcb/src/present.c +++ b/lib/libxcb/src/present.c @@ -22,7 +22,7 @@ xcb_extension_t xcb_present_id = { "Present", 0 }; void -xcb_present_notify_next (xcb_present_notify_iterator_t *i /**< */) +xcb_present_notify_next (xcb_present_notify_iterator_t *i) { --i->rem; ++i->data; @@ -30,7 +30,7 @@ xcb_present_notify_next (xcb_present_notify_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_present_notify_end (xcb_present_notify_iterator_t i /**< */) +xcb_present_notify_end (xcb_present_notify_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -40,15 +40,15 @@ xcb_present_notify_end (xcb_present_notify_iterator_t i /**< */) } xcb_present_query_version_cookie_t -xcb_present_query_version (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */) +xcb_present_query_version (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_present_id, - /* opcode */ XCB_PRESENT_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_present_id, + .opcode = XCB_PRESENT_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -68,15 +68,15 @@ xcb_present_query_version (xcb_connection_t *c /**< */, } xcb_present_query_version_cookie_t -xcb_present_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */) +xcb_present_query_version_unchecked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_present_id, - /* opcode */ XCB_PRESENT_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_present_id, + .opcode = XCB_PRESENT_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -96,16 +96,16 @@ xcb_present_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_present_query_version_reply_t * -xcb_present_query_version_reply (xcb_connection_t *c /**< */, +xcb_present_query_version_reply (xcb_connection_t *c, xcb_present_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_present_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_present_pixmap_sizeof (const void *_buffer /**< */, - uint32_t notifies_len /**< */) +xcb_present_pixmap_sizeof (const void *_buffer, + uint32_t notifies_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -135,29 +135,29 @@ xcb_present_pixmap_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_present_pixmap_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_pixmap_t pixmap /**< */, - uint32_t serial /**< */, - xcb_xfixes_region_t valid /**< */, - xcb_xfixes_region_t update /**< */, - int16_t x_off /**< */, - int16_t y_off /**< */, - xcb_randr_crtc_t target_crtc /**< */, - xcb_sync_fence_t wait_fence /**< */, - xcb_sync_fence_t idle_fence /**< */, - uint32_t options /**< */, - uint64_t target_msc /**< */, - uint64_t divisor /**< */, - uint64_t remainder /**< */, - uint32_t notifies_len /**< */, - const xcb_present_notify_t *notifies /**< */) +xcb_present_pixmap_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_pixmap_t pixmap, + uint32_t serial, + xcb_xfixes_region_t valid, + xcb_xfixes_region_t update, + int16_t x_off, + int16_t y_off, + xcb_randr_crtc_t target_crtc, + xcb_sync_fence_t wait_fence, + xcb_sync_fence_t idle_fence, + uint32_t options, + uint64_t target_msc, + uint64_t divisor, + uint64_t remainder, + uint32_t notifies_len, + const xcb_present_notify_t *notifies) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_present_id, - /* opcode */ XCB_PRESENT_PIXMAP, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_present_id, + .opcode = XCB_PRESENT_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -195,29 +195,29 @@ xcb_present_pixmap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_present_pixmap (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_pixmap_t pixmap /**< */, - uint32_t serial /**< */, - xcb_xfixes_region_t valid /**< */, - xcb_xfixes_region_t update /**< */, - int16_t x_off /**< */, - int16_t y_off /**< */, - xcb_randr_crtc_t target_crtc /**< */, - xcb_sync_fence_t wait_fence /**< */, - xcb_sync_fence_t idle_fence /**< */, - uint32_t options /**< */, - uint64_t target_msc /**< */, - uint64_t divisor /**< */, - uint64_t remainder /**< */, - uint32_t notifies_len /**< */, - const xcb_present_notify_t *notifies /**< */) +xcb_present_pixmap (xcb_connection_t *c, + xcb_window_t window, + xcb_pixmap_t pixmap, + uint32_t serial, + xcb_xfixes_region_t valid, + xcb_xfixes_region_t update, + int16_t x_off, + int16_t y_off, + xcb_randr_crtc_t target_crtc, + xcb_sync_fence_t wait_fence, + xcb_sync_fence_t idle_fence, + uint32_t options, + uint64_t target_msc, + uint64_t divisor, + uint64_t remainder, + uint32_t notifies_len, + const xcb_present_notify_t *notifies) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_present_id, - /* opcode */ XCB_PRESENT_PIXMAP, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_present_id, + .opcode = XCB_PRESENT_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -254,19 +254,41 @@ xcb_present_pixmap (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_present_notify_t * +xcb_present_pixmap_notifies (const xcb_present_pixmap_request_t *R) +{ + return (xcb_present_notify_t *) (R + 1); +} + +int +xcb_present_pixmap_notifies_length (const xcb_present_pixmap_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_present_pixmap_request_t))/sizeof(xcb_present_notify_t)); +} + +xcb_present_notify_iterator_t +xcb_present_pixmap_notifies_iterator (const xcb_present_pixmap_request_t *R) +{ + xcb_present_notify_iterator_t i; + i.data = (xcb_present_notify_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_present_pixmap_request_t))/sizeof(xcb_present_notify_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_present_notify_msc_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t serial /**< */, - uint64_t target_msc /**< */, - uint64_t divisor /**< */, - uint64_t remainder /**< */) +xcb_present_notify_msc_checked (xcb_connection_t *c, + xcb_window_t window, + uint32_t serial, + uint64_t target_msc, + uint64_t divisor, + uint64_t remainder) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_present_id, - /* opcode */ XCB_PRESENT_NOTIFY_MSC, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_present_id, + .opcode = XCB_PRESENT_NOTIFY_MSC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -290,18 +312,18 @@ xcb_present_notify_msc_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_present_notify_msc (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t serial /**< */, - uint64_t target_msc /**< */, - uint64_t divisor /**< */, - uint64_t remainder /**< */) +xcb_present_notify_msc (xcb_connection_t *c, + xcb_window_t window, + uint32_t serial, + uint64_t target_msc, + uint64_t divisor, + uint64_t remainder) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_present_id, - /* opcode */ XCB_PRESENT_NOTIFY_MSC, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_present_id, + .opcode = XCB_PRESENT_NOTIFY_MSC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -325,7 +347,7 @@ xcb_present_notify_msc (xcb_connection_t *c /**< */, } void -xcb_present_event_next (xcb_present_event_iterator_t *i /**< */) +xcb_present_event_next (xcb_present_event_iterator_t *i) { --i->rem; ++i->data; @@ -333,7 +355,7 @@ xcb_present_event_next (xcb_present_event_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_present_event_end (xcb_present_event_iterator_t i /**< */) +xcb_present_event_end (xcb_present_event_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -343,16 +365,16 @@ xcb_present_event_end (xcb_present_event_iterator_t i /**< */) } xcb_void_cookie_t -xcb_present_select_input_checked (xcb_connection_t *c /**< */, - xcb_present_event_t eid /**< */, - xcb_window_t window /**< */, - uint32_t event_mask /**< */) +xcb_present_select_input_checked (xcb_connection_t *c, + xcb_present_event_t eid, + xcb_window_t window, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_present_id, - /* opcode */ XCB_PRESENT_SELECT_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_present_id, + .opcode = XCB_PRESENT_SELECT_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -373,16 +395,16 @@ xcb_present_select_input_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_present_select_input (xcb_connection_t *c /**< */, - xcb_present_event_t eid /**< */, - xcb_window_t window /**< */, - uint32_t event_mask /**< */) +xcb_present_select_input (xcb_connection_t *c, + xcb_present_event_t eid, + xcb_window_t window, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_present_id, - /* opcode */ XCB_PRESENT_SELECT_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_present_id, + .opcode = XCB_PRESENT_SELECT_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -403,14 +425,14 @@ xcb_present_select_input (xcb_connection_t *c /**< */, } xcb_present_query_capabilities_cookie_t -xcb_present_query_capabilities (xcb_connection_t *c /**< */, - uint32_t target /**< */) +xcb_present_query_capabilities (xcb_connection_t *c, + uint32_t target) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_present_id, - /* opcode */ XCB_PRESENT_QUERY_CAPABILITIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_present_id, + .opcode = XCB_PRESENT_QUERY_CAPABILITIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -429,14 +451,14 @@ xcb_present_query_capabilities (xcb_connection_t *c /**< */, } xcb_present_query_capabilities_cookie_t -xcb_present_query_capabilities_unchecked (xcb_connection_t *c /**< */, - uint32_t target /**< */) +xcb_present_query_capabilities_unchecked (xcb_connection_t *c, + uint32_t target) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_present_id, - /* opcode */ XCB_PRESENT_QUERY_CAPABILITIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_present_id, + .opcode = XCB_PRESENT_QUERY_CAPABILITIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -455,16 +477,16 @@ xcb_present_query_capabilities_unchecked (xcb_connection_t *c /**< */, } xcb_present_query_capabilities_reply_t * -xcb_present_query_capabilities_reply (xcb_connection_t *c /**< */, +xcb_present_query_capabilities_reply (xcb_connection_t *c, xcb_present_query_capabilities_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_present_query_capabilities_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_present_redirect_notify_sizeof (const void *_buffer /**< */, - uint32_t notifies_len /**< */) +xcb_present_redirect_notify_sizeof (const void *_buffer, + uint32_t notifies_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -493,3 +515,25 @@ xcb_present_redirect_notify_sizeof (const void *_buffer /**< */, return xcb_buffer_len; } +xcb_present_notify_t * +xcb_present_redirect_notify_notifies (const xcb_present_redirect_notify_event_t *R) +{ + return (xcb_present_notify_t *) (R + 1); +} + +int +xcb_present_redirect_notify_notifies_length (const xcb_present_redirect_notify_event_t *R) +{ + return (((R->length * 4) - sizeof(xcb_present_redirect_notify_event_t))/sizeof(xcb_present_notify_t)); +} + +xcb_present_notify_iterator_t +xcb_present_redirect_notify_notifies_iterator (const xcb_present_redirect_notify_event_t *R) +{ + xcb_present_notify_iterator_t i; + i.data = (xcb_present_notify_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_present_redirect_notify_event_t))/sizeof(xcb_present_notify_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + diff --git a/lib/libxcb/src/present.h b/lib/libxcb/src/present.h index 79007d85f..3ae6ecb24 100644 --- a/lib/libxcb/src/present.h +++ b/lib/libxcb/src/present.h @@ -71,24 +71,24 @@ typedef enum xcb_present_complete_mode_t { * @brief xcb_present_notify_t **/ typedef struct xcb_present_notify_t { - xcb_window_t window; /**< */ - uint32_t serial; /**< */ + xcb_window_t window; + uint32_t serial; } xcb_present_notify_t; /** * @brief xcb_present_notify_iterator_t **/ typedef struct xcb_present_notify_iterator_t { - xcb_present_notify_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_present_notify_t *data; + int rem; + int index; } xcb_present_notify_iterator_t; /** * @brief xcb_present_query_version_cookie_t **/ typedef struct xcb_present_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_present_query_version_cookie_t; /** Opcode for xcb_present_query_version. */ @@ -98,23 +98,23 @@ typedef struct xcb_present_query_version_cookie_t { * @brief xcb_present_query_version_request_t **/ typedef struct xcb_present_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t major_version; + uint32_t minor_version; } xcb_present_query_version_request_t; /** * @brief xcb_present_query_version_reply_t **/ typedef struct xcb_present_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t major_version; + uint32_t minor_version; } xcb_present_query_version_reply_t; /** Opcode for xcb_present_pixmap. */ @@ -124,24 +124,24 @@ typedef struct xcb_present_query_version_reply_t { * @brief xcb_present_pixmap_request_t **/ typedef struct xcb_present_pixmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_pixmap_t pixmap; /**< */ - uint32_t serial; /**< */ - xcb_xfixes_region_t valid; /**< */ - xcb_xfixes_region_t update; /**< */ - int16_t x_off; /**< */ - int16_t y_off; /**< */ - xcb_randr_crtc_t target_crtc; /**< */ - xcb_sync_fence_t wait_fence; /**< */ - xcb_sync_fence_t idle_fence; /**< */ - uint32_t options; /**< */ - uint8_t pad0[4]; /**< */ - uint64_t target_msc; /**< */ - uint64_t divisor; /**< */ - uint64_t remainder; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_pixmap_t pixmap; + uint32_t serial; + xcb_xfixes_region_t valid; + xcb_xfixes_region_t update; + int16_t x_off; + int16_t y_off; + xcb_randr_crtc_t target_crtc; + xcb_sync_fence_t wait_fence; + xcb_sync_fence_t idle_fence; + uint32_t options; + uint8_t pad0[4]; + uint64_t target_msc; + uint64_t divisor; + uint64_t remainder; } xcb_present_pixmap_request_t; /** Opcode for xcb_present_notify_msc. */ @@ -151,15 +151,15 @@ typedef struct xcb_present_pixmap_request_t { * @brief xcb_present_notify_msc_request_t **/ typedef struct xcb_present_notify_msc_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint32_t serial; /**< */ - uint8_t pad0[4]; /**< */ - uint64_t target_msc; /**< */ - uint64_t divisor; /**< */ - uint64_t remainder; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint32_t serial; + uint8_t pad0[4]; + uint64_t target_msc; + uint64_t divisor; + uint64_t remainder; } xcb_present_notify_msc_request_t; typedef uint32_t xcb_present_event_t; @@ -168,9 +168,9 @@ typedef uint32_t xcb_present_event_t; * @brief xcb_present_event_iterator_t **/ typedef struct xcb_present_event_iterator_t { - xcb_present_event_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_present_event_t *data; + int rem; + int index; } xcb_present_event_iterator_t; /** Opcode for xcb_present_select_input. */ @@ -180,19 +180,19 @@ typedef struct xcb_present_event_iterator_t { * @brief xcb_present_select_input_request_t **/ typedef struct xcb_present_select_input_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_present_event_t eid; /**< */ - xcb_window_t window; /**< */ - uint32_t event_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_present_event_t eid; + xcb_window_t window; + uint32_t event_mask; } xcb_present_select_input_request_t; /** * @brief xcb_present_query_capabilities_cookie_t **/ typedef struct xcb_present_query_capabilities_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_present_query_capabilities_cookie_t; /** Opcode for xcb_present_query_capabilities. */ @@ -202,21 +202,21 @@ typedef struct xcb_present_query_capabilities_cookie_t { * @brief xcb_present_query_capabilities_request_t **/ typedef struct xcb_present_query_capabilities_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t target; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t target; } xcb_present_query_capabilities_request_t; /** * @brief xcb_present_query_capabilities_reply_t **/ typedef struct xcb_present_query_capabilities_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t capabilities; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t capabilities; } xcb_present_query_capabilities_reply_t; /** Opcode for xcb_present_generic. */ @@ -226,13 +226,13 @@ typedef struct xcb_present_query_capabilities_reply_t { * @brief xcb_present_generic_event_t **/ typedef struct xcb_present_generic_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t evtype; /**< */ - uint8_t pad0[2]; /**< */ - xcb_present_event_t event; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t evtype; + uint8_t pad0[2]; + xcb_present_event_t event; } xcb_present_generic_event_t; /** Opcode for xcb_present_configure_notify. */ @@ -242,24 +242,24 @@ typedef struct xcb_present_generic_event_t { * @brief xcb_present_configure_notify_event_t **/ typedef struct xcb_present_configure_notify_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - uint8_t pad0[2]; /**< */ - xcb_present_event_t event; /**< */ - xcb_window_t window; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - int16_t off_x; /**< */ - int16_t off_y; /**< */ - uint32_t full_sequence; /**< */ - uint16_t pixmap_width; /**< */ - uint16_t pixmap_height; /**< */ - uint32_t pixmap_flags; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + uint8_t pad0[2]; + xcb_present_event_t event; + xcb_window_t window; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + int16_t off_x; + int16_t off_y; + uint32_t full_sequence; + uint16_t pixmap_width; + uint16_t pixmap_height; + uint32_t pixmap_flags; } xcb_present_configure_notify_event_t; /** Opcode for xcb_present_complete_notify. */ @@ -269,19 +269,19 @@ typedef struct xcb_present_configure_notify_event_t { * @brief xcb_present_complete_notify_event_t **/ typedef struct xcb_present_complete_notify_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - uint8_t kind; /**< */ - uint8_t mode; /**< */ - xcb_present_event_t event; /**< */ - xcb_window_t window; /**< */ - uint32_t serial; /**< */ - uint64_t ust; /**< */ - uint32_t full_sequence; /**< */ - uint64_t msc; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + uint8_t kind; + uint8_t mode; + xcb_present_event_t event; + xcb_window_t window; + uint32_t serial; + uint64_t ust; + uint32_t full_sequence; + uint64_t msc; } XCB_PACKED xcb_present_complete_notify_event_t; /** Opcode for xcb_present_idle_notify. */ @@ -291,18 +291,18 @@ typedef struct xcb_present_complete_notify_event_t { * @brief xcb_present_idle_notify_event_t **/ typedef struct xcb_present_idle_notify_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - uint8_t pad0[2]; /**< */ - xcb_present_event_t event; /**< */ - xcb_window_t window; /**< */ - uint32_t serial; /**< */ - xcb_pixmap_t pixmap; /**< */ - xcb_sync_fence_t idle_fence; /**< */ - uint32_t full_sequence; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + uint8_t pad0[2]; + xcb_present_event_t event; + xcb_window_t window; + uint32_t serial; + xcb_pixmap_t pixmap; + xcb_sync_fence_t idle_fence; + uint32_t full_sequence; } xcb_present_idle_notify_event_t; /** Opcode for xcb_present_redirect_notify. */ @@ -312,33 +312,33 @@ typedef struct xcb_present_idle_notify_event_t { * @brief xcb_present_redirect_notify_event_t **/ typedef struct xcb_present_redirect_notify_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - uint8_t update_window; /**< */ - uint8_t pad0; /**< */ - xcb_present_event_t event; /**< */ - xcb_window_t event_window; /**< */ - xcb_window_t window; /**< */ - xcb_pixmap_t pixmap; /**< */ - uint32_t serial; /**< */ - uint32_t full_sequence; /**< */ - xcb_xfixes_region_t valid_region; /**< */ - xcb_xfixes_region_t update_region; /**< */ - xcb_rectangle_t valid_rect; /**< */ - xcb_rectangle_t update_rect; /**< */ - int16_t x_off; /**< */ - int16_t y_off; /**< */ - xcb_randr_crtc_t target_crtc; /**< */ - xcb_sync_fence_t wait_fence; /**< */ - xcb_sync_fence_t idle_fence; /**< */ - uint32_t options; /**< */ - uint8_t pad1[4]; /**< */ - uint64_t target_msc; /**< */ - uint64_t divisor; /**< */ - uint64_t remainder; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + uint8_t update_window; + uint8_t pad0; + xcb_present_event_t event; + xcb_window_t event_window; + xcb_window_t window; + xcb_pixmap_t pixmap; + uint32_t serial; + uint32_t full_sequence; + xcb_xfixes_region_t valid_region; + xcb_xfixes_region_t update_region; + xcb_rectangle_t valid_rect; + xcb_rectangle_t update_rect; + int16_t x_off; + int16_t y_off; + xcb_randr_crtc_t target_crtc; + xcb_sync_fence_t wait_fence; + xcb_sync_fence_t idle_fence; + uint32_t options; + uint8_t pad1[4]; + uint64_t target_msc; + uint64_t divisor; + uint64_t remainder; } XCB_PACKED xcb_present_redirect_notify_event_t; /** @@ -350,7 +350,7 @@ typedef struct xcb_present_redirect_notify_event_t { * element. The member index is increased by sizeof(xcb_present_notify_t) */ void -xcb_present_notify_next (xcb_present_notify_iterator_t *i /**< */); +xcb_present_notify_next (xcb_present_notify_iterator_t *i); /** * Return the iterator pointing to the last element @@ -362,7 +362,7 @@ xcb_present_notify_next (xcb_present_notify_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_present_notify_end (xcb_present_notify_iterator_t i /**< */); +xcb_present_notify_end (xcb_present_notify_iterator_t i); /** * @@ -373,9 +373,9 @@ xcb_present_notify_end (xcb_present_notify_iterator_t i /**< */); * */ xcb_present_query_version_cookie_t -xcb_present_query_version (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */); +xcb_present_query_version (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version); /** * @@ -389,9 +389,9 @@ xcb_present_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_present_query_version_cookie_t -xcb_present_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */); +xcb_present_query_version_unchecked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version); /** * Return the reply @@ -408,13 +408,13 @@ xcb_present_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_present_query_version_reply_t * -xcb_present_query_version_reply (xcb_connection_t *c /**< */, +xcb_present_query_version_reply (xcb_connection_t *c, xcb_present_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_present_pixmap_sizeof (const void *_buffer /**< */, - uint32_t notifies_len /**< */); +xcb_present_pixmap_sizeof (const void *_buffer, + uint32_t notifies_len); /** * @@ -428,23 +428,23 @@ xcb_present_pixmap_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_present_pixmap_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_pixmap_t pixmap /**< */, - uint32_t serial /**< */, - xcb_xfixes_region_t valid /**< */, - xcb_xfixes_region_t update /**< */, - int16_t x_off /**< */, - int16_t y_off /**< */, - xcb_randr_crtc_t target_crtc /**< */, - xcb_sync_fence_t wait_fence /**< */, - xcb_sync_fence_t idle_fence /**< */, - uint32_t options /**< */, - uint64_t target_msc /**< */, - uint64_t divisor /**< */, - uint64_t remainder /**< */, - uint32_t notifies_len /**< */, - const xcb_present_notify_t *notifies /**< */); +xcb_present_pixmap_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_pixmap_t pixmap, + uint32_t serial, + xcb_xfixes_region_t valid, + xcb_xfixes_region_t update, + int16_t x_off, + int16_t y_off, + xcb_randr_crtc_t target_crtc, + xcb_sync_fence_t wait_fence, + xcb_sync_fence_t idle_fence, + uint32_t options, + uint64_t target_msc, + uint64_t divisor, + uint64_t remainder, + uint32_t notifies_len, + const xcb_present_notify_t *notifies); /** * @@ -455,23 +455,32 @@ xcb_present_pixmap_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_present_pixmap (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_pixmap_t pixmap /**< */, - uint32_t serial /**< */, - xcb_xfixes_region_t valid /**< */, - xcb_xfixes_region_t update /**< */, - int16_t x_off /**< */, - int16_t y_off /**< */, - xcb_randr_crtc_t target_crtc /**< */, - xcb_sync_fence_t wait_fence /**< */, - xcb_sync_fence_t idle_fence /**< */, - uint32_t options /**< */, - uint64_t target_msc /**< */, - uint64_t divisor /**< */, - uint64_t remainder /**< */, - uint32_t notifies_len /**< */, - const xcb_present_notify_t *notifies /**< */); +xcb_present_pixmap (xcb_connection_t *c, + xcb_window_t window, + xcb_pixmap_t pixmap, + uint32_t serial, + xcb_xfixes_region_t valid, + xcb_xfixes_region_t update, + int16_t x_off, + int16_t y_off, + xcb_randr_crtc_t target_crtc, + xcb_sync_fence_t wait_fence, + xcb_sync_fence_t idle_fence, + uint32_t options, + uint64_t target_msc, + uint64_t divisor, + uint64_t remainder, + uint32_t notifies_len, + const xcb_present_notify_t *notifies); + +xcb_present_notify_t * +xcb_present_pixmap_notifies (const xcb_present_pixmap_request_t *R); + +int +xcb_present_pixmap_notifies_length (const xcb_present_pixmap_request_t *R); + +xcb_present_notify_iterator_t +xcb_present_pixmap_notifies_iterator (const xcb_present_pixmap_request_t *R); /** * @@ -485,12 +494,12 @@ xcb_present_pixmap (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_present_notify_msc_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t serial /**< */, - uint64_t target_msc /**< */, - uint64_t divisor /**< */, - uint64_t remainder /**< */); +xcb_present_notify_msc_checked (xcb_connection_t *c, + xcb_window_t window, + uint32_t serial, + uint64_t target_msc, + uint64_t divisor, + uint64_t remainder); /** * @@ -501,12 +510,12 @@ xcb_present_notify_msc_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_present_notify_msc (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t serial /**< */, - uint64_t target_msc /**< */, - uint64_t divisor /**< */, - uint64_t remainder /**< */); +xcb_present_notify_msc (xcb_connection_t *c, + xcb_window_t window, + uint32_t serial, + uint64_t target_msc, + uint64_t divisor, + uint64_t remainder); /** * Get the next element of the iterator @@ -517,7 +526,7 @@ xcb_present_notify_msc (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_present_event_t) */ void -xcb_present_event_next (xcb_present_event_iterator_t *i /**< */); +xcb_present_event_next (xcb_present_event_iterator_t *i); /** * Return the iterator pointing to the last element @@ -529,7 +538,7 @@ xcb_present_event_next (xcb_present_event_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_present_event_end (xcb_present_event_iterator_t i /**< */); +xcb_present_event_end (xcb_present_event_iterator_t i); /** * @@ -543,10 +552,10 @@ xcb_present_event_end (xcb_present_event_iterator_t i /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_present_select_input_checked (xcb_connection_t *c /**< */, - xcb_present_event_t eid /**< */, - xcb_window_t window /**< */, - uint32_t event_mask /**< */); +xcb_present_select_input_checked (xcb_connection_t *c, + xcb_present_event_t eid, + xcb_window_t window, + uint32_t event_mask); /** * @@ -557,10 +566,10 @@ xcb_present_select_input_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_present_select_input (xcb_connection_t *c /**< */, - xcb_present_event_t eid /**< */, - xcb_window_t window /**< */, - uint32_t event_mask /**< */); +xcb_present_select_input (xcb_connection_t *c, + xcb_present_event_t eid, + xcb_window_t window, + uint32_t event_mask); /** * @@ -571,8 +580,8 @@ xcb_present_select_input (xcb_connection_t *c /**< */, * */ xcb_present_query_capabilities_cookie_t -xcb_present_query_capabilities (xcb_connection_t *c /**< */, - uint32_t target /**< */); +xcb_present_query_capabilities (xcb_connection_t *c, + uint32_t target); /** * @@ -586,8 +595,8 @@ xcb_present_query_capabilities (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_present_query_capabilities_cookie_t -xcb_present_query_capabilities_unchecked (xcb_connection_t *c /**< */, - uint32_t target /**< */); +xcb_present_query_capabilities_unchecked (xcb_connection_t *c, + uint32_t target); /** * Return the reply @@ -604,13 +613,22 @@ xcb_present_query_capabilities_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_present_query_capabilities_reply_t * -xcb_present_query_capabilities_reply (xcb_connection_t *c /**< */, +xcb_present_query_capabilities_reply (xcb_connection_t *c, xcb_present_query_capabilities_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_present_redirect_notify_sizeof (const void *_buffer /**< */, - uint32_t notifies_len /**< */); +xcb_present_redirect_notify_sizeof (const void *_buffer, + uint32_t notifies_len); + +xcb_present_notify_t * +xcb_present_redirect_notify_notifies (const xcb_present_redirect_notify_event_t *R); + +int +xcb_present_redirect_notify_notifies_length (const xcb_present_redirect_notify_event_t *R); + +xcb_present_notify_iterator_t +xcb_present_redirect_notify_notifies_iterator (const xcb_present_redirect_notify_event_t *R); #ifdef __cplusplus diff --git a/lib/libxcb/src/randr.c b/lib/libxcb/src/randr.c index 63e1b470e..181d05cb7 100644 --- a/lib/libxcb/src/randr.c +++ b/lib/libxcb/src/randr.c @@ -20,7 +20,7 @@ xcb_extension_t xcb_randr_id = { "RANDR", 0 }; void -xcb_randr_mode_next (xcb_randr_mode_iterator_t *i /**< */) +xcb_randr_mode_next (xcb_randr_mode_iterator_t *i) { --i->rem; ++i->data; @@ -28,7 +28,7 @@ xcb_randr_mode_next (xcb_randr_mode_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_randr_mode_end (xcb_randr_mode_iterator_t i /**< */) +xcb_randr_mode_end (xcb_randr_mode_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -38,7 +38,7 @@ xcb_randr_mode_end (xcb_randr_mode_iterator_t i /**< */) } void -xcb_randr_crtc_next (xcb_randr_crtc_iterator_t *i /**< */) +xcb_randr_crtc_next (xcb_randr_crtc_iterator_t *i) { --i->rem; ++i->data; @@ -46,7 +46,7 @@ xcb_randr_crtc_next (xcb_randr_crtc_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_randr_crtc_end (xcb_randr_crtc_iterator_t i /**< */) +xcb_randr_crtc_end (xcb_randr_crtc_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -56,7 +56,7 @@ xcb_randr_crtc_end (xcb_randr_crtc_iterator_t i /**< */) } void -xcb_randr_output_next (xcb_randr_output_iterator_t *i /**< */) +xcb_randr_output_next (xcb_randr_output_iterator_t *i) { --i->rem; ++i->data; @@ -64,7 +64,7 @@ xcb_randr_output_next (xcb_randr_output_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_randr_output_end (xcb_randr_output_iterator_t i /**< */) +xcb_randr_output_end (xcb_randr_output_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -74,7 +74,7 @@ xcb_randr_output_end (xcb_randr_output_iterator_t i /**< */) } void -xcb_randr_provider_next (xcb_randr_provider_iterator_t *i /**< */) +xcb_randr_provider_next (xcb_randr_provider_iterator_t *i) { --i->rem; ++i->data; @@ -82,7 +82,7 @@ xcb_randr_provider_next (xcb_randr_provider_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_randr_provider_end (xcb_randr_provider_iterator_t i /**< */) +xcb_randr_provider_end (xcb_randr_provider_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -92,7 +92,7 @@ xcb_randr_provider_end (xcb_randr_provider_iterator_t i /**< */) } void -xcb_randr_screen_size_next (xcb_randr_screen_size_iterator_t *i /**< */) +xcb_randr_screen_size_next (xcb_randr_screen_size_iterator_t *i) { --i->rem; ++i->data; @@ -100,7 +100,7 @@ xcb_randr_screen_size_next (xcb_randr_screen_size_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_randr_screen_size_end (xcb_randr_screen_size_iterator_t i /**< */) +xcb_randr_screen_size_end (xcb_randr_screen_size_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -110,7 +110,7 @@ xcb_randr_screen_size_end (xcb_randr_screen_size_iterator_t i /**< */) } int -xcb_randr_refresh_rates_sizeof (const void *_buffer /**< */) +xcb_randr_refresh_rates_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_refresh_rates_t *_aux = (xcb_randr_refresh_rates_t *)_buffer; @@ -141,19 +141,19 @@ xcb_randr_refresh_rates_sizeof (const void *_buffer /**< */) } uint16_t * -xcb_randr_refresh_rates_rates (const xcb_randr_refresh_rates_t *R /**< */) +xcb_randr_refresh_rates_rates (const xcb_randr_refresh_rates_t *R) { return (uint16_t *) (R + 1); } int -xcb_randr_refresh_rates_rates_length (const xcb_randr_refresh_rates_t *R /**< */) +xcb_randr_refresh_rates_rates_length (const xcb_randr_refresh_rates_t *R) { return R->nRates; } xcb_generic_iterator_t -xcb_randr_refresh_rates_rates_end (const xcb_randr_refresh_rates_t *R /**< */) +xcb_randr_refresh_rates_rates_end (const xcb_randr_refresh_rates_t *R) { xcb_generic_iterator_t i; i.data = ((uint16_t *) (R + 1)) + (R->nRates); @@ -163,7 +163,7 @@ xcb_randr_refresh_rates_rates_end (const xcb_randr_refresh_rates_t *R /**< */) } void -xcb_randr_refresh_rates_next (xcb_randr_refresh_rates_iterator_t *i /**< */) +xcb_randr_refresh_rates_next (xcb_randr_refresh_rates_iterator_t *i) { xcb_randr_refresh_rates_t *R = i->data; xcb_generic_iterator_t child; @@ -174,7 +174,7 @@ xcb_randr_refresh_rates_next (xcb_randr_refresh_rates_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_randr_refresh_rates_end (xcb_randr_refresh_rates_iterator_t i /**< */) +xcb_randr_refresh_rates_end (xcb_randr_refresh_rates_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -186,15 +186,15 @@ xcb_randr_refresh_rates_end (xcb_randr_refresh_rates_iterator_t i /**< */) } xcb_randr_query_version_cookie_t -xcb_randr_query_version (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */) +xcb_randr_query_version (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -214,15 +214,15 @@ xcb_randr_query_version (xcb_connection_t *c /**< */, } xcb_randr_query_version_cookie_t -xcb_randr_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */) +xcb_randr_query_version_unchecked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -242,27 +242,27 @@ xcb_randr_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_randr_query_version_reply_t * -xcb_randr_query_version_reply (xcb_connection_t *c /**< */, +xcb_randr_query_version_reply (xcb_connection_t *c, xcb_randr_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_randr_set_screen_config_cookie_t -xcb_randr_set_screen_config (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t timestamp /**< */, - xcb_timestamp_t config_timestamp /**< */, - uint16_t sizeID /**< */, - uint16_t rotation /**< */, - uint16_t rate /**< */) +xcb_randr_set_screen_config (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t timestamp, + xcb_timestamp_t config_timestamp, + uint16_t sizeID, + uint16_t rotation, + uint16_t rate) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_SCREEN_CONFIG, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_SCREEN_CONFIG, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -287,19 +287,19 @@ xcb_randr_set_screen_config (xcb_connection_t *c /**< */, } xcb_randr_set_screen_config_cookie_t -xcb_randr_set_screen_config_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t timestamp /**< */, - xcb_timestamp_t config_timestamp /**< */, - uint16_t sizeID /**< */, - uint16_t rotation /**< */, - uint16_t rate /**< */) +xcb_randr_set_screen_config_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t timestamp, + xcb_timestamp_t config_timestamp, + uint16_t sizeID, + uint16_t rotation, + uint16_t rate) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_SCREEN_CONFIG, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_SCREEN_CONFIG, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -324,23 +324,23 @@ xcb_randr_set_screen_config_unchecked (xcb_connection_t *c /**< */, } xcb_randr_set_screen_config_reply_t * -xcb_randr_set_screen_config_reply (xcb_connection_t *c /**< */, +xcb_randr_set_screen_config_reply (xcb_connection_t *c, xcb_randr_set_screen_config_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_set_screen_config_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_randr_select_input_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t enable /**< */) +xcb_randr_select_input_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t enable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SELECT_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SELECT_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -361,15 +361,15 @@ xcb_randr_select_input_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_select_input (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t enable /**< */) +xcb_randr_select_input (xcb_connection_t *c, + xcb_window_t window, + uint16_t enable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SELECT_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SELECT_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -390,7 +390,7 @@ xcb_randr_select_input (xcb_connection_t *c /**< */, } int -xcb_randr_get_screen_info_sizeof (const void *_buffer /**< */) +xcb_randr_get_screen_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_screen_info_reply_t *_aux = (xcb_randr_get_screen_info_reply_t *)_buffer; @@ -438,14 +438,14 @@ xcb_randr_get_screen_info_sizeof (const void *_buffer /**< */) } xcb_randr_get_screen_info_cookie_t -xcb_randr_get_screen_info (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_screen_info (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_SCREEN_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_SCREEN_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -464,14 +464,14 @@ xcb_randr_get_screen_info (xcb_connection_t *c /**< */, } xcb_randr_get_screen_info_cookie_t -xcb_randr_get_screen_info_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_screen_info_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_SCREEN_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_SCREEN_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -490,19 +490,19 @@ xcb_randr_get_screen_info_unchecked (xcb_connection_t *c /**< */, } xcb_randr_screen_size_t * -xcb_randr_get_screen_info_sizes (const xcb_randr_get_screen_info_reply_t *R /**< */) +xcb_randr_get_screen_info_sizes (const xcb_randr_get_screen_info_reply_t *R) { return (xcb_randr_screen_size_t *) (R + 1); } int -xcb_randr_get_screen_info_sizes_length (const xcb_randr_get_screen_info_reply_t *R /**< */) +xcb_randr_get_screen_info_sizes_length (const xcb_randr_get_screen_info_reply_t *R) { return R->nSizes; } xcb_randr_screen_size_iterator_t -xcb_randr_get_screen_info_sizes_iterator (const xcb_randr_get_screen_info_reply_t *R /**< */) +xcb_randr_get_screen_info_sizes_iterator (const xcb_randr_get_screen_info_reply_t *R) { xcb_randr_screen_size_iterator_t i; i.data = (xcb_randr_screen_size_t *) (R + 1); @@ -512,13 +512,13 @@ xcb_randr_get_screen_info_sizes_iterator (const xcb_randr_get_screen_info_reply_ } int -xcb_randr_get_screen_info_rates_length (const xcb_randr_get_screen_info_reply_t *R /**< */) +xcb_randr_get_screen_info_rates_length (const xcb_randr_get_screen_info_reply_t *R) { return (R->nInfo - R->nSizes); } xcb_randr_refresh_rates_iterator_t -xcb_randr_get_screen_info_rates_iterator (const xcb_randr_get_screen_info_reply_t *R /**< */) +xcb_randr_get_screen_info_rates_iterator (const xcb_randr_get_screen_info_reply_t *R) { xcb_randr_refresh_rates_iterator_t i; xcb_generic_iterator_t prev = xcb_randr_screen_size_end(xcb_randr_get_screen_info_sizes_iterator(R)); @@ -529,22 +529,22 @@ xcb_randr_get_screen_info_rates_iterator (const xcb_randr_get_screen_info_reply_ } xcb_randr_get_screen_info_reply_t * -xcb_randr_get_screen_info_reply (xcb_connection_t *c /**< */, +xcb_randr_get_screen_info_reply (xcb_connection_t *c, xcb_randr_get_screen_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_screen_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_randr_get_screen_size_range_cookie_t -xcb_randr_get_screen_size_range (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_screen_size_range (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_SCREEN_SIZE_RANGE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_SCREEN_SIZE_RANGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -563,14 +563,14 @@ xcb_randr_get_screen_size_range (xcb_connection_t *c /**< */, } xcb_randr_get_screen_size_range_cookie_t -xcb_randr_get_screen_size_range_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_screen_size_range_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_SCREEN_SIZE_RANGE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_SCREEN_SIZE_RANGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -589,26 +589,26 @@ xcb_randr_get_screen_size_range_unchecked (xcb_connection_t *c /**< */, } xcb_randr_get_screen_size_range_reply_t * -xcb_randr_get_screen_size_range_reply (xcb_connection_t *c /**< */, +xcb_randr_get_screen_size_range_reply (xcb_connection_t *c, xcb_randr_get_screen_size_range_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_screen_size_range_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_randr_set_screen_size_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t mm_width /**< */, - uint32_t mm_height /**< */) +xcb_randr_set_screen_size_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t width, + uint16_t height, + uint32_t mm_width, + uint32_t mm_height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_SCREEN_SIZE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_SCREEN_SIZE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -631,18 +631,18 @@ xcb_randr_set_screen_size_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_set_screen_size (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t mm_width /**< */, - uint32_t mm_height /**< */) +xcb_randr_set_screen_size (xcb_connection_t *c, + xcb_window_t window, + uint16_t width, + uint16_t height, + uint32_t mm_width, + uint32_t mm_height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_SCREEN_SIZE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_SCREEN_SIZE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -665,7 +665,7 @@ xcb_randr_set_screen_size (xcb_connection_t *c /**< */, } void -xcb_randr_mode_info_next (xcb_randr_mode_info_iterator_t *i /**< */) +xcb_randr_mode_info_next (xcb_randr_mode_info_iterator_t *i) { --i->rem; ++i->data; @@ -673,7 +673,7 @@ xcb_randr_mode_info_next (xcb_randr_mode_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_randr_mode_info_end (xcb_randr_mode_info_iterator_t i /**< */) +xcb_randr_mode_info_end (xcb_randr_mode_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -683,7 +683,7 @@ xcb_randr_mode_info_end (xcb_randr_mode_info_iterator_t i /**< */) } int -xcb_randr_get_screen_resources_sizeof (const void *_buffer /**< */) +xcb_randr_get_screen_resources_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_screen_resources_reply_t *_aux = (xcb_randr_get_screen_resources_reply_t *)_buffer; @@ -750,14 +750,14 @@ xcb_randr_get_screen_resources_sizeof (const void *_buffer /**< */) } xcb_randr_get_screen_resources_cookie_t -xcb_randr_get_screen_resources (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_screen_resources (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_SCREEN_RESOURCES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_SCREEN_RESOURCES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -776,14 +776,14 @@ xcb_randr_get_screen_resources (xcb_connection_t *c /**< */, } xcb_randr_get_screen_resources_cookie_t -xcb_randr_get_screen_resources_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_screen_resources_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_SCREEN_RESOURCES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_SCREEN_RESOURCES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -802,19 +802,19 @@ xcb_randr_get_screen_resources_unchecked (xcb_connection_t *c /**< */, } xcb_randr_crtc_t * -xcb_randr_get_screen_resources_crtcs (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_crtcs (const xcb_randr_get_screen_resources_reply_t *R) { return (xcb_randr_crtc_t *) (R + 1); } int -xcb_randr_get_screen_resources_crtcs_length (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_crtcs_length (const xcb_randr_get_screen_resources_reply_t *R) { return R->num_crtcs; } xcb_generic_iterator_t -xcb_randr_get_screen_resources_crtcs_end (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_crtcs_end (const xcb_randr_get_screen_resources_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs); @@ -824,44 +824,44 @@ xcb_randr_get_screen_resources_crtcs_end (const xcb_randr_get_screen_resources_r } xcb_randr_output_t * -xcb_randr_get_screen_resources_outputs (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_outputs (const xcb_randr_get_screen_resources_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_crtcs_end(R); return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0); } int -xcb_randr_get_screen_resources_outputs_length (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_outputs_length (const xcb_randr_get_screen_resources_reply_t *R) { return R->num_outputs; } xcb_generic_iterator_t -xcb_randr_get_screen_resources_outputs_end (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_outputs_end (const xcb_randr_get_screen_resources_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_screen_resources_crtcs_end(R); - i.data = ((xcb_randr_output_t *) child.data) + (R->num_outputs); + xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_crtcs_end(R); + i.data = ((xcb_randr_output_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index))) + (R->num_outputs); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_mode_info_t * -xcb_randr_get_screen_resources_modes (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_modes (const xcb_randr_get_screen_resources_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_outputs_end(R); return (xcb_randr_mode_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_info_t, prev.index) + 0); } int -xcb_randr_get_screen_resources_modes_length (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_modes_length (const xcb_randr_get_screen_resources_reply_t *R) { return R->num_modes; } xcb_randr_mode_info_iterator_t -xcb_randr_get_screen_resources_modes_iterator (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_modes_iterator (const xcb_randr_get_screen_resources_reply_t *R) { xcb_randr_mode_info_iterator_t i; xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_outputs_end(R); @@ -872,39 +872,39 @@ xcb_randr_get_screen_resources_modes_iterator (const xcb_randr_get_screen_resour } uint8_t * -xcb_randr_get_screen_resources_names (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_names (const xcb_randr_get_screen_resources_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_modes_iterator(R)); return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0); } int -xcb_randr_get_screen_resources_names_length (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_names_length (const xcb_randr_get_screen_resources_reply_t *R) { return R->names_len; } xcb_generic_iterator_t -xcb_randr_get_screen_resources_names_end (const xcb_randr_get_screen_resources_reply_t *R /**< */) +xcb_randr_get_screen_resources_names_end (const xcb_randr_get_screen_resources_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_modes_iterator(R)); - i.data = ((uint8_t *) child.data) + (R->names_len); + xcb_generic_iterator_t prev = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_modes_iterator(R)); + i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (R->names_len); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_get_screen_resources_reply_t * -xcb_randr_get_screen_resources_reply (xcb_connection_t *c /**< */, +xcb_randr_get_screen_resources_reply (xcb_connection_t *c, xcb_randr_get_screen_resources_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_screen_resources_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_get_output_info_sizeof (const void *_buffer /**< */) +xcb_randr_get_output_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_output_info_reply_t *_aux = (xcb_randr_get_output_info_reply_t *)_buffer; @@ -971,15 +971,15 @@ xcb_randr_get_output_info_sizeof (const void *_buffer /**< */) } xcb_randr_get_output_info_cookie_t -xcb_randr_get_output_info (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_timestamp_t config_timestamp /**< */) +xcb_randr_get_output_info (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_timestamp_t config_timestamp) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_OUTPUT_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_OUTPUT_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -999,15 +999,15 @@ xcb_randr_get_output_info (xcb_connection_t *c /**< */, } xcb_randr_get_output_info_cookie_t -xcb_randr_get_output_info_unchecked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_timestamp_t config_timestamp /**< */) +xcb_randr_get_output_info_unchecked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_timestamp_t config_timestamp) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_OUTPUT_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_OUTPUT_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1027,19 +1027,19 @@ xcb_randr_get_output_info_unchecked (xcb_connection_t *c /**< */, } xcb_randr_crtc_t * -xcb_randr_get_output_info_crtcs (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_crtcs (const xcb_randr_get_output_info_reply_t *R) { return (xcb_randr_crtc_t *) (R + 1); } int -xcb_randr_get_output_info_crtcs_length (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_crtcs_length (const xcb_randr_get_output_info_reply_t *R) { return R->num_crtcs; } xcb_generic_iterator_t -xcb_randr_get_output_info_crtcs_end (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_crtcs_end (const xcb_randr_get_output_info_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs); @@ -1049,87 +1049,87 @@ xcb_randr_get_output_info_crtcs_end (const xcb_randr_get_output_info_reply_t *R } xcb_randr_mode_t * -xcb_randr_get_output_info_modes (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_modes (const xcb_randr_get_output_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_output_info_crtcs_end(R); return (xcb_randr_mode_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_t, prev.index) + 0); } int -xcb_randr_get_output_info_modes_length (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_modes_length (const xcb_randr_get_output_info_reply_t *R) { return R->num_modes; } xcb_generic_iterator_t -xcb_randr_get_output_info_modes_end (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_modes_end (const xcb_randr_get_output_info_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_output_info_crtcs_end(R); - i.data = ((xcb_randr_mode_t *) child.data) + (R->num_modes); + xcb_generic_iterator_t prev = xcb_randr_get_output_info_crtcs_end(R); + i.data = ((xcb_randr_mode_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_mode_t, prev.index))) + (R->num_modes); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_output_t * -xcb_randr_get_output_info_clones (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_clones (const xcb_randr_get_output_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_output_info_modes_end(R); return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0); } int -xcb_randr_get_output_info_clones_length (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_clones_length (const xcb_randr_get_output_info_reply_t *R) { return R->num_clones; } xcb_generic_iterator_t -xcb_randr_get_output_info_clones_end (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_clones_end (const xcb_randr_get_output_info_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_output_info_modes_end(R); - i.data = ((xcb_randr_output_t *) child.data) + (R->num_clones); + xcb_generic_iterator_t prev = xcb_randr_get_output_info_modes_end(R); + i.data = ((xcb_randr_output_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index))) + (R->num_clones); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } uint8_t * -xcb_randr_get_output_info_name (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_name (const xcb_randr_get_output_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_output_info_clones_end(R); return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0); } int -xcb_randr_get_output_info_name_length (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_name_length (const xcb_randr_get_output_info_reply_t *R) { return R->name_len; } xcb_generic_iterator_t -xcb_randr_get_output_info_name_end (const xcb_randr_get_output_info_reply_t *R /**< */) +xcb_randr_get_output_info_name_end (const xcb_randr_get_output_info_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_output_info_clones_end(R); - i.data = ((uint8_t *) child.data) + (R->name_len); + xcb_generic_iterator_t prev = xcb_randr_get_output_info_clones_end(R); + i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (R->name_len); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_get_output_info_reply_t * -xcb_randr_get_output_info_reply (xcb_connection_t *c /**< */, +xcb_randr_get_output_info_reply (xcb_connection_t *c, xcb_randr_get_output_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_output_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_list_output_properties_sizeof (const void *_buffer /**< */) +xcb_randr_list_output_properties_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_list_output_properties_reply_t *_aux = (xcb_randr_list_output_properties_reply_t *)_buffer; @@ -1160,14 +1160,14 @@ xcb_randr_list_output_properties_sizeof (const void *_buffer /**< */) } xcb_randr_list_output_properties_cookie_t -xcb_randr_list_output_properties (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */) +xcb_randr_list_output_properties (xcb_connection_t *c, + xcb_randr_output_t output) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_LIST_OUTPUT_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_LIST_OUTPUT_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1186,14 +1186,14 @@ xcb_randr_list_output_properties (xcb_connection_t *c /**< */, } xcb_randr_list_output_properties_cookie_t -xcb_randr_list_output_properties_unchecked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */) +xcb_randr_list_output_properties_unchecked (xcb_connection_t *c, + xcb_randr_output_t output) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_LIST_OUTPUT_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_LIST_OUTPUT_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1212,19 +1212,19 @@ xcb_randr_list_output_properties_unchecked (xcb_connection_t *c /**< */, } xcb_atom_t * -xcb_randr_list_output_properties_atoms (const xcb_randr_list_output_properties_reply_t *R /**< */) +xcb_randr_list_output_properties_atoms (const xcb_randr_list_output_properties_reply_t *R) { return (xcb_atom_t *) (R + 1); } int -xcb_randr_list_output_properties_atoms_length (const xcb_randr_list_output_properties_reply_t *R /**< */) +xcb_randr_list_output_properties_atoms_length (const xcb_randr_list_output_properties_reply_t *R) { return R->num_atoms; } xcb_generic_iterator_t -xcb_randr_list_output_properties_atoms_end (const xcb_randr_list_output_properties_reply_t *R /**< */) +xcb_randr_list_output_properties_atoms_end (const xcb_randr_list_output_properties_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_atom_t *) (R + 1)) + (R->num_atoms); @@ -1234,15 +1234,15 @@ xcb_randr_list_output_properties_atoms_end (const xcb_randr_list_output_properti } xcb_randr_list_output_properties_reply_t * -xcb_randr_list_output_properties_reply (xcb_connection_t *c /**< */, +xcb_randr_list_output_properties_reply (xcb_connection_t *c, xcb_randr_list_output_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_list_output_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_query_output_property_sizeof (const void *_buffer /**< */) +xcb_randr_query_output_property_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_query_output_property_reply_t *_aux = (xcb_randr_query_output_property_reply_t *)_buffer; @@ -1273,15 +1273,15 @@ xcb_randr_query_output_property_sizeof (const void *_buffer /**< */) } xcb_randr_query_output_property_cookie_t -xcb_randr_query_output_property (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */) +xcb_randr_query_output_property (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_QUERY_OUTPUT_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_QUERY_OUTPUT_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1301,15 +1301,15 @@ xcb_randr_query_output_property (xcb_connection_t *c /**< */, } xcb_randr_query_output_property_cookie_t -xcb_randr_query_output_property_unchecked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */) +xcb_randr_query_output_property_unchecked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_QUERY_OUTPUT_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_QUERY_OUTPUT_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1329,19 +1329,19 @@ xcb_randr_query_output_property_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_randr_query_output_property_valid_values (const xcb_randr_query_output_property_reply_t *R /**< */) +xcb_randr_query_output_property_valid_values (const xcb_randr_query_output_property_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_randr_query_output_property_valid_values_length (const xcb_randr_query_output_property_reply_t *R /**< */) +xcb_randr_query_output_property_valid_values_length (const xcb_randr_query_output_property_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_randr_query_output_property_valid_values_end (const xcb_randr_query_output_property_reply_t *R /**< */) +xcb_randr_query_output_property_valid_values_end (const xcb_randr_query_output_property_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->length); @@ -1351,16 +1351,16 @@ xcb_randr_query_output_property_valid_values_end (const xcb_randr_query_output_p } xcb_randr_query_output_property_reply_t * -xcb_randr_query_output_property_reply (xcb_connection_t *c /**< */, +xcb_randr_query_output_property_reply (xcb_connection_t *c, xcb_randr_query_output_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_query_output_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_configure_output_property_sizeof (const void *_buffer /**< */, - uint32_t values_len /**< */) +xcb_randr_configure_output_property_sizeof (const void *_buffer, + uint32_t values_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -1390,19 +1390,19 @@ xcb_randr_configure_output_property_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_randr_configure_output_property_checked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - uint8_t pending /**< */, - uint8_t range /**< */, - uint32_t values_len /**< */, - const int32_t *values /**< */) +xcb_randr_configure_output_property_checked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + uint8_t pending, + uint8_t range, + uint32_t values_len, + const int32_t *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_CONFIGURE_OUTPUT_PROPERTY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_CONFIGURE_OUTPUT_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1430,19 +1430,19 @@ xcb_randr_configure_output_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_configure_output_property (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - uint8_t pending /**< */, - uint8_t range /**< */, - uint32_t values_len /**< */, - const int32_t *values /**< */) +xcb_randr_configure_output_property (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + uint8_t pending, + uint8_t range, + uint32_t values_len, + const int32_t *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_CONFIGURE_OUTPUT_PROPERTY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_CONFIGURE_OUTPUT_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1469,8 +1469,30 @@ xcb_randr_configure_output_property (xcb_connection_t *c /**< */, return xcb_ret; } +int32_t * +xcb_randr_configure_output_property_values (const xcb_randr_configure_output_property_request_t *R) +{ + return (int32_t *) (R + 1); +} + int -xcb_randr_change_output_property_sizeof (const void *_buffer /**< */) +xcb_randr_configure_output_property_values_length (const xcb_randr_configure_output_property_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_randr_configure_output_property_request_t))/sizeof(int32_t)); +} + +xcb_generic_iterator_t +xcb_randr_configure_output_property_values_end (const xcb_randr_configure_output_property_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((int32_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_randr_configure_output_property_request_t))/sizeof(int32_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_randr_change_output_property_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_change_output_property_request_t *_aux = (xcb_randr_change_output_property_request_t *)_buffer; @@ -1501,20 +1523,20 @@ xcb_randr_change_output_property_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_randr_change_output_property_checked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_units /**< */, - const void *data /**< */) +xcb_randr_change_output_property_checked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint8_t mode, + uint32_t num_units, + const void *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_CHANGE_OUTPUT_PROPERTY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_CHANGE_OUTPUT_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1544,20 +1566,20 @@ xcb_randr_change_output_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_change_output_property (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_units /**< */, - const void *data /**< */) +xcb_randr_change_output_property (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint8_t mode, + uint32_t num_units, + const void *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_CHANGE_OUTPUT_PROPERTY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_CHANGE_OUTPUT_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1586,16 +1608,38 @@ xcb_randr_change_output_property (xcb_connection_t *c /**< */, return xcb_ret; } +void * +xcb_randr_change_output_property_data (const xcb_randr_change_output_property_request_t *R) +{ + return (void *) (R + 1); +} + +int +xcb_randr_change_output_property_data_length (const xcb_randr_change_output_property_request_t *R) +{ + return ((R->num_units * R->format) / 8); +} + +xcb_generic_iterator_t +xcb_randr_change_output_property_data_end (const xcb_randr_change_output_property_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (((R->num_units * R->format) / 8)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_randr_delete_output_property_checked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */) +xcb_randr_delete_output_property_checked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_DELETE_OUTPUT_PROPERTY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_DELETE_OUTPUT_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1615,15 +1659,15 @@ xcb_randr_delete_output_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_delete_output_property (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */) +xcb_randr_delete_output_property (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_DELETE_OUTPUT_PROPERTY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_DELETE_OUTPUT_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1643,7 +1687,7 @@ xcb_randr_delete_output_property (xcb_connection_t *c /**< */, } int -xcb_randr_get_output_property_sizeof (const void *_buffer /**< */) +xcb_randr_get_output_property_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_output_property_reply_t *_aux = (xcb_randr_get_output_property_reply_t *)_buffer; @@ -1674,20 +1718,20 @@ xcb_randr_get_output_property_sizeof (const void *_buffer /**< */) } xcb_randr_get_output_property_cookie_t -xcb_randr_get_output_property (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */, - uint8_t _delete /**< */, - uint8_t pending /**< */) +xcb_randr_get_output_property (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length, + uint8_t _delete, + uint8_t pending) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_OUTPUT_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_OUTPUT_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1713,20 +1757,20 @@ xcb_randr_get_output_property (xcb_connection_t *c /**< */, } xcb_randr_get_output_property_cookie_t -xcb_randr_get_output_property_unchecked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */, - uint8_t _delete /**< */, - uint8_t pending /**< */) +xcb_randr_get_output_property_unchecked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length, + uint8_t _delete, + uint8_t pending) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_OUTPUT_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_OUTPUT_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1752,19 +1796,19 @@ xcb_randr_get_output_property_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_randr_get_output_property_data (const xcb_randr_get_output_property_reply_t *R /**< */) +xcb_randr_get_output_property_data (const xcb_randr_get_output_property_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_randr_get_output_property_data_length (const xcb_randr_get_output_property_reply_t *R /**< */) +xcb_randr_get_output_property_data_length (const xcb_randr_get_output_property_reply_t *R) { return (R->num_items * (R->format / 8)); } xcb_generic_iterator_t -xcb_randr_get_output_property_data_end (const xcb_randr_get_output_property_reply_t *R /**< */) +xcb_randr_get_output_property_data_end (const xcb_randr_get_output_property_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->num_items * (R->format / 8))); @@ -1774,16 +1818,16 @@ xcb_randr_get_output_property_data_end (const xcb_randr_get_output_property_repl } xcb_randr_get_output_property_reply_t * -xcb_randr_get_output_property_reply (xcb_connection_t *c /**< */, +xcb_randr_get_output_property_reply (xcb_connection_t *c, xcb_randr_get_output_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_output_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_create_mode_sizeof (const void *_buffer /**< */, - uint32_t name_len /**< */) +xcb_randr_create_mode_sizeof (const void *_buffer, + uint32_t name_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -1813,17 +1857,17 @@ xcb_randr_create_mode_sizeof (const void *_buffer /**< */, } xcb_randr_create_mode_cookie_t -xcb_randr_create_mode (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_randr_mode_info_t mode_info /**< */, - uint32_t name_len /**< */, - const char *name /**< */) +xcb_randr_create_mode (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_mode_info_t mode_info, + uint32_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_CREATE_MODE, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_CREATE_MODE, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -1848,17 +1892,17 @@ xcb_randr_create_mode (xcb_connection_t *c /**< */, } xcb_randr_create_mode_cookie_t -xcb_randr_create_mode_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_randr_mode_info_t mode_info /**< */, - uint32_t name_len /**< */, - const char *name /**< */) +xcb_randr_create_mode_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_mode_info_t mode_info, + uint32_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_CREATE_MODE, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_CREATE_MODE, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -1883,22 +1927,22 @@ xcb_randr_create_mode_unchecked (xcb_connection_t *c /**< */, } xcb_randr_create_mode_reply_t * -xcb_randr_create_mode_reply (xcb_connection_t *c /**< */, +xcb_randr_create_mode_reply (xcb_connection_t *c, xcb_randr_create_mode_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_create_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_randr_destroy_mode_checked (xcb_connection_t *c /**< */, - xcb_randr_mode_t mode /**< */) +xcb_randr_destroy_mode_checked (xcb_connection_t *c, + xcb_randr_mode_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_DESTROY_MODE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_DESTROY_MODE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1917,14 +1961,14 @@ xcb_randr_destroy_mode_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_destroy_mode (xcb_connection_t *c /**< */, - xcb_randr_mode_t mode /**< */) +xcb_randr_destroy_mode (xcb_connection_t *c, + xcb_randr_mode_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_DESTROY_MODE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_DESTROY_MODE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1943,15 +1987,15 @@ xcb_randr_destroy_mode (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_add_output_mode_checked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_randr_mode_t mode /**< */) +xcb_randr_add_output_mode_checked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_randr_mode_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_ADD_OUTPUT_MODE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_ADD_OUTPUT_MODE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1971,15 +2015,15 @@ xcb_randr_add_output_mode_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_add_output_mode (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_randr_mode_t mode /**< */) +xcb_randr_add_output_mode (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_randr_mode_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_ADD_OUTPUT_MODE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_ADD_OUTPUT_MODE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1999,15 +2043,15 @@ xcb_randr_add_output_mode (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_delete_output_mode_checked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_randr_mode_t mode /**< */) +xcb_randr_delete_output_mode_checked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_randr_mode_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_DELETE_OUTPUT_MODE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_DELETE_OUTPUT_MODE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2027,15 +2071,15 @@ xcb_randr_delete_output_mode_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_delete_output_mode (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_randr_mode_t mode /**< */) +xcb_randr_delete_output_mode (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_randr_mode_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_DELETE_OUTPUT_MODE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_DELETE_OUTPUT_MODE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2055,7 +2099,7 @@ xcb_randr_delete_output_mode (xcb_connection_t *c /**< */, } int -xcb_randr_get_crtc_info_sizeof (const void *_buffer /**< */) +xcb_randr_get_crtc_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_crtc_info_reply_t *_aux = (xcb_randr_get_crtc_info_reply_t *)_buffer; @@ -2098,15 +2142,15 @@ xcb_randr_get_crtc_info_sizeof (const void *_buffer /**< */) } xcb_randr_get_crtc_info_cookie_t -xcb_randr_get_crtc_info (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t config_timestamp /**< */) +xcb_randr_get_crtc_info (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t config_timestamp) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_CRTC_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_CRTC_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2126,15 +2170,15 @@ xcb_randr_get_crtc_info (xcb_connection_t *c /**< */, } xcb_randr_get_crtc_info_cookie_t -xcb_randr_get_crtc_info_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t config_timestamp /**< */) +xcb_randr_get_crtc_info_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t config_timestamp) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_CRTC_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_CRTC_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2154,19 +2198,19 @@ xcb_randr_get_crtc_info_unchecked (xcb_connection_t *c /**< */, } xcb_randr_output_t * -xcb_randr_get_crtc_info_outputs (const xcb_randr_get_crtc_info_reply_t *R /**< */) +xcb_randr_get_crtc_info_outputs (const xcb_randr_get_crtc_info_reply_t *R) { return (xcb_randr_output_t *) (R + 1); } int -xcb_randr_get_crtc_info_outputs_length (const xcb_randr_get_crtc_info_reply_t *R /**< */) +xcb_randr_get_crtc_info_outputs_length (const xcb_randr_get_crtc_info_reply_t *R) { return R->num_outputs; } xcb_generic_iterator_t -xcb_randr_get_crtc_info_outputs_end (const xcb_randr_get_crtc_info_reply_t *R /**< */) +xcb_randr_get_crtc_info_outputs_end (const xcb_randr_get_crtc_info_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_randr_output_t *) (R + 1)) + (R->num_outputs); @@ -2176,40 +2220,40 @@ xcb_randr_get_crtc_info_outputs_end (const xcb_randr_get_crtc_info_reply_t *R / } xcb_randr_output_t * -xcb_randr_get_crtc_info_possible (const xcb_randr_get_crtc_info_reply_t *R /**< */) +xcb_randr_get_crtc_info_possible (const xcb_randr_get_crtc_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_crtc_info_outputs_end(R); return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0); } int -xcb_randr_get_crtc_info_possible_length (const xcb_randr_get_crtc_info_reply_t *R /**< */) +xcb_randr_get_crtc_info_possible_length (const xcb_randr_get_crtc_info_reply_t *R) { return R->num_possible_outputs; } xcb_generic_iterator_t -xcb_randr_get_crtc_info_possible_end (const xcb_randr_get_crtc_info_reply_t *R /**< */) +xcb_randr_get_crtc_info_possible_end (const xcb_randr_get_crtc_info_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_crtc_info_outputs_end(R); - i.data = ((xcb_randr_output_t *) child.data) + (R->num_possible_outputs); + xcb_generic_iterator_t prev = xcb_randr_get_crtc_info_outputs_end(R); + i.data = ((xcb_randr_output_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index))) + (R->num_possible_outputs); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_get_crtc_info_reply_t * -xcb_randr_get_crtc_info_reply (xcb_connection_t *c /**< */, +xcb_randr_get_crtc_info_reply (xcb_connection_t *c, xcb_randr_get_crtc_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_crtc_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_set_crtc_config_sizeof (const void *_buffer /**< */, - uint32_t outputs_len /**< */) +xcb_randr_set_crtc_config_sizeof (const void *_buffer, + uint32_t outputs_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -2239,22 +2283,22 @@ xcb_randr_set_crtc_config_sizeof (const void *_buffer /**< */, } xcb_randr_set_crtc_config_cookie_t -xcb_randr_set_crtc_config (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t timestamp /**< */, - xcb_timestamp_t config_timestamp /**< */, - int16_t x /**< */, - int16_t y /**< */, - xcb_randr_mode_t mode /**< */, - uint16_t rotation /**< */, - uint32_t outputs_len /**< */, - const xcb_randr_output_t *outputs /**< */) +xcb_randr_set_crtc_config (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t timestamp, + xcb_timestamp_t config_timestamp, + int16_t x, + int16_t y, + xcb_randr_mode_t mode, + uint16_t rotation, + uint32_t outputs_len, + const xcb_randr_output_t *outputs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_CRTC_CONFIG, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_CRTC_CONFIG, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -2285,22 +2329,22 @@ xcb_randr_set_crtc_config (xcb_connection_t *c /**< */, } xcb_randr_set_crtc_config_cookie_t -xcb_randr_set_crtc_config_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t timestamp /**< */, - xcb_timestamp_t config_timestamp /**< */, - int16_t x /**< */, - int16_t y /**< */, - xcb_randr_mode_t mode /**< */, - uint16_t rotation /**< */, - uint32_t outputs_len /**< */, - const xcb_randr_output_t *outputs /**< */) +xcb_randr_set_crtc_config_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t timestamp, + xcb_timestamp_t config_timestamp, + int16_t x, + int16_t y, + xcb_randr_mode_t mode, + uint16_t rotation, + uint32_t outputs_len, + const xcb_randr_output_t *outputs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_CRTC_CONFIG, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_CRTC_CONFIG, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -2331,22 +2375,22 @@ xcb_randr_set_crtc_config_unchecked (xcb_connection_t *c /**< */, } xcb_randr_set_crtc_config_reply_t * -xcb_randr_set_crtc_config_reply (xcb_connection_t *c /**< */, +xcb_randr_set_crtc_config_reply (xcb_connection_t *c, xcb_randr_set_crtc_config_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_set_crtc_config_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_randr_get_crtc_gamma_size_cookie_t -xcb_randr_get_crtc_gamma_size (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */) +xcb_randr_get_crtc_gamma_size (xcb_connection_t *c, + xcb_randr_crtc_t crtc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_CRTC_GAMMA_SIZE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_CRTC_GAMMA_SIZE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2365,14 +2409,14 @@ xcb_randr_get_crtc_gamma_size (xcb_connection_t *c /**< */, } xcb_randr_get_crtc_gamma_size_cookie_t -xcb_randr_get_crtc_gamma_size_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */) +xcb_randr_get_crtc_gamma_size_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_CRTC_GAMMA_SIZE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_CRTC_GAMMA_SIZE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2391,15 +2435,15 @@ xcb_randr_get_crtc_gamma_size_unchecked (xcb_connection_t *c /**< */, } xcb_randr_get_crtc_gamma_size_reply_t * -xcb_randr_get_crtc_gamma_size_reply (xcb_connection_t *c /**< */, +xcb_randr_get_crtc_gamma_size_reply (xcb_connection_t *c, xcb_randr_get_crtc_gamma_size_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_crtc_gamma_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_get_crtc_gamma_sizeof (const void *_buffer /**< */) +xcb_randr_get_crtc_gamma_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_crtc_gamma_reply_t *_aux = (xcb_randr_get_crtc_gamma_reply_t *)_buffer; @@ -2454,14 +2498,14 @@ xcb_randr_get_crtc_gamma_sizeof (const void *_buffer /**< */) } xcb_randr_get_crtc_gamma_cookie_t -xcb_randr_get_crtc_gamma (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */) +xcb_randr_get_crtc_gamma (xcb_connection_t *c, + xcb_randr_crtc_t crtc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_CRTC_GAMMA, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_CRTC_GAMMA, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2480,14 +2524,14 @@ xcb_randr_get_crtc_gamma (xcb_connection_t *c /**< */, } xcb_randr_get_crtc_gamma_cookie_t -xcb_randr_get_crtc_gamma_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */) +xcb_randr_get_crtc_gamma_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_CRTC_GAMMA, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_CRTC_GAMMA, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2506,19 +2550,19 @@ xcb_randr_get_crtc_gamma_unchecked (xcb_connection_t *c /**< */, } uint16_t * -xcb_randr_get_crtc_gamma_red (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) +xcb_randr_get_crtc_gamma_red (const xcb_randr_get_crtc_gamma_reply_t *R) { return (uint16_t *) (R + 1); } int -xcb_randr_get_crtc_gamma_red_length (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) +xcb_randr_get_crtc_gamma_red_length (const xcb_randr_get_crtc_gamma_reply_t *R) { return R->size; } xcb_generic_iterator_t -xcb_randr_get_crtc_gamma_red_end (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) +xcb_randr_get_crtc_gamma_red_end (const xcb_randr_get_crtc_gamma_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint16_t *) (R + 1)) + (R->size); @@ -2528,63 +2572,63 @@ xcb_randr_get_crtc_gamma_red_end (const xcb_randr_get_crtc_gamma_reply_t *R /** } uint16_t * -xcb_randr_get_crtc_gamma_green (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) +xcb_randr_get_crtc_gamma_green (const xcb_randr_get_crtc_gamma_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_crtc_gamma_red_end(R); return (uint16_t *) ((char *) prev.data + XCB_TYPE_PAD(uint16_t, prev.index) + 0); } int -xcb_randr_get_crtc_gamma_green_length (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) +xcb_randr_get_crtc_gamma_green_length (const xcb_randr_get_crtc_gamma_reply_t *R) { return R->size; } xcb_generic_iterator_t -xcb_randr_get_crtc_gamma_green_end (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) +xcb_randr_get_crtc_gamma_green_end (const xcb_randr_get_crtc_gamma_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_crtc_gamma_red_end(R); - i.data = ((uint16_t *) child.data) + (R->size); + xcb_generic_iterator_t prev = xcb_randr_get_crtc_gamma_red_end(R); + i.data = ((uint16_t *) ((char*) prev.data + XCB_TYPE_PAD(uint16_t, prev.index))) + (R->size); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } uint16_t * -xcb_randr_get_crtc_gamma_blue (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) +xcb_randr_get_crtc_gamma_blue (const xcb_randr_get_crtc_gamma_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_crtc_gamma_green_end(R); return (uint16_t *) ((char *) prev.data + XCB_TYPE_PAD(uint16_t, prev.index) + 0); } int -xcb_randr_get_crtc_gamma_blue_length (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) +xcb_randr_get_crtc_gamma_blue_length (const xcb_randr_get_crtc_gamma_reply_t *R) { return R->size; } xcb_generic_iterator_t -xcb_randr_get_crtc_gamma_blue_end (const xcb_randr_get_crtc_gamma_reply_t *R /**< */) +xcb_randr_get_crtc_gamma_blue_end (const xcb_randr_get_crtc_gamma_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_crtc_gamma_green_end(R); - i.data = ((uint16_t *) child.data) + (R->size); + xcb_generic_iterator_t prev = xcb_randr_get_crtc_gamma_green_end(R); + i.data = ((uint16_t *) ((char*) prev.data + XCB_TYPE_PAD(uint16_t, prev.index))) + (R->size); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_get_crtc_gamma_reply_t * -xcb_randr_get_crtc_gamma_reply (xcb_connection_t *c /**< */, +xcb_randr_get_crtc_gamma_reply (xcb_connection_t *c, xcb_randr_get_crtc_gamma_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_crtc_gamma_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_set_crtc_gamma_sizeof (const void *_buffer /**< */) +xcb_randr_set_crtc_gamma_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_set_crtc_gamma_request_t *_aux = (xcb_randr_set_crtc_gamma_request_t *)_buffer; @@ -2639,18 +2683,18 @@ xcb_randr_set_crtc_gamma_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - uint16_t size /**< */, - const uint16_t *red /**< */, - const uint16_t *green /**< */, - const uint16_t *blue /**< */) +xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + uint16_t size, + const uint16_t *red, + const uint16_t *green, + const uint16_t *blue) { static const xcb_protocol_request_t xcb_req = { - /* count */ 8, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_CRTC_GAMMA, - /* isvoid */ 1 + .count = 8, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_CRTC_GAMMA, + .isvoid = 1 }; struct iovec xcb_parts[10]; @@ -2686,18 +2730,18 @@ xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_set_crtc_gamma (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - uint16_t size /**< */, - const uint16_t *red /**< */, - const uint16_t *green /**< */, - const uint16_t *blue /**< */) +xcb_randr_set_crtc_gamma (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + uint16_t size, + const uint16_t *red, + const uint16_t *green, + const uint16_t *blue) { static const xcb_protocol_request_t xcb_req = { - /* count */ 8, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_CRTC_GAMMA, - /* isvoid */ 1 + .count = 8, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_CRTC_GAMMA, + .isvoid = 1 }; struct iovec xcb_parts[10]; @@ -2732,8 +2776,78 @@ xcb_randr_set_crtc_gamma (xcb_connection_t *c /**< */, return xcb_ret; } +uint16_t * +xcb_randr_set_crtc_gamma_red (const xcb_randr_set_crtc_gamma_request_t *R) +{ + return (uint16_t *) (R + 1); +} + int -xcb_randr_get_screen_resources_current_sizeof (const void *_buffer /**< */) +xcb_randr_set_crtc_gamma_red_length (const xcb_randr_set_crtc_gamma_request_t *R) +{ + return R->size; +} + +xcb_generic_iterator_t +xcb_randr_set_crtc_gamma_red_end (const xcb_randr_set_crtc_gamma_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint16_t *) (R + 1)) + (R->size); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint16_t * +xcb_randr_set_crtc_gamma_green (const xcb_randr_set_crtc_gamma_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_randr_set_crtc_gamma_red_end(R); + return (uint16_t *) ((char *) prev.data + XCB_TYPE_PAD(uint16_t, prev.index) + 0); +} + +int +xcb_randr_set_crtc_gamma_green_length (const xcb_randr_set_crtc_gamma_request_t *R) +{ + return R->size; +} + +xcb_generic_iterator_t +xcb_randr_set_crtc_gamma_green_end (const xcb_randr_set_crtc_gamma_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_randr_set_crtc_gamma_red_end(R); + i.data = ((uint16_t *) ((char*) prev.data + XCB_TYPE_PAD(uint16_t, prev.index))) + (R->size); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint16_t * +xcb_randr_set_crtc_gamma_blue (const xcb_randr_set_crtc_gamma_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_randr_set_crtc_gamma_green_end(R); + return (uint16_t *) ((char *) prev.data + XCB_TYPE_PAD(uint16_t, prev.index) + 0); +} + +int +xcb_randr_set_crtc_gamma_blue_length (const xcb_randr_set_crtc_gamma_request_t *R) +{ + return R->size; +} + +xcb_generic_iterator_t +xcb_randr_set_crtc_gamma_blue_end (const xcb_randr_set_crtc_gamma_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_randr_set_crtc_gamma_green_end(R); + i.data = ((uint16_t *) ((char*) prev.data + XCB_TYPE_PAD(uint16_t, prev.index))) + (R->size); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_randr_get_screen_resources_current_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_screen_resources_current_reply_t *_aux = (xcb_randr_get_screen_resources_current_reply_t *)_buffer; @@ -2800,14 +2914,14 @@ xcb_randr_get_screen_resources_current_sizeof (const void *_buffer /**< */) } xcb_randr_get_screen_resources_current_cookie_t -xcb_randr_get_screen_resources_current (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_screen_resources_current (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_SCREEN_RESOURCES_CURRENT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_SCREEN_RESOURCES_CURRENT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2826,14 +2940,14 @@ xcb_randr_get_screen_resources_current (xcb_connection_t *c /**< */, } xcb_randr_get_screen_resources_current_cookie_t -xcb_randr_get_screen_resources_current_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_screen_resources_current_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_SCREEN_RESOURCES_CURRENT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_SCREEN_RESOURCES_CURRENT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2852,19 +2966,19 @@ xcb_randr_get_screen_resources_current_unchecked (xcb_connection_t *c /**< */, } xcb_randr_crtc_t * -xcb_randr_get_screen_resources_current_crtcs (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_crtcs (const xcb_randr_get_screen_resources_current_reply_t *R) { return (xcb_randr_crtc_t *) (R + 1); } int -xcb_randr_get_screen_resources_current_crtcs_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_crtcs_length (const xcb_randr_get_screen_resources_current_reply_t *R) { return R->num_crtcs; } xcb_generic_iterator_t -xcb_randr_get_screen_resources_current_crtcs_end (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_crtcs_end (const xcb_randr_get_screen_resources_current_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs); @@ -2874,44 +2988,44 @@ xcb_randr_get_screen_resources_current_crtcs_end (const xcb_randr_get_screen_res } xcb_randr_output_t * -xcb_randr_get_screen_resources_current_outputs (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_outputs (const xcb_randr_get_screen_resources_current_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_crtcs_end(R); return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0); } int -xcb_randr_get_screen_resources_current_outputs_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_outputs_length (const xcb_randr_get_screen_resources_current_reply_t *R) { return R->num_outputs; } xcb_generic_iterator_t -xcb_randr_get_screen_resources_current_outputs_end (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_outputs_end (const xcb_randr_get_screen_resources_current_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_screen_resources_current_crtcs_end(R); - i.data = ((xcb_randr_output_t *) child.data) + (R->num_outputs); + xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_crtcs_end(R); + i.data = ((xcb_randr_output_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index))) + (R->num_outputs); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_mode_info_t * -xcb_randr_get_screen_resources_current_modes (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_modes (const xcb_randr_get_screen_resources_current_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_outputs_end(R); return (xcb_randr_mode_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_info_t, prev.index) + 0); } int -xcb_randr_get_screen_resources_current_modes_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_modes_length (const xcb_randr_get_screen_resources_current_reply_t *R) { return R->num_modes; } xcb_randr_mode_info_iterator_t -xcb_randr_get_screen_resources_current_modes_iterator (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_modes_iterator (const xcb_randr_get_screen_resources_current_reply_t *R) { xcb_randr_mode_info_iterator_t i; xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_outputs_end(R); @@ -2922,40 +3036,40 @@ xcb_randr_get_screen_resources_current_modes_iterator (const xcb_randr_get_scree } uint8_t * -xcb_randr_get_screen_resources_current_names (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_names (const xcb_randr_get_screen_resources_current_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_current_modes_iterator(R)); return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0); } int -xcb_randr_get_screen_resources_current_names_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_names_length (const xcb_randr_get_screen_resources_current_reply_t *R) { return R->names_len; } xcb_generic_iterator_t -xcb_randr_get_screen_resources_current_names_end (const xcb_randr_get_screen_resources_current_reply_t *R /**< */) +xcb_randr_get_screen_resources_current_names_end (const xcb_randr_get_screen_resources_current_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_current_modes_iterator(R)); - i.data = ((uint8_t *) child.data) + (R->names_len); + xcb_generic_iterator_t prev = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_current_modes_iterator(R)); + i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (R->names_len); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_get_screen_resources_current_reply_t * -xcb_randr_get_screen_resources_current_reply (xcb_connection_t *c /**< */, +xcb_randr_get_screen_resources_current_reply (xcb_connection_t *c, xcb_randr_get_screen_resources_current_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_screen_resources_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_set_crtc_transform_sizeof (const void *_buffer /**< */, - uint32_t filter_params_len /**< */) +xcb_randr_set_crtc_transform_sizeof (const void *_buffer, + uint32_t filter_params_len) { char *xcb_tmp = (char *)_buffer; const xcb_randr_set_crtc_transform_request_t *_aux = (xcb_randr_set_crtc_transform_request_t *)_buffer; @@ -2973,6 +3087,15 @@ xcb_randr_set_crtc_transform_sizeof (const void *_buffer /**< */, xcb_block_len += _aux->filter_len * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -2998,19 +3121,19 @@ xcb_randr_set_crtc_transform_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_randr_set_crtc_transform_checked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_render_transform_t transform /**< */, - uint16_t filter_len /**< */, - const char *filter_name /**< */, - uint32_t filter_params_len /**< */, - const xcb_render_fixed_t *filter_params /**< */) +xcb_randr_set_crtc_transform_checked (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_render_transform_t transform, + uint16_t filter_len, + const char *filter_name, + uint32_t filter_params_len, + const xcb_render_fixed_t *filter_params) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_CRTC_TRANSFORM, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_CRTC_TRANSFORM, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -3042,19 +3165,19 @@ xcb_randr_set_crtc_transform_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_set_crtc_transform (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_render_transform_t transform /**< */, - uint16_t filter_len /**< */, - const char *filter_name /**< */, - uint32_t filter_params_len /**< */, - const xcb_render_fixed_t *filter_params /**< */) +xcb_randr_set_crtc_transform (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_render_transform_t transform, + uint16_t filter_len, + const char *filter_name, + uint32_t filter_params_len, + const xcb_render_fixed_t *filter_params) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_CRTC_TRANSFORM, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_CRTC_TRANSFORM, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -3085,8 +3208,54 @@ xcb_randr_set_crtc_transform (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_randr_set_crtc_transform_filter_name (const xcb_randr_set_crtc_transform_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_randr_get_crtc_transform_sizeof (const void *_buffer /**< */) +xcb_randr_set_crtc_transform_filter_name_length (const xcb_randr_set_crtc_transform_request_t *R) +{ + return R->filter_len; +} + +xcb_generic_iterator_t +xcb_randr_set_crtc_transform_filter_name_end (const xcb_randr_set_crtc_transform_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->filter_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_render_fixed_t * +xcb_randr_set_crtc_transform_filter_params (const xcb_randr_set_crtc_transform_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_randr_set_crtc_transform_filter_name_end(R); + return (xcb_render_fixed_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); +} + +int +xcb_randr_set_crtc_transform_filter_params_length (const xcb_randr_set_crtc_transform_request_t *R) +{ + return ((((char*)R) + R->length * 4) - (char*)(xcb_randr_set_crtc_transform_filter_params(R))) / sizeof(xcb_render_fixed_t); +} + +xcb_generic_iterator_t +xcb_randr_set_crtc_transform_filter_params_end (const xcb_randr_set_crtc_transform_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_randr_set_crtc_transform_filter_name_end(R); + i.data = ((xcb_render_fixed_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (((((char*)R) + R->length * 4) - (char*)(xcb_randr_set_crtc_transform_filter_params(R))) / sizeof(xcb_render_fixed_t)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_randr_get_crtc_transform_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_crtc_transform_reply_t *_aux = (xcb_randr_get_crtc_transform_reply_t *)_buffer; @@ -3104,6 +3273,15 @@ xcb_randr_get_crtc_transform_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->pending_len * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -3128,6 +3306,15 @@ xcb_randr_get_crtc_transform_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->current_len * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -3153,14 +3340,14 @@ xcb_randr_get_crtc_transform_sizeof (const void *_buffer /**< */) } xcb_randr_get_crtc_transform_cookie_t -xcb_randr_get_crtc_transform (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */) +xcb_randr_get_crtc_transform (xcb_connection_t *c, + xcb_randr_crtc_t crtc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_CRTC_TRANSFORM, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_CRTC_TRANSFORM, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3179,14 +3366,14 @@ xcb_randr_get_crtc_transform (xcb_connection_t *c /**< */, } xcb_randr_get_crtc_transform_cookie_t -xcb_randr_get_crtc_transform_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */) +xcb_randr_get_crtc_transform_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_CRTC_TRANSFORM, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_CRTC_TRANSFORM, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3205,19 +3392,19 @@ xcb_randr_get_crtc_transform_unchecked (xcb_connection_t *c /**< */, } char * -xcb_randr_get_crtc_transform_pending_filter_name (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_pending_filter_name (const xcb_randr_get_crtc_transform_reply_t *R) { return (char *) (R + 1); } int -xcb_randr_get_crtc_transform_pending_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_pending_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R) { return R->pending_len; } xcb_generic_iterator_t -xcb_randr_get_crtc_transform_pending_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_pending_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->pending_len); @@ -3227,94 +3414,94 @@ xcb_randr_get_crtc_transform_pending_filter_name_end (const xcb_randr_get_crtc_t } xcb_render_fixed_t * -xcb_randr_get_crtc_transform_pending_params (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_pending_params (const xcb_randr_get_crtc_transform_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_pending_filter_name_end(R); - return (xcb_render_fixed_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_fixed_t, prev.index) + 0); + return (xcb_render_fixed_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); } int -xcb_randr_get_crtc_transform_pending_params_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_pending_params_length (const xcb_randr_get_crtc_transform_reply_t *R) { return R->pending_nparams; } xcb_generic_iterator_t -xcb_randr_get_crtc_transform_pending_params_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_pending_params_end (const xcb_randr_get_crtc_transform_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_crtc_transform_pending_filter_name_end(R); - i.data = ((xcb_render_fixed_t *) child.data) + (R->pending_nparams); + xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_pending_filter_name_end(R); + i.data = ((xcb_render_fixed_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->pending_nparams); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } char * -xcb_randr_get_crtc_transform_current_filter_name (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_current_filter_name (const xcb_randr_get_crtc_transform_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_pending_params_end(R); return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); } int -xcb_randr_get_crtc_transform_current_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_current_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R) { return R->current_len; } xcb_generic_iterator_t -xcb_randr_get_crtc_transform_current_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_current_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_crtc_transform_pending_params_end(R); - i.data = ((char *) child.data) + (R->current_len); + xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_pending_params_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->current_len); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_render_fixed_t * -xcb_randr_get_crtc_transform_current_params (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_current_params (const xcb_randr_get_crtc_transform_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_current_filter_name_end(R); - return (xcb_render_fixed_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_fixed_t, prev.index) + 0); + return (xcb_render_fixed_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); } int -xcb_randr_get_crtc_transform_current_params_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_current_params_length (const xcb_randr_get_crtc_transform_reply_t *R) { return R->current_nparams; } xcb_generic_iterator_t -xcb_randr_get_crtc_transform_current_params_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */) +xcb_randr_get_crtc_transform_current_params_end (const xcb_randr_get_crtc_transform_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_crtc_transform_current_filter_name_end(R); - i.data = ((xcb_render_fixed_t *) child.data) + (R->current_nparams); + xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_current_filter_name_end(R); + i.data = ((xcb_render_fixed_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->current_nparams); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_get_crtc_transform_reply_t * -xcb_randr_get_crtc_transform_reply (xcb_connection_t *c /**< */, +xcb_randr_get_crtc_transform_reply (xcb_connection_t *c, xcb_randr_get_crtc_transform_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_crtc_transform_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_randr_get_panning_cookie_t -xcb_randr_get_panning (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */) +xcb_randr_get_panning (xcb_connection_t *c, + xcb_randr_crtc_t crtc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_PANNING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_PANNING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3333,14 +3520,14 @@ xcb_randr_get_panning (xcb_connection_t *c /**< */, } xcb_randr_get_panning_cookie_t -xcb_randr_get_panning_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */) +xcb_randr_get_panning_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_PANNING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_PANNING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3359,35 +3546,35 @@ xcb_randr_get_panning_unchecked (xcb_connection_t *c /**< */, } xcb_randr_get_panning_reply_t * -xcb_randr_get_panning_reply (xcb_connection_t *c /**< */, +xcb_randr_get_panning_reply (xcb_connection_t *c, xcb_randr_get_panning_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_panning_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_randr_set_panning_cookie_t -xcb_randr_set_panning (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t timestamp /**< */, - uint16_t left /**< */, - uint16_t top /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t track_left /**< */, - uint16_t track_top /**< */, - uint16_t track_width /**< */, - uint16_t track_height /**< */, - int16_t border_left /**< */, - int16_t border_top /**< */, - int16_t border_right /**< */, - int16_t border_bottom /**< */) +xcb_randr_set_panning (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t timestamp, + uint16_t left, + uint16_t top, + uint16_t width, + uint16_t height, + uint16_t track_left, + uint16_t track_top, + uint16_t track_width, + uint16_t track_height, + int16_t border_left, + int16_t border_top, + int16_t border_right, + int16_t border_bottom) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_PANNING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_PANNING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3419,27 +3606,27 @@ xcb_randr_set_panning (xcb_connection_t *c /**< */, } xcb_randr_set_panning_cookie_t -xcb_randr_set_panning_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t timestamp /**< */, - uint16_t left /**< */, - uint16_t top /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t track_left /**< */, - uint16_t track_top /**< */, - uint16_t track_width /**< */, - uint16_t track_height /**< */, - int16_t border_left /**< */, - int16_t border_top /**< */, - int16_t border_right /**< */, - int16_t border_bottom /**< */) +xcb_randr_set_panning_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t timestamp, + uint16_t left, + uint16_t top, + uint16_t width, + uint16_t height, + uint16_t track_left, + uint16_t track_top, + uint16_t track_width, + uint16_t track_height, + int16_t border_left, + int16_t border_top, + int16_t border_right, + int16_t border_bottom) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_PANNING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_PANNING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3471,23 +3658,23 @@ xcb_randr_set_panning_unchecked (xcb_connection_t *c /**< */, } xcb_randr_set_panning_reply_t * -xcb_randr_set_panning_reply (xcb_connection_t *c /**< */, +xcb_randr_set_panning_reply (xcb_connection_t *c, xcb_randr_set_panning_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_set_panning_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_randr_set_output_primary_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_randr_output_t output /**< */) +xcb_randr_set_output_primary_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_output_t output) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_OUTPUT_PRIMARY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_OUTPUT_PRIMARY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3507,15 +3694,15 @@ xcb_randr_set_output_primary_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_set_output_primary (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_randr_output_t output /**< */) +xcb_randr_set_output_primary (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_output_t output) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_OUTPUT_PRIMARY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_OUTPUT_PRIMARY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3535,14 +3722,14 @@ xcb_randr_set_output_primary (xcb_connection_t *c /**< */, } xcb_randr_get_output_primary_cookie_t -xcb_randr_get_output_primary (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_output_primary (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_OUTPUT_PRIMARY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_OUTPUT_PRIMARY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3561,14 +3748,14 @@ xcb_randr_get_output_primary (xcb_connection_t *c /**< */, } xcb_randr_get_output_primary_cookie_t -xcb_randr_get_output_primary_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_output_primary_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_OUTPUT_PRIMARY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_OUTPUT_PRIMARY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3587,15 +3774,15 @@ xcb_randr_get_output_primary_unchecked (xcb_connection_t *c /**< */, } xcb_randr_get_output_primary_reply_t * -xcb_randr_get_output_primary_reply (xcb_connection_t *c /**< */, +xcb_randr_get_output_primary_reply (xcb_connection_t *c, xcb_randr_get_output_primary_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_output_primary_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_get_providers_sizeof (const void *_buffer /**< */) +xcb_randr_get_providers_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_providers_reply_t *_aux = (xcb_randr_get_providers_reply_t *)_buffer; @@ -3626,14 +3813,14 @@ xcb_randr_get_providers_sizeof (const void *_buffer /**< */) } xcb_randr_get_providers_cookie_t -xcb_randr_get_providers (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_providers (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_PROVIDERS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_PROVIDERS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3652,14 +3839,14 @@ xcb_randr_get_providers (xcb_connection_t *c /**< */, } xcb_randr_get_providers_cookie_t -xcb_randr_get_providers_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_randr_get_providers_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_PROVIDERS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_PROVIDERS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3678,19 +3865,19 @@ xcb_randr_get_providers_unchecked (xcb_connection_t *c /**< */, } xcb_randr_provider_t * -xcb_randr_get_providers_providers (const xcb_randr_get_providers_reply_t *R /**< */) +xcb_randr_get_providers_providers (const xcb_randr_get_providers_reply_t *R) { return (xcb_randr_provider_t *) (R + 1); } int -xcb_randr_get_providers_providers_length (const xcb_randr_get_providers_reply_t *R /**< */) +xcb_randr_get_providers_providers_length (const xcb_randr_get_providers_reply_t *R) { return R->num_providers; } xcb_generic_iterator_t -xcb_randr_get_providers_providers_end (const xcb_randr_get_providers_reply_t *R /**< */) +xcb_randr_get_providers_providers_end (const xcb_randr_get_providers_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_randr_provider_t *) (R + 1)) + (R->num_providers); @@ -3700,15 +3887,15 @@ xcb_randr_get_providers_providers_end (const xcb_randr_get_providers_reply_t *R } xcb_randr_get_providers_reply_t * -xcb_randr_get_providers_reply (xcb_connection_t *c /**< */, +xcb_randr_get_providers_reply (xcb_connection_t *c, xcb_randr_get_providers_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_providers_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_get_provider_info_sizeof (const void *_buffer /**< */) +xcb_randr_get_provider_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_provider_info_reply_t *_aux = (xcb_randr_get_provider_info_reply_t *)_buffer; @@ -3787,15 +3974,15 @@ xcb_randr_get_provider_info_sizeof (const void *_buffer /**< */) } xcb_randr_get_provider_info_cookie_t -xcb_randr_get_provider_info (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_timestamp_t config_timestamp /**< */) +xcb_randr_get_provider_info (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_timestamp_t config_timestamp) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_PROVIDER_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_PROVIDER_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3815,15 +4002,15 @@ xcb_randr_get_provider_info (xcb_connection_t *c /**< */, } xcb_randr_get_provider_info_cookie_t -xcb_randr_get_provider_info_unchecked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_timestamp_t config_timestamp /**< */) +xcb_randr_get_provider_info_unchecked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_timestamp_t config_timestamp) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_PROVIDER_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_PROVIDER_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3843,19 +4030,19 @@ xcb_randr_get_provider_info_unchecked (xcb_connection_t *c /**< */, } xcb_randr_crtc_t * -xcb_randr_get_provider_info_crtcs (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_crtcs (const xcb_randr_get_provider_info_reply_t *R) { return (xcb_randr_crtc_t *) (R + 1); } int -xcb_randr_get_provider_info_crtcs_length (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_crtcs_length (const xcb_randr_get_provider_info_reply_t *R) { return R->num_crtcs; } xcb_generic_iterator_t -xcb_randr_get_provider_info_crtcs_end (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_crtcs_end (const xcb_randr_get_provider_info_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs); @@ -3865,120 +4052,120 @@ xcb_randr_get_provider_info_crtcs_end (const xcb_randr_get_provider_info_reply_t } xcb_randr_output_t * -xcb_randr_get_provider_info_outputs (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_outputs (const xcb_randr_get_provider_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_provider_info_crtcs_end(R); return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0); } int -xcb_randr_get_provider_info_outputs_length (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_outputs_length (const xcb_randr_get_provider_info_reply_t *R) { return R->num_outputs; } xcb_generic_iterator_t -xcb_randr_get_provider_info_outputs_end (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_outputs_end (const xcb_randr_get_provider_info_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_provider_info_crtcs_end(R); - i.data = ((xcb_randr_output_t *) child.data) + (R->num_outputs); + xcb_generic_iterator_t prev = xcb_randr_get_provider_info_crtcs_end(R); + i.data = ((xcb_randr_output_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index))) + (R->num_outputs); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_provider_t * -xcb_randr_get_provider_info_associated_providers (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_associated_providers (const xcb_randr_get_provider_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_provider_info_outputs_end(R); return (xcb_randr_provider_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_provider_t, prev.index) + 0); } int -xcb_randr_get_provider_info_associated_providers_length (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_associated_providers_length (const xcb_randr_get_provider_info_reply_t *R) { return R->num_associated_providers; } xcb_generic_iterator_t -xcb_randr_get_provider_info_associated_providers_end (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_associated_providers_end (const xcb_randr_get_provider_info_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_provider_info_outputs_end(R); - i.data = ((xcb_randr_provider_t *) child.data) + (R->num_associated_providers); + xcb_generic_iterator_t prev = xcb_randr_get_provider_info_outputs_end(R); + i.data = ((xcb_randr_provider_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_provider_t, prev.index))) + (R->num_associated_providers); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } uint32_t * -xcb_randr_get_provider_info_associated_capability (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_associated_capability (const xcb_randr_get_provider_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_provider_info_associated_providers_end(R); return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); } int -xcb_randr_get_provider_info_associated_capability_length (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_associated_capability_length (const xcb_randr_get_provider_info_reply_t *R) { return R->num_associated_providers; } xcb_generic_iterator_t -xcb_randr_get_provider_info_associated_capability_end (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_associated_capability_end (const xcb_randr_get_provider_info_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_provider_info_associated_providers_end(R); - i.data = ((uint32_t *) child.data) + (R->num_associated_providers); + xcb_generic_iterator_t prev = xcb_randr_get_provider_info_associated_providers_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_associated_providers); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } char * -xcb_randr_get_provider_info_name (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_name (const xcb_randr_get_provider_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_randr_get_provider_info_associated_capability_end(R); return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); } int -xcb_randr_get_provider_info_name_length (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_name_length (const xcb_randr_get_provider_info_reply_t *R) { return R->name_len; } xcb_generic_iterator_t -xcb_randr_get_provider_info_name_end (const xcb_randr_get_provider_info_reply_t *R /**< */) +xcb_randr_get_provider_info_name_end (const xcb_randr_get_provider_info_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_randr_get_provider_info_associated_capability_end(R); - i.data = ((char *) child.data) + (R->name_len); + xcb_generic_iterator_t prev = xcb_randr_get_provider_info_associated_capability_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->name_len); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_randr_get_provider_info_reply_t * -xcb_randr_get_provider_info_reply (xcb_connection_t *c /**< */, +xcb_randr_get_provider_info_reply (xcb_connection_t *c, xcb_randr_get_provider_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_provider_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_randr_set_provider_offload_sink_checked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_randr_provider_t sink_provider /**< */, - xcb_timestamp_t config_timestamp /**< */) +xcb_randr_set_provider_offload_sink_checked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_randr_provider_t sink_provider, + xcb_timestamp_t config_timestamp) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_PROVIDER_OFFLOAD_SINK, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_PROVIDER_OFFLOAD_SINK, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3999,16 +4186,16 @@ xcb_randr_set_provider_offload_sink_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_set_provider_offload_sink (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_randr_provider_t sink_provider /**< */, - xcb_timestamp_t config_timestamp /**< */) +xcb_randr_set_provider_offload_sink (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_randr_provider_t sink_provider, + xcb_timestamp_t config_timestamp) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_PROVIDER_OFFLOAD_SINK, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_PROVIDER_OFFLOAD_SINK, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4029,16 +4216,16 @@ xcb_randr_set_provider_offload_sink (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_set_provider_output_source_checked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_randr_provider_t source_provider /**< */, - xcb_timestamp_t config_timestamp /**< */) +xcb_randr_set_provider_output_source_checked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_randr_provider_t source_provider, + xcb_timestamp_t config_timestamp) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_PROVIDER_OUTPUT_SOURCE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_PROVIDER_OUTPUT_SOURCE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4059,16 +4246,16 @@ xcb_randr_set_provider_output_source_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_set_provider_output_source (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_randr_provider_t source_provider /**< */, - xcb_timestamp_t config_timestamp /**< */) +xcb_randr_set_provider_output_source (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_randr_provider_t source_provider, + xcb_timestamp_t config_timestamp) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_SET_PROVIDER_OUTPUT_SOURCE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_PROVIDER_OUTPUT_SOURCE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4089,7 +4276,7 @@ xcb_randr_set_provider_output_source (xcb_connection_t *c /**< */, } int -xcb_randr_list_provider_properties_sizeof (const void *_buffer /**< */) +xcb_randr_list_provider_properties_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_list_provider_properties_reply_t *_aux = (xcb_randr_list_provider_properties_reply_t *)_buffer; @@ -4120,14 +4307,14 @@ xcb_randr_list_provider_properties_sizeof (const void *_buffer /**< */) } xcb_randr_list_provider_properties_cookie_t -xcb_randr_list_provider_properties (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */) +xcb_randr_list_provider_properties (xcb_connection_t *c, + xcb_randr_provider_t provider) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_LIST_PROVIDER_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_LIST_PROVIDER_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4146,14 +4333,14 @@ xcb_randr_list_provider_properties (xcb_connection_t *c /**< */, } xcb_randr_list_provider_properties_cookie_t -xcb_randr_list_provider_properties_unchecked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */) +xcb_randr_list_provider_properties_unchecked (xcb_connection_t *c, + xcb_randr_provider_t provider) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_LIST_PROVIDER_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_LIST_PROVIDER_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4172,19 +4359,19 @@ xcb_randr_list_provider_properties_unchecked (xcb_connection_t *c /**< */, } xcb_atom_t * -xcb_randr_list_provider_properties_atoms (const xcb_randr_list_provider_properties_reply_t *R /**< */) +xcb_randr_list_provider_properties_atoms (const xcb_randr_list_provider_properties_reply_t *R) { return (xcb_atom_t *) (R + 1); } int -xcb_randr_list_provider_properties_atoms_length (const xcb_randr_list_provider_properties_reply_t *R /**< */) +xcb_randr_list_provider_properties_atoms_length (const xcb_randr_list_provider_properties_reply_t *R) { return R->num_atoms; } xcb_generic_iterator_t -xcb_randr_list_provider_properties_atoms_end (const xcb_randr_list_provider_properties_reply_t *R /**< */) +xcb_randr_list_provider_properties_atoms_end (const xcb_randr_list_provider_properties_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_atom_t *) (R + 1)) + (R->num_atoms); @@ -4194,15 +4381,15 @@ xcb_randr_list_provider_properties_atoms_end (const xcb_randr_list_provider_prop } xcb_randr_list_provider_properties_reply_t * -xcb_randr_list_provider_properties_reply (xcb_connection_t *c /**< */, +xcb_randr_list_provider_properties_reply (xcb_connection_t *c, xcb_randr_list_provider_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_list_provider_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_query_provider_property_sizeof (const void *_buffer /**< */) +xcb_randr_query_provider_property_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_query_provider_property_reply_t *_aux = (xcb_randr_query_provider_property_reply_t *)_buffer; @@ -4233,15 +4420,15 @@ xcb_randr_query_provider_property_sizeof (const void *_buffer /**< */) } xcb_randr_query_provider_property_cookie_t -xcb_randr_query_provider_property (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */) +xcb_randr_query_provider_property (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_QUERY_PROVIDER_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_QUERY_PROVIDER_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4261,15 +4448,15 @@ xcb_randr_query_provider_property (xcb_connection_t *c /**< */, } xcb_randr_query_provider_property_cookie_t -xcb_randr_query_provider_property_unchecked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */) +xcb_randr_query_provider_property_unchecked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_QUERY_PROVIDER_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_QUERY_PROVIDER_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4289,19 +4476,19 @@ xcb_randr_query_provider_property_unchecked (xcb_connection_t *c /**< */, } int32_t * -xcb_randr_query_provider_property_valid_values (const xcb_randr_query_provider_property_reply_t *R /**< */) +xcb_randr_query_provider_property_valid_values (const xcb_randr_query_provider_property_reply_t *R) { return (int32_t *) (R + 1); } int -xcb_randr_query_provider_property_valid_values_length (const xcb_randr_query_provider_property_reply_t *R /**< */) +xcb_randr_query_provider_property_valid_values_length (const xcb_randr_query_provider_property_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_randr_query_provider_property_valid_values_end (const xcb_randr_query_provider_property_reply_t *R /**< */) +xcb_randr_query_provider_property_valid_values_end (const xcb_randr_query_provider_property_reply_t *R) { xcb_generic_iterator_t i; i.data = ((int32_t *) (R + 1)) + (R->length); @@ -4311,16 +4498,16 @@ xcb_randr_query_provider_property_valid_values_end (const xcb_randr_query_provid } xcb_randr_query_provider_property_reply_t * -xcb_randr_query_provider_property_reply (xcb_connection_t *c /**< */, +xcb_randr_query_provider_property_reply (xcb_connection_t *c, xcb_randr_query_provider_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_query_provider_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_randr_configure_provider_property_sizeof (const void *_buffer /**< */, - uint32_t values_len /**< */) +xcb_randr_configure_provider_property_sizeof (const void *_buffer, + uint32_t values_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -4350,19 +4537,19 @@ xcb_randr_configure_provider_property_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_randr_configure_provider_property_checked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - uint8_t pending /**< */, - uint8_t range /**< */, - uint32_t values_len /**< */, - const int32_t *values /**< */) +xcb_randr_configure_provider_property_checked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + uint8_t pending, + uint8_t range, + uint32_t values_len, + const int32_t *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_CONFIGURE_PROVIDER_PROPERTY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_CONFIGURE_PROVIDER_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -4390,19 +4577,19 @@ xcb_randr_configure_provider_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_configure_provider_property (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - uint8_t pending /**< */, - uint8_t range /**< */, - uint32_t values_len /**< */, - const int32_t *values /**< */) +xcb_randr_configure_provider_property (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + uint8_t pending, + uint8_t range, + uint32_t values_len, + const int32_t *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_CONFIGURE_PROVIDER_PROPERTY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_CONFIGURE_PROVIDER_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -4429,8 +4616,30 @@ xcb_randr_configure_provider_property (xcb_connection_t *c /**< */, return xcb_ret; } +int32_t * +xcb_randr_configure_provider_property_values (const xcb_randr_configure_provider_property_request_t *R) +{ + return (int32_t *) (R + 1); +} + int -xcb_randr_change_provider_property_sizeof (const void *_buffer /**< */) +xcb_randr_configure_provider_property_values_length (const xcb_randr_configure_provider_property_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_randr_configure_provider_property_request_t))/sizeof(int32_t)); +} + +xcb_generic_iterator_t +xcb_randr_configure_provider_property_values_end (const xcb_randr_configure_provider_property_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((int32_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_randr_configure_provider_property_request_t))/sizeof(int32_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_randr_change_provider_property_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_change_provider_property_request_t *_aux = (xcb_randr_change_provider_property_request_t *)_buffer; @@ -4461,20 +4670,20 @@ xcb_randr_change_provider_property_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_randr_change_provider_property_checked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const void *data /**< */) +xcb_randr_change_provider_property_checked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_CHANGE_PROVIDER_PROPERTY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_CHANGE_PROVIDER_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -4504,20 +4713,20 @@ xcb_randr_change_provider_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_change_provider_property (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const void *data /**< */) +xcb_randr_change_provider_property (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_CHANGE_PROVIDER_PROPERTY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_CHANGE_PROVIDER_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -4546,16 +4755,38 @@ xcb_randr_change_provider_property (xcb_connection_t *c /**< */, return xcb_ret; } +void * +xcb_randr_change_provider_property_data (const xcb_randr_change_provider_property_request_t *R) +{ + return (void *) (R + 1); +} + +int +xcb_randr_change_provider_property_data_length (const xcb_randr_change_provider_property_request_t *R) +{ + return (R->num_items * (R->format / 8)); +} + +xcb_generic_iterator_t +xcb_randr_change_provider_property_data_end (const xcb_randr_change_provider_property_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + ((R->num_items * (R->format / 8))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_randr_delete_provider_property_checked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */) +xcb_randr_delete_provider_property_checked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_DELETE_PROVIDER_PROPERTY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_DELETE_PROVIDER_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4575,15 +4806,15 @@ xcb_randr_delete_provider_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_randr_delete_provider_property (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */) +xcb_randr_delete_provider_property (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_DELETE_PROVIDER_PROPERTY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_DELETE_PROVIDER_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4603,7 +4834,7 @@ xcb_randr_delete_provider_property (xcb_connection_t *c /**< */, } int -xcb_randr_get_provider_property_sizeof (const void *_buffer /**< */) +xcb_randr_get_provider_property_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_randr_get_provider_property_reply_t *_aux = (xcb_randr_get_provider_property_reply_t *)_buffer; @@ -4634,20 +4865,20 @@ xcb_randr_get_provider_property_sizeof (const void *_buffer /**< */) } xcb_randr_get_provider_property_cookie_t -xcb_randr_get_provider_property (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */, - uint8_t _delete /**< */, - uint8_t pending /**< */) +xcb_randr_get_provider_property (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length, + uint8_t _delete, + uint8_t pending) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_PROVIDER_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_PROVIDER_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4673,20 +4904,20 @@ xcb_randr_get_provider_property (xcb_connection_t *c /**< */, } xcb_randr_get_provider_property_cookie_t -xcb_randr_get_provider_property_unchecked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */, - uint8_t _delete /**< */, - uint8_t pending /**< */) +xcb_randr_get_provider_property_unchecked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length, + uint8_t _delete, + uint8_t pending) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_randr_id, - /* opcode */ XCB_RANDR_GET_PROVIDER_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_PROVIDER_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4712,19 +4943,19 @@ xcb_randr_get_provider_property_unchecked (xcb_connection_t *c /**< */, } void * -xcb_randr_get_provider_property_data (const xcb_randr_get_provider_property_reply_t *R /**< */) +xcb_randr_get_provider_property_data (const xcb_randr_get_provider_property_reply_t *R) { return (void *) (R + 1); } int -xcb_randr_get_provider_property_data_length (const xcb_randr_get_provider_property_reply_t *R /**< */) +xcb_randr_get_provider_property_data_length (const xcb_randr_get_provider_property_reply_t *R) { return (R->num_items * (R->format / 8)); } xcb_generic_iterator_t -xcb_randr_get_provider_property_data_end (const xcb_randr_get_provider_property_reply_t *R /**< */) +xcb_randr_get_provider_property_data_end (const xcb_randr_get_provider_property_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + ((R->num_items * (R->format / 8))); @@ -4734,15 +4965,15 @@ xcb_randr_get_provider_property_data_end (const xcb_randr_get_provider_property_ } xcb_randr_get_provider_property_reply_t * -xcb_randr_get_provider_property_reply (xcb_connection_t *c /**< */, +xcb_randr_get_provider_property_reply (xcb_connection_t *c, xcb_randr_get_provider_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_randr_get_provider_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } void -xcb_randr_crtc_change_next (xcb_randr_crtc_change_iterator_t *i /**< */) +xcb_randr_crtc_change_next (xcb_randr_crtc_change_iterator_t *i) { --i->rem; ++i->data; @@ -4750,7 +4981,7 @@ xcb_randr_crtc_change_next (xcb_randr_crtc_change_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_randr_crtc_change_end (xcb_randr_crtc_change_iterator_t i /**< */) +xcb_randr_crtc_change_end (xcb_randr_crtc_change_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4760,7 +4991,7 @@ xcb_randr_crtc_change_end (xcb_randr_crtc_change_iterator_t i /**< */) } void -xcb_randr_output_change_next (xcb_randr_output_change_iterator_t *i /**< */) +xcb_randr_output_change_next (xcb_randr_output_change_iterator_t *i) { --i->rem; ++i->data; @@ -4768,7 +4999,7 @@ xcb_randr_output_change_next (xcb_randr_output_change_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_randr_output_change_end (xcb_randr_output_change_iterator_t i /**< */) +xcb_randr_output_change_end (xcb_randr_output_change_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4778,7 +5009,7 @@ xcb_randr_output_change_end (xcb_randr_output_change_iterator_t i /**< */) } void -xcb_randr_output_property_next (xcb_randr_output_property_iterator_t *i /**< */) +xcb_randr_output_property_next (xcb_randr_output_property_iterator_t *i) { --i->rem; ++i->data; @@ -4786,7 +5017,7 @@ xcb_randr_output_property_next (xcb_randr_output_property_iterator_t *i /**< */ } xcb_generic_iterator_t -xcb_randr_output_property_end (xcb_randr_output_property_iterator_t i /**< */) +xcb_randr_output_property_end (xcb_randr_output_property_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4796,7 +5027,7 @@ xcb_randr_output_property_end (xcb_randr_output_property_iterator_t i /**< */) } void -xcb_randr_provider_change_next (xcb_randr_provider_change_iterator_t *i /**< */) +xcb_randr_provider_change_next (xcb_randr_provider_change_iterator_t *i) { --i->rem; ++i->data; @@ -4804,7 +5035,7 @@ xcb_randr_provider_change_next (xcb_randr_provider_change_iterator_t *i /**< */ } xcb_generic_iterator_t -xcb_randr_provider_change_end (xcb_randr_provider_change_iterator_t i /**< */) +xcb_randr_provider_change_end (xcb_randr_provider_change_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4814,7 +5045,7 @@ xcb_randr_provider_change_end (xcb_randr_provider_change_iterator_t i /**< */) } void -xcb_randr_provider_property_next (xcb_randr_provider_property_iterator_t *i /**< */) +xcb_randr_provider_property_next (xcb_randr_provider_property_iterator_t *i) { --i->rem; ++i->data; @@ -4822,7 +5053,7 @@ xcb_randr_provider_property_next (xcb_randr_provider_property_iterator_t *i /** } xcb_generic_iterator_t -xcb_randr_provider_property_end (xcb_randr_provider_property_iterator_t i /**< */) +xcb_randr_provider_property_end (xcb_randr_provider_property_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4832,7 +5063,7 @@ xcb_randr_provider_property_end (xcb_randr_provider_property_iterator_t i /**< } void -xcb_randr_resource_change_next (xcb_randr_resource_change_iterator_t *i /**< */) +xcb_randr_resource_change_next (xcb_randr_resource_change_iterator_t *i) { --i->rem; ++i->data; @@ -4840,7 +5071,7 @@ xcb_randr_resource_change_next (xcb_randr_resource_change_iterator_t *i /**< */ } xcb_generic_iterator_t -xcb_randr_resource_change_end (xcb_randr_resource_change_iterator_t i /**< */) +xcb_randr_resource_change_end (xcb_randr_resource_change_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4850,7 +5081,7 @@ xcb_randr_resource_change_end (xcb_randr_resource_change_iterator_t i /**< */) } void -xcb_randr_notify_data_next (xcb_randr_notify_data_iterator_t *i /**< */) +xcb_randr_notify_data_next (xcb_randr_notify_data_iterator_t *i) { --i->rem; ++i->data; @@ -4858,7 +5089,7 @@ xcb_randr_notify_data_next (xcb_randr_notify_data_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_randr_notify_data_end (xcb_randr_notify_data_iterator_t i /**< */) +xcb_randr_notify_data_end (xcb_randr_notify_data_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4867,3 +5098,349 @@ xcb_randr_notify_data_end (xcb_randr_notify_data_iterator_t i /**< */) return ret; } +int +xcb_randr_monitor_info_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_monitor_info_t *_aux = (xcb_randr_monitor_info_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; + + + xcb_block_len += sizeof(xcb_randr_monitor_info_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* outputs */ + xcb_block_len += _aux->nOutput * sizeof(xcb_randr_output_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_output_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; + + return xcb_buffer_len; +} + +xcb_randr_output_t * +xcb_randr_monitor_info_outputs (const xcb_randr_monitor_info_t *R) +{ + return (xcb_randr_output_t *) (R + 1); +} + +int +xcb_randr_monitor_info_outputs_length (const xcb_randr_monitor_info_t *R) +{ + return R->nOutput; +} + +xcb_generic_iterator_t +xcb_randr_monitor_info_outputs_end (const xcb_randr_monitor_info_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_randr_output_t *) (R + 1)) + (R->nOutput); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +void +xcb_randr_monitor_info_next (xcb_randr_monitor_info_iterator_t *i) +{ + xcb_randr_monitor_info_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_randr_monitor_info_t *)(((char *)R) + xcb_randr_monitor_info_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; + --i->rem; + i->data = (xcb_randr_monitor_info_t *) child.data; +} + +xcb_generic_iterator_t +xcb_randr_monitor_info_end (xcb_randr_monitor_info_iterator_t i) +{ + xcb_generic_iterator_t ret; + while(i.rem > 0) + xcb_randr_monitor_info_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + return ret; +} + +int +xcb_randr_get_monitors_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_randr_get_monitors_reply_t *_aux = (xcb_randr_get_monitors_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_randr_get_monitors_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* monitors */ + for(i=0; i<_aux->nMonitors; i++) { + xcb_tmp_len = xcb_randr_monitor_info_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_randr_monitor_info_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; + + return xcb_buffer_len; +} + +xcb_randr_get_monitors_cookie_t +xcb_randr_get_monitors (xcb_connection_t *c, + xcb_window_t window, + uint8_t get_active) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_MONITORS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_randr_get_monitors_cookie_t xcb_ret; + xcb_randr_get_monitors_request_t xcb_out; + + xcb_out.window = window; + xcb_out.get_active = get_active; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_randr_get_monitors_cookie_t +xcb_randr_get_monitors_unchecked (xcb_connection_t *c, + xcb_window_t window, + uint8_t get_active) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_GET_MONITORS, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_randr_get_monitors_cookie_t xcb_ret; + xcb_randr_get_monitors_request_t xcb_out; + + xcb_out.window = window; + xcb_out.get_active = get_active; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + 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_randr_get_monitors_monitors_length (const xcb_randr_get_monitors_reply_t *R) +{ + return R->nMonitors; +} + +xcb_randr_monitor_info_iterator_t +xcb_randr_get_monitors_monitors_iterator (const xcb_randr_get_monitors_reply_t *R) +{ + xcb_randr_monitor_info_iterator_t i; + i.data = (xcb_randr_monitor_info_t *) (R + 1); + i.rem = R->nMonitors; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_randr_get_monitors_reply_t * +xcb_randr_get_monitors_reply (xcb_connection_t *c, + xcb_randr_get_monitors_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_randr_get_monitors_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_randr_set_monitor_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + 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_randr_set_monitor_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* monitorinfo */ + xcb_block_len += xcb_randr_monitor_info_sizeof(xcb_tmp); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_randr_monitor_info_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_randr_set_monitor_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_monitor_info_t *monitorinfo) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_MONITOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_randr_set_monitor_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_randr_monitor_info_t monitorinfo */ + xcb_parts[4].iov_base = (char *) monitorinfo; + xcb_parts[4].iov_len = + xcb_randr_monitor_info_sizeof (monitorinfo); + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_randr_set_monitor (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_monitor_info_t *monitorinfo) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_SET_MONITOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_randr_set_monitor_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_randr_monitor_info_t monitorinfo */ + xcb_parts[4].iov_base = (char *) monitorinfo; + xcb_parts[4].iov_len = + xcb_randr_monitor_info_sizeof (monitorinfo); + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_randr_monitor_info_t * +xcb_randr_set_monitor_monitorinfo (const xcb_randr_set_monitor_request_t *R) +{ + return (xcb_randr_monitor_info_t *) (R + 1); +} + +xcb_void_cookie_t +xcb_randr_delete_monitor_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t name) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_DELETE_MONITOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_randr_delete_monitor_request_t xcb_out; + + xcb_out.window = window; + xcb_out.name = name; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_randr_delete_monitor (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t name) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_randr_id, + .opcode = XCB_RANDR_DELETE_MONITOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_randr_delete_monitor_request_t xcb_out; + + xcb_out.window = window; + xcb_out.name = name; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + 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; +} + diff --git a/lib/libxcb/src/randr.h b/lib/libxcb/src/randr.h index 654624cfb..3be747038 100644 --- a/lib/libxcb/src/randr.h +++ b/lib/libxcb/src/randr.h @@ -21,7 +21,7 @@ extern "C" { #endif #define XCB_RANDR_MAJOR_VERSION 1 -#define XCB_RANDR_MINOR_VERSION 4 +#define XCB_RANDR_MINOR_VERSION 5 extern xcb_extension_t xcb_randr_id; @@ -31,9 +31,9 @@ typedef uint32_t xcb_randr_mode_t; * @brief xcb_randr_mode_iterator_t **/ typedef struct xcb_randr_mode_iterator_t { - xcb_randr_mode_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_mode_t *data; + int rem; + int index; } xcb_randr_mode_iterator_t; typedef uint32_t xcb_randr_crtc_t; @@ -42,9 +42,9 @@ typedef uint32_t xcb_randr_crtc_t; * @brief xcb_randr_crtc_iterator_t **/ typedef struct xcb_randr_crtc_iterator_t { - xcb_randr_crtc_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_crtc_t *data; + int rem; + int index; } xcb_randr_crtc_iterator_t; typedef uint32_t xcb_randr_output_t; @@ -53,9 +53,9 @@ typedef uint32_t xcb_randr_output_t; * @brief xcb_randr_output_iterator_t **/ typedef struct xcb_randr_output_iterator_t { - xcb_randr_output_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_output_t *data; + int rem; + int index; } xcb_randr_output_iterator_t; typedef uint32_t xcb_randr_provider_t; @@ -64,9 +64,9 @@ typedef uint32_t xcb_randr_provider_t; * @brief xcb_randr_provider_iterator_t **/ typedef struct xcb_randr_provider_iterator_t { - xcb_randr_provider_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_provider_t *data; + int rem; + int index; } xcb_randr_provider_iterator_t; /** Opcode for xcb_randr_bad_output. */ @@ -76,9 +76,9 @@ typedef struct xcb_randr_provider_iterator_t { * @brief xcb_randr_bad_output_error_t **/ typedef struct xcb_randr_bad_output_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_randr_bad_output_error_t; /** Opcode for xcb_randr_bad_crtc. */ @@ -88,9 +88,9 @@ typedef struct xcb_randr_bad_output_error_t { * @brief xcb_randr_bad_crtc_error_t **/ typedef struct xcb_randr_bad_crtc_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_randr_bad_crtc_error_t; /** Opcode for xcb_randr_bad_mode. */ @@ -100,9 +100,9 @@ typedef struct xcb_randr_bad_crtc_error_t { * @brief xcb_randr_bad_mode_error_t **/ typedef struct xcb_randr_bad_mode_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_randr_bad_mode_error_t; /** Opcode for xcb_randr_bad_provider. */ @@ -112,9 +112,9 @@ typedef struct xcb_randr_bad_mode_error_t { * @brief xcb_randr_bad_provider_error_t **/ typedef struct xcb_randr_bad_provider_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_randr_bad_provider_error_t; typedef enum xcb_randr_rotation_t { @@ -130,42 +130,42 @@ typedef enum xcb_randr_rotation_t { * @brief xcb_randr_screen_size_t **/ typedef struct xcb_randr_screen_size_t { - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t mwidth; /**< */ - uint16_t mheight; /**< */ + uint16_t width; + uint16_t height; + uint16_t mwidth; + uint16_t mheight; } xcb_randr_screen_size_t; /** * @brief xcb_randr_screen_size_iterator_t **/ typedef struct xcb_randr_screen_size_iterator_t { - xcb_randr_screen_size_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_screen_size_t *data; + int rem; + int index; } xcb_randr_screen_size_iterator_t; /** * @brief xcb_randr_refresh_rates_t **/ typedef struct xcb_randr_refresh_rates_t { - uint16_t nRates; /**< */ + uint16_t nRates; } xcb_randr_refresh_rates_t; /** * @brief xcb_randr_refresh_rates_iterator_t **/ typedef struct xcb_randr_refresh_rates_iterator_t { - xcb_randr_refresh_rates_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_refresh_rates_t *data; + int rem; + int index; } xcb_randr_refresh_rates_iterator_t; /** * @brief xcb_randr_query_version_cookie_t **/ typedef struct xcb_randr_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_query_version_cookie_t; /** Opcode for xcb_randr_query_version. */ @@ -175,24 +175,24 @@ typedef struct xcb_randr_query_version_cookie_t { * @brief xcb_randr_query_version_request_t **/ typedef struct xcb_randr_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t major_version; + uint32_t minor_version; } xcb_randr_query_version_request_t; /** * @brief xcb_randr_query_version_reply_t **/ typedef struct xcb_randr_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t major_version; + uint32_t minor_version; + uint8_t pad1[16]; } xcb_randr_query_version_reply_t; typedef enum xcb_randr_set_config_t { @@ -206,7 +206,7 @@ typedef enum xcb_randr_set_config_t { * @brief xcb_randr_set_screen_config_cookie_t **/ typedef struct xcb_randr_set_screen_config_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_set_screen_config_cookie_t; /** Opcode for xcb_randr_set_screen_config. */ @@ -216,31 +216,31 @@ typedef struct xcb_randr_set_screen_config_cookie_t { * @brief xcb_randr_set_screen_config_request_t **/ typedef struct xcb_randr_set_screen_config_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_timestamp_t timestamp; /**< */ - xcb_timestamp_t config_timestamp; /**< */ - uint16_t sizeID; /**< */ - uint16_t rotation; /**< */ - uint16_t rate; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_timestamp_t timestamp; + xcb_timestamp_t config_timestamp; + uint16_t sizeID; + uint16_t rotation; + uint16_t rate; + uint8_t pad0[2]; } xcb_randr_set_screen_config_request_t; /** * @brief xcb_randr_set_screen_config_reply_t **/ typedef struct xcb_randr_set_screen_config_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_timestamp_t new_timestamp; /**< */ - xcb_timestamp_t config_timestamp; /**< */ - xcb_window_t root; /**< */ - uint16_t subpixel_order; /**< */ - uint8_t pad0[10]; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t new_timestamp; + xcb_timestamp_t config_timestamp; + xcb_window_t root; + uint16_t subpixel_order; + uint8_t pad0[10]; } xcb_randr_set_screen_config_reply_t; typedef enum xcb_randr_notify_mask_t { @@ -260,19 +260,19 @@ typedef enum xcb_randr_notify_mask_t { * @brief xcb_randr_select_input_request_t **/ typedef struct xcb_randr_select_input_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint16_t enable; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint16_t enable; + uint8_t pad0[2]; } xcb_randr_select_input_request_t; /** * @brief xcb_randr_get_screen_info_cookie_t **/ typedef struct xcb_randr_get_screen_info_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_screen_info_cookie_t; /** Opcode for xcb_randr_get_screen_info. */ @@ -282,36 +282,36 @@ typedef struct xcb_randr_get_screen_info_cookie_t { * @brief xcb_randr_get_screen_info_request_t **/ typedef struct xcb_randr_get_screen_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_randr_get_screen_info_request_t; /** * @brief xcb_randr_get_screen_info_reply_t **/ typedef struct xcb_randr_get_screen_info_reply_t { - uint8_t response_type; /**< */ - uint8_t rotations; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t root; /**< */ - xcb_timestamp_t timestamp; /**< */ - xcb_timestamp_t config_timestamp; /**< */ - uint16_t nSizes; /**< */ - uint16_t sizeID; /**< */ - uint16_t rotation; /**< */ - uint16_t rate; /**< */ - uint16_t nInfo; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t response_type; + uint8_t rotations; + uint16_t sequence; + uint32_t length; + xcb_window_t root; + xcb_timestamp_t timestamp; + xcb_timestamp_t config_timestamp; + uint16_t nSizes; + uint16_t sizeID; + uint16_t rotation; + uint16_t rate; + uint16_t nInfo; + uint8_t pad0[2]; } xcb_randr_get_screen_info_reply_t; /** * @brief xcb_randr_get_screen_size_range_cookie_t **/ typedef struct xcb_randr_get_screen_size_range_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_screen_size_range_cookie_t; /** Opcode for xcb_randr_get_screen_size_range. */ @@ -321,25 +321,25 @@ typedef struct xcb_randr_get_screen_size_range_cookie_t { * @brief xcb_randr_get_screen_size_range_request_t **/ typedef struct xcb_randr_get_screen_size_range_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_randr_get_screen_size_range_request_t; /** * @brief xcb_randr_get_screen_size_range_reply_t **/ typedef struct xcb_randr_get_screen_size_range_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t min_width; /**< */ - uint16_t min_height; /**< */ - uint16_t max_width; /**< */ - uint16_t max_height; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t min_width; + uint16_t min_height; + uint16_t max_width; + uint16_t max_height; + uint8_t pad1[16]; } xcb_randr_get_screen_size_range_reply_t; /** Opcode for xcb_randr_set_screen_size. */ @@ -349,14 +349,14 @@ typedef struct xcb_randr_get_screen_size_range_reply_t { * @brief xcb_randr_set_screen_size_request_t **/ typedef struct xcb_randr_set_screen_size_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint32_t mm_width; /**< */ - uint32_t mm_height; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint16_t width; + uint16_t height; + uint32_t mm_width; + uint32_t mm_height; } xcb_randr_set_screen_size_request_t; typedef enum xcb_randr_mode_flag_t { @@ -380,35 +380,35 @@ typedef enum xcb_randr_mode_flag_t { * @brief xcb_randr_mode_info_t **/ typedef struct xcb_randr_mode_info_t { - uint32_t id; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint32_t dot_clock; /**< */ - uint16_t hsync_start; /**< */ - uint16_t hsync_end; /**< */ - uint16_t htotal; /**< */ - uint16_t hskew; /**< */ - uint16_t vsync_start; /**< */ - uint16_t vsync_end; /**< */ - uint16_t vtotal; /**< */ - uint16_t name_len; /**< */ - uint32_t mode_flags; /**< */ + uint32_t id; + uint16_t width; + uint16_t height; + uint32_t dot_clock; + uint16_t hsync_start; + uint16_t hsync_end; + uint16_t htotal; + uint16_t hskew; + uint16_t vsync_start; + uint16_t vsync_end; + uint16_t vtotal; + uint16_t name_len; + uint32_t mode_flags; } xcb_randr_mode_info_t; /** * @brief xcb_randr_mode_info_iterator_t **/ typedef struct xcb_randr_mode_info_iterator_t { - xcb_randr_mode_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_mode_info_t *data; + int rem; + int index; } xcb_randr_mode_info_iterator_t; /** * @brief xcb_randr_get_screen_resources_cookie_t **/ typedef struct xcb_randr_get_screen_resources_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_screen_resources_cookie_t; /** Opcode for xcb_randr_get_screen_resources. */ @@ -418,27 +418,27 @@ typedef struct xcb_randr_get_screen_resources_cookie_t { * @brief xcb_randr_get_screen_resources_request_t **/ typedef struct xcb_randr_get_screen_resources_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_randr_get_screen_resources_request_t; /** * @brief xcb_randr_get_screen_resources_reply_t **/ typedef struct xcb_randr_get_screen_resources_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_timestamp_t timestamp; /**< */ - xcb_timestamp_t config_timestamp; /**< */ - uint16_t num_crtcs; /**< */ - uint16_t num_outputs; /**< */ - uint16_t num_modes; /**< */ - uint16_t names_len; /**< */ - uint8_t pad1[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t timestamp; + xcb_timestamp_t config_timestamp; + uint16_t num_crtcs; + uint16_t num_outputs; + uint16_t num_modes; + uint16_t names_len; + uint8_t pad1[8]; } xcb_randr_get_screen_resources_reply_t; typedef enum xcb_randr_connection_t { @@ -451,7 +451,7 @@ typedef enum xcb_randr_connection_t { * @brief xcb_randr_get_output_info_cookie_t **/ typedef struct xcb_randr_get_output_info_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_output_info_cookie_t; /** Opcode for xcb_randr_get_output_info. */ @@ -461,39 +461,39 @@ typedef struct xcb_randr_get_output_info_cookie_t { * @brief xcb_randr_get_output_info_request_t **/ typedef struct xcb_randr_get_output_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_output_t output; /**< */ - xcb_timestamp_t config_timestamp; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_output_t output; + xcb_timestamp_t config_timestamp; } xcb_randr_get_output_info_request_t; /** * @brief xcb_randr_get_output_info_reply_t **/ typedef struct xcb_randr_get_output_info_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_timestamp_t timestamp; /**< */ - xcb_randr_crtc_t crtc; /**< */ - uint32_t mm_width; /**< */ - uint32_t mm_height; /**< */ - uint8_t connection; /**< */ - uint8_t subpixel_order; /**< */ - uint16_t num_crtcs; /**< */ - uint16_t num_modes; /**< */ - uint16_t num_preferred; /**< */ - uint16_t num_clones; /**< */ - uint16_t name_len; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t timestamp; + xcb_randr_crtc_t crtc; + uint32_t mm_width; + uint32_t mm_height; + uint8_t connection; + uint8_t subpixel_order; + uint16_t num_crtcs; + uint16_t num_modes; + uint16_t num_preferred; + uint16_t num_clones; + uint16_t name_len; } xcb_randr_get_output_info_reply_t; /** * @brief xcb_randr_list_output_properties_cookie_t **/ typedef struct xcb_randr_list_output_properties_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_list_output_properties_cookie_t; /** Opcode for xcb_randr_list_output_properties. */ @@ -503,29 +503,29 @@ typedef struct xcb_randr_list_output_properties_cookie_t { * @brief xcb_randr_list_output_properties_request_t **/ typedef struct xcb_randr_list_output_properties_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_output_t output; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_output_t output; } xcb_randr_list_output_properties_request_t; /** * @brief xcb_randr_list_output_properties_reply_t **/ typedef struct xcb_randr_list_output_properties_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_atoms; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_atoms; + uint8_t pad1[22]; } xcb_randr_list_output_properties_reply_t; /** * @brief xcb_randr_query_output_property_cookie_t **/ typedef struct xcb_randr_query_output_property_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_query_output_property_cookie_t; /** Opcode for xcb_randr_query_output_property. */ @@ -535,25 +535,25 @@ typedef struct xcb_randr_query_output_property_cookie_t { * @brief xcb_randr_query_output_property_request_t **/ typedef struct xcb_randr_query_output_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_output_t output; /**< */ - xcb_atom_t property; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_output_t output; + xcb_atom_t property; } xcb_randr_query_output_property_request_t; /** * @brief xcb_randr_query_output_property_reply_t **/ typedef struct xcb_randr_query_output_property_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pending; /**< */ - uint8_t range; /**< */ - uint8_t immutable; /**< */ - uint8_t pad1[21]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pending; + uint8_t range; + uint8_t immutable; + uint8_t pad1[21]; } xcb_randr_query_output_property_reply_t; /** Opcode for xcb_randr_configure_output_property. */ @@ -563,14 +563,14 @@ typedef struct xcb_randr_query_output_property_reply_t { * @brief xcb_randr_configure_output_property_request_t **/ typedef struct xcb_randr_configure_output_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_output_t output; /**< */ - xcb_atom_t property; /**< */ - uint8_t pending; /**< */ - uint8_t range; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_output_t output; + xcb_atom_t property; + uint8_t pending; + uint8_t range; + uint8_t pad0[2]; } xcb_randr_configure_output_property_request_t; /** Opcode for xcb_randr_change_output_property. */ @@ -580,16 +580,16 @@ typedef struct xcb_randr_configure_output_property_request_t { * @brief xcb_randr_change_output_property_request_t **/ typedef struct xcb_randr_change_output_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_output_t output; /**< */ - xcb_atom_t property; /**< */ - xcb_atom_t type; /**< */ - uint8_t format; /**< */ - uint8_t mode; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t num_units; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_output_t output; + xcb_atom_t property; + xcb_atom_t type; + uint8_t format; + uint8_t mode; + uint8_t pad0[2]; + uint32_t num_units; } xcb_randr_change_output_property_request_t; /** Opcode for xcb_randr_delete_output_property. */ @@ -599,18 +599,18 @@ typedef struct xcb_randr_change_output_property_request_t { * @brief xcb_randr_delete_output_property_request_t **/ typedef struct xcb_randr_delete_output_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_output_t output; /**< */ - xcb_atom_t property; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_output_t output; + xcb_atom_t property; } xcb_randr_delete_output_property_request_t; /** * @brief xcb_randr_get_output_property_cookie_t **/ typedef struct xcb_randr_get_output_property_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_output_property_cookie_t; /** Opcode for xcb_randr_get_output_property. */ @@ -620,38 +620,38 @@ typedef struct xcb_randr_get_output_property_cookie_t { * @brief xcb_randr_get_output_property_request_t **/ typedef struct xcb_randr_get_output_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_output_t output; /**< */ - xcb_atom_t property; /**< */ - xcb_atom_t type; /**< */ - uint32_t long_offset; /**< */ - uint32_t long_length; /**< */ - uint8_t _delete; /**< */ - uint8_t pending; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_output_t output; + xcb_atom_t property; + xcb_atom_t type; + uint32_t long_offset; + uint32_t long_length; + uint8_t _delete; + uint8_t pending; + uint8_t pad0[2]; } xcb_randr_get_output_property_request_t; /** * @brief xcb_randr_get_output_property_reply_t **/ typedef struct xcb_randr_get_output_property_reply_t { - uint8_t response_type; /**< */ - uint8_t format; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_atom_t type; /**< */ - uint32_t bytes_after; /**< */ - uint32_t num_items; /**< */ - uint8_t pad0[12]; /**< */ + uint8_t response_type; + uint8_t format; + uint16_t sequence; + uint32_t length; + xcb_atom_t type; + uint32_t bytes_after; + uint32_t num_items; + uint8_t pad0[12]; } xcb_randr_get_output_property_reply_t; /** * @brief xcb_randr_create_mode_cookie_t **/ typedef struct xcb_randr_create_mode_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_create_mode_cookie_t; /** Opcode for xcb_randr_create_mode. */ @@ -661,23 +661,23 @@ typedef struct xcb_randr_create_mode_cookie_t { * @brief xcb_randr_create_mode_request_t **/ typedef struct xcb_randr_create_mode_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_randr_mode_info_t mode_info; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_randr_mode_info_t mode_info; } xcb_randr_create_mode_request_t; /** * @brief xcb_randr_create_mode_reply_t **/ typedef struct xcb_randr_create_mode_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_randr_mode_t mode; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_randr_mode_t mode; + uint8_t pad1[20]; } xcb_randr_create_mode_reply_t; /** Opcode for xcb_randr_destroy_mode. */ @@ -687,10 +687,10 @@ typedef struct xcb_randr_create_mode_reply_t { * @brief xcb_randr_destroy_mode_request_t **/ typedef struct xcb_randr_destroy_mode_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_mode_t mode; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_mode_t mode; } xcb_randr_destroy_mode_request_t; /** Opcode for xcb_randr_add_output_mode. */ @@ -700,11 +700,11 @@ typedef struct xcb_randr_destroy_mode_request_t { * @brief xcb_randr_add_output_mode_request_t **/ typedef struct xcb_randr_add_output_mode_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_output_t output; /**< */ - xcb_randr_mode_t mode; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_output_t output; + xcb_randr_mode_t mode; } xcb_randr_add_output_mode_request_t; /** Opcode for xcb_randr_delete_output_mode. */ @@ -714,18 +714,18 @@ typedef struct xcb_randr_add_output_mode_request_t { * @brief xcb_randr_delete_output_mode_request_t **/ typedef struct xcb_randr_delete_output_mode_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_output_t output; /**< */ - xcb_randr_mode_t mode; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_output_t output; + xcb_randr_mode_t mode; } xcb_randr_delete_output_mode_request_t; /** * @brief xcb_randr_get_crtc_info_cookie_t **/ typedef struct xcb_randr_get_crtc_info_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_crtc_info_cookie_t; /** Opcode for xcb_randr_get_crtc_info. */ @@ -735,38 +735,38 @@ typedef struct xcb_randr_get_crtc_info_cookie_t { * @brief xcb_randr_get_crtc_info_request_t **/ typedef struct xcb_randr_get_crtc_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_crtc_t crtc; /**< */ - xcb_timestamp_t config_timestamp; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_crtc_t crtc; + xcb_timestamp_t config_timestamp; } xcb_randr_get_crtc_info_request_t; /** * @brief xcb_randr_get_crtc_info_reply_t **/ typedef struct xcb_randr_get_crtc_info_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_timestamp_t timestamp; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - xcb_randr_mode_t mode; /**< */ - uint16_t rotation; /**< */ - uint16_t rotations; /**< */ - uint16_t num_outputs; /**< */ - uint16_t num_possible_outputs; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t timestamp; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + xcb_randr_mode_t mode; + uint16_t rotation; + uint16_t rotations; + uint16_t num_outputs; + uint16_t num_possible_outputs; } xcb_randr_get_crtc_info_reply_t; /** * @brief xcb_randr_set_crtc_config_cookie_t **/ typedef struct xcb_randr_set_crtc_config_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_set_crtc_config_cookie_t; /** Opcode for xcb_randr_set_crtc_config. */ @@ -776,36 +776,36 @@ typedef struct xcb_randr_set_crtc_config_cookie_t { * @brief xcb_randr_set_crtc_config_request_t **/ typedef struct xcb_randr_set_crtc_config_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_crtc_t crtc; /**< */ - xcb_timestamp_t timestamp; /**< */ - xcb_timestamp_t config_timestamp; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - xcb_randr_mode_t mode; /**< */ - uint16_t rotation; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_crtc_t crtc; + xcb_timestamp_t timestamp; + xcb_timestamp_t config_timestamp; + int16_t x; + int16_t y; + xcb_randr_mode_t mode; + uint16_t rotation; + uint8_t pad0[2]; } xcb_randr_set_crtc_config_request_t; /** * @brief xcb_randr_set_crtc_config_reply_t **/ typedef struct xcb_randr_set_crtc_config_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_timestamp_t timestamp; /**< */ - uint8_t pad0[20]; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t timestamp; + uint8_t pad0[20]; } xcb_randr_set_crtc_config_reply_t; /** * @brief xcb_randr_get_crtc_gamma_size_cookie_t **/ typedef struct xcb_randr_get_crtc_gamma_size_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_crtc_gamma_size_cookie_t; /** Opcode for xcb_randr_get_crtc_gamma_size. */ @@ -815,29 +815,29 @@ typedef struct xcb_randr_get_crtc_gamma_size_cookie_t { * @brief xcb_randr_get_crtc_gamma_size_request_t **/ typedef struct xcb_randr_get_crtc_gamma_size_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_crtc_t crtc; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_crtc_t crtc; } xcb_randr_get_crtc_gamma_size_request_t; /** * @brief xcb_randr_get_crtc_gamma_size_reply_t **/ typedef struct xcb_randr_get_crtc_gamma_size_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t size; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t size; + uint8_t pad1[22]; } xcb_randr_get_crtc_gamma_size_reply_t; /** * @brief xcb_randr_get_crtc_gamma_cookie_t **/ typedef struct xcb_randr_get_crtc_gamma_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_crtc_gamma_cookie_t; /** Opcode for xcb_randr_get_crtc_gamma. */ @@ -847,22 +847,22 @@ typedef struct xcb_randr_get_crtc_gamma_cookie_t { * @brief xcb_randr_get_crtc_gamma_request_t **/ typedef struct xcb_randr_get_crtc_gamma_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_crtc_t crtc; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_crtc_t crtc; } xcb_randr_get_crtc_gamma_request_t; /** * @brief xcb_randr_get_crtc_gamma_reply_t **/ typedef struct xcb_randr_get_crtc_gamma_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t size; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t size; + uint8_t pad1[22]; } xcb_randr_get_crtc_gamma_reply_t; /** Opcode for xcb_randr_set_crtc_gamma. */ @@ -872,19 +872,19 @@ typedef struct xcb_randr_get_crtc_gamma_reply_t { * @brief xcb_randr_set_crtc_gamma_request_t **/ typedef struct xcb_randr_set_crtc_gamma_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_crtc_t crtc; /**< */ - uint16_t size; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_crtc_t crtc; + uint16_t size; + uint8_t pad0[2]; } xcb_randr_set_crtc_gamma_request_t; /** * @brief xcb_randr_get_screen_resources_current_cookie_t **/ typedef struct xcb_randr_get_screen_resources_current_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_screen_resources_current_cookie_t; /** Opcode for xcb_randr_get_screen_resources_current. */ @@ -894,27 +894,27 @@ typedef struct xcb_randr_get_screen_resources_current_cookie_t { * @brief xcb_randr_get_screen_resources_current_request_t **/ typedef struct xcb_randr_get_screen_resources_current_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_randr_get_screen_resources_current_request_t; /** * @brief xcb_randr_get_screen_resources_current_reply_t **/ typedef struct xcb_randr_get_screen_resources_current_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_timestamp_t timestamp; /**< */ - xcb_timestamp_t config_timestamp; /**< */ - uint16_t num_crtcs; /**< */ - uint16_t num_outputs; /**< */ - uint16_t num_modes; /**< */ - uint16_t names_len; /**< */ - uint8_t pad1[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t timestamp; + xcb_timestamp_t config_timestamp; + uint16_t num_crtcs; + uint16_t num_outputs; + uint16_t num_modes; + uint16_t names_len; + uint8_t pad1[8]; } xcb_randr_get_screen_resources_current_reply_t; typedef enum xcb_randr_transform_t { @@ -931,20 +931,20 @@ typedef enum xcb_randr_transform_t { * @brief xcb_randr_set_crtc_transform_request_t **/ typedef struct xcb_randr_set_crtc_transform_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_crtc_t crtc; /**< */ - xcb_render_transform_t transform; /**< */ - uint16_t filter_len; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_crtc_t crtc; + xcb_render_transform_t transform; + uint16_t filter_len; + uint8_t pad0[2]; } xcb_randr_set_crtc_transform_request_t; /** * @brief xcb_randr_get_crtc_transform_cookie_t **/ typedef struct xcb_randr_get_crtc_transform_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_crtc_transform_cookie_t; /** Opcode for xcb_randr_get_crtc_transform. */ @@ -954,36 +954,36 @@ typedef struct xcb_randr_get_crtc_transform_cookie_t { * @brief xcb_randr_get_crtc_transform_request_t **/ typedef struct xcb_randr_get_crtc_transform_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_crtc_t crtc; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_crtc_t crtc; } xcb_randr_get_crtc_transform_request_t; /** * @brief xcb_randr_get_crtc_transform_reply_t **/ typedef struct xcb_randr_get_crtc_transform_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_render_transform_t pending_transform; /**< */ - uint8_t has_transforms; /**< */ - uint8_t pad1[3]; /**< */ - xcb_render_transform_t current_transform; /**< */ - uint8_t pad2[4]; /**< */ - uint16_t pending_len; /**< */ - uint16_t pending_nparams; /**< */ - uint16_t current_len; /**< */ - uint16_t current_nparams; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_render_transform_t pending_transform; + uint8_t has_transforms; + uint8_t pad1[3]; + xcb_render_transform_t current_transform; + uint8_t pad2[4]; + uint16_t pending_len; + uint16_t pending_nparams; + uint16_t current_len; + uint16_t current_nparams; } xcb_randr_get_crtc_transform_reply_t; /** * @brief xcb_randr_get_panning_cookie_t **/ typedef struct xcb_randr_get_panning_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_panning_cookie_t; /** Opcode for xcb_randr_get_panning. */ @@ -993,40 +993,40 @@ typedef struct xcb_randr_get_panning_cookie_t { * @brief xcb_randr_get_panning_request_t **/ typedef struct xcb_randr_get_panning_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_crtc_t crtc; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_crtc_t crtc; } xcb_randr_get_panning_request_t; /** * @brief xcb_randr_get_panning_reply_t **/ typedef struct xcb_randr_get_panning_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_timestamp_t timestamp; /**< */ - uint16_t left; /**< */ - uint16_t top; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t track_left; /**< */ - uint16_t track_top; /**< */ - uint16_t track_width; /**< */ - uint16_t track_height; /**< */ - int16_t border_left; /**< */ - int16_t border_top; /**< */ - int16_t border_right; /**< */ - int16_t border_bottom; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t timestamp; + uint16_t left; + uint16_t top; + uint16_t width; + uint16_t height; + uint16_t track_left; + uint16_t track_top; + uint16_t track_width; + uint16_t track_height; + int16_t border_left; + int16_t border_top; + int16_t border_right; + int16_t border_bottom; } xcb_randr_get_panning_reply_t; /** * @brief xcb_randr_set_panning_cookie_t **/ typedef struct xcb_randr_set_panning_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_set_panning_cookie_t; /** Opcode for xcb_randr_set_panning. */ @@ -1036,34 +1036,34 @@ typedef struct xcb_randr_set_panning_cookie_t { * @brief xcb_randr_set_panning_request_t **/ typedef struct xcb_randr_set_panning_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_crtc_t crtc; /**< */ - xcb_timestamp_t timestamp; /**< */ - uint16_t left; /**< */ - uint16_t top; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t track_left; /**< */ - uint16_t track_top; /**< */ - uint16_t track_width; /**< */ - uint16_t track_height; /**< */ - int16_t border_left; /**< */ - int16_t border_top; /**< */ - int16_t border_right; /**< */ - int16_t border_bottom; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_crtc_t crtc; + xcb_timestamp_t timestamp; + uint16_t left; + uint16_t top; + uint16_t width; + uint16_t height; + uint16_t track_left; + uint16_t track_top; + uint16_t track_width; + uint16_t track_height; + int16_t border_left; + int16_t border_top; + int16_t border_right; + int16_t border_bottom; } xcb_randr_set_panning_request_t; /** * @brief xcb_randr_set_panning_reply_t **/ typedef struct xcb_randr_set_panning_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_timestamp_t timestamp; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t timestamp; } xcb_randr_set_panning_reply_t; /** Opcode for xcb_randr_set_output_primary. */ @@ -1073,18 +1073,18 @@ typedef struct xcb_randr_set_panning_reply_t { * @brief xcb_randr_set_output_primary_request_t **/ typedef struct xcb_randr_set_output_primary_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_randr_output_t output; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_randr_output_t output; } xcb_randr_set_output_primary_request_t; /** * @brief xcb_randr_get_output_primary_cookie_t **/ typedef struct xcb_randr_get_output_primary_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_output_primary_cookie_t; /** Opcode for xcb_randr_get_output_primary. */ @@ -1094,28 +1094,28 @@ typedef struct xcb_randr_get_output_primary_cookie_t { * @brief xcb_randr_get_output_primary_request_t **/ typedef struct xcb_randr_get_output_primary_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_randr_get_output_primary_request_t; /** * @brief xcb_randr_get_output_primary_reply_t **/ typedef struct xcb_randr_get_output_primary_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_randr_output_t output; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_randr_output_t output; } xcb_randr_get_output_primary_reply_t; /** * @brief xcb_randr_get_providers_cookie_t **/ typedef struct xcb_randr_get_providers_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_providers_cookie_t; /** Opcode for xcb_randr_get_providers. */ @@ -1125,23 +1125,23 @@ typedef struct xcb_randr_get_providers_cookie_t { * @brief xcb_randr_get_providers_request_t **/ typedef struct xcb_randr_get_providers_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_randr_get_providers_request_t; /** * @brief xcb_randr_get_providers_reply_t **/ typedef struct xcb_randr_get_providers_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_timestamp_t timestamp; /**< */ - uint16_t num_providers; /**< */ - uint8_t pad1[18]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t timestamp; + uint16_t num_providers; + uint8_t pad1[18]; } xcb_randr_get_providers_reply_t; typedef enum xcb_randr_provider_capability_t { @@ -1155,7 +1155,7 @@ typedef enum xcb_randr_provider_capability_t { * @brief xcb_randr_get_provider_info_cookie_t **/ typedef struct xcb_randr_get_provider_info_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_provider_info_cookie_t; /** Opcode for xcb_randr_get_provider_info. */ @@ -1165,28 +1165,28 @@ typedef struct xcb_randr_get_provider_info_cookie_t { * @brief xcb_randr_get_provider_info_request_t **/ typedef struct xcb_randr_get_provider_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_provider_t provider; /**< */ - xcb_timestamp_t config_timestamp; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_provider_t provider; + xcb_timestamp_t config_timestamp; } xcb_randr_get_provider_info_request_t; /** * @brief xcb_randr_get_provider_info_reply_t **/ typedef struct xcb_randr_get_provider_info_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_timestamp_t timestamp; /**< */ - uint32_t capabilities; /**< */ - uint16_t num_crtcs; /**< */ - uint16_t num_outputs; /**< */ - uint16_t num_associated_providers; /**< */ - uint16_t name_len; /**< */ - uint8_t pad0[8]; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t timestamp; + uint32_t capabilities; + uint16_t num_crtcs; + uint16_t num_outputs; + uint16_t num_associated_providers; + uint16_t name_len; + uint8_t pad0[8]; } xcb_randr_get_provider_info_reply_t; /** Opcode for xcb_randr_set_provider_offload_sink. */ @@ -1196,12 +1196,12 @@ typedef struct xcb_randr_get_provider_info_reply_t { * @brief xcb_randr_set_provider_offload_sink_request_t **/ typedef struct xcb_randr_set_provider_offload_sink_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_provider_t provider; /**< */ - xcb_randr_provider_t sink_provider; /**< */ - xcb_timestamp_t config_timestamp; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_provider_t provider; + xcb_randr_provider_t sink_provider; + xcb_timestamp_t config_timestamp; } xcb_randr_set_provider_offload_sink_request_t; /** Opcode for xcb_randr_set_provider_output_source. */ @@ -1211,19 +1211,19 @@ typedef struct xcb_randr_set_provider_offload_sink_request_t { * @brief xcb_randr_set_provider_output_source_request_t **/ typedef struct xcb_randr_set_provider_output_source_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_provider_t provider; /**< */ - xcb_randr_provider_t source_provider; /**< */ - xcb_timestamp_t config_timestamp; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_provider_t provider; + xcb_randr_provider_t source_provider; + xcb_timestamp_t config_timestamp; } xcb_randr_set_provider_output_source_request_t; /** * @brief xcb_randr_list_provider_properties_cookie_t **/ typedef struct xcb_randr_list_provider_properties_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_list_provider_properties_cookie_t; /** Opcode for xcb_randr_list_provider_properties. */ @@ -1233,29 +1233,29 @@ typedef struct xcb_randr_list_provider_properties_cookie_t { * @brief xcb_randr_list_provider_properties_request_t **/ typedef struct xcb_randr_list_provider_properties_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_provider_t provider; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_provider_t provider; } xcb_randr_list_provider_properties_request_t; /** * @brief xcb_randr_list_provider_properties_reply_t **/ typedef struct xcb_randr_list_provider_properties_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_atoms; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_atoms; + uint8_t pad1[22]; } xcb_randr_list_provider_properties_reply_t; /** * @brief xcb_randr_query_provider_property_cookie_t **/ typedef struct xcb_randr_query_provider_property_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_query_provider_property_cookie_t; /** Opcode for xcb_randr_query_provider_property. */ @@ -1265,25 +1265,25 @@ typedef struct xcb_randr_query_provider_property_cookie_t { * @brief xcb_randr_query_provider_property_request_t **/ typedef struct xcb_randr_query_provider_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_provider_t provider; /**< */ - xcb_atom_t property; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_provider_t provider; + xcb_atom_t property; } xcb_randr_query_provider_property_request_t; /** * @brief xcb_randr_query_provider_property_reply_t **/ typedef struct xcb_randr_query_provider_property_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pending; /**< */ - uint8_t range; /**< */ - uint8_t immutable; /**< */ - uint8_t pad1[21]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pending; + uint8_t range; + uint8_t immutable; + uint8_t pad1[21]; } xcb_randr_query_provider_property_reply_t; /** Opcode for xcb_randr_configure_provider_property. */ @@ -1293,14 +1293,14 @@ typedef struct xcb_randr_query_provider_property_reply_t { * @brief xcb_randr_configure_provider_property_request_t **/ typedef struct xcb_randr_configure_provider_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_provider_t provider; /**< */ - xcb_atom_t property; /**< */ - uint8_t pending; /**< */ - uint8_t range; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_provider_t provider; + xcb_atom_t property; + uint8_t pending; + uint8_t range; + uint8_t pad0[2]; } xcb_randr_configure_provider_property_request_t; /** Opcode for xcb_randr_change_provider_property. */ @@ -1310,16 +1310,16 @@ typedef struct xcb_randr_configure_provider_property_request_t { * @brief xcb_randr_change_provider_property_request_t **/ typedef struct xcb_randr_change_provider_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_provider_t provider; /**< */ - xcb_atom_t property; /**< */ - xcb_atom_t type; /**< */ - uint8_t format; /**< */ - uint8_t mode; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t num_items; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_provider_t provider; + xcb_atom_t property; + xcb_atom_t type; + uint8_t format; + uint8_t mode; + uint8_t pad0[2]; + uint32_t num_items; } xcb_randr_change_provider_property_request_t; /** Opcode for xcb_randr_delete_provider_property. */ @@ -1329,18 +1329,18 @@ typedef struct xcb_randr_change_provider_property_request_t { * @brief xcb_randr_delete_provider_property_request_t **/ typedef struct xcb_randr_delete_provider_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_provider_t provider; /**< */ - xcb_atom_t property; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_provider_t provider; + xcb_atom_t property; } xcb_randr_delete_provider_property_request_t; /** * @brief xcb_randr_get_provider_property_cookie_t **/ typedef struct xcb_randr_get_provider_property_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_randr_get_provider_property_cookie_t; /** Opcode for xcb_randr_get_provider_property. */ @@ -1350,31 +1350,31 @@ typedef struct xcb_randr_get_provider_property_cookie_t { * @brief xcb_randr_get_provider_property_request_t **/ typedef struct xcb_randr_get_provider_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_randr_provider_t provider; /**< */ - xcb_atom_t property; /**< */ - xcb_atom_t type; /**< */ - uint32_t long_offset; /**< */ - uint32_t long_length; /**< */ - uint8_t _delete; /**< */ - uint8_t pending; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_randr_provider_t provider; + xcb_atom_t property; + xcb_atom_t type; + uint32_t long_offset; + uint32_t long_length; + uint8_t _delete; + uint8_t pending; + uint8_t pad0[2]; } xcb_randr_get_provider_property_request_t; /** * @brief xcb_randr_get_provider_property_reply_t **/ typedef struct xcb_randr_get_provider_property_reply_t { - uint8_t response_type; /**< */ - uint8_t format; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_atom_t type; /**< */ - uint32_t bytes_after; /**< */ - uint32_t num_items; /**< */ - uint8_t pad0[12]; /**< */ + uint8_t response_type; + uint8_t format; + uint16_t sequence; + uint32_t length; + xcb_atom_t type; + uint32_t bytes_after; + uint32_t num_items; + uint8_t pad0[12]; } xcb_randr_get_provider_property_reply_t; /** Opcode for xcb_randr_screen_change_notify. */ @@ -1384,19 +1384,19 @@ typedef struct xcb_randr_get_provider_property_reply_t { * @brief xcb_randr_screen_change_notify_event_t **/ typedef struct xcb_randr_screen_change_notify_event_t { - uint8_t response_type; /**< */ - uint8_t rotation; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t timestamp; /**< */ - xcb_timestamp_t config_timestamp; /**< */ - xcb_window_t root; /**< */ - xcb_window_t request_window; /**< */ - uint16_t sizeID; /**< */ - uint16_t subpixel_order; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t mwidth; /**< */ - uint16_t mheight; /**< */ + uint8_t response_type; + uint8_t rotation; + uint16_t sequence; + xcb_timestamp_t timestamp; + xcb_timestamp_t config_timestamp; + xcb_window_t root; + xcb_window_t request_window; + uint16_t sizeID; + uint16_t subpixel_order; + uint16_t width; + uint16_t height; + uint16_t mwidth; + uint16_t mheight; } xcb_randr_screen_change_notify_event_t; typedef enum xcb_randr_notify_t { @@ -1412,149 +1412,149 @@ typedef enum xcb_randr_notify_t { * @brief xcb_randr_crtc_change_t **/ typedef struct xcb_randr_crtc_change_t { - xcb_timestamp_t timestamp; /**< */ - xcb_window_t window; /**< */ - xcb_randr_crtc_t crtc; /**< */ - xcb_randr_mode_t mode; /**< */ - uint16_t rotation; /**< */ - uint8_t pad0[2]; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + xcb_timestamp_t timestamp; + xcb_window_t window; + xcb_randr_crtc_t crtc; + xcb_randr_mode_t mode; + uint16_t rotation; + uint8_t pad0[2]; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; } xcb_randr_crtc_change_t; /** * @brief xcb_randr_crtc_change_iterator_t **/ typedef struct xcb_randr_crtc_change_iterator_t { - xcb_randr_crtc_change_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_crtc_change_t *data; + int rem; + int index; } xcb_randr_crtc_change_iterator_t; /** * @brief xcb_randr_output_change_t **/ typedef struct xcb_randr_output_change_t { - xcb_timestamp_t timestamp; /**< */ - xcb_timestamp_t config_timestamp; /**< */ - xcb_window_t window; /**< */ - xcb_randr_output_t output; /**< */ - xcb_randr_crtc_t crtc; /**< */ - xcb_randr_mode_t mode; /**< */ - uint16_t rotation; /**< */ - uint8_t connection; /**< */ - uint8_t subpixel_order; /**< */ + xcb_timestamp_t timestamp; + xcb_timestamp_t config_timestamp; + xcb_window_t window; + xcb_randr_output_t output; + xcb_randr_crtc_t crtc; + xcb_randr_mode_t mode; + uint16_t rotation; + uint8_t connection; + uint8_t subpixel_order; } xcb_randr_output_change_t; /** * @brief xcb_randr_output_change_iterator_t **/ typedef struct xcb_randr_output_change_iterator_t { - xcb_randr_output_change_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_output_change_t *data; + int rem; + int index; } xcb_randr_output_change_iterator_t; /** * @brief xcb_randr_output_property_t **/ typedef struct xcb_randr_output_property_t { - xcb_window_t window; /**< */ - xcb_randr_output_t output; /**< */ - xcb_atom_t atom; /**< */ - xcb_timestamp_t timestamp; /**< */ - uint8_t status; /**< */ - uint8_t pad0[11]; /**< */ + xcb_window_t window; + xcb_randr_output_t output; + xcb_atom_t atom; + xcb_timestamp_t timestamp; + uint8_t status; + uint8_t pad0[11]; } xcb_randr_output_property_t; /** * @brief xcb_randr_output_property_iterator_t **/ typedef struct xcb_randr_output_property_iterator_t { - xcb_randr_output_property_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_output_property_t *data; + int rem; + int index; } xcb_randr_output_property_iterator_t; /** * @brief xcb_randr_provider_change_t **/ typedef struct xcb_randr_provider_change_t { - xcb_timestamp_t timestamp; /**< */ - xcb_window_t window; /**< */ - xcb_randr_provider_t provider; /**< */ - uint8_t pad0[16]; /**< */ + xcb_timestamp_t timestamp; + xcb_window_t window; + xcb_randr_provider_t provider; + uint8_t pad0[16]; } xcb_randr_provider_change_t; /** * @brief xcb_randr_provider_change_iterator_t **/ typedef struct xcb_randr_provider_change_iterator_t { - xcb_randr_provider_change_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_provider_change_t *data; + int rem; + int index; } xcb_randr_provider_change_iterator_t; /** * @brief xcb_randr_provider_property_t **/ typedef struct xcb_randr_provider_property_t { - xcb_window_t window; /**< */ - xcb_randr_provider_t provider; /**< */ - xcb_atom_t atom; /**< */ - xcb_timestamp_t timestamp; /**< */ - uint8_t state; /**< */ - uint8_t pad0[11]; /**< */ + xcb_window_t window; + xcb_randr_provider_t provider; + xcb_atom_t atom; + xcb_timestamp_t timestamp; + uint8_t state; + uint8_t pad0[11]; } xcb_randr_provider_property_t; /** * @brief xcb_randr_provider_property_iterator_t **/ typedef struct xcb_randr_provider_property_iterator_t { - xcb_randr_provider_property_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_provider_property_t *data; + int rem; + int index; } xcb_randr_provider_property_iterator_t; /** * @brief xcb_randr_resource_change_t **/ typedef struct xcb_randr_resource_change_t { - xcb_timestamp_t timestamp; /**< */ - xcb_window_t window; /**< */ - uint8_t pad0[20]; /**< */ + xcb_timestamp_t timestamp; + xcb_window_t window; + uint8_t pad0[20]; } xcb_randr_resource_change_t; /** * @brief xcb_randr_resource_change_iterator_t **/ typedef struct xcb_randr_resource_change_iterator_t { - xcb_randr_resource_change_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_resource_change_t *data; + int rem; + int index; } xcb_randr_resource_change_iterator_t; /** * @brief xcb_randr_notify_data_t **/ typedef union xcb_randr_notify_data_t { - xcb_randr_crtc_change_t cc; /**< */ - xcb_randr_output_change_t oc; /**< */ - xcb_randr_output_property_t op; /**< */ - xcb_randr_provider_change_t pc; /**< */ - xcb_randr_provider_property_t pp; /**< */ - xcb_randr_resource_change_t rc; /**< */ + xcb_randr_crtc_change_t cc; + xcb_randr_output_change_t oc; + xcb_randr_output_property_t op; + xcb_randr_provider_change_t pc; + xcb_randr_provider_property_t pp; + xcb_randr_resource_change_t rc; } xcb_randr_notify_data_t; /** * @brief xcb_randr_notify_data_iterator_t **/ typedef struct xcb_randr_notify_data_iterator_t { - xcb_randr_notify_data_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_randr_notify_data_t *data; + int rem; + int index; } xcb_randr_notify_data_iterator_t; /** Opcode for xcb_randr_notify. */ @@ -1564,12 +1564,99 @@ typedef struct xcb_randr_notify_data_iterator_t { * @brief xcb_randr_notify_event_t **/ typedef struct xcb_randr_notify_event_t { - uint8_t response_type; /**< */ - uint8_t subCode; /**< */ - uint16_t sequence; /**< */ - xcb_randr_notify_data_t u; /**< */ + uint8_t response_type; + uint8_t subCode; + uint16_t sequence; + xcb_randr_notify_data_t u; } xcb_randr_notify_event_t; +/** + * @brief xcb_randr_monitor_info_t + **/ +typedef struct xcb_randr_monitor_info_t { + xcb_atom_t name; + uint8_t primary; + uint8_t automatic; + uint16_t nOutput; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint32_t width_in_millimeters; + uint32_t height_in_millimeters; +} xcb_randr_monitor_info_t; + +/** + * @brief xcb_randr_monitor_info_iterator_t + **/ +typedef struct xcb_randr_monitor_info_iterator_t { + xcb_randr_monitor_info_t *data; + int rem; + int index; +} xcb_randr_monitor_info_iterator_t; + +/** + * @brief xcb_randr_get_monitors_cookie_t + **/ +typedef struct xcb_randr_get_monitors_cookie_t { + unsigned int sequence; +} xcb_randr_get_monitors_cookie_t; + +/** Opcode for xcb_randr_get_monitors. */ +#define XCB_RANDR_GET_MONITORS 42 + +/** + * @brief xcb_randr_get_monitors_request_t + **/ +typedef struct xcb_randr_get_monitors_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint8_t get_active; +} xcb_randr_get_monitors_request_t; + +/** + * @brief xcb_randr_get_monitors_reply_t + **/ +typedef struct xcb_randr_get_monitors_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_timestamp_t timestamp; + uint32_t nMonitors; + uint32_t nOutputs; + uint8_t pad1[12]; +} xcb_randr_get_monitors_reply_t; + +/** Opcode for xcb_randr_set_monitor. */ +#define XCB_RANDR_SET_MONITOR 43 + +/** + * @brief xcb_randr_set_monitor_request_t + **/ +typedef struct xcb_randr_set_monitor_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; +} xcb_randr_set_monitor_request_t; + +/** Opcode for xcb_randr_delete_monitor. */ +#define XCB_RANDR_DELETE_MONITOR 44 + +/** + * @brief xcb_randr_delete_monitor_request_t + **/ +typedef struct xcb_randr_delete_monitor_request_t { + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_atom_t name; +} xcb_randr_delete_monitor_request_t; + /** * Get the next element of the iterator * @param i Pointer to a xcb_randr_mode_iterator_t @@ -1579,7 +1666,7 @@ typedef struct xcb_randr_notify_event_t { * element. The member index is increased by sizeof(xcb_randr_mode_t) */ void -xcb_randr_mode_next (xcb_randr_mode_iterator_t *i /**< */); +xcb_randr_mode_next (xcb_randr_mode_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1591,7 +1678,7 @@ xcb_randr_mode_next (xcb_randr_mode_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_randr_mode_end (xcb_randr_mode_iterator_t i /**< */); +xcb_randr_mode_end (xcb_randr_mode_iterator_t i); /** * Get the next element of the iterator @@ -1602,7 +1689,7 @@ xcb_randr_mode_end (xcb_randr_mode_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_randr_crtc_t) */ void -xcb_randr_crtc_next (xcb_randr_crtc_iterator_t *i /**< */); +xcb_randr_crtc_next (xcb_randr_crtc_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1614,7 +1701,7 @@ xcb_randr_crtc_next (xcb_randr_crtc_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_randr_crtc_end (xcb_randr_crtc_iterator_t i /**< */); +xcb_randr_crtc_end (xcb_randr_crtc_iterator_t i); /** * Get the next element of the iterator @@ -1625,7 +1712,7 @@ xcb_randr_crtc_end (xcb_randr_crtc_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_randr_output_t) */ void -xcb_randr_output_next (xcb_randr_output_iterator_t *i /**< */); +xcb_randr_output_next (xcb_randr_output_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1637,7 +1724,7 @@ xcb_randr_output_next (xcb_randr_output_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_randr_output_end (xcb_randr_output_iterator_t i /**< */); +xcb_randr_output_end (xcb_randr_output_iterator_t i); /** * Get the next element of the iterator @@ -1648,7 +1735,7 @@ xcb_randr_output_end (xcb_randr_output_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_randr_provider_t) */ void -xcb_randr_provider_next (xcb_randr_provider_iterator_t *i /**< */); +xcb_randr_provider_next (xcb_randr_provider_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1660,7 +1747,7 @@ xcb_randr_provider_next (xcb_randr_provider_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_randr_provider_end (xcb_randr_provider_iterator_t i /**< */); +xcb_randr_provider_end (xcb_randr_provider_iterator_t i); /** * Get the next element of the iterator @@ -1671,7 +1758,7 @@ xcb_randr_provider_end (xcb_randr_provider_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_randr_screen_size_t) */ void -xcb_randr_screen_size_next (xcb_randr_screen_size_iterator_t *i /**< */); +xcb_randr_screen_size_next (xcb_randr_screen_size_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1683,19 +1770,19 @@ xcb_randr_screen_size_next (xcb_randr_screen_size_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_randr_screen_size_end (xcb_randr_screen_size_iterator_t i /**< */); +xcb_randr_screen_size_end (xcb_randr_screen_size_iterator_t i); int -xcb_randr_refresh_rates_sizeof (const void *_buffer /**< */); +xcb_randr_refresh_rates_sizeof (const void *_buffer); uint16_t * -xcb_randr_refresh_rates_rates (const xcb_randr_refresh_rates_t *R /**< */); +xcb_randr_refresh_rates_rates (const xcb_randr_refresh_rates_t *R); int -xcb_randr_refresh_rates_rates_length (const xcb_randr_refresh_rates_t *R /**< */); +xcb_randr_refresh_rates_rates_length (const xcb_randr_refresh_rates_t *R); xcb_generic_iterator_t -xcb_randr_refresh_rates_rates_end (const xcb_randr_refresh_rates_t *R /**< */); +xcb_randr_refresh_rates_rates_end (const xcb_randr_refresh_rates_t *R); /** * Get the next element of the iterator @@ -1706,7 +1793,7 @@ xcb_randr_refresh_rates_rates_end (const xcb_randr_refresh_rates_t *R /**< */); * element. The member index is increased by sizeof(xcb_randr_refresh_rates_t) */ void -xcb_randr_refresh_rates_next (xcb_randr_refresh_rates_iterator_t *i /**< */); +xcb_randr_refresh_rates_next (xcb_randr_refresh_rates_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1718,7 +1805,7 @@ xcb_randr_refresh_rates_next (xcb_randr_refresh_rates_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_randr_refresh_rates_end (xcb_randr_refresh_rates_iterator_t i /**< */); +xcb_randr_refresh_rates_end (xcb_randr_refresh_rates_iterator_t i); /** * @@ -1729,9 +1816,9 @@ xcb_randr_refresh_rates_end (xcb_randr_refresh_rates_iterator_t i /**< */); * */ xcb_randr_query_version_cookie_t -xcb_randr_query_version (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */); +xcb_randr_query_version (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version); /** * @@ -1745,9 +1832,9 @@ xcb_randr_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_query_version_cookie_t -xcb_randr_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t major_version /**< */, - uint32_t minor_version /**< */); +xcb_randr_query_version_unchecked (xcb_connection_t *c, + uint32_t major_version, + uint32_t minor_version); /** * Return the reply @@ -1764,9 +1851,9 @@ xcb_randr_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_randr_query_version_reply_t * -xcb_randr_query_version_reply (xcb_connection_t *c /**< */, +xcb_randr_query_version_reply (xcb_connection_t *c, xcb_randr_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1777,13 +1864,13 @@ xcb_randr_query_version_reply (xcb_connection_t *c /**< */, * */ xcb_randr_set_screen_config_cookie_t -xcb_randr_set_screen_config (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t timestamp /**< */, - xcb_timestamp_t config_timestamp /**< */, - uint16_t sizeID /**< */, - uint16_t rotation /**< */, - uint16_t rate /**< */); +xcb_randr_set_screen_config (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t timestamp, + xcb_timestamp_t config_timestamp, + uint16_t sizeID, + uint16_t rotation, + uint16_t rate); /** * @@ -1797,13 +1884,13 @@ xcb_randr_set_screen_config (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_set_screen_config_cookie_t -xcb_randr_set_screen_config_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t timestamp /**< */, - xcb_timestamp_t config_timestamp /**< */, - uint16_t sizeID /**< */, - uint16_t rotation /**< */, - uint16_t rate /**< */); +xcb_randr_set_screen_config_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t timestamp, + xcb_timestamp_t config_timestamp, + uint16_t sizeID, + uint16_t rotation, + uint16_t rate); /** * Return the reply @@ -1820,9 +1907,9 @@ xcb_randr_set_screen_config_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_randr_set_screen_config_reply_t * -xcb_randr_set_screen_config_reply (xcb_connection_t *c /**< */, +xcb_randr_set_screen_config_reply (xcb_connection_t *c, xcb_randr_set_screen_config_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1836,9 +1923,9 @@ xcb_randr_set_screen_config_reply (xcb_connection_t *c /** * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_select_input_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t enable /**< */); +xcb_randr_select_input_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t enable); /** * @@ -1849,12 +1936,12 @@ xcb_randr_select_input_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_select_input (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t enable /**< */); +xcb_randr_select_input (xcb_connection_t *c, + xcb_window_t window, + uint16_t enable); int -xcb_randr_get_screen_info_sizeof (const void *_buffer /**< */); +xcb_randr_get_screen_info_sizeof (const void *_buffer); /** * @@ -1865,8 +1952,8 @@ xcb_randr_get_screen_info_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_screen_info_cookie_t -xcb_randr_get_screen_info (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_screen_info (xcb_connection_t *c, + xcb_window_t window); /** * @@ -1880,23 +1967,23 @@ xcb_randr_get_screen_info (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_screen_info_cookie_t -xcb_randr_get_screen_info_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_screen_info_unchecked (xcb_connection_t *c, + xcb_window_t window); xcb_randr_screen_size_t * -xcb_randr_get_screen_info_sizes (const xcb_randr_get_screen_info_reply_t *R /**< */); +xcb_randr_get_screen_info_sizes (const xcb_randr_get_screen_info_reply_t *R); int -xcb_randr_get_screen_info_sizes_length (const xcb_randr_get_screen_info_reply_t *R /**< */); +xcb_randr_get_screen_info_sizes_length (const xcb_randr_get_screen_info_reply_t *R); xcb_randr_screen_size_iterator_t -xcb_randr_get_screen_info_sizes_iterator (const xcb_randr_get_screen_info_reply_t *R /**< */); +xcb_randr_get_screen_info_sizes_iterator (const xcb_randr_get_screen_info_reply_t *R); int -xcb_randr_get_screen_info_rates_length (const xcb_randr_get_screen_info_reply_t *R /**< */); +xcb_randr_get_screen_info_rates_length (const xcb_randr_get_screen_info_reply_t *R); xcb_randr_refresh_rates_iterator_t -xcb_randr_get_screen_info_rates_iterator (const xcb_randr_get_screen_info_reply_t *R /**< */); +xcb_randr_get_screen_info_rates_iterator (const xcb_randr_get_screen_info_reply_t *R); /** * Return the reply @@ -1913,9 +2000,9 @@ xcb_randr_get_screen_info_rates_iterator (const xcb_randr_get_screen_info_reply_ * The returned value must be freed by the caller using free(). */ xcb_randr_get_screen_info_reply_t * -xcb_randr_get_screen_info_reply (xcb_connection_t *c /**< */, +xcb_randr_get_screen_info_reply (xcb_connection_t *c, xcb_randr_get_screen_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1926,8 +2013,8 @@ xcb_randr_get_screen_info_reply (xcb_connection_t *c /**< */ * */ xcb_randr_get_screen_size_range_cookie_t -xcb_randr_get_screen_size_range (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_screen_size_range (xcb_connection_t *c, + xcb_window_t window); /** * @@ -1941,8 +2028,8 @@ xcb_randr_get_screen_size_range (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_screen_size_range_cookie_t -xcb_randr_get_screen_size_range_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_screen_size_range_unchecked (xcb_connection_t *c, + xcb_window_t window); /** * Return the reply @@ -1959,9 +2046,9 @@ xcb_randr_get_screen_size_range_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_randr_get_screen_size_range_reply_t * -xcb_randr_get_screen_size_range_reply (xcb_connection_t *c /**< */, +xcb_randr_get_screen_size_range_reply (xcb_connection_t *c, xcb_randr_get_screen_size_range_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1975,12 +2062,12 @@ xcb_randr_get_screen_size_range_reply (xcb_connection_t * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_set_screen_size_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t mm_width /**< */, - uint32_t mm_height /**< */); +xcb_randr_set_screen_size_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t width, + uint16_t height, + uint32_t mm_width, + uint32_t mm_height); /** * @@ -1991,12 +2078,12 @@ xcb_randr_set_screen_size_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_set_screen_size (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t mm_width /**< */, - uint32_t mm_height /**< */); +xcb_randr_set_screen_size (xcb_connection_t *c, + xcb_window_t window, + uint16_t width, + uint16_t height, + uint32_t mm_width, + uint32_t mm_height); /** * Get the next element of the iterator @@ -2007,7 +2094,7 @@ xcb_randr_set_screen_size (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_randr_mode_info_t) */ void -xcb_randr_mode_info_next (xcb_randr_mode_info_iterator_t *i /**< */); +xcb_randr_mode_info_next (xcb_randr_mode_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -2019,10 +2106,10 @@ xcb_randr_mode_info_next (xcb_randr_mode_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_randr_mode_info_end (xcb_randr_mode_info_iterator_t i /**< */); +xcb_randr_mode_info_end (xcb_randr_mode_info_iterator_t i); int -xcb_randr_get_screen_resources_sizeof (const void *_buffer /**< */); +xcb_randr_get_screen_resources_sizeof (const void *_buffer); /** * @@ -2033,8 +2120,8 @@ xcb_randr_get_screen_resources_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_screen_resources_cookie_t -xcb_randr_get_screen_resources (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_screen_resources (xcb_connection_t *c, + xcb_window_t window); /** * @@ -2048,44 +2135,44 @@ xcb_randr_get_screen_resources (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_screen_resources_cookie_t -xcb_randr_get_screen_resources_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_screen_resources_unchecked (xcb_connection_t *c, + xcb_window_t window); xcb_randr_crtc_t * -xcb_randr_get_screen_resources_crtcs (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_crtcs (const xcb_randr_get_screen_resources_reply_t *R); int -xcb_randr_get_screen_resources_crtcs_length (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_crtcs_length (const xcb_randr_get_screen_resources_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_screen_resources_crtcs_end (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_crtcs_end (const xcb_randr_get_screen_resources_reply_t *R); xcb_randr_output_t * -xcb_randr_get_screen_resources_outputs (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_outputs (const xcb_randr_get_screen_resources_reply_t *R); int -xcb_randr_get_screen_resources_outputs_length (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_outputs_length (const xcb_randr_get_screen_resources_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_screen_resources_outputs_end (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_outputs_end (const xcb_randr_get_screen_resources_reply_t *R); xcb_randr_mode_info_t * -xcb_randr_get_screen_resources_modes (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_modes (const xcb_randr_get_screen_resources_reply_t *R); int -xcb_randr_get_screen_resources_modes_length (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_modes_length (const xcb_randr_get_screen_resources_reply_t *R); xcb_randr_mode_info_iterator_t -xcb_randr_get_screen_resources_modes_iterator (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_modes_iterator (const xcb_randr_get_screen_resources_reply_t *R); uint8_t * -xcb_randr_get_screen_resources_names (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_names (const xcb_randr_get_screen_resources_reply_t *R); int -xcb_randr_get_screen_resources_names_length (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_names_length (const xcb_randr_get_screen_resources_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_screen_resources_names_end (const xcb_randr_get_screen_resources_reply_t *R /**< */); +xcb_randr_get_screen_resources_names_end (const xcb_randr_get_screen_resources_reply_t *R); /** * Return the reply @@ -2102,12 +2189,12 @@ xcb_randr_get_screen_resources_names_end (const xcb_randr_get_screen_resources_r * The returned value must be freed by the caller using free(). */ xcb_randr_get_screen_resources_reply_t * -xcb_randr_get_screen_resources_reply (xcb_connection_t *c /**< */, +xcb_randr_get_screen_resources_reply (xcb_connection_t *c, xcb_randr_get_screen_resources_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_get_output_info_sizeof (const void *_buffer /**< */); +xcb_randr_get_output_info_sizeof (const void *_buffer); /** * @@ -2118,9 +2205,9 @@ xcb_randr_get_output_info_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_output_info_cookie_t -xcb_randr_get_output_info (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_timestamp_t config_timestamp /**< */); +xcb_randr_get_output_info (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_timestamp_t config_timestamp); /** * @@ -2134,45 +2221,45 @@ xcb_randr_get_output_info (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_output_info_cookie_t -xcb_randr_get_output_info_unchecked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_timestamp_t config_timestamp /**< */); +xcb_randr_get_output_info_unchecked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_timestamp_t config_timestamp); xcb_randr_crtc_t * -xcb_randr_get_output_info_crtcs (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_crtcs (const xcb_randr_get_output_info_reply_t *R); int -xcb_randr_get_output_info_crtcs_length (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_crtcs_length (const xcb_randr_get_output_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_output_info_crtcs_end (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_crtcs_end (const xcb_randr_get_output_info_reply_t *R); xcb_randr_mode_t * -xcb_randr_get_output_info_modes (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_modes (const xcb_randr_get_output_info_reply_t *R); int -xcb_randr_get_output_info_modes_length (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_modes_length (const xcb_randr_get_output_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_output_info_modes_end (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_modes_end (const xcb_randr_get_output_info_reply_t *R); xcb_randr_output_t * -xcb_randr_get_output_info_clones (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_clones (const xcb_randr_get_output_info_reply_t *R); int -xcb_randr_get_output_info_clones_length (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_clones_length (const xcb_randr_get_output_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_output_info_clones_end (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_clones_end (const xcb_randr_get_output_info_reply_t *R); uint8_t * -xcb_randr_get_output_info_name (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_name (const xcb_randr_get_output_info_reply_t *R); int -xcb_randr_get_output_info_name_length (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_name_length (const xcb_randr_get_output_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_output_info_name_end (const xcb_randr_get_output_info_reply_t *R /**< */); +xcb_randr_get_output_info_name_end (const xcb_randr_get_output_info_reply_t *R); /** * Return the reply @@ -2189,12 +2276,12 @@ xcb_randr_get_output_info_name_end (const xcb_randr_get_output_info_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_randr_get_output_info_reply_t * -xcb_randr_get_output_info_reply (xcb_connection_t *c /**< */, +xcb_randr_get_output_info_reply (xcb_connection_t *c, xcb_randr_get_output_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_list_output_properties_sizeof (const void *_buffer /**< */); +xcb_randr_list_output_properties_sizeof (const void *_buffer); /** * @@ -2205,8 +2292,8 @@ xcb_randr_list_output_properties_sizeof (const void *_buffer /**< */); * */ xcb_randr_list_output_properties_cookie_t -xcb_randr_list_output_properties (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */); +xcb_randr_list_output_properties (xcb_connection_t *c, + xcb_randr_output_t output); /** * @@ -2220,17 +2307,17 @@ xcb_randr_list_output_properties (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_list_output_properties_cookie_t -xcb_randr_list_output_properties_unchecked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */); +xcb_randr_list_output_properties_unchecked (xcb_connection_t *c, + xcb_randr_output_t output); xcb_atom_t * -xcb_randr_list_output_properties_atoms (const xcb_randr_list_output_properties_reply_t *R /**< */); +xcb_randr_list_output_properties_atoms (const xcb_randr_list_output_properties_reply_t *R); int -xcb_randr_list_output_properties_atoms_length (const xcb_randr_list_output_properties_reply_t *R /**< */); +xcb_randr_list_output_properties_atoms_length (const xcb_randr_list_output_properties_reply_t *R); xcb_generic_iterator_t -xcb_randr_list_output_properties_atoms_end (const xcb_randr_list_output_properties_reply_t *R /**< */); +xcb_randr_list_output_properties_atoms_end (const xcb_randr_list_output_properties_reply_t *R); /** * Return the reply @@ -2247,12 +2334,12 @@ xcb_randr_list_output_properties_atoms_end (const xcb_randr_list_output_properti * The returned value must be freed by the caller using free(). */ xcb_randr_list_output_properties_reply_t * -xcb_randr_list_output_properties_reply (xcb_connection_t *c /**< */, +xcb_randr_list_output_properties_reply (xcb_connection_t *c, xcb_randr_list_output_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_query_output_property_sizeof (const void *_buffer /**< */); +xcb_randr_query_output_property_sizeof (const void *_buffer); /** * @@ -2263,9 +2350,9 @@ xcb_randr_query_output_property_sizeof (const void *_buffer /**< */); * */ xcb_randr_query_output_property_cookie_t -xcb_randr_query_output_property (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */); +xcb_randr_query_output_property (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property); /** * @@ -2279,18 +2366,18 @@ xcb_randr_query_output_property (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_query_output_property_cookie_t -xcb_randr_query_output_property_unchecked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */); +xcb_randr_query_output_property_unchecked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property); int32_t * -xcb_randr_query_output_property_valid_values (const xcb_randr_query_output_property_reply_t *R /**< */); +xcb_randr_query_output_property_valid_values (const xcb_randr_query_output_property_reply_t *R); int -xcb_randr_query_output_property_valid_values_length (const xcb_randr_query_output_property_reply_t *R /**< */); +xcb_randr_query_output_property_valid_values_length (const xcb_randr_query_output_property_reply_t *R); xcb_generic_iterator_t -xcb_randr_query_output_property_valid_values_end (const xcb_randr_query_output_property_reply_t *R /**< */); +xcb_randr_query_output_property_valid_values_end (const xcb_randr_query_output_property_reply_t *R); /** * Return the reply @@ -2307,13 +2394,13 @@ xcb_randr_query_output_property_valid_values_end (const xcb_randr_query_output_p * The returned value must be freed by the caller using free(). */ xcb_randr_query_output_property_reply_t * -xcb_randr_query_output_property_reply (xcb_connection_t *c /**< */, +xcb_randr_query_output_property_reply (xcb_connection_t *c, xcb_randr_query_output_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_configure_output_property_sizeof (const void *_buffer /**< */, - uint32_t values_len /**< */); +xcb_randr_configure_output_property_sizeof (const void *_buffer, + uint32_t values_len); /** * @@ -2327,13 +2414,13 @@ xcb_randr_configure_output_property_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_configure_output_property_checked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - uint8_t pending /**< */, - uint8_t range /**< */, - uint32_t values_len /**< */, - const int32_t *values /**< */); +xcb_randr_configure_output_property_checked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + uint8_t pending, + uint8_t range, + uint32_t values_len, + const int32_t *values); /** * @@ -2344,16 +2431,25 @@ xcb_randr_configure_output_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_configure_output_property (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - uint8_t pending /**< */, - uint8_t range /**< */, - uint32_t values_len /**< */, - const int32_t *values /**< */); +xcb_randr_configure_output_property (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + uint8_t pending, + uint8_t range, + uint32_t values_len, + const int32_t *values); + +int32_t * +xcb_randr_configure_output_property_values (const xcb_randr_configure_output_property_request_t *R); int -xcb_randr_change_output_property_sizeof (const void *_buffer /**< */); +xcb_randr_configure_output_property_values_length (const xcb_randr_configure_output_property_request_t *R); + +xcb_generic_iterator_t +xcb_randr_configure_output_property_values_end (const xcb_randr_configure_output_property_request_t *R); + +int +xcb_randr_change_output_property_sizeof (const void *_buffer); /** * @@ -2367,14 +2463,14 @@ xcb_randr_change_output_property_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_change_output_property_checked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_units /**< */, - const void *data /**< */); +xcb_randr_change_output_property_checked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint8_t mode, + uint32_t num_units, + const void *data); /** * @@ -2385,14 +2481,23 @@ xcb_randr_change_output_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_change_output_property (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_units /**< */, - const void *data /**< */); +xcb_randr_change_output_property (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint8_t mode, + uint32_t num_units, + const void *data); + +void * +xcb_randr_change_output_property_data (const xcb_randr_change_output_property_request_t *R); + +int +xcb_randr_change_output_property_data_length (const xcb_randr_change_output_property_request_t *R); + +xcb_generic_iterator_t +xcb_randr_change_output_property_data_end (const xcb_randr_change_output_property_request_t *R); /** * @@ -2406,9 +2511,9 @@ xcb_randr_change_output_property (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_delete_output_property_checked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */); +xcb_randr_delete_output_property_checked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property); /** * @@ -2419,12 +2524,12 @@ xcb_randr_delete_output_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_delete_output_property (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */); +xcb_randr_delete_output_property (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property); int -xcb_randr_get_output_property_sizeof (const void *_buffer /**< */); +xcb_randr_get_output_property_sizeof (const void *_buffer); /** * @@ -2435,14 +2540,14 @@ xcb_randr_get_output_property_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_output_property_cookie_t -xcb_randr_get_output_property (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */, - uint8_t _delete /**< */, - uint8_t pending /**< */); +xcb_randr_get_output_property (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length, + uint8_t _delete, + uint8_t pending); /** * @@ -2456,23 +2561,23 @@ xcb_randr_get_output_property (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_output_property_cookie_t -xcb_randr_get_output_property_unchecked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */, - uint8_t _delete /**< */, - uint8_t pending /**< */); +xcb_randr_get_output_property_unchecked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length, + uint8_t _delete, + uint8_t pending); uint8_t * -xcb_randr_get_output_property_data (const xcb_randr_get_output_property_reply_t *R /**< */); +xcb_randr_get_output_property_data (const xcb_randr_get_output_property_reply_t *R); int -xcb_randr_get_output_property_data_length (const xcb_randr_get_output_property_reply_t *R /**< */); +xcb_randr_get_output_property_data_length (const xcb_randr_get_output_property_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_output_property_data_end (const xcb_randr_get_output_property_reply_t *R /**< */); +xcb_randr_get_output_property_data_end (const xcb_randr_get_output_property_reply_t *R); /** * Return the reply @@ -2489,13 +2594,13 @@ xcb_randr_get_output_property_data_end (const xcb_randr_get_output_property_repl * The returned value must be freed by the caller using free(). */ xcb_randr_get_output_property_reply_t * -xcb_randr_get_output_property_reply (xcb_connection_t *c /**< */, +xcb_randr_get_output_property_reply (xcb_connection_t *c, xcb_randr_get_output_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_create_mode_sizeof (const void *_buffer /**< */, - uint32_t name_len /**< */); +xcb_randr_create_mode_sizeof (const void *_buffer, + uint32_t name_len); /** * @@ -2506,11 +2611,11 @@ xcb_randr_create_mode_sizeof (const void *_buffer /**< */, * */ xcb_randr_create_mode_cookie_t -xcb_randr_create_mode (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_randr_mode_info_t mode_info /**< */, - uint32_t name_len /**< */, - const char *name /**< */); +xcb_randr_create_mode (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_mode_info_t mode_info, + uint32_t name_len, + const char *name); /** * @@ -2524,11 +2629,11 @@ xcb_randr_create_mode (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_create_mode_cookie_t -xcb_randr_create_mode_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_randr_mode_info_t mode_info /**< */, - uint32_t name_len /**< */, - const char *name /**< */); +xcb_randr_create_mode_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_mode_info_t mode_info, + uint32_t name_len, + const char *name); /** * Return the reply @@ -2545,9 +2650,9 @@ xcb_randr_create_mode_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_randr_create_mode_reply_t * -xcb_randr_create_mode_reply (xcb_connection_t *c /**< */, +xcb_randr_create_mode_reply (xcb_connection_t *c, xcb_randr_create_mode_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -2561,8 +2666,8 @@ xcb_randr_create_mode_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_destroy_mode_checked (xcb_connection_t *c /**< */, - xcb_randr_mode_t mode /**< */); +xcb_randr_destroy_mode_checked (xcb_connection_t *c, + xcb_randr_mode_t mode); /** * @@ -2573,8 +2678,8 @@ xcb_randr_destroy_mode_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_destroy_mode (xcb_connection_t *c /**< */, - xcb_randr_mode_t mode /**< */); +xcb_randr_destroy_mode (xcb_connection_t *c, + xcb_randr_mode_t mode); /** * @@ -2588,9 +2693,9 @@ xcb_randr_destroy_mode (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_add_output_mode_checked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_randr_mode_t mode /**< */); +xcb_randr_add_output_mode_checked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_randr_mode_t mode); /** * @@ -2601,9 +2706,9 @@ xcb_randr_add_output_mode_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_add_output_mode (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_randr_mode_t mode /**< */); +xcb_randr_add_output_mode (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_randr_mode_t mode); /** * @@ -2617,9 +2722,9 @@ xcb_randr_add_output_mode (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_delete_output_mode_checked (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_randr_mode_t mode /**< */); +xcb_randr_delete_output_mode_checked (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_randr_mode_t mode); /** * @@ -2630,12 +2735,12 @@ xcb_randr_delete_output_mode_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_delete_output_mode (xcb_connection_t *c /**< */, - xcb_randr_output_t output /**< */, - xcb_randr_mode_t mode /**< */); +xcb_randr_delete_output_mode (xcb_connection_t *c, + xcb_randr_output_t output, + xcb_randr_mode_t mode); int -xcb_randr_get_crtc_info_sizeof (const void *_buffer /**< */); +xcb_randr_get_crtc_info_sizeof (const void *_buffer); /** * @@ -2646,9 +2751,9 @@ xcb_randr_get_crtc_info_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_crtc_info_cookie_t -xcb_randr_get_crtc_info (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t config_timestamp /**< */); +xcb_randr_get_crtc_info (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t config_timestamp); /** * @@ -2662,27 +2767,27 @@ xcb_randr_get_crtc_info (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_crtc_info_cookie_t -xcb_randr_get_crtc_info_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t config_timestamp /**< */); +xcb_randr_get_crtc_info_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t config_timestamp); xcb_randr_output_t * -xcb_randr_get_crtc_info_outputs (const xcb_randr_get_crtc_info_reply_t *R /**< */); +xcb_randr_get_crtc_info_outputs (const xcb_randr_get_crtc_info_reply_t *R); int -xcb_randr_get_crtc_info_outputs_length (const xcb_randr_get_crtc_info_reply_t *R /**< */); +xcb_randr_get_crtc_info_outputs_length (const xcb_randr_get_crtc_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_crtc_info_outputs_end (const xcb_randr_get_crtc_info_reply_t *R /**< */); +xcb_randr_get_crtc_info_outputs_end (const xcb_randr_get_crtc_info_reply_t *R); xcb_randr_output_t * -xcb_randr_get_crtc_info_possible (const xcb_randr_get_crtc_info_reply_t *R /**< */); +xcb_randr_get_crtc_info_possible (const xcb_randr_get_crtc_info_reply_t *R); int -xcb_randr_get_crtc_info_possible_length (const xcb_randr_get_crtc_info_reply_t *R /**< */); +xcb_randr_get_crtc_info_possible_length (const xcb_randr_get_crtc_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_crtc_info_possible_end (const xcb_randr_get_crtc_info_reply_t *R /**< */); +xcb_randr_get_crtc_info_possible_end (const xcb_randr_get_crtc_info_reply_t *R); /** * Return the reply @@ -2699,13 +2804,13 @@ xcb_randr_get_crtc_info_possible_end (const xcb_randr_get_crtc_info_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_randr_get_crtc_info_reply_t * -xcb_randr_get_crtc_info_reply (xcb_connection_t *c /**< */, +xcb_randr_get_crtc_info_reply (xcb_connection_t *c, xcb_randr_get_crtc_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_set_crtc_config_sizeof (const void *_buffer /**< */, - uint32_t outputs_len /**< */); +xcb_randr_set_crtc_config_sizeof (const void *_buffer, + uint32_t outputs_len); /** * @@ -2716,16 +2821,16 @@ xcb_randr_set_crtc_config_sizeof (const void *_buffer /**< */, * */ xcb_randr_set_crtc_config_cookie_t -xcb_randr_set_crtc_config (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t timestamp /**< */, - xcb_timestamp_t config_timestamp /**< */, - int16_t x /**< */, - int16_t y /**< */, - xcb_randr_mode_t mode /**< */, - uint16_t rotation /**< */, - uint32_t outputs_len /**< */, - const xcb_randr_output_t *outputs /**< */); +xcb_randr_set_crtc_config (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t timestamp, + xcb_timestamp_t config_timestamp, + int16_t x, + int16_t y, + xcb_randr_mode_t mode, + uint16_t rotation, + uint32_t outputs_len, + const xcb_randr_output_t *outputs); /** * @@ -2739,16 +2844,16 @@ xcb_randr_set_crtc_config (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_set_crtc_config_cookie_t -xcb_randr_set_crtc_config_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t timestamp /**< */, - xcb_timestamp_t config_timestamp /**< */, - int16_t x /**< */, - int16_t y /**< */, - xcb_randr_mode_t mode /**< */, - uint16_t rotation /**< */, - uint32_t outputs_len /**< */, - const xcb_randr_output_t *outputs /**< */); +xcb_randr_set_crtc_config_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t timestamp, + xcb_timestamp_t config_timestamp, + int16_t x, + int16_t y, + xcb_randr_mode_t mode, + uint16_t rotation, + uint32_t outputs_len, + const xcb_randr_output_t *outputs); /** * Return the reply @@ -2765,9 +2870,9 @@ xcb_randr_set_crtc_config_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_randr_set_crtc_config_reply_t * -xcb_randr_set_crtc_config_reply (xcb_connection_t *c /**< */, +xcb_randr_set_crtc_config_reply (xcb_connection_t *c, xcb_randr_set_crtc_config_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -2778,8 +2883,8 @@ xcb_randr_set_crtc_config_reply (xcb_connection_t *c /**< */ * */ xcb_randr_get_crtc_gamma_size_cookie_t -xcb_randr_get_crtc_gamma_size (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */); +xcb_randr_get_crtc_gamma_size (xcb_connection_t *c, + xcb_randr_crtc_t crtc); /** * @@ -2793,8 +2898,8 @@ xcb_randr_get_crtc_gamma_size (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_crtc_gamma_size_cookie_t -xcb_randr_get_crtc_gamma_size_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */); +xcb_randr_get_crtc_gamma_size_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc); /** * Return the reply @@ -2811,12 +2916,12 @@ xcb_randr_get_crtc_gamma_size_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_randr_get_crtc_gamma_size_reply_t * -xcb_randr_get_crtc_gamma_size_reply (xcb_connection_t *c /**< */, +xcb_randr_get_crtc_gamma_size_reply (xcb_connection_t *c, xcb_randr_get_crtc_gamma_size_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_get_crtc_gamma_sizeof (const void *_buffer /**< */); +xcb_randr_get_crtc_gamma_sizeof (const void *_buffer); /** * @@ -2827,8 +2932,8 @@ xcb_randr_get_crtc_gamma_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_crtc_gamma_cookie_t -xcb_randr_get_crtc_gamma (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */); +xcb_randr_get_crtc_gamma (xcb_connection_t *c, + xcb_randr_crtc_t crtc); /** * @@ -2842,35 +2947,35 @@ xcb_randr_get_crtc_gamma (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_crtc_gamma_cookie_t -xcb_randr_get_crtc_gamma_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */); +xcb_randr_get_crtc_gamma_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc); uint16_t * -xcb_randr_get_crtc_gamma_red (const xcb_randr_get_crtc_gamma_reply_t *R /**< */); +xcb_randr_get_crtc_gamma_red (const xcb_randr_get_crtc_gamma_reply_t *R); int -xcb_randr_get_crtc_gamma_red_length (const xcb_randr_get_crtc_gamma_reply_t *R /**< */); +xcb_randr_get_crtc_gamma_red_length (const xcb_randr_get_crtc_gamma_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_crtc_gamma_red_end (const xcb_randr_get_crtc_gamma_reply_t *R /**< */); +xcb_randr_get_crtc_gamma_red_end (const xcb_randr_get_crtc_gamma_reply_t *R); uint16_t * -xcb_randr_get_crtc_gamma_green (const xcb_randr_get_crtc_gamma_reply_t *R /**< */); +xcb_randr_get_crtc_gamma_green (const xcb_randr_get_crtc_gamma_reply_t *R); int -xcb_randr_get_crtc_gamma_green_length (const xcb_randr_get_crtc_gamma_reply_t *R /**< */); +xcb_randr_get_crtc_gamma_green_length (const xcb_randr_get_crtc_gamma_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_crtc_gamma_green_end (const xcb_randr_get_crtc_gamma_reply_t *R /**< */); +xcb_randr_get_crtc_gamma_green_end (const xcb_randr_get_crtc_gamma_reply_t *R); uint16_t * -xcb_randr_get_crtc_gamma_blue (const xcb_randr_get_crtc_gamma_reply_t *R /**< */); +xcb_randr_get_crtc_gamma_blue (const xcb_randr_get_crtc_gamma_reply_t *R); int -xcb_randr_get_crtc_gamma_blue_length (const xcb_randr_get_crtc_gamma_reply_t *R /**< */); +xcb_randr_get_crtc_gamma_blue_length (const xcb_randr_get_crtc_gamma_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_crtc_gamma_blue_end (const xcb_randr_get_crtc_gamma_reply_t *R /**< */); +xcb_randr_get_crtc_gamma_blue_end (const xcb_randr_get_crtc_gamma_reply_t *R); /** * Return the reply @@ -2887,12 +2992,12 @@ xcb_randr_get_crtc_gamma_blue_end (const xcb_randr_get_crtc_gamma_reply_t *R /* * The returned value must be freed by the caller using free(). */ xcb_randr_get_crtc_gamma_reply_t * -xcb_randr_get_crtc_gamma_reply (xcb_connection_t *c /**< */, +xcb_randr_get_crtc_gamma_reply (xcb_connection_t *c, xcb_randr_get_crtc_gamma_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_set_crtc_gamma_sizeof (const void *_buffer /**< */); +xcb_randr_set_crtc_gamma_sizeof (const void *_buffer); /** * @@ -2906,12 +3011,12 @@ xcb_randr_set_crtc_gamma_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - uint16_t size /**< */, - const uint16_t *red /**< */, - const uint16_t *green /**< */, - const uint16_t *blue /**< */); +xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + uint16_t size, + const uint16_t *red, + const uint16_t *green, + const uint16_t *blue); /** * @@ -2922,15 +3027,42 @@ xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_set_crtc_gamma (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - uint16_t size /**< */, - const uint16_t *red /**< */, - const uint16_t *green /**< */, - const uint16_t *blue /**< */); +xcb_randr_set_crtc_gamma (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + uint16_t size, + const uint16_t *red, + const uint16_t *green, + const uint16_t *blue); + +uint16_t * +xcb_randr_set_crtc_gamma_red (const xcb_randr_set_crtc_gamma_request_t *R); int -xcb_randr_get_screen_resources_current_sizeof (const void *_buffer /**< */); +xcb_randr_set_crtc_gamma_red_length (const xcb_randr_set_crtc_gamma_request_t *R); + +xcb_generic_iterator_t +xcb_randr_set_crtc_gamma_red_end (const xcb_randr_set_crtc_gamma_request_t *R); + +uint16_t * +xcb_randr_set_crtc_gamma_green (const xcb_randr_set_crtc_gamma_request_t *R); + +int +xcb_randr_set_crtc_gamma_green_length (const xcb_randr_set_crtc_gamma_request_t *R); + +xcb_generic_iterator_t +xcb_randr_set_crtc_gamma_green_end (const xcb_randr_set_crtc_gamma_request_t *R); + +uint16_t * +xcb_randr_set_crtc_gamma_blue (const xcb_randr_set_crtc_gamma_request_t *R); + +int +xcb_randr_set_crtc_gamma_blue_length (const xcb_randr_set_crtc_gamma_request_t *R); + +xcb_generic_iterator_t +xcb_randr_set_crtc_gamma_blue_end (const xcb_randr_set_crtc_gamma_request_t *R); + +int +xcb_randr_get_screen_resources_current_sizeof (const void *_buffer); /** * @@ -2941,8 +3073,8 @@ xcb_randr_get_screen_resources_current_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_screen_resources_current_cookie_t -xcb_randr_get_screen_resources_current (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_screen_resources_current (xcb_connection_t *c, + xcb_window_t window); /** * @@ -2956,44 +3088,44 @@ xcb_randr_get_screen_resources_current (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_screen_resources_current_cookie_t -xcb_randr_get_screen_resources_current_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_screen_resources_current_unchecked (xcb_connection_t *c, + xcb_window_t window); xcb_randr_crtc_t * -xcb_randr_get_screen_resources_current_crtcs (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_crtcs (const xcb_randr_get_screen_resources_current_reply_t *R); int -xcb_randr_get_screen_resources_current_crtcs_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_crtcs_length (const xcb_randr_get_screen_resources_current_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_screen_resources_current_crtcs_end (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_crtcs_end (const xcb_randr_get_screen_resources_current_reply_t *R); xcb_randr_output_t * -xcb_randr_get_screen_resources_current_outputs (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_outputs (const xcb_randr_get_screen_resources_current_reply_t *R); int -xcb_randr_get_screen_resources_current_outputs_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_outputs_length (const xcb_randr_get_screen_resources_current_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_screen_resources_current_outputs_end (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_outputs_end (const xcb_randr_get_screen_resources_current_reply_t *R); xcb_randr_mode_info_t * -xcb_randr_get_screen_resources_current_modes (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_modes (const xcb_randr_get_screen_resources_current_reply_t *R); int -xcb_randr_get_screen_resources_current_modes_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_modes_length (const xcb_randr_get_screen_resources_current_reply_t *R); xcb_randr_mode_info_iterator_t -xcb_randr_get_screen_resources_current_modes_iterator (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_modes_iterator (const xcb_randr_get_screen_resources_current_reply_t *R); uint8_t * -xcb_randr_get_screen_resources_current_names (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_names (const xcb_randr_get_screen_resources_current_reply_t *R); int -xcb_randr_get_screen_resources_current_names_length (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_names_length (const xcb_randr_get_screen_resources_current_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_screen_resources_current_names_end (const xcb_randr_get_screen_resources_current_reply_t *R /**< */); +xcb_randr_get_screen_resources_current_names_end (const xcb_randr_get_screen_resources_current_reply_t *R); /** * Return the reply @@ -3010,13 +3142,13 @@ xcb_randr_get_screen_resources_current_names_end (const xcb_randr_get_screen_res * The returned value must be freed by the caller using free(). */ xcb_randr_get_screen_resources_current_reply_t * -xcb_randr_get_screen_resources_current_reply (xcb_connection_t *c /**< */, +xcb_randr_get_screen_resources_current_reply (xcb_connection_t *c, xcb_randr_get_screen_resources_current_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_set_crtc_transform_sizeof (const void *_buffer /**< */, - uint32_t filter_params_len /**< */); +xcb_randr_set_crtc_transform_sizeof (const void *_buffer, + uint32_t filter_params_len); /** * @@ -3030,13 +3162,13 @@ xcb_randr_set_crtc_transform_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_set_crtc_transform_checked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_render_transform_t transform /**< */, - uint16_t filter_len /**< */, - const char *filter_name /**< */, - uint32_t filter_params_len /**< */, - const xcb_render_fixed_t *filter_params /**< */); +xcb_randr_set_crtc_transform_checked (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_render_transform_t transform, + uint16_t filter_len, + const char *filter_name, + uint32_t filter_params_len, + const xcb_render_fixed_t *filter_params); /** * @@ -3047,16 +3179,34 @@ xcb_randr_set_crtc_transform_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_set_crtc_transform (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_render_transform_t transform /**< */, - uint16_t filter_len /**< */, - const char *filter_name /**< */, - uint32_t filter_params_len /**< */, - const xcb_render_fixed_t *filter_params /**< */); +xcb_randr_set_crtc_transform (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_render_transform_t transform, + uint16_t filter_len, + const char *filter_name, + uint32_t filter_params_len, + const xcb_render_fixed_t *filter_params); + +char * +xcb_randr_set_crtc_transform_filter_name (const xcb_randr_set_crtc_transform_request_t *R); int -xcb_randr_get_crtc_transform_sizeof (const void *_buffer /**< */); +xcb_randr_set_crtc_transform_filter_name_length (const xcb_randr_set_crtc_transform_request_t *R); + +xcb_generic_iterator_t +xcb_randr_set_crtc_transform_filter_name_end (const xcb_randr_set_crtc_transform_request_t *R); + +xcb_render_fixed_t * +xcb_randr_set_crtc_transform_filter_params (const xcb_randr_set_crtc_transform_request_t *R); + +int +xcb_randr_set_crtc_transform_filter_params_length (const xcb_randr_set_crtc_transform_request_t *R); + +xcb_generic_iterator_t +xcb_randr_set_crtc_transform_filter_params_end (const xcb_randr_set_crtc_transform_request_t *R); + +int +xcb_randr_get_crtc_transform_sizeof (const void *_buffer); /** * @@ -3067,8 +3217,8 @@ xcb_randr_get_crtc_transform_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_crtc_transform_cookie_t -xcb_randr_get_crtc_transform (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */); +xcb_randr_get_crtc_transform (xcb_connection_t *c, + xcb_randr_crtc_t crtc); /** * @@ -3082,44 +3232,44 @@ xcb_randr_get_crtc_transform (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_crtc_transform_cookie_t -xcb_randr_get_crtc_transform_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */); +xcb_randr_get_crtc_transform_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc); char * -xcb_randr_get_crtc_transform_pending_filter_name (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_pending_filter_name (const xcb_randr_get_crtc_transform_reply_t *R); int -xcb_randr_get_crtc_transform_pending_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_pending_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_crtc_transform_pending_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_pending_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R); xcb_render_fixed_t * -xcb_randr_get_crtc_transform_pending_params (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_pending_params (const xcb_randr_get_crtc_transform_reply_t *R); int -xcb_randr_get_crtc_transform_pending_params_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_pending_params_length (const xcb_randr_get_crtc_transform_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_crtc_transform_pending_params_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_pending_params_end (const xcb_randr_get_crtc_transform_reply_t *R); char * -xcb_randr_get_crtc_transform_current_filter_name (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_current_filter_name (const xcb_randr_get_crtc_transform_reply_t *R); int -xcb_randr_get_crtc_transform_current_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_current_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_crtc_transform_current_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_current_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R); xcb_render_fixed_t * -xcb_randr_get_crtc_transform_current_params (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_current_params (const xcb_randr_get_crtc_transform_reply_t *R); int -xcb_randr_get_crtc_transform_current_params_length (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_current_params_length (const xcb_randr_get_crtc_transform_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_crtc_transform_current_params_end (const xcb_randr_get_crtc_transform_reply_t *R /**< */); +xcb_randr_get_crtc_transform_current_params_end (const xcb_randr_get_crtc_transform_reply_t *R); /** * Return the reply @@ -3136,9 +3286,9 @@ xcb_randr_get_crtc_transform_current_params_end (const xcb_randr_get_crtc_transf * The returned value must be freed by the caller using free(). */ xcb_randr_get_crtc_transform_reply_t * -xcb_randr_get_crtc_transform_reply (xcb_connection_t *c /**< */, +xcb_randr_get_crtc_transform_reply (xcb_connection_t *c, xcb_randr_get_crtc_transform_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -3149,8 +3299,8 @@ xcb_randr_get_crtc_transform_reply (xcb_connection_t *c / * */ xcb_randr_get_panning_cookie_t -xcb_randr_get_panning (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */); +xcb_randr_get_panning (xcb_connection_t *c, + xcb_randr_crtc_t crtc); /** * @@ -3164,8 +3314,8 @@ xcb_randr_get_panning (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_panning_cookie_t -xcb_randr_get_panning_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */); +xcb_randr_get_panning_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc); /** * Return the reply @@ -3182,9 +3332,9 @@ xcb_randr_get_panning_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_randr_get_panning_reply_t * -xcb_randr_get_panning_reply (xcb_connection_t *c /**< */, +xcb_randr_get_panning_reply (xcb_connection_t *c, xcb_randr_get_panning_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -3195,21 +3345,21 @@ xcb_randr_get_panning_reply (xcb_connection_t *c /**< */, * */ xcb_randr_set_panning_cookie_t -xcb_randr_set_panning (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t timestamp /**< */, - uint16_t left /**< */, - uint16_t top /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t track_left /**< */, - uint16_t track_top /**< */, - uint16_t track_width /**< */, - uint16_t track_height /**< */, - int16_t border_left /**< */, - int16_t border_top /**< */, - int16_t border_right /**< */, - int16_t border_bottom /**< */); +xcb_randr_set_panning (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t timestamp, + uint16_t left, + uint16_t top, + uint16_t width, + uint16_t height, + uint16_t track_left, + uint16_t track_top, + uint16_t track_width, + uint16_t track_height, + int16_t border_left, + int16_t border_top, + int16_t border_right, + int16_t border_bottom); /** * @@ -3223,21 +3373,21 @@ xcb_randr_set_panning (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_set_panning_cookie_t -xcb_randr_set_panning_unchecked (xcb_connection_t *c /**< */, - xcb_randr_crtc_t crtc /**< */, - xcb_timestamp_t timestamp /**< */, - uint16_t left /**< */, - uint16_t top /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t track_left /**< */, - uint16_t track_top /**< */, - uint16_t track_width /**< */, - uint16_t track_height /**< */, - int16_t border_left /**< */, - int16_t border_top /**< */, - int16_t border_right /**< */, - int16_t border_bottom /**< */); +xcb_randr_set_panning_unchecked (xcb_connection_t *c, + xcb_randr_crtc_t crtc, + xcb_timestamp_t timestamp, + uint16_t left, + uint16_t top, + uint16_t width, + uint16_t height, + uint16_t track_left, + uint16_t track_top, + uint16_t track_width, + uint16_t track_height, + int16_t border_left, + int16_t border_top, + int16_t border_right, + int16_t border_bottom); /** * Return the reply @@ -3254,9 +3404,9 @@ xcb_randr_set_panning_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_randr_set_panning_reply_t * -xcb_randr_set_panning_reply (xcb_connection_t *c /**< */, +xcb_randr_set_panning_reply (xcb_connection_t *c, xcb_randr_set_panning_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -3270,9 +3420,9 @@ xcb_randr_set_panning_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_set_output_primary_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_randr_output_t output /**< */); +xcb_randr_set_output_primary_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_output_t output); /** * @@ -3283,9 +3433,9 @@ xcb_randr_set_output_primary_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_set_output_primary (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_randr_output_t output /**< */); +xcb_randr_set_output_primary (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_output_t output); /** * @@ -3296,8 +3446,8 @@ xcb_randr_set_output_primary (xcb_connection_t *c /**< */, * */ xcb_randr_get_output_primary_cookie_t -xcb_randr_get_output_primary (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_output_primary (xcb_connection_t *c, + xcb_window_t window); /** * @@ -3311,8 +3461,8 @@ xcb_randr_get_output_primary (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_output_primary_cookie_t -xcb_randr_get_output_primary_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_output_primary_unchecked (xcb_connection_t *c, + xcb_window_t window); /** * Return the reply @@ -3329,12 +3479,12 @@ xcb_randr_get_output_primary_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_randr_get_output_primary_reply_t * -xcb_randr_get_output_primary_reply (xcb_connection_t *c /**< */, +xcb_randr_get_output_primary_reply (xcb_connection_t *c, xcb_randr_get_output_primary_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_get_providers_sizeof (const void *_buffer /**< */); +xcb_randr_get_providers_sizeof (const void *_buffer); /** * @@ -3345,8 +3495,8 @@ xcb_randr_get_providers_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_providers_cookie_t -xcb_randr_get_providers (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_providers (xcb_connection_t *c, + xcb_window_t window); /** * @@ -3360,17 +3510,17 @@ xcb_randr_get_providers (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_providers_cookie_t -xcb_randr_get_providers_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_randr_get_providers_unchecked (xcb_connection_t *c, + xcb_window_t window); xcb_randr_provider_t * -xcb_randr_get_providers_providers (const xcb_randr_get_providers_reply_t *R /**< */); +xcb_randr_get_providers_providers (const xcb_randr_get_providers_reply_t *R); int -xcb_randr_get_providers_providers_length (const xcb_randr_get_providers_reply_t *R /**< */); +xcb_randr_get_providers_providers_length (const xcb_randr_get_providers_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_providers_providers_end (const xcb_randr_get_providers_reply_t *R /**< */); +xcb_randr_get_providers_providers_end (const xcb_randr_get_providers_reply_t *R); /** * Return the reply @@ -3387,12 +3537,12 @@ xcb_randr_get_providers_providers_end (const xcb_randr_get_providers_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_randr_get_providers_reply_t * -xcb_randr_get_providers_reply (xcb_connection_t *c /**< */, +xcb_randr_get_providers_reply (xcb_connection_t *c, xcb_randr_get_providers_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_get_provider_info_sizeof (const void *_buffer /**< */); +xcb_randr_get_provider_info_sizeof (const void *_buffer); /** * @@ -3403,9 +3553,9 @@ xcb_randr_get_provider_info_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_provider_info_cookie_t -xcb_randr_get_provider_info (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_timestamp_t config_timestamp /**< */); +xcb_randr_get_provider_info (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_timestamp_t config_timestamp); /** * @@ -3419,54 +3569,54 @@ xcb_randr_get_provider_info (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_provider_info_cookie_t -xcb_randr_get_provider_info_unchecked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_timestamp_t config_timestamp /**< */); +xcb_randr_get_provider_info_unchecked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_timestamp_t config_timestamp); xcb_randr_crtc_t * -xcb_randr_get_provider_info_crtcs (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_crtcs (const xcb_randr_get_provider_info_reply_t *R); int -xcb_randr_get_provider_info_crtcs_length (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_crtcs_length (const xcb_randr_get_provider_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_provider_info_crtcs_end (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_crtcs_end (const xcb_randr_get_provider_info_reply_t *R); xcb_randr_output_t * -xcb_randr_get_provider_info_outputs (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_outputs (const xcb_randr_get_provider_info_reply_t *R); int -xcb_randr_get_provider_info_outputs_length (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_outputs_length (const xcb_randr_get_provider_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_provider_info_outputs_end (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_outputs_end (const xcb_randr_get_provider_info_reply_t *R); xcb_randr_provider_t * -xcb_randr_get_provider_info_associated_providers (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_associated_providers (const xcb_randr_get_provider_info_reply_t *R); int -xcb_randr_get_provider_info_associated_providers_length (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_associated_providers_length (const xcb_randr_get_provider_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_provider_info_associated_providers_end (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_associated_providers_end (const xcb_randr_get_provider_info_reply_t *R); uint32_t * -xcb_randr_get_provider_info_associated_capability (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_associated_capability (const xcb_randr_get_provider_info_reply_t *R); int -xcb_randr_get_provider_info_associated_capability_length (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_associated_capability_length (const xcb_randr_get_provider_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_provider_info_associated_capability_end (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_associated_capability_end (const xcb_randr_get_provider_info_reply_t *R); char * -xcb_randr_get_provider_info_name (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_name (const xcb_randr_get_provider_info_reply_t *R); int -xcb_randr_get_provider_info_name_length (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_name_length (const xcb_randr_get_provider_info_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_provider_info_name_end (const xcb_randr_get_provider_info_reply_t *R /**< */); +xcb_randr_get_provider_info_name_end (const xcb_randr_get_provider_info_reply_t *R); /** * Return the reply @@ -3483,9 +3633,9 @@ xcb_randr_get_provider_info_name_end (const xcb_randr_get_provider_info_reply_t * The returned value must be freed by the caller using free(). */ xcb_randr_get_provider_info_reply_t * -xcb_randr_get_provider_info_reply (xcb_connection_t *c /**< */, +xcb_randr_get_provider_info_reply (xcb_connection_t *c, xcb_randr_get_provider_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -3499,10 +3649,10 @@ xcb_randr_get_provider_info_reply (xcb_connection_t *c /** * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_set_provider_offload_sink_checked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_randr_provider_t sink_provider /**< */, - xcb_timestamp_t config_timestamp /**< */); +xcb_randr_set_provider_offload_sink_checked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_randr_provider_t sink_provider, + xcb_timestamp_t config_timestamp); /** * @@ -3513,10 +3663,10 @@ xcb_randr_set_provider_offload_sink_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_set_provider_offload_sink (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_randr_provider_t sink_provider /**< */, - xcb_timestamp_t config_timestamp /**< */); +xcb_randr_set_provider_offload_sink (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_randr_provider_t sink_provider, + xcb_timestamp_t config_timestamp); /** * @@ -3530,10 +3680,10 @@ xcb_randr_set_provider_offload_sink (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_set_provider_output_source_checked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_randr_provider_t source_provider /**< */, - xcb_timestamp_t config_timestamp /**< */); +xcb_randr_set_provider_output_source_checked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_randr_provider_t source_provider, + xcb_timestamp_t config_timestamp); /** * @@ -3544,13 +3694,13 @@ xcb_randr_set_provider_output_source_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_set_provider_output_source (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_randr_provider_t source_provider /**< */, - xcb_timestamp_t config_timestamp /**< */); +xcb_randr_set_provider_output_source (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_randr_provider_t source_provider, + xcb_timestamp_t config_timestamp); int -xcb_randr_list_provider_properties_sizeof (const void *_buffer /**< */); +xcb_randr_list_provider_properties_sizeof (const void *_buffer); /** * @@ -3561,8 +3711,8 @@ xcb_randr_list_provider_properties_sizeof (const void *_buffer /**< */); * */ xcb_randr_list_provider_properties_cookie_t -xcb_randr_list_provider_properties (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */); +xcb_randr_list_provider_properties (xcb_connection_t *c, + xcb_randr_provider_t provider); /** * @@ -3576,17 +3726,17 @@ xcb_randr_list_provider_properties (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_list_provider_properties_cookie_t -xcb_randr_list_provider_properties_unchecked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */); +xcb_randr_list_provider_properties_unchecked (xcb_connection_t *c, + xcb_randr_provider_t provider); xcb_atom_t * -xcb_randr_list_provider_properties_atoms (const xcb_randr_list_provider_properties_reply_t *R /**< */); +xcb_randr_list_provider_properties_atoms (const xcb_randr_list_provider_properties_reply_t *R); int -xcb_randr_list_provider_properties_atoms_length (const xcb_randr_list_provider_properties_reply_t *R /**< */); +xcb_randr_list_provider_properties_atoms_length (const xcb_randr_list_provider_properties_reply_t *R); xcb_generic_iterator_t -xcb_randr_list_provider_properties_atoms_end (const xcb_randr_list_provider_properties_reply_t *R /**< */); +xcb_randr_list_provider_properties_atoms_end (const xcb_randr_list_provider_properties_reply_t *R); /** * Return the reply @@ -3603,12 +3753,12 @@ xcb_randr_list_provider_properties_atoms_end (const xcb_randr_list_provider_prop * The returned value must be freed by the caller using free(). */ xcb_randr_list_provider_properties_reply_t * -xcb_randr_list_provider_properties_reply (xcb_connection_t *c /**< */, +xcb_randr_list_provider_properties_reply (xcb_connection_t *c, xcb_randr_list_provider_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_query_provider_property_sizeof (const void *_buffer /**< */); +xcb_randr_query_provider_property_sizeof (const void *_buffer); /** * @@ -3619,9 +3769,9 @@ xcb_randr_query_provider_property_sizeof (const void *_buffer /**< */); * */ xcb_randr_query_provider_property_cookie_t -xcb_randr_query_provider_property (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */); +xcb_randr_query_provider_property (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property); /** * @@ -3635,18 +3785,18 @@ xcb_randr_query_provider_property (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_query_provider_property_cookie_t -xcb_randr_query_provider_property_unchecked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */); +xcb_randr_query_provider_property_unchecked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property); int32_t * -xcb_randr_query_provider_property_valid_values (const xcb_randr_query_provider_property_reply_t *R /**< */); +xcb_randr_query_provider_property_valid_values (const xcb_randr_query_provider_property_reply_t *R); int -xcb_randr_query_provider_property_valid_values_length (const xcb_randr_query_provider_property_reply_t *R /**< */); +xcb_randr_query_provider_property_valid_values_length (const xcb_randr_query_provider_property_reply_t *R); xcb_generic_iterator_t -xcb_randr_query_provider_property_valid_values_end (const xcb_randr_query_provider_property_reply_t *R /**< */); +xcb_randr_query_provider_property_valid_values_end (const xcb_randr_query_provider_property_reply_t *R); /** * Return the reply @@ -3663,13 +3813,13 @@ xcb_randr_query_provider_property_valid_values_end (const xcb_randr_query_provid * The returned value must be freed by the caller using free(). */ xcb_randr_query_provider_property_reply_t * -xcb_randr_query_provider_property_reply (xcb_connection_t *c /**< */, +xcb_randr_query_provider_property_reply (xcb_connection_t *c, xcb_randr_query_provider_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_randr_configure_provider_property_sizeof (const void *_buffer /**< */, - uint32_t values_len /**< */); +xcb_randr_configure_provider_property_sizeof (const void *_buffer, + uint32_t values_len); /** * @@ -3683,13 +3833,13 @@ xcb_randr_configure_provider_property_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_configure_provider_property_checked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - uint8_t pending /**< */, - uint8_t range /**< */, - uint32_t values_len /**< */, - const int32_t *values /**< */); +xcb_randr_configure_provider_property_checked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + uint8_t pending, + uint8_t range, + uint32_t values_len, + const int32_t *values); /** * @@ -3700,16 +3850,25 @@ xcb_randr_configure_provider_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_configure_provider_property (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - uint8_t pending /**< */, - uint8_t range /**< */, - uint32_t values_len /**< */, - const int32_t *values /**< */); +xcb_randr_configure_provider_property (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + uint8_t pending, + uint8_t range, + uint32_t values_len, + const int32_t *values); + +int32_t * +xcb_randr_configure_provider_property_values (const xcb_randr_configure_provider_property_request_t *R); int -xcb_randr_change_provider_property_sizeof (const void *_buffer /**< */); +xcb_randr_configure_provider_property_values_length (const xcb_randr_configure_provider_property_request_t *R); + +xcb_generic_iterator_t +xcb_randr_configure_provider_property_values_end (const xcb_randr_configure_provider_property_request_t *R); + +int +xcb_randr_change_provider_property_sizeof (const void *_buffer); /** * @@ -3723,14 +3882,14 @@ xcb_randr_change_provider_property_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_change_provider_property_checked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const void *data /**< */); +xcb_randr_change_provider_property_checked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *data); /** * @@ -3741,14 +3900,23 @@ xcb_randr_change_provider_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_change_provider_property (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const void *data /**< */); +xcb_randr_change_provider_property (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *data); + +void * +xcb_randr_change_provider_property_data (const xcb_randr_change_provider_property_request_t *R); + +int +xcb_randr_change_provider_property_data_length (const xcb_randr_change_provider_property_request_t *R); + +xcb_generic_iterator_t +xcb_randr_change_provider_property_data_end (const xcb_randr_change_provider_property_request_t *R); /** * @@ -3762,9 +3930,9 @@ xcb_randr_change_provider_property (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_randr_delete_provider_property_checked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */); +xcb_randr_delete_provider_property_checked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property); /** * @@ -3775,12 +3943,12 @@ xcb_randr_delete_provider_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_randr_delete_provider_property (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */); +xcb_randr_delete_provider_property (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property); int -xcb_randr_get_provider_property_sizeof (const void *_buffer /**< */); +xcb_randr_get_provider_property_sizeof (const void *_buffer); /** * @@ -3791,14 +3959,14 @@ xcb_randr_get_provider_property_sizeof (const void *_buffer /**< */); * */ xcb_randr_get_provider_property_cookie_t -xcb_randr_get_provider_property (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */, - uint8_t _delete /**< */, - uint8_t pending /**< */); +xcb_randr_get_provider_property (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length, + uint8_t _delete, + uint8_t pending); /** * @@ -3812,23 +3980,23 @@ xcb_randr_get_provider_property (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_randr_get_provider_property_cookie_t -xcb_randr_get_provider_property_unchecked (xcb_connection_t *c /**< */, - xcb_randr_provider_t provider /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */, - uint8_t _delete /**< */, - uint8_t pending /**< */); +xcb_randr_get_provider_property_unchecked (xcb_connection_t *c, + xcb_randr_provider_t provider, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length, + uint8_t _delete, + uint8_t pending); void * -xcb_randr_get_provider_property_data (const xcb_randr_get_provider_property_reply_t *R /**< */); +xcb_randr_get_provider_property_data (const xcb_randr_get_provider_property_reply_t *R); int -xcb_randr_get_provider_property_data_length (const xcb_randr_get_provider_property_reply_t *R /**< */); +xcb_randr_get_provider_property_data_length (const xcb_randr_get_provider_property_reply_t *R); xcb_generic_iterator_t -xcb_randr_get_provider_property_data_end (const xcb_randr_get_provider_property_reply_t *R /**< */); +xcb_randr_get_provider_property_data_end (const xcb_randr_get_provider_property_reply_t *R); /** * Return the reply @@ -3845,9 +4013,9 @@ xcb_randr_get_provider_property_data_end (const xcb_randr_get_provider_property_ * The returned value must be freed by the caller using free(). */ xcb_randr_get_provider_property_reply_t * -xcb_randr_get_provider_property_reply (xcb_connection_t *c /**< */, +xcb_randr_get_provider_property_reply (xcb_connection_t *c, xcb_randr_get_provider_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Get the next element of the iterator @@ -3858,7 +4026,7 @@ xcb_randr_get_provider_property_reply (xcb_connection_t * element. The member index is increased by sizeof(xcb_randr_crtc_change_t) */ void -xcb_randr_crtc_change_next (xcb_randr_crtc_change_iterator_t *i /**< */); +xcb_randr_crtc_change_next (xcb_randr_crtc_change_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3870,7 +4038,7 @@ xcb_randr_crtc_change_next (xcb_randr_crtc_change_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_randr_crtc_change_end (xcb_randr_crtc_change_iterator_t i /**< */); +xcb_randr_crtc_change_end (xcb_randr_crtc_change_iterator_t i); /** * Get the next element of the iterator @@ -3881,7 +4049,7 @@ xcb_randr_crtc_change_end (xcb_randr_crtc_change_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_randr_output_change_t) */ void -xcb_randr_output_change_next (xcb_randr_output_change_iterator_t *i /**< */); +xcb_randr_output_change_next (xcb_randr_output_change_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3893,7 +4061,7 @@ xcb_randr_output_change_next (xcb_randr_output_change_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_randr_output_change_end (xcb_randr_output_change_iterator_t i /**< */); +xcb_randr_output_change_end (xcb_randr_output_change_iterator_t i); /** * Get the next element of the iterator @@ -3904,7 +4072,7 @@ xcb_randr_output_change_end (xcb_randr_output_change_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_randr_output_property_t) */ void -xcb_randr_output_property_next (xcb_randr_output_property_iterator_t *i /**< */); +xcb_randr_output_property_next (xcb_randr_output_property_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3916,7 +4084,7 @@ xcb_randr_output_property_next (xcb_randr_output_property_iterator_t *i /**< */ * last element. */ xcb_generic_iterator_t -xcb_randr_output_property_end (xcb_randr_output_property_iterator_t i /**< */); +xcb_randr_output_property_end (xcb_randr_output_property_iterator_t i); /** * Get the next element of the iterator @@ -3927,7 +4095,7 @@ xcb_randr_output_property_end (xcb_randr_output_property_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_randr_provider_change_t) */ void -xcb_randr_provider_change_next (xcb_randr_provider_change_iterator_t *i /**< */); +xcb_randr_provider_change_next (xcb_randr_provider_change_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3939,7 +4107,7 @@ xcb_randr_provider_change_next (xcb_randr_provider_change_iterator_t *i /**< */ * last element. */ xcb_generic_iterator_t -xcb_randr_provider_change_end (xcb_randr_provider_change_iterator_t i /**< */); +xcb_randr_provider_change_end (xcb_randr_provider_change_iterator_t i); /** * Get the next element of the iterator @@ -3950,7 +4118,7 @@ xcb_randr_provider_change_end (xcb_randr_provider_change_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_randr_provider_property_t) */ void -xcb_randr_provider_property_next (xcb_randr_provider_property_iterator_t *i /**< */); +xcb_randr_provider_property_next (xcb_randr_provider_property_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3962,7 +4130,7 @@ xcb_randr_provider_property_next (xcb_randr_provider_property_iterator_t *i /** * last element. */ xcb_generic_iterator_t -xcb_randr_provider_property_end (xcb_randr_provider_property_iterator_t i /**< */); +xcb_randr_provider_property_end (xcb_randr_provider_property_iterator_t i); /** * Get the next element of the iterator @@ -3973,7 +4141,7 @@ xcb_randr_provider_property_end (xcb_randr_provider_property_iterator_t i /**< * element. The member index is increased by sizeof(xcb_randr_resource_change_t) */ void -xcb_randr_resource_change_next (xcb_randr_resource_change_iterator_t *i /**< */); +xcb_randr_resource_change_next (xcb_randr_resource_change_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3985,7 +4153,7 @@ xcb_randr_resource_change_next (xcb_randr_resource_change_iterator_t *i /**< */ * last element. */ xcb_generic_iterator_t -xcb_randr_resource_change_end (xcb_randr_resource_change_iterator_t i /**< */); +xcb_randr_resource_change_end (xcb_randr_resource_change_iterator_t i); /** * Get the next element of the iterator @@ -3996,7 +4164,7 @@ xcb_randr_resource_change_end (xcb_randr_resource_change_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_randr_notify_data_t) */ void -xcb_randr_notify_data_next (xcb_randr_notify_data_iterator_t *i /**< */); +xcb_randr_notify_data_next (xcb_randr_notify_data_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4008,7 +4176,163 @@ xcb_randr_notify_data_next (xcb_randr_notify_data_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_randr_notify_data_end (xcb_randr_notify_data_iterator_t i /**< */); +xcb_randr_notify_data_end (xcb_randr_notify_data_iterator_t i); + +int +xcb_randr_monitor_info_sizeof (const void *_buffer); + +xcb_randr_output_t * +xcb_randr_monitor_info_outputs (const xcb_randr_monitor_info_t *R); + +int +xcb_randr_monitor_info_outputs_length (const xcb_randr_monitor_info_t *R); + +xcb_generic_iterator_t +xcb_randr_monitor_info_outputs_end (const xcb_randr_monitor_info_t *R); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_randr_monitor_info_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_randr_monitor_info_t) + */ +void +xcb_randr_monitor_info_next (xcb_randr_monitor_info_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_randr_monitor_info_iterator_t + * @return The iterator pointing to the last element + * + * 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_randr_monitor_info_end (xcb_randr_monitor_info_iterator_t i); + +int +xcb_randr_get_monitors_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_randr_get_monitors_cookie_t +xcb_randr_get_monitors (xcb_connection_t *c, + xcb_window_t window, + uint8_t get_active); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will cause + * a reply to be generated. Any returned error will be + * placed in the event queue. + */ +xcb_randr_get_monitors_cookie_t +xcb_randr_get_monitors_unchecked (xcb_connection_t *c, + xcb_window_t window, + uint8_t get_active); + +int +xcb_randr_get_monitors_monitors_length (const xcb_randr_get_monitors_reply_t *R); + +xcb_randr_monitor_info_iterator_t +xcb_randr_get_monitors_monitors_iterator (const xcb_randr_get_monitors_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 + * + * The parameter @p e supplied to this function must be NULL if + * xcb_randr_get_monitors_unchecked(). is used. + * Otherwise, it stores the error if any. + * + * The returned value must be freed by the caller using free(). + */ +xcb_randr_get_monitors_reply_t * +xcb_randr_get_monitors_reply (xcb_connection_t *c, + xcb_randr_get_monitors_cookie_t cookie /**< */, + xcb_generic_error_t **e); + +int +xcb_randr_set_monitor_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_randr_set_monitor_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_monitor_info_t *monitorinfo); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_randr_set_monitor (xcb_connection_t *c, + xcb_window_t window, + xcb_randr_monitor_info_t *monitorinfo); + +xcb_randr_monitor_info_t * +xcb_randr_set_monitor_monitorinfo (const xcb_randr_set_monitor_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_randr_delete_monitor_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t name); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_randr_delete_monitor (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t name); #ifdef __cplusplus diff --git a/lib/libxcb/src/record.c b/lib/libxcb/src/record.c index 040c87b61..8c934d57c 100644 --- a/lib/libxcb/src/record.c +++ b/lib/libxcb/src/record.c @@ -18,7 +18,7 @@ xcb_extension_t xcb_record_id = { "RECORD", 0 }; void -xcb_record_context_next (xcb_record_context_iterator_t *i /**< */) +xcb_record_context_next (xcb_record_context_iterator_t *i) { --i->rem; ++i->data; @@ -26,7 +26,7 @@ xcb_record_context_next (xcb_record_context_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_record_context_end (xcb_record_context_iterator_t i /**< */) +xcb_record_context_end (xcb_record_context_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -36,7 +36,7 @@ xcb_record_context_end (xcb_record_context_iterator_t i /**< */) } void -xcb_record_range_8_next (xcb_record_range_8_iterator_t *i /**< */) +xcb_record_range_8_next (xcb_record_range_8_iterator_t *i) { --i->rem; ++i->data; @@ -44,7 +44,7 @@ xcb_record_range_8_next (xcb_record_range_8_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_record_range_8_end (xcb_record_range_8_iterator_t i /**< */) +xcb_record_range_8_end (xcb_record_range_8_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -54,7 +54,7 @@ xcb_record_range_8_end (xcb_record_range_8_iterator_t i /**< */) } void -xcb_record_range_16_next (xcb_record_range_16_iterator_t *i /**< */) +xcb_record_range_16_next (xcb_record_range_16_iterator_t *i) { --i->rem; ++i->data; @@ -62,7 +62,7 @@ xcb_record_range_16_next (xcb_record_range_16_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_record_range_16_end (xcb_record_range_16_iterator_t i /**< */) +xcb_record_range_16_end (xcb_record_range_16_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -72,7 +72,7 @@ xcb_record_range_16_end (xcb_record_range_16_iterator_t i /**< */) } void -xcb_record_ext_range_next (xcb_record_ext_range_iterator_t *i /**< */) +xcb_record_ext_range_next (xcb_record_ext_range_iterator_t *i) { --i->rem; ++i->data; @@ -80,7 +80,7 @@ xcb_record_ext_range_next (xcb_record_ext_range_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_record_ext_range_end (xcb_record_ext_range_iterator_t i /**< */) +xcb_record_ext_range_end (xcb_record_ext_range_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -90,7 +90,7 @@ xcb_record_ext_range_end (xcb_record_ext_range_iterator_t i /**< */) } void -xcb_record_range_next (xcb_record_range_iterator_t *i /**< */) +xcb_record_range_next (xcb_record_range_iterator_t *i) { --i->rem; ++i->data; @@ -98,7 +98,7 @@ xcb_record_range_next (xcb_record_range_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_record_range_end (xcb_record_range_iterator_t i /**< */) +xcb_record_range_end (xcb_record_range_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -108,7 +108,7 @@ xcb_record_range_end (xcb_record_range_iterator_t i /**< */) } void -xcb_record_element_header_next (xcb_record_element_header_iterator_t *i /**< */) +xcb_record_element_header_next (xcb_record_element_header_iterator_t *i) { --i->rem; ++i->data; @@ -116,7 +116,7 @@ xcb_record_element_header_next (xcb_record_element_header_iterator_t *i /**< */ } xcb_generic_iterator_t -xcb_record_element_header_end (xcb_record_element_header_iterator_t i /**< */) +xcb_record_element_header_end (xcb_record_element_header_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -126,7 +126,7 @@ xcb_record_element_header_end (xcb_record_element_header_iterator_t i /**< */) } void -xcb_record_client_spec_next (xcb_record_client_spec_iterator_t *i /**< */) +xcb_record_client_spec_next (xcb_record_client_spec_iterator_t *i) { --i->rem; ++i->data; @@ -134,7 +134,7 @@ xcb_record_client_spec_next (xcb_record_client_spec_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_record_client_spec_end (xcb_record_client_spec_iterator_t i /**< */) +xcb_record_client_spec_end (xcb_record_client_spec_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -144,7 +144,7 @@ xcb_record_client_spec_end (xcb_record_client_spec_iterator_t i /**< */) } int -xcb_record_client_info_sizeof (const void *_buffer /**< */) +xcb_record_client_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_record_client_info_t *_aux = (xcb_record_client_info_t *)_buffer; @@ -175,19 +175,19 @@ xcb_record_client_info_sizeof (const void *_buffer /**< */) } xcb_record_range_t * -xcb_record_client_info_ranges (const xcb_record_client_info_t *R /**< */) +xcb_record_client_info_ranges (const xcb_record_client_info_t *R) { return (xcb_record_range_t *) (R + 1); } int -xcb_record_client_info_ranges_length (const xcb_record_client_info_t *R /**< */) +xcb_record_client_info_ranges_length (const xcb_record_client_info_t *R) { return R->num_ranges; } xcb_record_range_iterator_t -xcb_record_client_info_ranges_iterator (const xcb_record_client_info_t *R /**< */) +xcb_record_client_info_ranges_iterator (const xcb_record_client_info_t *R) { xcb_record_range_iterator_t i; i.data = (xcb_record_range_t *) (R + 1); @@ -197,7 +197,7 @@ xcb_record_client_info_ranges_iterator (const xcb_record_client_info_t *R /**< } void -xcb_record_client_info_next (xcb_record_client_info_iterator_t *i /**< */) +xcb_record_client_info_next (xcb_record_client_info_iterator_t *i) { xcb_record_client_info_t *R = i->data; xcb_generic_iterator_t child; @@ -208,7 +208,7 @@ xcb_record_client_info_next (xcb_record_client_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_record_client_info_end (xcb_record_client_info_iterator_t i /**< */) +xcb_record_client_info_end (xcb_record_client_info_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -220,15 +220,15 @@ xcb_record_client_info_end (xcb_record_client_info_iterator_t i /**< */) } xcb_record_query_version_cookie_t -xcb_record_query_version (xcb_connection_t *c /**< */, - uint16_t major_version /**< */, - uint16_t minor_version /**< */) +xcb_record_query_version (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -248,15 +248,15 @@ xcb_record_query_version (xcb_connection_t *c /**< */, } xcb_record_query_version_cookie_t -xcb_record_query_version_unchecked (xcb_connection_t *c /**< */, - uint16_t major_version /**< */, - uint16_t minor_version /**< */) +xcb_record_query_version_unchecked (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -276,15 +276,15 @@ xcb_record_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_record_query_version_reply_t * -xcb_record_query_version_reply (xcb_connection_t *c /**< */, +xcb_record_query_version_reply (xcb_connection_t *c, xcb_record_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_record_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_record_create_context_sizeof (const void *_buffer /**< */) +xcb_record_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_record_create_context_request_t *_aux = (xcb_record_create_context_request_t *)_buffer; @@ -327,19 +327,19 @@ xcb_record_create_context_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_record_create_context_checked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - xcb_record_element_header_t element_header /**< */, - uint32_t num_client_specs /**< */, - uint32_t num_ranges /**< */, - const xcb_record_client_spec_t *client_specs /**< */, - const xcb_record_range_t *ranges /**< */) +xcb_record_create_context_checked (xcb_connection_t *c, + xcb_record_context_t context, + xcb_record_element_header_t element_header, + uint32_t num_client_specs, + uint32_t num_ranges, + const xcb_record_client_spec_t *client_specs, + const xcb_record_range_t *ranges) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -372,19 +372,19 @@ xcb_record_create_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_record_create_context (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - xcb_record_element_header_t element_header /**< */, - uint32_t num_client_specs /**< */, - uint32_t num_ranges /**< */, - const xcb_record_client_spec_t *client_specs /**< */, - const xcb_record_range_t *ranges /**< */) +xcb_record_create_context (xcb_connection_t *c, + xcb_record_context_t context, + xcb_record_element_header_t element_header, + uint32_t num_client_specs, + uint32_t num_ranges, + const xcb_record_client_spec_t *client_specs, + const xcb_record_range_t *ranges) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -416,8 +416,54 @@ xcb_record_create_context (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_record_client_spec_t * +xcb_record_create_context_client_specs (const xcb_record_create_context_request_t *R) +{ + return (xcb_record_client_spec_t *) (R + 1); +} + int -xcb_record_register_clients_sizeof (const void *_buffer /**< */) +xcb_record_create_context_client_specs_length (const xcb_record_create_context_request_t *R) +{ + return R->num_client_specs; +} + +xcb_generic_iterator_t +xcb_record_create_context_client_specs_end (const xcb_record_create_context_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_record_client_spec_t *) (R + 1)) + (R->num_client_specs); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_record_range_t * +xcb_record_create_context_ranges (const xcb_record_create_context_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_record_create_context_client_specs_end(R); + return (xcb_record_range_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_record_range_t, prev.index) + 0); +} + +int +xcb_record_create_context_ranges_length (const xcb_record_create_context_request_t *R) +{ + return R->num_ranges; +} + +xcb_record_range_iterator_t +xcb_record_create_context_ranges_iterator (const xcb_record_create_context_request_t *R) +{ + xcb_record_range_iterator_t i; + xcb_generic_iterator_t prev = xcb_record_create_context_client_specs_end(R); + i.data = (xcb_record_range_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_record_range_t, prev.index)); + i.rem = R->num_ranges; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_record_register_clients_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_record_register_clients_request_t *_aux = (xcb_record_register_clients_request_t *)_buffer; @@ -460,19 +506,19 @@ xcb_record_register_clients_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_record_register_clients_checked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - xcb_record_element_header_t element_header /**< */, - uint32_t num_client_specs /**< */, - uint32_t num_ranges /**< */, - const xcb_record_client_spec_t *client_specs /**< */, - const xcb_record_range_t *ranges /**< */) +xcb_record_register_clients_checked (xcb_connection_t *c, + xcb_record_context_t context, + xcb_record_element_header_t element_header, + uint32_t num_client_specs, + uint32_t num_ranges, + const xcb_record_client_spec_t *client_specs, + const xcb_record_range_t *ranges) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_REGISTER_CLIENTS, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_REGISTER_CLIENTS, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -505,19 +551,19 @@ xcb_record_register_clients_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_record_register_clients (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - xcb_record_element_header_t element_header /**< */, - uint32_t num_client_specs /**< */, - uint32_t num_ranges /**< */, - const xcb_record_client_spec_t *client_specs /**< */, - const xcb_record_range_t *ranges /**< */) +xcb_record_register_clients (xcb_connection_t *c, + xcb_record_context_t context, + xcb_record_element_header_t element_header, + uint32_t num_client_specs, + uint32_t num_ranges, + const xcb_record_client_spec_t *client_specs, + const xcb_record_range_t *ranges) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_REGISTER_CLIENTS, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_REGISTER_CLIENTS, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -549,8 +595,54 @@ xcb_record_register_clients (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_record_client_spec_t * +xcb_record_register_clients_client_specs (const xcb_record_register_clients_request_t *R) +{ + return (xcb_record_client_spec_t *) (R + 1); +} + int -xcb_record_unregister_clients_sizeof (const void *_buffer /**< */) +xcb_record_register_clients_client_specs_length (const xcb_record_register_clients_request_t *R) +{ + return R->num_client_specs; +} + +xcb_generic_iterator_t +xcb_record_register_clients_client_specs_end (const xcb_record_register_clients_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_record_client_spec_t *) (R + 1)) + (R->num_client_specs); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_record_range_t * +xcb_record_register_clients_ranges (const xcb_record_register_clients_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_record_register_clients_client_specs_end(R); + return (xcb_record_range_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_record_range_t, prev.index) + 0); +} + +int +xcb_record_register_clients_ranges_length (const xcb_record_register_clients_request_t *R) +{ + return R->num_ranges; +} + +xcb_record_range_iterator_t +xcb_record_register_clients_ranges_iterator (const xcb_record_register_clients_request_t *R) +{ + xcb_record_range_iterator_t i; + xcb_generic_iterator_t prev = xcb_record_register_clients_client_specs_end(R); + i.data = (xcb_record_range_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_record_range_t, prev.index)); + i.rem = R->num_ranges; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_record_unregister_clients_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_record_unregister_clients_request_t *_aux = (xcb_record_unregister_clients_request_t *)_buffer; @@ -581,16 +673,16 @@ xcb_record_unregister_clients_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_record_unregister_clients_checked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - uint32_t num_client_specs /**< */, - const xcb_record_client_spec_t *client_specs /**< */) +xcb_record_unregister_clients_checked (xcb_connection_t *c, + xcb_record_context_t context, + uint32_t num_client_specs, + const xcb_record_client_spec_t *client_specs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_UNREGISTER_CLIENTS, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_UNREGISTER_CLIENTS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -615,16 +707,16 @@ xcb_record_unregister_clients_checked (xcb_connection_t *c /**< * } xcb_void_cookie_t -xcb_record_unregister_clients (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - uint32_t num_client_specs /**< */, - const xcb_record_client_spec_t *client_specs /**< */) +xcb_record_unregister_clients (xcb_connection_t *c, + xcb_record_context_t context, + uint32_t num_client_specs, + const xcb_record_client_spec_t *client_specs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_UNREGISTER_CLIENTS, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_UNREGISTER_CLIENTS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -648,8 +740,30 @@ xcb_record_unregister_clients (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_record_client_spec_t * +xcb_record_unregister_clients_client_specs (const xcb_record_unregister_clients_request_t *R) +{ + return (xcb_record_client_spec_t *) (R + 1); +} + int -xcb_record_get_context_sizeof (const void *_buffer /**< */) +xcb_record_unregister_clients_client_specs_length (const xcb_record_unregister_clients_request_t *R) +{ + return R->num_client_specs; +} + +xcb_generic_iterator_t +xcb_record_unregister_clients_client_specs_end (const xcb_record_unregister_clients_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_record_client_spec_t *) (R + 1)) + (R->num_client_specs); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_record_get_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_record_get_context_reply_t *_aux = (xcb_record_get_context_reply_t *)_buffer; @@ -685,14 +799,14 @@ xcb_record_get_context_sizeof (const void *_buffer /**< */) } xcb_record_get_context_cookie_t -xcb_record_get_context (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */) +xcb_record_get_context (xcb_connection_t *c, + xcb_record_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_GET_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_GET_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -711,14 +825,14 @@ xcb_record_get_context (xcb_connection_t *c /**< */, } xcb_record_get_context_cookie_t -xcb_record_get_context_unchecked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */) +xcb_record_get_context_unchecked (xcb_connection_t *c, + xcb_record_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_GET_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_GET_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -737,13 +851,13 @@ xcb_record_get_context_unchecked (xcb_connection_t *c /**< */, } int -xcb_record_get_context_intercepted_clients_length (const xcb_record_get_context_reply_t *R /**< */) +xcb_record_get_context_intercepted_clients_length (const xcb_record_get_context_reply_t *R) { return R->num_intercepted_clients; } xcb_record_client_info_iterator_t -xcb_record_get_context_intercepted_clients_iterator (const xcb_record_get_context_reply_t *R /**< */) +xcb_record_get_context_intercepted_clients_iterator (const xcb_record_get_context_reply_t *R) { xcb_record_client_info_iterator_t i; i.data = (xcb_record_client_info_t *) (R + 1); @@ -753,15 +867,15 @@ xcb_record_get_context_intercepted_clients_iterator (const xcb_record_get_contex } xcb_record_get_context_reply_t * -xcb_record_get_context_reply (xcb_connection_t *c /**< */, +xcb_record_get_context_reply (xcb_connection_t *c, xcb_record_get_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_record_get_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_record_enable_context_sizeof (const void *_buffer /**< */) +xcb_record_enable_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_record_enable_context_reply_t *_aux = (xcb_record_enable_context_reply_t *)_buffer; @@ -792,14 +906,14 @@ xcb_record_enable_context_sizeof (const void *_buffer /**< */) } xcb_record_enable_context_cookie_t -xcb_record_enable_context (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */) +xcb_record_enable_context (xcb_connection_t *c, + xcb_record_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_ENABLE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_ENABLE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -818,14 +932,14 @@ xcb_record_enable_context (xcb_connection_t *c /**< */, } xcb_record_enable_context_cookie_t -xcb_record_enable_context_unchecked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */) +xcb_record_enable_context_unchecked (xcb_connection_t *c, + xcb_record_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_ENABLE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_ENABLE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -844,19 +958,19 @@ xcb_record_enable_context_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_record_enable_context_data (const xcb_record_enable_context_reply_t *R /**< */) +xcb_record_enable_context_data (const xcb_record_enable_context_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_record_enable_context_data_length (const xcb_record_enable_context_reply_t *R /**< */) +xcb_record_enable_context_data_length (const xcb_record_enable_context_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_record_enable_context_data_end (const xcb_record_enable_context_reply_t *R /**< */) +xcb_record_enable_context_data_end (const xcb_record_enable_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -866,22 +980,22 @@ xcb_record_enable_context_data_end (const xcb_record_enable_context_reply_t *R } xcb_record_enable_context_reply_t * -xcb_record_enable_context_reply (xcb_connection_t *c /**< */, +xcb_record_enable_context_reply (xcb_connection_t *c, xcb_record_enable_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_record_enable_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_record_disable_context_checked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */) +xcb_record_disable_context_checked (xcb_connection_t *c, + xcb_record_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_DISABLE_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_DISABLE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -900,14 +1014,14 @@ xcb_record_disable_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_record_disable_context (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */) +xcb_record_disable_context (xcb_connection_t *c, + xcb_record_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_DISABLE_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_DISABLE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -926,14 +1040,14 @@ xcb_record_disable_context (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_record_free_context_checked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */) +xcb_record_free_context_checked (xcb_connection_t *c, + xcb_record_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_FREE_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_FREE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -952,14 +1066,14 @@ xcb_record_free_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_record_free_context (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */) +xcb_record_free_context (xcb_connection_t *c, + xcb_record_context_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_record_id, - /* opcode */ XCB_RECORD_FREE_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_record_id, + .opcode = XCB_RECORD_FREE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; diff --git a/lib/libxcb/src/record.h b/lib/libxcb/src/record.h index 171e60e42..34c41c17e 100644 --- a/lib/libxcb/src/record.h +++ b/lib/libxcb/src/record.h @@ -29,84 +29,84 @@ typedef uint32_t xcb_record_context_t; * @brief xcb_record_context_iterator_t **/ typedef struct xcb_record_context_iterator_t { - xcb_record_context_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_record_context_t *data; + int rem; + int index; } xcb_record_context_iterator_t; /** * @brief xcb_record_range_8_t **/ typedef struct xcb_record_range_8_t { - uint8_t first; /**< */ - uint8_t last; /**< */ + uint8_t first; + uint8_t last; } xcb_record_range_8_t; /** * @brief xcb_record_range_8_iterator_t **/ typedef struct xcb_record_range_8_iterator_t { - xcb_record_range_8_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_record_range_8_t *data; + int rem; + int index; } xcb_record_range_8_iterator_t; /** * @brief xcb_record_range_16_t **/ typedef struct xcb_record_range_16_t { - uint16_t first; /**< */ - uint16_t last; /**< */ + uint16_t first; + uint16_t last; } xcb_record_range_16_t; /** * @brief xcb_record_range_16_iterator_t **/ typedef struct xcb_record_range_16_iterator_t { - xcb_record_range_16_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_record_range_16_t *data; + int rem; + int index; } xcb_record_range_16_iterator_t; /** * @brief xcb_record_ext_range_t **/ typedef struct xcb_record_ext_range_t { - xcb_record_range_8_t major; /**< */ - xcb_record_range_16_t minor; /**< */ + xcb_record_range_8_t major; + xcb_record_range_16_t minor; } xcb_record_ext_range_t; /** * @brief xcb_record_ext_range_iterator_t **/ typedef struct xcb_record_ext_range_iterator_t { - xcb_record_ext_range_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_record_ext_range_t *data; + int rem; + int index; } xcb_record_ext_range_iterator_t; /** * @brief xcb_record_range_t **/ typedef struct xcb_record_range_t { - xcb_record_range_8_t core_requests; /**< */ - xcb_record_range_8_t core_replies; /**< */ - xcb_record_ext_range_t ext_requests; /**< */ - xcb_record_ext_range_t ext_replies; /**< */ - xcb_record_range_8_t delivered_events; /**< */ - xcb_record_range_8_t device_events; /**< */ - xcb_record_range_8_t errors; /**< */ - uint8_t client_started; /**< */ - uint8_t client_died; /**< */ + xcb_record_range_8_t core_requests; + xcb_record_range_8_t core_replies; + xcb_record_ext_range_t ext_requests; + xcb_record_ext_range_t ext_replies; + xcb_record_range_8_t delivered_events; + xcb_record_range_8_t device_events; + xcb_record_range_8_t errors; + uint8_t client_started; + uint8_t client_died; } xcb_record_range_t; /** * @brief xcb_record_range_iterator_t **/ typedef struct xcb_record_range_iterator_t { - xcb_record_range_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_record_range_t *data; + int rem; + int index; } xcb_record_range_iterator_t; typedef uint8_t xcb_record_element_header_t; @@ -115,9 +115,9 @@ typedef uint8_t xcb_record_element_header_t; * @brief xcb_record_element_header_iterator_t **/ typedef struct xcb_record_element_header_iterator_t { - xcb_record_element_header_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_record_element_header_t *data; + int rem; + int index; } xcb_record_element_header_iterator_t; typedef enum xcb_record_h_type_t { @@ -132,9 +132,9 @@ typedef uint32_t xcb_record_client_spec_t; * @brief xcb_record_client_spec_iterator_t **/ typedef struct xcb_record_client_spec_iterator_t { - xcb_record_client_spec_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_record_client_spec_t *data; + int rem; + int index; } xcb_record_client_spec_iterator_t; typedef enum xcb_record_cs_t { @@ -147,17 +147,17 @@ typedef enum xcb_record_cs_t { * @brief xcb_record_client_info_t **/ typedef struct xcb_record_client_info_t { - xcb_record_client_spec_t client_resource; /**< */ - uint32_t num_ranges; /**< */ + xcb_record_client_spec_t client_resource; + uint32_t num_ranges; } xcb_record_client_info_t; /** * @brief xcb_record_client_info_iterator_t **/ typedef struct xcb_record_client_info_iterator_t { - xcb_record_client_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_record_client_info_t *data; + int rem; + int index; } xcb_record_client_info_iterator_t; /** Opcode for xcb_record_bad_context. */ @@ -167,17 +167,17 @@ typedef struct xcb_record_client_info_iterator_t { * @brief xcb_record_bad_context_error_t **/ typedef struct xcb_record_bad_context_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ - uint32_t invalid_record; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; + uint32_t invalid_record; } xcb_record_bad_context_error_t; /** * @brief xcb_record_query_version_cookie_t **/ typedef struct xcb_record_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_record_query_version_cookie_t; /** Opcode for xcb_record_query_version. */ @@ -187,23 +187,23 @@ typedef struct xcb_record_query_version_cookie_t { * @brief xcb_record_query_version_request_t **/ typedef struct xcb_record_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t major_version; /**< */ - uint16_t minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t major_version; + uint16_t minor_version; } xcb_record_query_version_request_t; /** * @brief xcb_record_query_version_reply_t **/ typedef struct xcb_record_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t major_version; /**< */ - uint16_t minor_version; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t major_version; + uint16_t minor_version; } xcb_record_query_version_reply_t; /** Opcode for xcb_record_create_context. */ @@ -213,14 +213,14 @@ typedef struct xcb_record_query_version_reply_t { * @brief xcb_record_create_context_request_t **/ typedef struct xcb_record_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_record_context_t context; /**< */ - xcb_record_element_header_t element_header; /**< */ - uint8_t pad0[3]; /**< */ - uint32_t num_client_specs; /**< */ - uint32_t num_ranges; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_record_context_t context; + xcb_record_element_header_t element_header; + uint8_t pad0[3]; + uint32_t num_client_specs; + uint32_t num_ranges; } xcb_record_create_context_request_t; /** Opcode for xcb_record_register_clients. */ @@ -230,14 +230,14 @@ typedef struct xcb_record_create_context_request_t { * @brief xcb_record_register_clients_request_t **/ typedef struct xcb_record_register_clients_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_record_context_t context; /**< */ - xcb_record_element_header_t element_header; /**< */ - uint8_t pad0[3]; /**< */ - uint32_t num_client_specs; /**< */ - uint32_t num_ranges; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_record_context_t context; + xcb_record_element_header_t element_header; + uint8_t pad0[3]; + uint32_t num_client_specs; + uint32_t num_ranges; } xcb_record_register_clients_request_t; /** Opcode for xcb_record_unregister_clients. */ @@ -247,18 +247,18 @@ typedef struct xcb_record_register_clients_request_t { * @brief xcb_record_unregister_clients_request_t **/ typedef struct xcb_record_unregister_clients_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_record_context_t context; /**< */ - uint32_t num_client_specs; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_record_context_t context; + uint32_t num_client_specs; } xcb_record_unregister_clients_request_t; /** * @brief xcb_record_get_context_cookie_t **/ typedef struct xcb_record_get_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_record_get_context_cookie_t; /** Opcode for xcb_record_get_context. */ @@ -268,31 +268,31 @@ typedef struct xcb_record_get_context_cookie_t { * @brief xcb_record_get_context_request_t **/ typedef struct xcb_record_get_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_record_context_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_record_context_t context; } xcb_record_get_context_request_t; /** * @brief xcb_record_get_context_reply_t **/ typedef struct xcb_record_get_context_reply_t { - uint8_t response_type; /**< */ - uint8_t enabled; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_record_element_header_t element_header; /**< */ - uint8_t pad0[3]; /**< */ - uint32_t num_intercepted_clients; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t enabled; + uint16_t sequence; + uint32_t length; + xcb_record_element_header_t element_header; + uint8_t pad0[3]; + uint32_t num_intercepted_clients; + uint8_t pad1[16]; } xcb_record_get_context_reply_t; /** * @brief xcb_record_enable_context_cookie_t **/ typedef struct xcb_record_enable_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_record_enable_context_cookie_t; /** Opcode for xcb_record_enable_context. */ @@ -302,27 +302,27 @@ typedef struct xcb_record_enable_context_cookie_t { * @brief xcb_record_enable_context_request_t **/ typedef struct xcb_record_enable_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_record_context_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_record_context_t context; } xcb_record_enable_context_request_t; /** * @brief xcb_record_enable_context_reply_t **/ typedef struct xcb_record_enable_context_reply_t { - uint8_t response_type; /**< */ - uint8_t category; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_record_element_header_t element_header; /**< */ - uint8_t client_swapped; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t xid_base; /**< */ - uint32_t server_time; /**< */ - uint32_t rec_sequence_num; /**< */ - uint8_t pad1[8]; /**< */ + uint8_t response_type; + uint8_t category; + uint16_t sequence; + uint32_t length; + xcb_record_element_header_t element_header; + uint8_t client_swapped; + uint8_t pad0[2]; + uint32_t xid_base; + uint32_t server_time; + uint32_t rec_sequence_num; + uint8_t pad1[8]; } xcb_record_enable_context_reply_t; /** Opcode for xcb_record_disable_context. */ @@ -332,10 +332,10 @@ typedef struct xcb_record_enable_context_reply_t { * @brief xcb_record_disable_context_request_t **/ typedef struct xcb_record_disable_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_record_context_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_record_context_t context; } xcb_record_disable_context_request_t; /** Opcode for xcb_record_free_context. */ @@ -345,10 +345,10 @@ typedef struct xcb_record_disable_context_request_t { * @brief xcb_record_free_context_request_t **/ typedef struct xcb_record_free_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_record_context_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_record_context_t context; } xcb_record_free_context_request_t; /** @@ -360,7 +360,7 @@ typedef struct xcb_record_free_context_request_t { * element. The member index is increased by sizeof(xcb_record_context_t) */ void -xcb_record_context_next (xcb_record_context_iterator_t *i /**< */); +xcb_record_context_next (xcb_record_context_iterator_t *i); /** * Return the iterator pointing to the last element @@ -372,7 +372,7 @@ xcb_record_context_next (xcb_record_context_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_record_context_end (xcb_record_context_iterator_t i /**< */); +xcb_record_context_end (xcb_record_context_iterator_t i); /** * Get the next element of the iterator @@ -383,7 +383,7 @@ xcb_record_context_end (xcb_record_context_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_record_range_8_t) */ void -xcb_record_range_8_next (xcb_record_range_8_iterator_t *i /**< */); +xcb_record_range_8_next (xcb_record_range_8_iterator_t *i); /** * Return the iterator pointing to the last element @@ -395,7 +395,7 @@ xcb_record_range_8_next (xcb_record_range_8_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_record_range_8_end (xcb_record_range_8_iterator_t i /**< */); +xcb_record_range_8_end (xcb_record_range_8_iterator_t i); /** * Get the next element of the iterator @@ -406,7 +406,7 @@ xcb_record_range_8_end (xcb_record_range_8_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_record_range_16_t) */ void -xcb_record_range_16_next (xcb_record_range_16_iterator_t *i /**< */); +xcb_record_range_16_next (xcb_record_range_16_iterator_t *i); /** * Return the iterator pointing to the last element @@ -418,7 +418,7 @@ xcb_record_range_16_next (xcb_record_range_16_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_record_range_16_end (xcb_record_range_16_iterator_t i /**< */); +xcb_record_range_16_end (xcb_record_range_16_iterator_t i); /** * Get the next element of the iterator @@ -429,7 +429,7 @@ xcb_record_range_16_end (xcb_record_range_16_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_record_ext_range_t) */ void -xcb_record_ext_range_next (xcb_record_ext_range_iterator_t *i /**< */); +xcb_record_ext_range_next (xcb_record_ext_range_iterator_t *i); /** * Return the iterator pointing to the last element @@ -441,7 +441,7 @@ xcb_record_ext_range_next (xcb_record_ext_range_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_record_ext_range_end (xcb_record_ext_range_iterator_t i /**< */); +xcb_record_ext_range_end (xcb_record_ext_range_iterator_t i); /** * Get the next element of the iterator @@ -452,7 +452,7 @@ xcb_record_ext_range_end (xcb_record_ext_range_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_record_range_t) */ void -xcb_record_range_next (xcb_record_range_iterator_t *i /**< */); +xcb_record_range_next (xcb_record_range_iterator_t *i); /** * Return the iterator pointing to the last element @@ -464,7 +464,7 @@ xcb_record_range_next (xcb_record_range_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_record_range_end (xcb_record_range_iterator_t i /**< */); +xcb_record_range_end (xcb_record_range_iterator_t i); /** * Get the next element of the iterator @@ -475,7 +475,7 @@ xcb_record_range_end (xcb_record_range_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_record_element_header_t) */ void -xcb_record_element_header_next (xcb_record_element_header_iterator_t *i /**< */); +xcb_record_element_header_next (xcb_record_element_header_iterator_t *i); /** * Return the iterator pointing to the last element @@ -487,7 +487,7 @@ xcb_record_element_header_next (xcb_record_element_header_iterator_t *i /**< */ * last element. */ xcb_generic_iterator_t -xcb_record_element_header_end (xcb_record_element_header_iterator_t i /**< */); +xcb_record_element_header_end (xcb_record_element_header_iterator_t i); /** * Get the next element of the iterator @@ -498,7 +498,7 @@ xcb_record_element_header_end (xcb_record_element_header_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_record_client_spec_t) */ void -xcb_record_client_spec_next (xcb_record_client_spec_iterator_t *i /**< */); +xcb_record_client_spec_next (xcb_record_client_spec_iterator_t *i); /** * Return the iterator pointing to the last element @@ -510,19 +510,19 @@ xcb_record_client_spec_next (xcb_record_client_spec_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_record_client_spec_end (xcb_record_client_spec_iterator_t i /**< */); +xcb_record_client_spec_end (xcb_record_client_spec_iterator_t i); int -xcb_record_client_info_sizeof (const void *_buffer /**< */); +xcb_record_client_info_sizeof (const void *_buffer); xcb_record_range_t * -xcb_record_client_info_ranges (const xcb_record_client_info_t *R /**< */); +xcb_record_client_info_ranges (const xcb_record_client_info_t *R); int -xcb_record_client_info_ranges_length (const xcb_record_client_info_t *R /**< */); +xcb_record_client_info_ranges_length (const xcb_record_client_info_t *R); xcb_record_range_iterator_t -xcb_record_client_info_ranges_iterator (const xcb_record_client_info_t *R /**< */); +xcb_record_client_info_ranges_iterator (const xcb_record_client_info_t *R); /** * Get the next element of the iterator @@ -533,7 +533,7 @@ xcb_record_client_info_ranges_iterator (const xcb_record_client_info_t *R /**< * element. The member index is increased by sizeof(xcb_record_client_info_t) */ void -xcb_record_client_info_next (xcb_record_client_info_iterator_t *i /**< */); +xcb_record_client_info_next (xcb_record_client_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -545,7 +545,7 @@ xcb_record_client_info_next (xcb_record_client_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_record_client_info_end (xcb_record_client_info_iterator_t i /**< */); +xcb_record_client_info_end (xcb_record_client_info_iterator_t i); /** * @@ -556,9 +556,9 @@ xcb_record_client_info_end (xcb_record_client_info_iterator_t i /**< */); * */ xcb_record_query_version_cookie_t -xcb_record_query_version (xcb_connection_t *c /**< */, - uint16_t major_version /**< */, - uint16_t minor_version /**< */); +xcb_record_query_version (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version); /** * @@ -572,9 +572,9 @@ xcb_record_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_record_query_version_cookie_t -xcb_record_query_version_unchecked (xcb_connection_t *c /**< */, - uint16_t major_version /**< */, - uint16_t minor_version /**< */); +xcb_record_query_version_unchecked (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version); /** * Return the reply @@ -591,12 +591,12 @@ xcb_record_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_record_query_version_reply_t * -xcb_record_query_version_reply (xcb_connection_t *c /**< */, +xcb_record_query_version_reply (xcb_connection_t *c, xcb_record_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_record_create_context_sizeof (const void *_buffer /**< */); +xcb_record_create_context_sizeof (const void *_buffer); /** * @@ -610,13 +610,13 @@ xcb_record_create_context_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_record_create_context_checked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - xcb_record_element_header_t element_header /**< */, - uint32_t num_client_specs /**< */, - uint32_t num_ranges /**< */, - const xcb_record_client_spec_t *client_specs /**< */, - const xcb_record_range_t *ranges /**< */); +xcb_record_create_context_checked (xcb_connection_t *c, + xcb_record_context_t context, + xcb_record_element_header_t element_header, + uint32_t num_client_specs, + uint32_t num_ranges, + const xcb_record_client_spec_t *client_specs, + const xcb_record_range_t *ranges); /** * @@ -627,16 +627,34 @@ xcb_record_create_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_record_create_context (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - xcb_record_element_header_t element_header /**< */, - uint32_t num_client_specs /**< */, - uint32_t num_ranges /**< */, - const xcb_record_client_spec_t *client_specs /**< */, - const xcb_record_range_t *ranges /**< */); +xcb_record_create_context (xcb_connection_t *c, + xcb_record_context_t context, + xcb_record_element_header_t element_header, + uint32_t num_client_specs, + uint32_t num_ranges, + const xcb_record_client_spec_t *client_specs, + const xcb_record_range_t *ranges); + +xcb_record_client_spec_t * +xcb_record_create_context_client_specs (const xcb_record_create_context_request_t *R); int -xcb_record_register_clients_sizeof (const void *_buffer /**< */); +xcb_record_create_context_client_specs_length (const xcb_record_create_context_request_t *R); + +xcb_generic_iterator_t +xcb_record_create_context_client_specs_end (const xcb_record_create_context_request_t *R); + +xcb_record_range_t * +xcb_record_create_context_ranges (const xcb_record_create_context_request_t *R); + +int +xcb_record_create_context_ranges_length (const xcb_record_create_context_request_t *R); + +xcb_record_range_iterator_t +xcb_record_create_context_ranges_iterator (const xcb_record_create_context_request_t *R); + +int +xcb_record_register_clients_sizeof (const void *_buffer); /** * @@ -650,13 +668,13 @@ xcb_record_register_clients_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_record_register_clients_checked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - xcb_record_element_header_t element_header /**< */, - uint32_t num_client_specs /**< */, - uint32_t num_ranges /**< */, - const xcb_record_client_spec_t *client_specs /**< */, - const xcb_record_range_t *ranges /**< */); +xcb_record_register_clients_checked (xcb_connection_t *c, + xcb_record_context_t context, + xcb_record_element_header_t element_header, + uint32_t num_client_specs, + uint32_t num_ranges, + const xcb_record_client_spec_t *client_specs, + const xcb_record_range_t *ranges); /** * @@ -667,16 +685,34 @@ xcb_record_register_clients_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_record_register_clients (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - xcb_record_element_header_t element_header /**< */, - uint32_t num_client_specs /**< */, - uint32_t num_ranges /**< */, - const xcb_record_client_spec_t *client_specs /**< */, - const xcb_record_range_t *ranges /**< */); +xcb_record_register_clients (xcb_connection_t *c, + xcb_record_context_t context, + xcb_record_element_header_t element_header, + uint32_t num_client_specs, + uint32_t num_ranges, + const xcb_record_client_spec_t *client_specs, + const xcb_record_range_t *ranges); + +xcb_record_client_spec_t * +xcb_record_register_clients_client_specs (const xcb_record_register_clients_request_t *R); int -xcb_record_unregister_clients_sizeof (const void *_buffer /**< */); +xcb_record_register_clients_client_specs_length (const xcb_record_register_clients_request_t *R); + +xcb_generic_iterator_t +xcb_record_register_clients_client_specs_end (const xcb_record_register_clients_request_t *R); + +xcb_record_range_t * +xcb_record_register_clients_ranges (const xcb_record_register_clients_request_t *R); + +int +xcb_record_register_clients_ranges_length (const xcb_record_register_clients_request_t *R); + +xcb_record_range_iterator_t +xcb_record_register_clients_ranges_iterator (const xcb_record_register_clients_request_t *R); + +int +xcb_record_unregister_clients_sizeof (const void *_buffer); /** * @@ -690,10 +726,10 @@ xcb_record_unregister_clients_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_record_unregister_clients_checked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - uint32_t num_client_specs /**< */, - const xcb_record_client_spec_t *client_specs /**< */); +xcb_record_unregister_clients_checked (xcb_connection_t *c, + xcb_record_context_t context, + uint32_t num_client_specs, + const xcb_record_client_spec_t *client_specs); /** * @@ -704,13 +740,22 @@ xcb_record_unregister_clients_checked (xcb_connection_t *c /**< * * */ xcb_void_cookie_t -xcb_record_unregister_clients (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */, - uint32_t num_client_specs /**< */, - const xcb_record_client_spec_t *client_specs /**< */); +xcb_record_unregister_clients (xcb_connection_t *c, + xcb_record_context_t context, + uint32_t num_client_specs, + const xcb_record_client_spec_t *client_specs); + +xcb_record_client_spec_t * +xcb_record_unregister_clients_client_specs (const xcb_record_unregister_clients_request_t *R); int -xcb_record_get_context_sizeof (const void *_buffer /**< */); +xcb_record_unregister_clients_client_specs_length (const xcb_record_unregister_clients_request_t *R); + +xcb_generic_iterator_t +xcb_record_unregister_clients_client_specs_end (const xcb_record_unregister_clients_request_t *R); + +int +xcb_record_get_context_sizeof (const void *_buffer); /** * @@ -721,8 +766,8 @@ xcb_record_get_context_sizeof (const void *_buffer /**< */); * */ xcb_record_get_context_cookie_t -xcb_record_get_context (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */); +xcb_record_get_context (xcb_connection_t *c, + xcb_record_context_t context); /** * @@ -736,14 +781,14 @@ xcb_record_get_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_record_get_context_cookie_t -xcb_record_get_context_unchecked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */); +xcb_record_get_context_unchecked (xcb_connection_t *c, + xcb_record_context_t context); int -xcb_record_get_context_intercepted_clients_length (const xcb_record_get_context_reply_t *R /**< */); +xcb_record_get_context_intercepted_clients_length (const xcb_record_get_context_reply_t *R); xcb_record_client_info_iterator_t -xcb_record_get_context_intercepted_clients_iterator (const xcb_record_get_context_reply_t *R /**< */); +xcb_record_get_context_intercepted_clients_iterator (const xcb_record_get_context_reply_t *R); /** * Return the reply @@ -760,12 +805,12 @@ xcb_record_get_context_intercepted_clients_iterator (const xcb_record_get_contex * The returned value must be freed by the caller using free(). */ xcb_record_get_context_reply_t * -xcb_record_get_context_reply (xcb_connection_t *c /**< */, +xcb_record_get_context_reply (xcb_connection_t *c, xcb_record_get_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_record_enable_context_sizeof (const void *_buffer /**< */); +xcb_record_enable_context_sizeof (const void *_buffer); /** * @@ -776,8 +821,8 @@ xcb_record_enable_context_sizeof (const void *_buffer /**< */); * */ xcb_record_enable_context_cookie_t -xcb_record_enable_context (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */); +xcb_record_enable_context (xcb_connection_t *c, + xcb_record_context_t context); /** * @@ -791,17 +836,17 @@ xcb_record_enable_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_record_enable_context_cookie_t -xcb_record_enable_context_unchecked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */); +xcb_record_enable_context_unchecked (xcb_connection_t *c, + xcb_record_context_t context); uint8_t * -xcb_record_enable_context_data (const xcb_record_enable_context_reply_t *R /**< */); +xcb_record_enable_context_data (const xcb_record_enable_context_reply_t *R); int -xcb_record_enable_context_data_length (const xcb_record_enable_context_reply_t *R /**< */); +xcb_record_enable_context_data_length (const xcb_record_enable_context_reply_t *R); xcb_generic_iterator_t -xcb_record_enable_context_data_end (const xcb_record_enable_context_reply_t *R /**< */); +xcb_record_enable_context_data_end (const xcb_record_enable_context_reply_t *R); /** * Return the reply @@ -818,9 +863,9 @@ xcb_record_enable_context_data_end (const xcb_record_enable_context_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_record_enable_context_reply_t * -xcb_record_enable_context_reply (xcb_connection_t *c /**< */, +xcb_record_enable_context_reply (xcb_connection_t *c, xcb_record_enable_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -834,8 +879,8 @@ xcb_record_enable_context_reply (xcb_connection_t *c /**< */ * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_record_disable_context_checked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */); +xcb_record_disable_context_checked (xcb_connection_t *c, + xcb_record_context_t context); /** * @@ -846,8 +891,8 @@ xcb_record_disable_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_record_disable_context (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */); +xcb_record_disable_context (xcb_connection_t *c, + xcb_record_context_t context); /** * @@ -861,8 +906,8 @@ xcb_record_disable_context (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_record_free_context_checked (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */); +xcb_record_free_context_checked (xcb_connection_t *c, + xcb_record_context_t context); /** * @@ -873,8 +918,8 @@ xcb_record_free_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_record_free_context (xcb_connection_t *c /**< */, - xcb_record_context_t context /**< */); +xcb_record_free_context (xcb_connection_t *c, + xcb_record_context_t context); #ifdef __cplusplus diff --git a/lib/libxcb/src/render.c b/lib/libxcb/src/render.c index 5ac468ce2..1f0d7fee8 100644 --- a/lib/libxcb/src/render.c +++ b/lib/libxcb/src/render.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_render_id = { "RENDER", 0 }; void -xcb_render_glyph_next (xcb_render_glyph_iterator_t *i /**< */) +xcb_render_glyph_next (xcb_render_glyph_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_render_glyph_next (xcb_render_glyph_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_glyph_end (xcb_render_glyph_iterator_t i /**< */) +xcb_render_glyph_end (xcb_render_glyph_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,7 +37,7 @@ xcb_render_glyph_end (xcb_render_glyph_iterator_t i /**< */) } void -xcb_render_glyphset_next (xcb_render_glyphset_iterator_t *i /**< */) +xcb_render_glyphset_next (xcb_render_glyphset_iterator_t *i) { --i->rem; ++i->data; @@ -45,7 +45,7 @@ xcb_render_glyphset_next (xcb_render_glyphset_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_glyphset_end (xcb_render_glyphset_iterator_t i /**< */) +xcb_render_glyphset_end (xcb_render_glyphset_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -55,7 +55,7 @@ xcb_render_glyphset_end (xcb_render_glyphset_iterator_t i /**< */) } void -xcb_render_picture_next (xcb_render_picture_iterator_t *i /**< */) +xcb_render_picture_next (xcb_render_picture_iterator_t *i) { --i->rem; ++i->data; @@ -63,7 +63,7 @@ xcb_render_picture_next (xcb_render_picture_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_picture_end (xcb_render_picture_iterator_t i /**< */) +xcb_render_picture_end (xcb_render_picture_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -73,7 +73,7 @@ xcb_render_picture_end (xcb_render_picture_iterator_t i /**< */) } void -xcb_render_pictformat_next (xcb_render_pictformat_iterator_t *i /**< */) +xcb_render_pictformat_next (xcb_render_pictformat_iterator_t *i) { --i->rem; ++i->data; @@ -81,7 +81,7 @@ xcb_render_pictformat_next (xcb_render_pictformat_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_pictformat_end (xcb_render_pictformat_iterator_t i /**< */) +xcb_render_pictformat_end (xcb_render_pictformat_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -91,7 +91,7 @@ xcb_render_pictformat_end (xcb_render_pictformat_iterator_t i /**< */) } void -xcb_render_fixed_next (xcb_render_fixed_iterator_t *i /**< */) +xcb_render_fixed_next (xcb_render_fixed_iterator_t *i) { --i->rem; ++i->data; @@ -99,7 +99,7 @@ xcb_render_fixed_next (xcb_render_fixed_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_fixed_end (xcb_render_fixed_iterator_t i /**< */) +xcb_render_fixed_end (xcb_render_fixed_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -109,7 +109,7 @@ xcb_render_fixed_end (xcb_render_fixed_iterator_t i /**< */) } void -xcb_render_directformat_next (xcb_render_directformat_iterator_t *i /**< */) +xcb_render_directformat_next (xcb_render_directformat_iterator_t *i) { --i->rem; ++i->data; @@ -117,7 +117,7 @@ xcb_render_directformat_next (xcb_render_directformat_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_directformat_end (xcb_render_directformat_iterator_t i /**< */) +xcb_render_directformat_end (xcb_render_directformat_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -127,7 +127,7 @@ xcb_render_directformat_end (xcb_render_directformat_iterator_t i /**< */) } void -xcb_render_pictforminfo_next (xcb_render_pictforminfo_iterator_t *i /**< */) +xcb_render_pictforminfo_next (xcb_render_pictforminfo_iterator_t *i) { --i->rem; ++i->data; @@ -135,7 +135,7 @@ xcb_render_pictforminfo_next (xcb_render_pictforminfo_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_pictforminfo_end (xcb_render_pictforminfo_iterator_t i /**< */) +xcb_render_pictforminfo_end (xcb_render_pictforminfo_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -145,7 +145,7 @@ xcb_render_pictforminfo_end (xcb_render_pictforminfo_iterator_t i /**< */) } void -xcb_render_pictvisual_next (xcb_render_pictvisual_iterator_t *i /**< */) +xcb_render_pictvisual_next (xcb_render_pictvisual_iterator_t *i) { --i->rem; ++i->data; @@ -153,7 +153,7 @@ xcb_render_pictvisual_next (xcb_render_pictvisual_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_pictvisual_end (xcb_render_pictvisual_iterator_t i /**< */) +xcb_render_pictvisual_end (xcb_render_pictvisual_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -163,7 +163,7 @@ xcb_render_pictvisual_end (xcb_render_pictvisual_iterator_t i /**< */) } int -xcb_render_pictdepth_sizeof (const void *_buffer /**< */) +xcb_render_pictdepth_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_render_pictdepth_t *_aux = (xcb_render_pictdepth_t *)_buffer; @@ -194,19 +194,19 @@ xcb_render_pictdepth_sizeof (const void *_buffer /**< */) } xcb_render_pictvisual_t * -xcb_render_pictdepth_visuals (const xcb_render_pictdepth_t *R /**< */) +xcb_render_pictdepth_visuals (const xcb_render_pictdepth_t *R) { return (xcb_render_pictvisual_t *) (R + 1); } int -xcb_render_pictdepth_visuals_length (const xcb_render_pictdepth_t *R /**< */) +xcb_render_pictdepth_visuals_length (const xcb_render_pictdepth_t *R) { return R->num_visuals; } xcb_render_pictvisual_iterator_t -xcb_render_pictdepth_visuals_iterator (const xcb_render_pictdepth_t *R /**< */) +xcb_render_pictdepth_visuals_iterator (const xcb_render_pictdepth_t *R) { xcb_render_pictvisual_iterator_t i; i.data = (xcb_render_pictvisual_t *) (R + 1); @@ -216,7 +216,7 @@ xcb_render_pictdepth_visuals_iterator (const xcb_render_pictdepth_t *R /**< */) } void -xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i /**< */) +xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i) { xcb_render_pictdepth_t *R = i->data; xcb_generic_iterator_t child; @@ -227,7 +227,7 @@ xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_pictdepth_end (xcb_render_pictdepth_iterator_t i /**< */) +xcb_render_pictdepth_end (xcb_render_pictdepth_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -239,7 +239,7 @@ xcb_render_pictdepth_end (xcb_render_pictdepth_iterator_t i /**< */) } int -xcb_render_pictscreen_sizeof (const void *_buffer /**< */) +xcb_render_pictscreen_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_render_pictscreen_t *_aux = (xcb_render_pictscreen_t *)_buffer; @@ -275,13 +275,13 @@ xcb_render_pictscreen_sizeof (const void *_buffer /**< */) } int -xcb_render_pictscreen_depths_length (const xcb_render_pictscreen_t *R /**< */) +xcb_render_pictscreen_depths_length (const xcb_render_pictscreen_t *R) { return R->num_depths; } xcb_render_pictdepth_iterator_t -xcb_render_pictscreen_depths_iterator (const xcb_render_pictscreen_t *R /**< */) +xcb_render_pictscreen_depths_iterator (const xcb_render_pictscreen_t *R) { xcb_render_pictdepth_iterator_t i; i.data = (xcb_render_pictdepth_t *) (R + 1); @@ -291,7 +291,7 @@ xcb_render_pictscreen_depths_iterator (const xcb_render_pictscreen_t *R /**< */ } void -xcb_render_pictscreen_next (xcb_render_pictscreen_iterator_t *i /**< */) +xcb_render_pictscreen_next (xcb_render_pictscreen_iterator_t *i) { xcb_render_pictscreen_t *R = i->data; xcb_generic_iterator_t child; @@ -302,7 +302,7 @@ xcb_render_pictscreen_next (xcb_render_pictscreen_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_pictscreen_end (xcb_render_pictscreen_iterator_t i /**< */) +xcb_render_pictscreen_end (xcb_render_pictscreen_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -314,7 +314,7 @@ xcb_render_pictscreen_end (xcb_render_pictscreen_iterator_t i /**< */) } void -xcb_render_indexvalue_next (xcb_render_indexvalue_iterator_t *i /**< */) +xcb_render_indexvalue_next (xcb_render_indexvalue_iterator_t *i) { --i->rem; ++i->data; @@ -322,7 +322,7 @@ xcb_render_indexvalue_next (xcb_render_indexvalue_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_indexvalue_end (xcb_render_indexvalue_iterator_t i /**< */) +xcb_render_indexvalue_end (xcb_render_indexvalue_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -332,7 +332,7 @@ xcb_render_indexvalue_end (xcb_render_indexvalue_iterator_t i /**< */) } void -xcb_render_color_next (xcb_render_color_iterator_t *i /**< */) +xcb_render_color_next (xcb_render_color_iterator_t *i) { --i->rem; ++i->data; @@ -340,7 +340,7 @@ xcb_render_color_next (xcb_render_color_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_color_end (xcb_render_color_iterator_t i /**< */) +xcb_render_color_end (xcb_render_color_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -350,7 +350,7 @@ xcb_render_color_end (xcb_render_color_iterator_t i /**< */) } void -xcb_render_pointfix_next (xcb_render_pointfix_iterator_t *i /**< */) +xcb_render_pointfix_next (xcb_render_pointfix_iterator_t *i) { --i->rem; ++i->data; @@ -358,7 +358,7 @@ xcb_render_pointfix_next (xcb_render_pointfix_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_pointfix_end (xcb_render_pointfix_iterator_t i /**< */) +xcb_render_pointfix_end (xcb_render_pointfix_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -368,7 +368,7 @@ xcb_render_pointfix_end (xcb_render_pointfix_iterator_t i /**< */) } void -xcb_render_linefix_next (xcb_render_linefix_iterator_t *i /**< */) +xcb_render_linefix_next (xcb_render_linefix_iterator_t *i) { --i->rem; ++i->data; @@ -376,7 +376,7 @@ xcb_render_linefix_next (xcb_render_linefix_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_linefix_end (xcb_render_linefix_iterator_t i /**< */) +xcb_render_linefix_end (xcb_render_linefix_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -386,7 +386,7 @@ xcb_render_linefix_end (xcb_render_linefix_iterator_t i /**< */) } void -xcb_render_triangle_next (xcb_render_triangle_iterator_t *i /**< */) +xcb_render_triangle_next (xcb_render_triangle_iterator_t *i) { --i->rem; ++i->data; @@ -394,7 +394,7 @@ xcb_render_triangle_next (xcb_render_triangle_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_triangle_end (xcb_render_triangle_iterator_t i /**< */) +xcb_render_triangle_end (xcb_render_triangle_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -404,7 +404,7 @@ xcb_render_triangle_end (xcb_render_triangle_iterator_t i /**< */) } void -xcb_render_trapezoid_next (xcb_render_trapezoid_iterator_t *i /**< */) +xcb_render_trapezoid_next (xcb_render_trapezoid_iterator_t *i) { --i->rem; ++i->data; @@ -412,7 +412,7 @@ xcb_render_trapezoid_next (xcb_render_trapezoid_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_trapezoid_end (xcb_render_trapezoid_iterator_t i /**< */) +xcb_render_trapezoid_end (xcb_render_trapezoid_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -422,7 +422,7 @@ xcb_render_trapezoid_end (xcb_render_trapezoid_iterator_t i /**< */) } void -xcb_render_glyphinfo_next (xcb_render_glyphinfo_iterator_t *i /**< */) +xcb_render_glyphinfo_next (xcb_render_glyphinfo_iterator_t *i) { --i->rem; ++i->data; @@ -430,7 +430,7 @@ xcb_render_glyphinfo_next (xcb_render_glyphinfo_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_glyphinfo_end (xcb_render_glyphinfo_iterator_t i /**< */) +xcb_render_glyphinfo_end (xcb_render_glyphinfo_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -440,15 +440,15 @@ xcb_render_glyphinfo_end (xcb_render_glyphinfo_iterator_t i /**< */) } xcb_render_query_version_cookie_t -xcb_render_query_version (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */) +xcb_render_query_version (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -468,15 +468,15 @@ xcb_render_query_version (xcb_connection_t *c /**< */, } xcb_render_query_version_cookie_t -xcb_render_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */) +xcb_render_query_version_unchecked (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -496,15 +496,15 @@ xcb_render_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_render_query_version_reply_t * -xcb_render_query_version_reply (xcb_connection_t *c /**< */, +xcb_render_query_version_reply (xcb_connection_t *c, xcb_render_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_render_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_render_query_pict_formats_sizeof (const void *_buffer /**< */) +xcb_render_query_pict_formats_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_render_query_pict_formats_reply_t *_aux = (xcb_render_query_pict_formats_reply_t *)_buffer; @@ -564,13 +564,13 @@ xcb_render_query_pict_formats_sizeof (const void *_buffer /**< */) } xcb_render_query_pict_formats_cookie_t -xcb_render_query_pict_formats (xcb_connection_t *c /**< */) +xcb_render_query_pict_formats (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_QUERY_PICT_FORMATS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_QUERY_PICT_FORMATS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -588,13 +588,13 @@ xcb_render_query_pict_formats (xcb_connection_t *c /**< */) } xcb_render_query_pict_formats_cookie_t -xcb_render_query_pict_formats_unchecked (xcb_connection_t *c /**< */) +xcb_render_query_pict_formats_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_QUERY_PICT_FORMATS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_QUERY_PICT_FORMATS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -612,19 +612,19 @@ xcb_render_query_pict_formats_unchecked (xcb_connection_t *c /**< */) } xcb_render_pictforminfo_t * -xcb_render_query_pict_formats_formats (const xcb_render_query_pict_formats_reply_t *R /**< */) +xcb_render_query_pict_formats_formats (const xcb_render_query_pict_formats_reply_t *R) { return (xcb_render_pictforminfo_t *) (R + 1); } int -xcb_render_query_pict_formats_formats_length (const xcb_render_query_pict_formats_reply_t *R /**< */) +xcb_render_query_pict_formats_formats_length (const xcb_render_query_pict_formats_reply_t *R) { return R->num_formats; } xcb_render_pictforminfo_iterator_t -xcb_render_query_pict_formats_formats_iterator (const xcb_render_query_pict_formats_reply_t *R /**< */) +xcb_render_query_pict_formats_formats_iterator (const xcb_render_query_pict_formats_reply_t *R) { xcb_render_pictforminfo_iterator_t i; i.data = (xcb_render_pictforminfo_t *) (R + 1); @@ -634,13 +634,13 @@ xcb_render_query_pict_formats_formats_iterator (const xcb_render_query_pict_form } int -xcb_render_query_pict_formats_screens_length (const xcb_render_query_pict_formats_reply_t *R /**< */) +xcb_render_query_pict_formats_screens_length (const xcb_render_query_pict_formats_reply_t *R) { return R->num_screens; } xcb_render_pictscreen_iterator_t -xcb_render_query_pict_formats_screens_iterator (const xcb_render_query_pict_formats_reply_t *R /**< */) +xcb_render_query_pict_formats_screens_iterator (const xcb_render_query_pict_formats_reply_t *R) { xcb_render_pictscreen_iterator_t i; xcb_generic_iterator_t prev = xcb_render_pictforminfo_end(xcb_render_query_pict_formats_formats_iterator(R)); @@ -651,39 +651,39 @@ xcb_render_query_pict_formats_screens_iterator (const xcb_render_query_pict_form } uint32_t * -xcb_render_query_pict_formats_subpixels (const xcb_render_query_pict_formats_reply_t *R /**< */) +xcb_render_query_pict_formats_subpixels (const xcb_render_query_pict_formats_reply_t *R) { xcb_generic_iterator_t prev = xcb_render_pictscreen_end(xcb_render_query_pict_formats_screens_iterator(R)); return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); } int -xcb_render_query_pict_formats_subpixels_length (const xcb_render_query_pict_formats_reply_t *R /**< */) +xcb_render_query_pict_formats_subpixels_length (const xcb_render_query_pict_formats_reply_t *R) { return R->num_subpixel; } xcb_generic_iterator_t -xcb_render_query_pict_formats_subpixels_end (const xcb_render_query_pict_formats_reply_t *R /**< */) +xcb_render_query_pict_formats_subpixels_end (const xcb_render_query_pict_formats_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_render_pictscreen_end(xcb_render_query_pict_formats_screens_iterator(R)); - i.data = ((uint32_t *) child.data) + (R->num_subpixel); + xcb_generic_iterator_t prev = xcb_render_pictscreen_end(xcb_render_query_pict_formats_screens_iterator(R)); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_subpixel); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_render_query_pict_formats_reply_t * -xcb_render_query_pict_formats_reply (xcb_connection_t *c /**< */, +xcb_render_query_pict_formats_reply (xcb_connection_t *c, xcb_render_query_pict_formats_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_render_query_pict_formats_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_render_query_pict_index_values_sizeof (const void *_buffer /**< */) +xcb_render_query_pict_index_values_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_render_query_pict_index_values_reply_t *_aux = (xcb_render_query_pict_index_values_reply_t *)_buffer; @@ -714,14 +714,14 @@ xcb_render_query_pict_index_values_sizeof (const void *_buffer /**< */) } xcb_render_query_pict_index_values_cookie_t -xcb_render_query_pict_index_values (xcb_connection_t *c /**< */, - xcb_render_pictformat_t format /**< */) +xcb_render_query_pict_index_values (xcb_connection_t *c, + xcb_render_pictformat_t format) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_QUERY_PICT_INDEX_VALUES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_QUERY_PICT_INDEX_VALUES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -740,14 +740,14 @@ xcb_render_query_pict_index_values (xcb_connection_t *c /**< */, } xcb_render_query_pict_index_values_cookie_t -xcb_render_query_pict_index_values_unchecked (xcb_connection_t *c /**< */, - xcb_render_pictformat_t format /**< */) +xcb_render_query_pict_index_values_unchecked (xcb_connection_t *c, + xcb_render_pictformat_t format) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_QUERY_PICT_INDEX_VALUES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_QUERY_PICT_INDEX_VALUES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -766,19 +766,19 @@ xcb_render_query_pict_index_values_unchecked (xcb_connection_t *c /**< * } xcb_render_indexvalue_t * -xcb_render_query_pict_index_values_values (const xcb_render_query_pict_index_values_reply_t *R /**< */) +xcb_render_query_pict_index_values_values (const xcb_render_query_pict_index_values_reply_t *R) { return (xcb_render_indexvalue_t *) (R + 1); } int -xcb_render_query_pict_index_values_values_length (const xcb_render_query_pict_index_values_reply_t *R /**< */) +xcb_render_query_pict_index_values_values_length (const xcb_render_query_pict_index_values_reply_t *R) { return R->num_values; } xcb_render_indexvalue_iterator_t -xcb_render_query_pict_index_values_values_iterator (const xcb_render_query_pict_index_values_reply_t *R /**< */) +xcb_render_query_pict_index_values_values_iterator (const xcb_render_query_pict_index_values_reply_t *R) { xcb_render_indexvalue_iterator_t i; i.data = (xcb_render_indexvalue_t *) (R + 1); @@ -788,15 +788,291 @@ xcb_render_query_pict_index_values_values_iterator (const xcb_render_query_pict_ } xcb_render_query_pict_index_values_reply_t * -xcb_render_query_pict_index_values_reply (xcb_connection_t *c /**< */, +xcb_render_query_pict_index_values_reply (xcb_connection_t *c, xcb_render_query_pict_index_values_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_render_query_pict_index_values_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_render_create_picture_sizeof (const void *_buffer /**< */) +xcb_render_create_picture_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_render_create_picture_value_list_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[14]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(value_mask & XCB_RENDER_CP_REPEAT) { + /* xcb_render_create_picture_value_list_t.repeat */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->repeat; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_MAP) { + /* xcb_render_create_picture_value_list_t.alphamap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphamap; + xcb_block_len += sizeof(xcb_render_picture_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_render_picture_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_render_picture_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) { + /* xcb_render_create_picture_value_list_t.alphaxorigin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphaxorigin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) { + /* xcb_render_create_picture_value_list_t.alphayorigin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphayorigin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) { + /* xcb_render_create_picture_value_list_t.clipxorigin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipxorigin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) { + /* xcb_render_create_picture_value_list_t.clipyorigin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipyorigin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_MASK) { + /* xcb_render_create_picture_value_list_t.clipmask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipmask; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) { + /* xcb_render_create_picture_value_list_t.graphicsexposure */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphicsexposure; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) { + /* xcb_render_create_picture_value_list_t.subwindowmode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindowmode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_POLY_EDGE) { + /* xcb_render_create_picture_value_list_t.polyedge */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polyedge; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_POLY_MODE) { + /* xcb_render_create_picture_value_list_t.polymode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polymode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_DITHER) { + /* xcb_render_create_picture_value_list_t.dither */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dither; + xcb_block_len += sizeof(xcb_atom_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_atom_t); + } + if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) { + /* xcb_render_create_picture_value_list_t.componentalpha */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->componentalpha; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; irepeat = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_MAP) { + /* xcb_render_create_picture_value_list_t.alphamap */ + _aux->alphamap = *(xcb_render_picture_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_render_picture_t); + xcb_tmp += sizeof(xcb_render_picture_t); + xcb_align_to = ALIGNOF(xcb_render_picture_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) { + /* xcb_render_create_picture_value_list_t.alphaxorigin */ + _aux->alphaxorigin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) { + /* xcb_render_create_picture_value_list_t.alphayorigin */ + _aux->alphayorigin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) { + /* xcb_render_create_picture_value_list_t.clipxorigin */ + _aux->clipxorigin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) { + /* xcb_render_create_picture_value_list_t.clipyorigin */ + _aux->clipyorigin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_MASK) { + /* xcb_render_create_picture_value_list_t.clipmask */ + _aux->clipmask = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) { + /* xcb_render_create_picture_value_list_t.graphicsexposure */ + _aux->graphicsexposure = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) { + /* xcb_render_create_picture_value_list_t.subwindowmode */ + _aux->subwindowmode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_POLY_EDGE) { + /* xcb_render_create_picture_value_list_t.polyedge */ + _aux->polyedge = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_POLY_MODE) { + /* xcb_render_create_picture_value_list_t.polymode */ + _aux->polymode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_DITHER) { + /* xcb_render_create_picture_value_list_t.dither */ + _aux->dither = *(xcb_atom_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_atom_t); + xcb_tmp += sizeof(xcb_atom_t); + xcb_align_to = ALIGNOF(xcb_atom_t); + } + if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) { + /* xcb_render_create_picture_value_list_t.componentalpha */ + _aux->componentalpha = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_render_create_picture_value_list_sizeof (const void *_buffer, + uint32_t value_mask) +{ + xcb_render_create_picture_value_list_t _aux; + return xcb_render_create_picture_value_list_unpack(_buffer, value_mask, &_aux); +} + +int +xcb_render_create_picture_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_render_create_picture_request_t *_aux = (xcb_render_create_picture_request_t *)_buffer; @@ -811,9 +1087,9 @@ xcb_render_create_picture_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* value_list */ - xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_block_len += xcb_render_create_picture_value_list_sizeof(xcb_tmp, _aux->value_mask); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -827,21 +1103,21 @@ xcb_render_create_picture_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_render_create_picture_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t pid /**< */, - xcb_drawable_t drawable /**< */, - xcb_render_pictformat_t format /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_render_create_picture_checked (xcb_connection_t *c, + xcb_render_picture_t pid, + xcb_drawable_t drawable, + xcb_render_pictformat_t format, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_PICTURE, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_PICTURE, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_render_create_picture_request_t xcb_out; @@ -854,32 +1130,31 @@ xcb_render_create_picture_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_render_create_picture_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_render_create_picture_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_render_create_picture (xcb_connection_t *c /**< */, - xcb_render_picture_t pid /**< */, - xcb_drawable_t drawable /**< */, - xcb_render_pictformat_t format /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_render_create_picture (xcb_connection_t *c, + xcb_render_picture_t pid, + xcb_drawable_t drawable, + xcb_render_pictformat_t format, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_PICTURE, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_PICTURE, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_render_create_picture_request_t xcb_out; @@ -892,18 +1167,377 @@ xcb_render_create_picture (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_render_create_picture_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_render_create_picture_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +xcb_void_cookie_t +xcb_render_create_picture_aux_checked (xcb_connection_t *c, + xcb_render_picture_t pid, + xcb_drawable_t drawable, + xcb_render_pictformat_t format, + uint32_t value_mask, + const xcb_render_create_picture_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_PICTURE, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_render_create_picture_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pid = pid; + xcb_out.drawable = drawable; + xcb_out.format = format; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_create_picture_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_render_create_picture_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_render_create_picture_aux (xcb_connection_t *c, + xcb_render_picture_t pid, + xcb_drawable_t drawable, + xcb_render_pictformat_t format, + uint32_t value_mask, + const xcb_render_create_picture_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_PICTURE, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_render_create_picture_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pid = pid; + xcb_out.drawable = drawable; + xcb_out.format = format; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_create_picture_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_render_create_picture_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_render_create_picture_value_list (const xcb_render_create_picture_request_t *R) +{ + return (void *) (R + 1); +} + int -xcb_render_change_picture_sizeof (const void *_buffer /**< */) +xcb_render_change_picture_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_render_change_picture_value_list_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[14]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(value_mask & XCB_RENDER_CP_REPEAT) { + /* xcb_render_change_picture_value_list_t.repeat */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->repeat; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_MAP) { + /* xcb_render_change_picture_value_list_t.alphamap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphamap; + xcb_block_len += sizeof(xcb_render_picture_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_render_picture_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_render_picture_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) { + /* xcb_render_change_picture_value_list_t.alphaxorigin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphaxorigin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) { + /* xcb_render_change_picture_value_list_t.alphayorigin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphayorigin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) { + /* xcb_render_change_picture_value_list_t.clipxorigin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipxorigin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) { + /* xcb_render_change_picture_value_list_t.clipyorigin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipyorigin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_MASK) { + /* xcb_render_change_picture_value_list_t.clipmask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipmask; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) { + /* xcb_render_change_picture_value_list_t.graphicsexposure */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphicsexposure; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) { + /* xcb_render_change_picture_value_list_t.subwindowmode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindowmode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_POLY_EDGE) { + /* xcb_render_change_picture_value_list_t.polyedge */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polyedge; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_POLY_MODE) { + /* xcb_render_change_picture_value_list_t.polymode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polymode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_DITHER) { + /* xcb_render_change_picture_value_list_t.dither */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dither; + xcb_block_len += sizeof(xcb_atom_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_atom_t); + } + if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) { + /* xcb_render_change_picture_value_list_t.componentalpha */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->componentalpha; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; irepeat = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_MAP) { + /* xcb_render_change_picture_value_list_t.alphamap */ + _aux->alphamap = *(xcb_render_picture_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_render_picture_t); + xcb_tmp += sizeof(xcb_render_picture_t); + xcb_align_to = ALIGNOF(xcb_render_picture_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) { + /* xcb_render_change_picture_value_list_t.alphaxorigin */ + _aux->alphaxorigin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) { + /* xcb_render_change_picture_value_list_t.alphayorigin */ + _aux->alphayorigin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) { + /* xcb_render_change_picture_value_list_t.clipxorigin */ + _aux->clipxorigin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) { + /* xcb_render_change_picture_value_list_t.clipyorigin */ + _aux->clipyorigin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_RENDER_CP_CLIP_MASK) { + /* xcb_render_change_picture_value_list_t.clipmask */ + _aux->clipmask = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) { + /* xcb_render_change_picture_value_list_t.graphicsexposure */ + _aux->graphicsexposure = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) { + /* xcb_render_change_picture_value_list_t.subwindowmode */ + _aux->subwindowmode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_POLY_EDGE) { + /* xcb_render_change_picture_value_list_t.polyedge */ + _aux->polyedge = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_POLY_MODE) { + /* xcb_render_change_picture_value_list_t.polymode */ + _aux->polymode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_RENDER_CP_DITHER) { + /* xcb_render_change_picture_value_list_t.dither */ + _aux->dither = *(xcb_atom_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_atom_t); + xcb_tmp += sizeof(xcb_atom_t); + xcb_align_to = ALIGNOF(xcb_atom_t); + } + if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) { + /* xcb_render_change_picture_value_list_t.componentalpha */ + _aux->componentalpha = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_render_change_picture_value_list_sizeof (const void *_buffer, + uint32_t value_mask) +{ + xcb_render_change_picture_value_list_t _aux; + return xcb_render_change_picture_value_list_unpack(_buffer, value_mask, &_aux); +} + +int +xcb_render_change_picture_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_render_change_picture_request_t *_aux = (xcb_render_change_picture_request_t *)_buffer; @@ -918,9 +1552,9 @@ xcb_render_change_picture_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* value_list */ - xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_block_len += xcb_render_change_picture_value_list_sizeof(xcb_tmp, _aux->value_mask); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -934,19 +1568,19 @@ xcb_render_change_picture_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_render_change_picture_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_render_change_picture_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CHANGE_PICTURE, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CHANGE_PICTURE, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_render_change_picture_request_t xcb_out; @@ -957,30 +1591,29 @@ xcb_render_change_picture_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_render_change_picture_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_render_change_picture_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_render_change_picture (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_render_change_picture (xcb_connection_t *c, + xcb_render_picture_t picture, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CHANGE_PICTURE, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CHANGE_PICTURE, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_render_change_picture_request_t xcb_out; @@ -991,19 +1624,94 @@ xcb_render_change_picture (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_render_change_picture_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_render_change_picture_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +xcb_void_cookie_t +xcb_render_change_picture_aux_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + uint32_t value_mask, + const xcb_render_change_picture_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CHANGE_PICTURE, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_render_change_picture_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.picture = picture; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_change_picture_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_render_change_picture_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_render_change_picture_aux (xcb_connection_t *c, + xcb_render_picture_t picture, + uint32_t value_mask, + const xcb_render_change_picture_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CHANGE_PICTURE, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_render_change_picture_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.picture = picture; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_render_change_picture_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_render_change_picture_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_render_change_picture_value_list (const xcb_render_change_picture_request_t *R) +{ + return (void *) (R + 1); +} + int -xcb_render_set_picture_clip_rectangles_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */) +xcb_render_set_picture_clip_rectangles_sizeof (const void *_buffer, + uint32_t rectangles_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -1033,18 +1741,18 @@ xcb_render_set_picture_clip_rectangles_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - int16_t clip_x_origin /**< */, - int16_t clip_y_origin /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + int16_t clip_x_origin, + int16_t clip_y_origin, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1070,18 +1778,18 @@ xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t *c /**< * } xcb_void_cookie_t -xcb_render_set_picture_clip_rectangles (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - int16_t clip_x_origin /**< */, - int16_t clip_y_origin /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_render_set_picture_clip_rectangles (xcb_connection_t *c, + xcb_render_picture_t picture, + int16_t clip_x_origin, + int16_t clip_y_origin, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1106,15 +1814,37 @@ xcb_render_set_picture_clip_rectangles (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_rectangle_t * +xcb_render_set_picture_clip_rectangles_rectangles (const xcb_render_set_picture_clip_rectangles_request_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + +int +xcb_render_set_picture_clip_rectangles_rectangles_length (const xcb_render_set_picture_clip_rectangles_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_set_picture_clip_rectangles_request_t))/sizeof(xcb_rectangle_t)); +} + +xcb_rectangle_iterator_t +xcb_render_set_picture_clip_rectangles_rectangles_iterator (const xcb_render_set_picture_clip_rectangles_request_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_render_set_picture_clip_rectangles_request_t))/sizeof(xcb_rectangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_render_free_picture_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */) +xcb_render_free_picture_checked (xcb_connection_t *c, + xcb_render_picture_t picture) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_FREE_PICTURE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_FREE_PICTURE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1133,14 +1863,14 @@ xcb_render_free_picture_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_free_picture (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */) +xcb_render_free_picture (xcb_connection_t *c, + xcb_render_picture_t picture) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_FREE_PICTURE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_FREE_PICTURE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1159,25 +1889,25 @@ xcb_render_free_picture (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_composite_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t mask /**< */, - xcb_render_picture_t dst /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t mask_x /**< */, - int16_t mask_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_render_composite_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t mask, + xcb_render_picture_t dst, + int16_t src_x, + int16_t src_y, + int16_t mask_x, + int16_t mask_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_COMPOSITE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_COMPOSITE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1208,25 +1938,25 @@ xcb_render_composite_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_composite (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t mask /**< */, - xcb_render_picture_t dst /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t mask_x /**< */, - int16_t mask_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_render_composite (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t mask, + xcb_render_picture_t dst, + int16_t src_x, + int16_t src_y, + int16_t mask_x, + int16_t mask_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_COMPOSITE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_COMPOSITE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1257,8 +1987,8 @@ xcb_render_composite (xcb_connection_t *c /**< */, } int -xcb_render_trapezoids_sizeof (const void *_buffer /**< */, - uint32_t traps_len /**< */) +xcb_render_trapezoids_sizeof (const void *_buffer, + uint32_t traps_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -1288,21 +2018,21 @@ xcb_render_trapezoids_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_trapezoids_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t traps_len /**< */, - const xcb_render_trapezoid_t *traps /**< */) +xcb_render_trapezoids_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t traps_len, + const xcb_render_trapezoid_t *traps) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_TRAPEZOIDS, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_TRAPEZOIDS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1332,21 +2062,21 @@ xcb_render_trapezoids_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_trapezoids (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t traps_len /**< */, - const xcb_render_trapezoid_t *traps /**< */) +xcb_render_trapezoids (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t traps_len, + const xcb_render_trapezoid_t *traps) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_TRAPEZOIDS, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_TRAPEZOIDS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1375,9 +2105,31 @@ xcb_render_trapezoids (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_render_trapezoid_t * +xcb_render_trapezoids_traps (const xcb_render_trapezoids_request_t *R) +{ + return (xcb_render_trapezoid_t *) (R + 1); +} + int -xcb_render_triangles_sizeof (const void *_buffer /**< */, - uint32_t triangles_len /**< */) +xcb_render_trapezoids_traps_length (const xcb_render_trapezoids_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_trapezoids_request_t))/sizeof(xcb_render_trapezoid_t)); +} + +xcb_render_trapezoid_iterator_t +xcb_render_trapezoids_traps_iterator (const xcb_render_trapezoids_request_t *R) +{ + xcb_render_trapezoid_iterator_t i; + i.data = (xcb_render_trapezoid_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_render_trapezoids_request_t))/sizeof(xcb_render_trapezoid_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_render_triangles_sizeof (const void *_buffer, + uint32_t triangles_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -1407,21 +2159,21 @@ xcb_render_triangles_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_triangles_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t triangles_len /**< */, - const xcb_render_triangle_t *triangles /**< */) +xcb_render_triangles_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t triangles_len, + const xcb_render_triangle_t *triangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_TRIANGLES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_TRIANGLES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1451,21 +2203,21 @@ xcb_render_triangles_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_triangles (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t triangles_len /**< */, - const xcb_render_triangle_t *triangles /**< */) +xcb_render_triangles (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t triangles_len, + const xcb_render_triangle_t *triangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_TRIANGLES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_TRIANGLES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1494,9 +2246,31 @@ xcb_render_triangles (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_render_triangle_t * +xcb_render_triangles_triangles (const xcb_render_triangles_request_t *R) +{ + return (xcb_render_triangle_t *) (R + 1); +} + int -xcb_render_tri_strip_sizeof (const void *_buffer /**< */, - uint32_t points_len /**< */) +xcb_render_triangles_triangles_length (const xcb_render_triangles_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_triangles_request_t))/sizeof(xcb_render_triangle_t)); +} + +xcb_render_triangle_iterator_t +xcb_render_triangles_triangles_iterator (const xcb_render_triangles_request_t *R) +{ + xcb_render_triangle_iterator_t i; + i.data = (xcb_render_triangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_render_triangles_request_t))/sizeof(xcb_render_triangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_render_tri_strip_sizeof (const void *_buffer, + uint32_t points_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -1526,21 +2300,21 @@ xcb_render_tri_strip_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_tri_strip_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t points_len /**< */, - const xcb_render_pointfix_t *points /**< */) +xcb_render_tri_strip_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t points_len, + const xcb_render_pointfix_t *points) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_TRI_STRIP, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_TRI_STRIP, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1570,21 +2344,21 @@ xcb_render_tri_strip_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_tri_strip (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t points_len /**< */, - const xcb_render_pointfix_t *points /**< */) +xcb_render_tri_strip (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t points_len, + const xcb_render_pointfix_t *points) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_TRI_STRIP, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_TRI_STRIP, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1613,9 +2387,31 @@ xcb_render_tri_strip (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_render_pointfix_t * +xcb_render_tri_strip_points (const xcb_render_tri_strip_request_t *R) +{ + return (xcb_render_pointfix_t *) (R + 1); +} + int -xcb_render_tri_fan_sizeof (const void *_buffer /**< */, - uint32_t points_len /**< */) +xcb_render_tri_strip_points_length (const xcb_render_tri_strip_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_tri_strip_request_t))/sizeof(xcb_render_pointfix_t)); +} + +xcb_render_pointfix_iterator_t +xcb_render_tri_strip_points_iterator (const xcb_render_tri_strip_request_t *R) +{ + xcb_render_pointfix_iterator_t i; + i.data = (xcb_render_pointfix_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_render_tri_strip_request_t))/sizeof(xcb_render_pointfix_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_render_tri_fan_sizeof (const void *_buffer, + uint32_t points_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -1645,21 +2441,21 @@ xcb_render_tri_fan_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_tri_fan_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t points_len /**< */, - const xcb_render_pointfix_t *points /**< */) +xcb_render_tri_fan_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t points_len, + const xcb_render_pointfix_t *points) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_TRI_FAN, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_TRI_FAN, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1689,21 +2485,21 @@ xcb_render_tri_fan_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_tri_fan (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t points_len /**< */, - const xcb_render_pointfix_t *points /**< */) +xcb_render_tri_fan (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t points_len, + const xcb_render_pointfix_t *points) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_TRI_FAN, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_TRI_FAN, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1732,16 +2528,38 @@ xcb_render_tri_fan (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_render_pointfix_t * +xcb_render_tri_fan_points (const xcb_render_tri_fan_request_t *R) +{ + return (xcb_render_pointfix_t *) (R + 1); +} + +int +xcb_render_tri_fan_points_length (const xcb_render_tri_fan_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_tri_fan_request_t))/sizeof(xcb_render_pointfix_t)); +} + +xcb_render_pointfix_iterator_t +xcb_render_tri_fan_points_iterator (const xcb_render_tri_fan_request_t *R) +{ + xcb_render_pointfix_iterator_t i; + i.data = (xcb_render_pointfix_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_render_tri_fan_request_t))/sizeof(xcb_render_pointfix_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_render_create_glyph_set_checked (xcb_connection_t *c /**< */, - xcb_render_glyphset_t gsid /**< */, - xcb_render_pictformat_t format /**< */) +xcb_render_create_glyph_set_checked (xcb_connection_t *c, + xcb_render_glyphset_t gsid, + xcb_render_pictformat_t format) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_GLYPH_SET, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_GLYPH_SET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1761,15 +2579,15 @@ xcb_render_create_glyph_set_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_create_glyph_set (xcb_connection_t *c /**< */, - xcb_render_glyphset_t gsid /**< */, - xcb_render_pictformat_t format /**< */) +xcb_render_create_glyph_set (xcb_connection_t *c, + xcb_render_glyphset_t gsid, + xcb_render_pictformat_t format) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_GLYPH_SET, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_GLYPH_SET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1789,15 +2607,15 @@ xcb_render_create_glyph_set (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_reference_glyph_set_checked (xcb_connection_t *c /**< */, - xcb_render_glyphset_t gsid /**< */, - xcb_render_glyphset_t existing /**< */) +xcb_render_reference_glyph_set_checked (xcb_connection_t *c, + xcb_render_glyphset_t gsid, + xcb_render_glyphset_t existing) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_REFERENCE_GLYPH_SET, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_REFERENCE_GLYPH_SET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1817,15 +2635,15 @@ xcb_render_reference_glyph_set_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_reference_glyph_set (xcb_connection_t *c /**< */, - xcb_render_glyphset_t gsid /**< */, - xcb_render_glyphset_t existing /**< */) +xcb_render_reference_glyph_set (xcb_connection_t *c, + xcb_render_glyphset_t gsid, + xcb_render_glyphset_t existing) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_REFERENCE_GLYPH_SET, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_REFERENCE_GLYPH_SET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1845,14 +2663,14 @@ xcb_render_reference_glyph_set (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_free_glyph_set_checked (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */) +xcb_render_free_glyph_set_checked (xcb_connection_t *c, + xcb_render_glyphset_t glyphset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_FREE_GLYPH_SET, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_FREE_GLYPH_SET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1871,14 +2689,14 @@ xcb_render_free_glyph_set_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_free_glyph_set (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */) +xcb_render_free_glyph_set (xcb_connection_t *c, + xcb_render_glyphset_t glyphset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_FREE_GLYPH_SET, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_FREE_GLYPH_SET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1897,8 +2715,8 @@ xcb_render_free_glyph_set (xcb_connection_t *c /**< */, } int -xcb_render_add_glyphs_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */) +xcb_render_add_glyphs_sizeof (const void *_buffer, + uint32_t data_len) { char *xcb_tmp = (char *)_buffer; const xcb_render_add_glyphs_request_t *_aux = (xcb_render_add_glyphs_request_t *)_buffer; @@ -1953,19 +2771,19 @@ xcb_render_add_glyphs_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_add_glyphs_checked (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */, - uint32_t glyphs_len /**< */, - const uint32_t *glyphids /**< */, - const xcb_render_glyphinfo_t *glyphs /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_render_add_glyphs_checked (xcb_connection_t *c, + xcb_render_glyphset_t glyphset, + uint32_t glyphs_len, + const uint32_t *glyphids, + const xcb_render_glyphinfo_t *glyphs, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 8, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_ADD_GLYPHS, - /* isvoid */ 1 + .count = 8, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_ADD_GLYPHS, + .isvoid = 1 }; struct iovec xcb_parts[10]; @@ -2000,19 +2818,19 @@ xcb_render_add_glyphs_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_add_glyphs (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */, - uint32_t glyphs_len /**< */, - const uint32_t *glyphids /**< */, - const xcb_render_glyphinfo_t *glyphs /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_render_add_glyphs (xcb_connection_t *c, + xcb_render_glyphset_t glyphset, + uint32_t glyphs_len, + const uint32_t *glyphids, + const xcb_render_glyphinfo_t *glyphs, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 8, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_ADD_GLYPHS, - /* isvoid */ 1 + .count = 8, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_ADD_GLYPHS, + .isvoid = 1 }; struct iovec xcb_parts[10]; @@ -2046,9 +2864,79 @@ xcb_render_add_glyphs (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_render_add_glyphs_glyphids (const xcb_render_add_glyphs_request_t *R) +{ + return (uint32_t *) (R + 1); +} + int -xcb_render_free_glyphs_sizeof (const void *_buffer /**< */, - uint32_t glyphs_len /**< */) +xcb_render_add_glyphs_glyphids_length (const xcb_render_add_glyphs_request_t *R) +{ + return R->glyphs_len; +} + +xcb_generic_iterator_t +xcb_render_add_glyphs_glyphids_end (const xcb_render_add_glyphs_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->glyphs_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_render_glyphinfo_t * +xcb_render_add_glyphs_glyphs (const xcb_render_add_glyphs_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_render_add_glyphs_glyphids_end(R); + return (xcb_render_glyphinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_glyphinfo_t, prev.index) + 0); +} + +int +xcb_render_add_glyphs_glyphs_length (const xcb_render_add_glyphs_request_t *R) +{ + return R->glyphs_len; +} + +xcb_render_glyphinfo_iterator_t +xcb_render_add_glyphs_glyphs_iterator (const xcb_render_add_glyphs_request_t *R) +{ + xcb_render_glyphinfo_iterator_t i; + xcb_generic_iterator_t prev = xcb_render_add_glyphs_glyphids_end(R); + i.data = (xcb_render_glyphinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_glyphinfo_t, prev.index)); + i.rem = R->glyphs_len; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint8_t * +xcb_render_add_glyphs_data (const xcb_render_add_glyphs_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_render_glyphinfo_end(xcb_render_add_glyphs_glyphs_iterator(R)); + return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0); +} + +int +xcb_render_add_glyphs_data_length (const xcb_render_add_glyphs_request_t *R) +{ + return ((((char*)R) + R->length * 4) - (char*)(xcb_render_add_glyphs_data(R))) / sizeof(uint8_t); +} + +xcb_generic_iterator_t +xcb_render_add_glyphs_data_end (const xcb_render_add_glyphs_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_render_glyphinfo_end(xcb_render_add_glyphs_glyphs_iterator(R)); + i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (((((char*)R) + R->length * 4) - (char*)(xcb_render_add_glyphs_data(R))) / sizeof(uint8_t)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_render_free_glyphs_sizeof (const void *_buffer, + uint32_t glyphs_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -2078,16 +2966,16 @@ xcb_render_free_glyphs_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_free_glyphs_checked (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */, - uint32_t glyphs_len /**< */, - const xcb_render_glyph_t *glyphs /**< */) +xcb_render_free_glyphs_checked (xcb_connection_t *c, + xcb_render_glyphset_t glyphset, + uint32_t glyphs_len, + const xcb_render_glyph_t *glyphs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_FREE_GLYPHS, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_FREE_GLYPHS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2111,16 +2999,16 @@ xcb_render_free_glyphs_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_free_glyphs (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */, - uint32_t glyphs_len /**< */, - const xcb_render_glyph_t *glyphs /**< */) +xcb_render_free_glyphs (xcb_connection_t *c, + xcb_render_glyphset_t glyphset, + uint32_t glyphs_len, + const xcb_render_glyph_t *glyphs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_FREE_GLYPHS, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_FREE_GLYPHS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2143,9 +3031,31 @@ xcb_render_free_glyphs (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_render_glyph_t * +xcb_render_free_glyphs_glyphs (const xcb_render_free_glyphs_request_t *R) +{ + return (xcb_render_glyph_t *) (R + 1); +} + int -xcb_render_composite_glyphs_8_sizeof (const void *_buffer /**< */, - uint32_t glyphcmds_len /**< */) +xcb_render_free_glyphs_glyphs_length (const xcb_render_free_glyphs_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_free_glyphs_request_t))/sizeof(xcb_render_glyph_t)); +} + +xcb_generic_iterator_t +xcb_render_free_glyphs_glyphs_end (const xcb_render_free_glyphs_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_render_glyph_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_free_glyphs_request_t))/sizeof(xcb_render_glyph_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_render_composite_glyphs_8_sizeof (const void *_buffer, + uint32_t glyphcmds_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -2175,22 +3085,22 @@ xcb_render_composite_glyphs_8_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_composite_glyphs_8_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */) +xcb_render_composite_glyphs_8_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_8, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_COMPOSITE_GLYPHS_8, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2221,22 +3131,22 @@ xcb_render_composite_glyphs_8_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_composite_glyphs_8 (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */) +xcb_render_composite_glyphs_8 (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_8, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_COMPOSITE_GLYPHS_8, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2266,9 +3176,31 @@ xcb_render_composite_glyphs_8 (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_render_composite_glyphs_8_glyphcmds (const xcb_render_composite_glyphs_8_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_render_composite_glyphs_16_sizeof (const void *_buffer /**< */, - uint32_t glyphcmds_len /**< */) +xcb_render_composite_glyphs_8_glyphcmds_length (const xcb_render_composite_glyphs_8_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_composite_glyphs_8_request_t))/sizeof(uint8_t)); +} + +xcb_generic_iterator_t +xcb_render_composite_glyphs_8_glyphcmds_end (const xcb_render_composite_glyphs_8_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_composite_glyphs_8_request_t))/sizeof(uint8_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_render_composite_glyphs_16_sizeof (const void *_buffer, + uint32_t glyphcmds_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -2298,22 +3230,22 @@ xcb_render_composite_glyphs_16_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_composite_glyphs_16_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */) +xcb_render_composite_glyphs_16_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_16, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_COMPOSITE_GLYPHS_16, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2344,22 +3276,22 @@ xcb_render_composite_glyphs_16_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_composite_glyphs_16 (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */) +xcb_render_composite_glyphs_16 (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_16, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_COMPOSITE_GLYPHS_16, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2389,9 +3321,31 @@ xcb_render_composite_glyphs_16 (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_render_composite_glyphs_16_glyphcmds (const xcb_render_composite_glyphs_16_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_render_composite_glyphs_32_sizeof (const void *_buffer /**< */, - uint32_t glyphcmds_len /**< */) +xcb_render_composite_glyphs_16_glyphcmds_length (const xcb_render_composite_glyphs_16_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_composite_glyphs_16_request_t))/sizeof(uint8_t)); +} + +xcb_generic_iterator_t +xcb_render_composite_glyphs_16_glyphcmds_end (const xcb_render_composite_glyphs_16_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_composite_glyphs_16_request_t))/sizeof(uint8_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_render_composite_glyphs_32_sizeof (const void *_buffer, + uint32_t glyphcmds_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -2421,22 +3375,22 @@ xcb_render_composite_glyphs_32_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_composite_glyphs_32_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */) +xcb_render_composite_glyphs_32_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_32, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_COMPOSITE_GLYPHS_32, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2467,22 +3421,22 @@ xcb_render_composite_glyphs_32_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_composite_glyphs_32 (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */) +xcb_render_composite_glyphs_32 (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_COMPOSITE_GLYPHS_32, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_COMPOSITE_GLYPHS_32, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2512,9 +3466,31 @@ xcb_render_composite_glyphs_32 (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_render_composite_glyphs_32_glyphcmds (const xcb_render_composite_glyphs_32_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_render_fill_rectangles_sizeof (const void *_buffer /**< */, - uint32_t rects_len /**< */) +xcb_render_composite_glyphs_32_glyphcmds_length (const xcb_render_composite_glyphs_32_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_composite_glyphs_32_request_t))/sizeof(uint8_t)); +} + +xcb_generic_iterator_t +xcb_render_composite_glyphs_32_glyphcmds_end (const xcb_render_composite_glyphs_32_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_composite_glyphs_32_request_t))/sizeof(uint8_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_render_fill_rectangles_sizeof (const void *_buffer, + uint32_t rects_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -2544,18 +3520,18 @@ xcb_render_fill_rectangles_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_fill_rectangles_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_color_t color /**< */, - uint32_t rects_len /**< */, - const xcb_rectangle_t *rects /**< */) +xcb_render_fill_rectangles_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t dst, + xcb_render_color_t color, + uint32_t rects_len, + const xcb_rectangle_t *rects) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_FILL_RECTANGLES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_FILL_RECTANGLES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2582,18 +3558,18 @@ xcb_render_fill_rectangles_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_fill_rectangles (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_color_t color /**< */, - uint32_t rects_len /**< */, - const xcb_rectangle_t *rects /**< */) +xcb_render_fill_rectangles (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t dst, + xcb_render_color_t color, + uint32_t rects_len, + const xcb_rectangle_t *rects) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_FILL_RECTANGLES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_FILL_RECTANGLES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2619,18 +3595,40 @@ xcb_render_fill_rectangles (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_rectangle_t * +xcb_render_fill_rectangles_rects (const xcb_render_fill_rectangles_request_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + +int +xcb_render_fill_rectangles_rects_length (const xcb_render_fill_rectangles_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_fill_rectangles_request_t))/sizeof(xcb_rectangle_t)); +} + +xcb_rectangle_iterator_t +xcb_render_fill_rectangles_rects_iterator (const xcb_render_fill_rectangles_request_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_render_fill_rectangles_request_t))/sizeof(xcb_rectangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_render_create_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_render_picture_t source /**< */, - uint16_t x /**< */, - uint16_t y /**< */) +xcb_render_create_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_render_picture_t source, + uint16_t x, + uint16_t y) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2652,17 +3650,17 @@ xcb_render_create_cursor_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_create_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_render_picture_t source /**< */, - uint16_t x /**< */, - uint16_t y /**< */) +xcb_render_create_cursor (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_render_picture_t source, + uint16_t x, + uint16_t y) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2684,7 +3682,7 @@ xcb_render_create_cursor (xcb_connection_t *c /**< */, } void -xcb_render_transform_next (xcb_render_transform_iterator_t *i /**< */) +xcb_render_transform_next (xcb_render_transform_iterator_t *i) { --i->rem; ++i->data; @@ -2692,7 +3690,7 @@ xcb_render_transform_next (xcb_render_transform_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_transform_end (xcb_render_transform_iterator_t i /**< */) +xcb_render_transform_end (xcb_render_transform_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2702,15 +3700,15 @@ xcb_render_transform_end (xcb_render_transform_iterator_t i /**< */) } xcb_void_cookie_t -xcb_render_set_picture_transform_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_transform_t transform /**< */) +xcb_render_set_picture_transform_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_transform_t transform) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_SET_PICTURE_TRANSFORM, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_SET_PICTURE_TRANSFORM, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2730,15 +3728,15 @@ xcb_render_set_picture_transform_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_set_picture_transform (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_transform_t transform /**< */) +xcb_render_set_picture_transform (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_transform_t transform) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_SET_PICTURE_TRANSFORM, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_SET_PICTURE_TRANSFORM, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2758,7 +3756,7 @@ xcb_render_set_picture_transform (xcb_connection_t *c /**< */, } int -xcb_render_query_filters_sizeof (const void *_buffer /**< */) +xcb_render_query_filters_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_render_query_filters_reply_t *_aux = (xcb_render_query_filters_reply_t *)_buffer; @@ -2806,14 +3804,14 @@ xcb_render_query_filters_sizeof (const void *_buffer /**< */) } xcb_render_query_filters_cookie_t -xcb_render_query_filters (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_render_query_filters (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_QUERY_FILTERS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_QUERY_FILTERS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2832,14 +3830,14 @@ xcb_render_query_filters (xcb_connection_t *c /**< */, } xcb_render_query_filters_cookie_t -xcb_render_query_filters_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_render_query_filters_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_QUERY_FILTERS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_QUERY_FILTERS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2858,19 +3856,19 @@ xcb_render_query_filters_unchecked (xcb_connection_t *c /**< */, } uint16_t * -xcb_render_query_filters_aliases (const xcb_render_query_filters_reply_t *R /**< */) +xcb_render_query_filters_aliases (const xcb_render_query_filters_reply_t *R) { return (uint16_t *) (R + 1); } int -xcb_render_query_filters_aliases_length (const xcb_render_query_filters_reply_t *R /**< */) +xcb_render_query_filters_aliases_length (const xcb_render_query_filters_reply_t *R) { return R->num_aliases; } xcb_generic_iterator_t -xcb_render_query_filters_aliases_end (const xcb_render_query_filters_reply_t *R /**< */) +xcb_render_query_filters_aliases_end (const xcb_render_query_filters_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint16_t *) (R + 1)) + (R->num_aliases); @@ -2880,13 +3878,13 @@ xcb_render_query_filters_aliases_end (const xcb_render_query_filters_reply_t *R } int -xcb_render_query_filters_filters_length (const xcb_render_query_filters_reply_t *R /**< */) +xcb_render_query_filters_filters_length (const xcb_render_query_filters_reply_t *R) { return R->num_filters; } xcb_str_iterator_t -xcb_render_query_filters_filters_iterator (const xcb_render_query_filters_reply_t *R /**< */) +xcb_render_query_filters_filters_iterator (const xcb_render_query_filters_reply_t *R) { xcb_str_iterator_t i; xcb_generic_iterator_t prev = xcb_render_query_filters_aliases_end(R); @@ -2897,16 +3895,16 @@ xcb_render_query_filters_filters_iterator (const xcb_render_query_filters_reply_ } xcb_render_query_filters_reply_t * -xcb_render_query_filters_reply (xcb_connection_t *c /**< */, +xcb_render_query_filters_reply (xcb_connection_t *c, xcb_render_query_filters_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_render_query_filters_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_render_set_picture_filter_sizeof (const void *_buffer /**< */, - uint32_t values_len /**< */) +xcb_render_set_picture_filter_sizeof (const void *_buffer, + uint32_t values_len) { char *xcb_tmp = (char *)_buffer; const xcb_render_set_picture_filter_request_t *_aux = (xcb_render_set_picture_filter_request_t *)_buffer; @@ -2924,6 +3922,15 @@ xcb_render_set_picture_filter_sizeof (const void *_buffer /**< */, xcb_block_len += _aux->filter_len * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -2949,18 +3956,18 @@ xcb_render_set_picture_filter_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_set_picture_filter_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - uint16_t filter_len /**< */, - const char *filter /**< */, - uint32_t values_len /**< */, - const xcb_render_fixed_t *values /**< */) +xcb_render_set_picture_filter_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + uint16_t filter_len, + const char *filter, + uint32_t values_len, + const xcb_render_fixed_t *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_SET_PICTURE_FILTER, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_SET_PICTURE_FILTER, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -2991,18 +3998,18 @@ xcb_render_set_picture_filter_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_set_picture_filter (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - uint16_t filter_len /**< */, - const char *filter /**< */, - uint32_t values_len /**< */, - const xcb_render_fixed_t *values /**< */) +xcb_render_set_picture_filter (xcb_connection_t *c, + xcb_render_picture_t picture, + uint16_t filter_len, + const char *filter, + uint32_t values_len, + const xcb_render_fixed_t *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_SET_PICTURE_FILTER, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_SET_PICTURE_FILTER, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -3032,8 +4039,54 @@ xcb_render_set_picture_filter (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_render_set_picture_filter_filter (const xcb_render_set_picture_filter_request_t *R) +{ + return (char *) (R + 1); +} + +int +xcb_render_set_picture_filter_filter_length (const xcb_render_set_picture_filter_request_t *R) +{ + return R->filter_len; +} + +xcb_generic_iterator_t +xcb_render_set_picture_filter_filter_end (const xcb_render_set_picture_filter_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->filter_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_render_fixed_t * +xcb_render_set_picture_filter_values (const xcb_render_set_picture_filter_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_render_set_picture_filter_filter_end(R); + return (xcb_render_fixed_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); +} + +int +xcb_render_set_picture_filter_values_length (const xcb_render_set_picture_filter_request_t *R) +{ + return ((((char*)R) + R->length * 4) - (char*)(xcb_render_set_picture_filter_values(R))) / sizeof(xcb_render_fixed_t); +} + +xcb_generic_iterator_t +xcb_render_set_picture_filter_values_end (const xcb_render_set_picture_filter_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_render_set_picture_filter_filter_end(R); + i.data = ((xcb_render_fixed_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (((((char*)R) + R->length * 4) - (char*)(xcb_render_set_picture_filter_values(R))) / sizeof(xcb_render_fixed_t)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + void -xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i /**< */) +xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i) { --i->rem; ++i->data; @@ -3041,7 +4094,7 @@ xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i /**< */) +xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -3051,8 +4104,8 @@ xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i /**< */) } int -xcb_render_create_anim_cursor_sizeof (const void *_buffer /**< */, - uint32_t cursors_len /**< */) +xcb_render_create_anim_cursor_sizeof (const void *_buffer, + uint32_t cursors_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -3082,16 +4135,16 @@ xcb_render_create_anim_cursor_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_create_anim_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - uint32_t cursors_len /**< */, - const xcb_render_animcursorelt_t *cursors /**< */) +xcb_render_create_anim_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cid, + uint32_t cursors_len, + const xcb_render_animcursorelt_t *cursors) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_ANIM_CURSOR, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_ANIM_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -3115,16 +4168,16 @@ xcb_render_create_anim_cursor_checked (xcb_connection_t *c /**< } xcb_void_cookie_t -xcb_render_create_anim_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - uint32_t cursors_len /**< */, - const xcb_render_animcursorelt_t *cursors /**< */) +xcb_render_create_anim_cursor (xcb_connection_t *c, + xcb_cursor_t cid, + uint32_t cursors_len, + const xcb_render_animcursorelt_t *cursors) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_ANIM_CURSOR, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_ANIM_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -3147,8 +4200,30 @@ xcb_render_create_anim_cursor (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_render_animcursorelt_t * +xcb_render_create_anim_cursor_cursors (const xcb_render_create_anim_cursor_request_t *R) +{ + return (xcb_render_animcursorelt_t *) (R + 1); +} + +int +xcb_render_create_anim_cursor_cursors_length (const xcb_render_create_anim_cursor_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_create_anim_cursor_request_t))/sizeof(xcb_render_animcursorelt_t)); +} + +xcb_render_animcursorelt_iterator_t +xcb_render_create_anim_cursor_cursors_iterator (const xcb_render_create_anim_cursor_request_t *R) +{ + xcb_render_animcursorelt_iterator_t i; + i.data = (xcb_render_animcursorelt_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_render_create_anim_cursor_request_t))/sizeof(xcb_render_animcursorelt_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + void -xcb_render_spanfix_next (xcb_render_spanfix_iterator_t *i /**< */) +xcb_render_spanfix_next (xcb_render_spanfix_iterator_t *i) { --i->rem; ++i->data; @@ -3156,7 +4231,7 @@ xcb_render_spanfix_next (xcb_render_spanfix_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_spanfix_end (xcb_render_spanfix_iterator_t i /**< */) +xcb_render_spanfix_end (xcb_render_spanfix_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -3166,7 +4241,7 @@ xcb_render_spanfix_end (xcb_render_spanfix_iterator_t i /**< */) } void -xcb_render_trap_next (xcb_render_trap_iterator_t *i /**< */) +xcb_render_trap_next (xcb_render_trap_iterator_t *i) { --i->rem; ++i->data; @@ -3174,7 +4249,7 @@ xcb_render_trap_next (xcb_render_trap_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_render_trap_end (xcb_render_trap_iterator_t i /**< */) +xcb_render_trap_end (xcb_render_trap_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -3184,8 +4259,8 @@ xcb_render_trap_end (xcb_render_trap_iterator_t i /**< */) } int -xcb_render_add_traps_sizeof (const void *_buffer /**< */, - uint32_t traps_len /**< */) +xcb_render_add_traps_sizeof (const void *_buffer, + uint32_t traps_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -3215,18 +4290,18 @@ xcb_render_add_traps_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_render_add_traps_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - int16_t x_off /**< */, - int16_t y_off /**< */, - uint32_t traps_len /**< */, - const xcb_render_trap_t *traps /**< */) +xcb_render_add_traps_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + int16_t x_off, + int16_t y_off, + uint32_t traps_len, + const xcb_render_trap_t *traps) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_ADD_TRAPS, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_ADD_TRAPS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -3252,18 +4327,18 @@ xcb_render_add_traps_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_add_traps (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - int16_t x_off /**< */, - int16_t y_off /**< */, - uint32_t traps_len /**< */, - const xcb_render_trap_t *traps /**< */) +xcb_render_add_traps (xcb_connection_t *c, + xcb_render_picture_t picture, + int16_t x_off, + int16_t y_off, + uint32_t traps_len, + const xcb_render_trap_t *traps) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_ADD_TRAPS, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_ADD_TRAPS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -3288,16 +4363,38 @@ xcb_render_add_traps (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_render_trap_t * +xcb_render_add_traps_traps (const xcb_render_add_traps_request_t *R) +{ + return (xcb_render_trap_t *) (R + 1); +} + +int +xcb_render_add_traps_traps_length (const xcb_render_add_traps_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_render_add_traps_request_t))/sizeof(xcb_render_trap_t)); +} + +xcb_render_trap_iterator_t +xcb_render_add_traps_traps_iterator (const xcb_render_add_traps_request_t *R) +{ + xcb_render_trap_iterator_t i; + i.data = (xcb_render_trap_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_render_add_traps_request_t))/sizeof(xcb_render_trap_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_render_create_solid_fill_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_color_t color /**< */) +xcb_render_create_solid_fill_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_color_t color) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_SOLID_FILL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_SOLID_FILL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3317,15 +4414,15 @@ xcb_render_create_solid_fill_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_create_solid_fill (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_color_t color /**< */) +xcb_render_create_solid_fill (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_color_t color) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_SOLID_FILL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_SOLID_FILL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3345,7 +4442,7 @@ xcb_render_create_solid_fill (xcb_connection_t *c /**< */, } int -xcb_render_create_linear_gradient_sizeof (const void *_buffer /**< */) +xcb_render_create_linear_gradient_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_render_create_linear_gradient_request_t *_aux = (xcb_render_create_linear_gradient_request_t *)_buffer; @@ -3388,19 +4485,19 @@ xcb_render_create_linear_gradient_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_render_create_linear_gradient_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t p1 /**< */, - xcb_render_pointfix_t p2 /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */) +xcb_render_create_linear_gradient_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t p1, + xcb_render_pointfix_t p2, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_LINEAR_GRADIENT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_LINEAR_GRADIENT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -3432,19 +4529,19 @@ xcb_render_create_linear_gradient_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_create_linear_gradient (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t p1 /**< */, - xcb_render_pointfix_t p2 /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */) +xcb_render_create_linear_gradient (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t p1, + xcb_render_pointfix_t p2, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_LINEAR_GRADIENT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_LINEAR_GRADIENT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -3475,8 +4572,54 @@ xcb_render_create_linear_gradient (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_render_fixed_t * +xcb_render_create_linear_gradient_stops (const xcb_render_create_linear_gradient_request_t *R) +{ + return (xcb_render_fixed_t *) (R + 1); +} + int -xcb_render_create_radial_gradient_sizeof (const void *_buffer /**< */) +xcb_render_create_linear_gradient_stops_length (const xcb_render_create_linear_gradient_request_t *R) +{ + return R->num_stops; +} + +xcb_generic_iterator_t +xcb_render_create_linear_gradient_stops_end (const xcb_render_create_linear_gradient_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_render_fixed_t *) (R + 1)) + (R->num_stops); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_render_color_t * +xcb_render_create_linear_gradient_colors (const xcb_render_create_linear_gradient_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_render_create_linear_gradient_stops_end(R); + return (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index) + 0); +} + +int +xcb_render_create_linear_gradient_colors_length (const xcb_render_create_linear_gradient_request_t *R) +{ + return R->num_stops; +} + +xcb_render_color_iterator_t +xcb_render_create_linear_gradient_colors_iterator (const xcb_render_create_linear_gradient_request_t *R) +{ + xcb_render_color_iterator_t i; + xcb_generic_iterator_t prev = xcb_render_create_linear_gradient_stops_end(R); + i.data = (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index)); + i.rem = R->num_stops; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_render_create_radial_gradient_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_render_create_radial_gradient_request_t *_aux = (xcb_render_create_radial_gradient_request_t *)_buffer; @@ -3519,21 +4662,21 @@ xcb_render_create_radial_gradient_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_render_create_radial_gradient_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t inner /**< */, - xcb_render_pointfix_t outer /**< */, - xcb_render_fixed_t inner_radius /**< */, - xcb_render_fixed_t outer_radius /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */) +xcb_render_create_radial_gradient_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t inner, + xcb_render_pointfix_t outer, + xcb_render_fixed_t inner_radius, + xcb_render_fixed_t outer_radius, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_RADIAL_GRADIENT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_RADIAL_GRADIENT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -3567,21 +4710,21 @@ xcb_render_create_radial_gradient_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_render_create_radial_gradient (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t inner /**< */, - xcb_render_pointfix_t outer /**< */, - xcb_render_fixed_t inner_radius /**< */, - xcb_render_fixed_t outer_radius /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */) +xcb_render_create_radial_gradient (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t inner, + xcb_render_pointfix_t outer, + xcb_render_fixed_t inner_radius, + xcb_render_fixed_t outer_radius, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_RADIAL_GRADIENT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_RADIAL_GRADIENT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -3614,8 +4757,54 @@ xcb_render_create_radial_gradient (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_render_fixed_t * +xcb_render_create_radial_gradient_stops (const xcb_render_create_radial_gradient_request_t *R) +{ + return (xcb_render_fixed_t *) (R + 1); +} + int -xcb_render_create_conical_gradient_sizeof (const void *_buffer /**< */) +xcb_render_create_radial_gradient_stops_length (const xcb_render_create_radial_gradient_request_t *R) +{ + return R->num_stops; +} + +xcb_generic_iterator_t +xcb_render_create_radial_gradient_stops_end (const xcb_render_create_radial_gradient_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_render_fixed_t *) (R + 1)) + (R->num_stops); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_render_color_t * +xcb_render_create_radial_gradient_colors (const xcb_render_create_radial_gradient_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_render_create_radial_gradient_stops_end(R); + return (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index) + 0); +} + +int +xcb_render_create_radial_gradient_colors_length (const xcb_render_create_radial_gradient_request_t *R) +{ + return R->num_stops; +} + +xcb_render_color_iterator_t +xcb_render_create_radial_gradient_colors_iterator (const xcb_render_create_radial_gradient_request_t *R) +{ + xcb_render_color_iterator_t i; + xcb_generic_iterator_t prev = xcb_render_create_radial_gradient_stops_end(R); + i.data = (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index)); + i.rem = R->num_stops; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_render_create_conical_gradient_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_render_create_conical_gradient_request_t *_aux = (xcb_render_create_conical_gradient_request_t *)_buffer; @@ -3658,19 +4847,19 @@ xcb_render_create_conical_gradient_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_render_create_conical_gradient_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t center /**< */, - xcb_render_fixed_t angle /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */) +xcb_render_create_conical_gradient_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t center, + xcb_render_fixed_t angle, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_CONICAL_GRADIENT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_CONICAL_GRADIENT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -3702,19 +4891,19 @@ xcb_render_create_conical_gradient_checked (xcb_connection_t *c /**< */ } xcb_void_cookie_t -xcb_render_create_conical_gradient (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t center /**< */, - xcb_render_fixed_t angle /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */) +xcb_render_create_conical_gradient (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t center, + xcb_render_fixed_t angle, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_render_id, - /* opcode */ XCB_RENDER_CREATE_CONICAL_GRADIENT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_render_id, + .opcode = XCB_RENDER_CREATE_CONICAL_GRADIENT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -3745,3 +4934,49 @@ xcb_render_create_conical_gradient (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_render_fixed_t * +xcb_render_create_conical_gradient_stops (const xcb_render_create_conical_gradient_request_t *R) +{ + return (xcb_render_fixed_t *) (R + 1); +} + +int +xcb_render_create_conical_gradient_stops_length (const xcb_render_create_conical_gradient_request_t *R) +{ + return R->num_stops; +} + +xcb_generic_iterator_t +xcb_render_create_conical_gradient_stops_end (const xcb_render_create_conical_gradient_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_render_fixed_t *) (R + 1)) + (R->num_stops); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_render_color_t * +xcb_render_create_conical_gradient_colors (const xcb_render_create_conical_gradient_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_render_create_conical_gradient_stops_end(R); + return (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index) + 0); +} + +int +xcb_render_create_conical_gradient_colors_length (const xcb_render_create_conical_gradient_request_t *R) +{ + return R->num_stops; +} + +xcb_render_color_iterator_t +xcb_render_create_conical_gradient_colors_iterator (const xcb_render_create_conical_gradient_request_t *R) +{ + xcb_render_color_iterator_t i; + xcb_generic_iterator_t prev = xcb_render_create_conical_gradient_stops_end(R); + i.data = (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index)); + i.rem = R->num_stops; + i.index = (char *) i.data - (char *) R; + return i; +} + diff --git a/lib/libxcb/src/render.h b/lib/libxcb/src/render.h index 8b4a5243d..795c76dd9 100644 --- a/lib/libxcb/src/render.h +++ b/lib/libxcb/src/render.h @@ -137,9 +137,9 @@ typedef uint32_t xcb_render_glyph_t; * @brief xcb_render_glyph_iterator_t **/ typedef struct xcb_render_glyph_iterator_t { - xcb_render_glyph_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_glyph_t *data; + int rem; + int index; } xcb_render_glyph_iterator_t; typedef uint32_t xcb_render_glyphset_t; @@ -148,9 +148,9 @@ typedef uint32_t xcb_render_glyphset_t; * @brief xcb_render_glyphset_iterator_t **/ typedef struct xcb_render_glyphset_iterator_t { - xcb_render_glyphset_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_glyphset_t *data; + int rem; + int index; } xcb_render_glyphset_iterator_t; typedef uint32_t xcb_render_picture_t; @@ -159,9 +159,9 @@ typedef uint32_t xcb_render_picture_t; * @brief xcb_render_picture_iterator_t **/ typedef struct xcb_render_picture_iterator_t { - xcb_render_picture_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_picture_t *data; + int rem; + int index; } xcb_render_picture_iterator_t; typedef uint32_t xcb_render_pictformat_t; @@ -170,9 +170,9 @@ typedef uint32_t xcb_render_pictformat_t; * @brief xcb_render_pictformat_iterator_t **/ typedef struct xcb_render_pictformat_iterator_t { - xcb_render_pictformat_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_pictformat_t *data; + int rem; + int index; } xcb_render_pictformat_iterator_t; typedef int32_t xcb_render_fixed_t; @@ -181,9 +181,9 @@ typedef int32_t xcb_render_fixed_t; * @brief xcb_render_fixed_iterator_t **/ typedef struct xcb_render_fixed_iterator_t { - xcb_render_fixed_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_fixed_t *data; + int rem; + int index; } xcb_render_fixed_iterator_t; /** Opcode for xcb_render_pict_format. */ @@ -193,9 +193,9 @@ typedef struct xcb_render_fixed_iterator_t { * @brief xcb_render_pict_format_error_t **/ typedef struct xcb_render_pict_format_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_render_pict_format_error_t; /** Opcode for xcb_render_picture. */ @@ -205,9 +205,9 @@ typedef struct xcb_render_pict_format_error_t { * @brief xcb_render_picture_error_t **/ typedef struct xcb_render_picture_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_render_picture_error_t; /** Opcode for xcb_render_pict_op. */ @@ -217,9 +217,9 @@ typedef struct xcb_render_picture_error_t { * @brief xcb_render_pict_op_error_t **/ typedef struct xcb_render_pict_op_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_render_pict_op_error_t; /** Opcode for xcb_render_glyph_set. */ @@ -229,9 +229,9 @@ typedef struct xcb_render_pict_op_error_t { * @brief xcb_render_glyph_set_error_t **/ typedef struct xcb_render_glyph_set_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_render_glyph_set_error_t; /** Opcode for xcb_render_glyph. */ @@ -241,244 +241,244 @@ typedef struct xcb_render_glyph_set_error_t { * @brief xcb_render_glyph_error_t **/ typedef struct xcb_render_glyph_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_render_glyph_error_t; /** * @brief xcb_render_directformat_t **/ typedef struct xcb_render_directformat_t { - uint16_t red_shift; /**< */ - uint16_t red_mask; /**< */ - uint16_t green_shift; /**< */ - uint16_t green_mask; /**< */ - uint16_t blue_shift; /**< */ - uint16_t blue_mask; /**< */ - uint16_t alpha_shift; /**< */ - uint16_t alpha_mask; /**< */ + uint16_t red_shift; + uint16_t red_mask; + uint16_t green_shift; + uint16_t green_mask; + uint16_t blue_shift; + uint16_t blue_mask; + uint16_t alpha_shift; + uint16_t alpha_mask; } xcb_render_directformat_t; /** * @brief xcb_render_directformat_iterator_t **/ typedef struct xcb_render_directformat_iterator_t { - xcb_render_directformat_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_directformat_t *data; + int rem; + int index; } xcb_render_directformat_iterator_t; /** * @brief xcb_render_pictforminfo_t **/ typedef struct xcb_render_pictforminfo_t { - xcb_render_pictformat_t id; /**< */ - uint8_t type; /**< */ - uint8_t depth; /**< */ - uint8_t pad0[2]; /**< */ - xcb_render_directformat_t direct; /**< */ - xcb_colormap_t colormap; /**< */ + xcb_render_pictformat_t id; + uint8_t type; + uint8_t depth; + uint8_t pad0[2]; + xcb_render_directformat_t direct; + xcb_colormap_t colormap; } xcb_render_pictforminfo_t; /** * @brief xcb_render_pictforminfo_iterator_t **/ typedef struct xcb_render_pictforminfo_iterator_t { - xcb_render_pictforminfo_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_pictforminfo_t *data; + int rem; + int index; } xcb_render_pictforminfo_iterator_t; /** * @brief xcb_render_pictvisual_t **/ typedef struct xcb_render_pictvisual_t { - xcb_visualid_t visual; /**< */ - xcb_render_pictformat_t format; /**< */ + xcb_visualid_t visual; + xcb_render_pictformat_t format; } xcb_render_pictvisual_t; /** * @brief xcb_render_pictvisual_iterator_t **/ typedef struct xcb_render_pictvisual_iterator_t { - xcb_render_pictvisual_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_pictvisual_t *data; + int rem; + int index; } xcb_render_pictvisual_iterator_t; /** * @brief xcb_render_pictdepth_t **/ typedef struct xcb_render_pictdepth_t { - uint8_t depth; /**< */ - uint8_t pad0; /**< */ - uint16_t num_visuals; /**< */ - uint8_t pad1[4]; /**< */ + uint8_t depth; + uint8_t pad0; + uint16_t num_visuals; + uint8_t pad1[4]; } xcb_render_pictdepth_t; /** * @brief xcb_render_pictdepth_iterator_t **/ typedef struct xcb_render_pictdepth_iterator_t { - xcb_render_pictdepth_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_pictdepth_t *data; + int rem; + int index; } xcb_render_pictdepth_iterator_t; /** * @brief xcb_render_pictscreen_t **/ typedef struct xcb_render_pictscreen_t { - uint32_t num_depths; /**< */ - xcb_render_pictformat_t fallback; /**< */ + uint32_t num_depths; + xcb_render_pictformat_t fallback; } xcb_render_pictscreen_t; /** * @brief xcb_render_pictscreen_iterator_t **/ typedef struct xcb_render_pictscreen_iterator_t { - xcb_render_pictscreen_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_pictscreen_t *data; + int rem; + int index; } xcb_render_pictscreen_iterator_t; /** * @brief xcb_render_indexvalue_t **/ typedef struct xcb_render_indexvalue_t { - uint32_t pixel; /**< */ - uint16_t red; /**< */ - uint16_t green; /**< */ - uint16_t blue; /**< */ - uint16_t alpha; /**< */ + uint32_t pixel; + uint16_t red; + uint16_t green; + uint16_t blue; + uint16_t alpha; } xcb_render_indexvalue_t; /** * @brief xcb_render_indexvalue_iterator_t **/ typedef struct xcb_render_indexvalue_iterator_t { - xcb_render_indexvalue_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_indexvalue_t *data; + int rem; + int index; } xcb_render_indexvalue_iterator_t; /** * @brief xcb_render_color_t **/ typedef struct xcb_render_color_t { - uint16_t red; /**< */ - uint16_t green; /**< */ - uint16_t blue; /**< */ - uint16_t alpha; /**< */ + uint16_t red; + uint16_t green; + uint16_t blue; + uint16_t alpha; } xcb_render_color_t; /** * @brief xcb_render_color_iterator_t **/ typedef struct xcb_render_color_iterator_t { - xcb_render_color_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_color_t *data; + int rem; + int index; } xcb_render_color_iterator_t; /** * @brief xcb_render_pointfix_t **/ typedef struct xcb_render_pointfix_t { - xcb_render_fixed_t x; /**< */ - xcb_render_fixed_t y; /**< */ + xcb_render_fixed_t x; + xcb_render_fixed_t y; } xcb_render_pointfix_t; /** * @brief xcb_render_pointfix_iterator_t **/ typedef struct xcb_render_pointfix_iterator_t { - xcb_render_pointfix_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_pointfix_t *data; + int rem; + int index; } xcb_render_pointfix_iterator_t; /** * @brief xcb_render_linefix_t **/ typedef struct xcb_render_linefix_t { - xcb_render_pointfix_t p1; /**< */ - xcb_render_pointfix_t p2; /**< */ + xcb_render_pointfix_t p1; + xcb_render_pointfix_t p2; } xcb_render_linefix_t; /** * @brief xcb_render_linefix_iterator_t **/ typedef struct xcb_render_linefix_iterator_t { - xcb_render_linefix_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_linefix_t *data; + int rem; + int index; } xcb_render_linefix_iterator_t; /** * @brief xcb_render_triangle_t **/ typedef struct xcb_render_triangle_t { - xcb_render_pointfix_t p1; /**< */ - xcb_render_pointfix_t p2; /**< */ - xcb_render_pointfix_t p3; /**< */ + xcb_render_pointfix_t p1; + xcb_render_pointfix_t p2; + xcb_render_pointfix_t p3; } xcb_render_triangle_t; /** * @brief xcb_render_triangle_iterator_t **/ typedef struct xcb_render_triangle_iterator_t { - xcb_render_triangle_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_triangle_t *data; + int rem; + int index; } xcb_render_triangle_iterator_t; /** * @brief xcb_render_trapezoid_t **/ typedef struct xcb_render_trapezoid_t { - xcb_render_fixed_t top; /**< */ - xcb_render_fixed_t bottom; /**< */ - xcb_render_linefix_t left; /**< */ - xcb_render_linefix_t right; /**< */ + xcb_render_fixed_t top; + xcb_render_fixed_t bottom; + xcb_render_linefix_t left; + xcb_render_linefix_t right; } xcb_render_trapezoid_t; /** * @brief xcb_render_trapezoid_iterator_t **/ typedef struct xcb_render_trapezoid_iterator_t { - xcb_render_trapezoid_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_trapezoid_t *data; + int rem; + int index; } xcb_render_trapezoid_iterator_t; /** * @brief xcb_render_glyphinfo_t **/ typedef struct xcb_render_glyphinfo_t { - uint16_t width; /**< */ - uint16_t height; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - int16_t x_off; /**< */ - int16_t y_off; /**< */ + uint16_t width; + uint16_t height; + int16_t x; + int16_t y; + int16_t x_off; + int16_t y_off; } xcb_render_glyphinfo_t; /** * @brief xcb_render_glyphinfo_iterator_t **/ typedef struct xcb_render_glyphinfo_iterator_t { - xcb_render_glyphinfo_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_glyphinfo_t *data; + int rem; + int index; } xcb_render_glyphinfo_iterator_t; /** * @brief xcb_render_query_version_cookie_t **/ typedef struct xcb_render_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_render_query_version_cookie_t; /** Opcode for xcb_render_query_version. */ @@ -488,31 +488,31 @@ typedef struct xcb_render_query_version_cookie_t { * @brief xcb_render_query_version_request_t **/ typedef struct xcb_render_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t client_major_version; /**< */ - uint32_t client_minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t client_major_version; + uint32_t client_minor_version; } xcb_render_query_version_request_t; /** * @brief xcb_render_query_version_reply_t **/ typedef struct xcb_render_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t major_version; + uint32_t minor_version; + uint8_t pad1[16]; } xcb_render_query_version_reply_t; /** * @brief xcb_render_query_pict_formats_cookie_t **/ typedef struct xcb_render_query_pict_formats_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_render_query_pict_formats_cookie_t; /** Opcode for xcb_render_query_pict_formats. */ @@ -522,32 +522,32 @@ typedef struct xcb_render_query_pict_formats_cookie_t { * @brief xcb_render_query_pict_formats_request_t **/ typedef struct xcb_render_query_pict_formats_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_render_query_pict_formats_request_t; /** * @brief xcb_render_query_pict_formats_reply_t **/ typedef struct xcb_render_query_pict_formats_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_formats; /**< */ - uint32_t num_screens; /**< */ - uint32_t num_depths; /**< */ - uint32_t num_visuals; /**< */ - uint32_t num_subpixel; /**< */ - uint8_t pad1[4]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_formats; + uint32_t num_screens; + uint32_t num_depths; + uint32_t num_visuals; + uint32_t num_subpixel; + uint8_t pad1[4]; } xcb_render_query_pict_formats_reply_t; /** * @brief xcb_render_query_pict_index_values_cookie_t **/ typedef struct xcb_render_query_pict_index_values_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_render_query_pict_index_values_cookie_t; /** Opcode for xcb_render_query_pict_index_values. */ @@ -557,24 +557,43 @@ typedef struct xcb_render_query_pict_index_values_cookie_t { * @brief xcb_render_query_pict_index_values_request_t **/ typedef struct xcb_render_query_pict_index_values_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_pictformat_t format; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_pictformat_t format; } xcb_render_query_pict_index_values_request_t; /** * @brief xcb_render_query_pict_index_values_reply_t **/ typedef struct xcb_render_query_pict_index_values_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_values; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_values; + uint8_t pad1[20]; } xcb_render_query_pict_index_values_reply_t; +/** + * @brief xcb_render_create_picture_value_list_t + **/ +typedef struct xcb_render_create_picture_value_list_t { + uint32_t repeat; + xcb_render_picture_t alphamap; + int32_t alphaxorigin; + int32_t alphayorigin; + int32_t clipxorigin; + int32_t clipyorigin; + xcb_pixmap_t clipmask; + uint32_t graphicsexposure; + uint32_t subwindowmode; + uint32_t polyedge; + uint32_t polymode; + xcb_atom_t dither; + uint32_t componentalpha; +} xcb_render_create_picture_value_list_t; + /** Opcode for xcb_render_create_picture. */ #define XCB_RENDER_CREATE_PICTURE 4 @@ -582,15 +601,34 @@ typedef struct xcb_render_query_pict_index_values_reply_t { * @brief xcb_render_create_picture_request_t **/ typedef struct xcb_render_create_picture_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t pid; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_render_pictformat_t format; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t pid; + xcb_drawable_t drawable; + xcb_render_pictformat_t format; + uint32_t value_mask; } xcb_render_create_picture_request_t; +/** + * @brief xcb_render_change_picture_value_list_t + **/ +typedef struct xcb_render_change_picture_value_list_t { + uint32_t repeat; + xcb_render_picture_t alphamap; + int32_t alphaxorigin; + int32_t alphayorigin; + int32_t clipxorigin; + int32_t clipyorigin; + xcb_pixmap_t clipmask; + uint32_t graphicsexposure; + uint32_t subwindowmode; + uint32_t polyedge; + uint32_t polymode; + xcb_atom_t dither; + uint32_t componentalpha; +} xcb_render_change_picture_value_list_t; + /** Opcode for xcb_render_change_picture. */ #define XCB_RENDER_CHANGE_PICTURE 5 @@ -598,11 +636,11 @@ typedef struct xcb_render_create_picture_request_t { * @brief xcb_render_change_picture_request_t **/ typedef struct xcb_render_change_picture_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; + uint32_t value_mask; } xcb_render_change_picture_request_t; /** Opcode for xcb_render_set_picture_clip_rectangles. */ @@ -612,12 +650,12 @@ typedef struct xcb_render_change_picture_request_t { * @brief xcb_render_set_picture_clip_rectangles_request_t **/ typedef struct xcb_render_set_picture_clip_rectangles_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ - int16_t clip_x_origin; /**< */ - int16_t clip_y_origin; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; + int16_t clip_x_origin; + int16_t clip_y_origin; } xcb_render_set_picture_clip_rectangles_request_t; /** Opcode for xcb_render_free_picture. */ @@ -627,10 +665,10 @@ typedef struct xcb_render_set_picture_clip_rectangles_request_t { * @brief xcb_render_free_picture_request_t **/ typedef struct xcb_render_free_picture_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; } xcb_render_free_picture_request_t; /** Opcode for xcb_render_composite. */ @@ -640,22 +678,22 @@ typedef struct xcb_render_free_picture_request_t { * @brief xcb_render_composite_request_t **/ typedef struct xcb_render_composite_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t op; /**< */ - uint8_t pad0[3]; /**< */ - xcb_render_picture_t src; /**< */ - xcb_render_picture_t mask; /**< */ - xcb_render_picture_t dst; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ - int16_t mask_x; /**< */ - int16_t mask_y; /**< */ - int16_t dst_x; /**< */ - int16_t dst_y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t op; + uint8_t pad0[3]; + xcb_render_picture_t src; + xcb_render_picture_t mask; + xcb_render_picture_t dst; + int16_t src_x; + int16_t src_y; + int16_t mask_x; + int16_t mask_y; + int16_t dst_x; + int16_t dst_y; + uint16_t width; + uint16_t height; } xcb_render_composite_request_t; /** Opcode for xcb_render_trapezoids. */ @@ -665,16 +703,16 @@ typedef struct xcb_render_composite_request_t { * @brief xcb_render_trapezoids_request_t **/ typedef struct xcb_render_trapezoids_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t op; /**< */ - uint8_t pad0[3]; /**< */ - xcb_render_picture_t src; /**< */ - xcb_render_picture_t dst; /**< */ - xcb_render_pictformat_t mask_format; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t op; + uint8_t pad0[3]; + xcb_render_picture_t src; + xcb_render_picture_t dst; + xcb_render_pictformat_t mask_format; + int16_t src_x; + int16_t src_y; } xcb_render_trapezoids_request_t; /** Opcode for xcb_render_triangles. */ @@ -684,16 +722,16 @@ typedef struct xcb_render_trapezoids_request_t { * @brief xcb_render_triangles_request_t **/ typedef struct xcb_render_triangles_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t op; /**< */ - uint8_t pad0[3]; /**< */ - xcb_render_picture_t src; /**< */ - xcb_render_picture_t dst; /**< */ - xcb_render_pictformat_t mask_format; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t op; + uint8_t pad0[3]; + xcb_render_picture_t src; + xcb_render_picture_t dst; + xcb_render_pictformat_t mask_format; + int16_t src_x; + int16_t src_y; } xcb_render_triangles_request_t; /** Opcode for xcb_render_tri_strip. */ @@ -703,16 +741,16 @@ typedef struct xcb_render_triangles_request_t { * @brief xcb_render_tri_strip_request_t **/ typedef struct xcb_render_tri_strip_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t op; /**< */ - uint8_t pad0[3]; /**< */ - xcb_render_picture_t src; /**< */ - xcb_render_picture_t dst; /**< */ - xcb_render_pictformat_t mask_format; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t op; + uint8_t pad0[3]; + xcb_render_picture_t src; + xcb_render_picture_t dst; + xcb_render_pictformat_t mask_format; + int16_t src_x; + int16_t src_y; } xcb_render_tri_strip_request_t; /** Opcode for xcb_render_tri_fan. */ @@ -722,16 +760,16 @@ typedef struct xcb_render_tri_strip_request_t { * @brief xcb_render_tri_fan_request_t **/ typedef struct xcb_render_tri_fan_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t op; /**< */ - uint8_t pad0[3]; /**< */ - xcb_render_picture_t src; /**< */ - xcb_render_picture_t dst; /**< */ - xcb_render_pictformat_t mask_format; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t op; + uint8_t pad0[3]; + xcb_render_picture_t src; + xcb_render_picture_t dst; + xcb_render_pictformat_t mask_format; + int16_t src_x; + int16_t src_y; } xcb_render_tri_fan_request_t; /** Opcode for xcb_render_create_glyph_set. */ @@ -741,11 +779,11 @@ typedef struct xcb_render_tri_fan_request_t { * @brief xcb_render_create_glyph_set_request_t **/ typedef struct xcb_render_create_glyph_set_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_glyphset_t gsid; /**< */ - xcb_render_pictformat_t format; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_glyphset_t gsid; + xcb_render_pictformat_t format; } xcb_render_create_glyph_set_request_t; /** Opcode for xcb_render_reference_glyph_set. */ @@ -755,11 +793,11 @@ typedef struct xcb_render_create_glyph_set_request_t { * @brief xcb_render_reference_glyph_set_request_t **/ typedef struct xcb_render_reference_glyph_set_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_glyphset_t gsid; /**< */ - xcb_render_glyphset_t existing; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_glyphset_t gsid; + xcb_render_glyphset_t existing; } xcb_render_reference_glyph_set_request_t; /** Opcode for xcb_render_free_glyph_set. */ @@ -769,10 +807,10 @@ typedef struct xcb_render_reference_glyph_set_request_t { * @brief xcb_render_free_glyph_set_request_t **/ typedef struct xcb_render_free_glyph_set_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_glyphset_t glyphset; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_glyphset_t glyphset; } xcb_render_free_glyph_set_request_t; /** Opcode for xcb_render_add_glyphs. */ @@ -782,11 +820,11 @@ typedef struct xcb_render_free_glyph_set_request_t { * @brief xcb_render_add_glyphs_request_t **/ typedef struct xcb_render_add_glyphs_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_glyphset_t glyphset; /**< */ - uint32_t glyphs_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_glyphset_t glyphset; + uint32_t glyphs_len; } xcb_render_add_glyphs_request_t; /** Opcode for xcb_render_free_glyphs. */ @@ -796,10 +834,10 @@ typedef struct xcb_render_add_glyphs_request_t { * @brief xcb_render_free_glyphs_request_t **/ typedef struct xcb_render_free_glyphs_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_glyphset_t glyphset; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_glyphset_t glyphset; } xcb_render_free_glyphs_request_t; /** Opcode for xcb_render_composite_glyphs_8. */ @@ -809,17 +847,17 @@ typedef struct xcb_render_free_glyphs_request_t { * @brief xcb_render_composite_glyphs_8_request_t **/ typedef struct xcb_render_composite_glyphs_8_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t op; /**< */ - uint8_t pad0[3]; /**< */ - xcb_render_picture_t src; /**< */ - xcb_render_picture_t dst; /**< */ - xcb_render_pictformat_t mask_format; /**< */ - xcb_render_glyphset_t glyphset; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t op; + uint8_t pad0[3]; + xcb_render_picture_t src; + xcb_render_picture_t dst; + xcb_render_pictformat_t mask_format; + xcb_render_glyphset_t glyphset; + int16_t src_x; + int16_t src_y; } xcb_render_composite_glyphs_8_request_t; /** Opcode for xcb_render_composite_glyphs_16. */ @@ -829,17 +867,17 @@ typedef struct xcb_render_composite_glyphs_8_request_t { * @brief xcb_render_composite_glyphs_16_request_t **/ typedef struct xcb_render_composite_glyphs_16_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t op; /**< */ - uint8_t pad0[3]; /**< */ - xcb_render_picture_t src; /**< */ - xcb_render_picture_t dst; /**< */ - xcb_render_pictformat_t mask_format; /**< */ - xcb_render_glyphset_t glyphset; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t op; + uint8_t pad0[3]; + xcb_render_picture_t src; + xcb_render_picture_t dst; + xcb_render_pictformat_t mask_format; + xcb_render_glyphset_t glyphset; + int16_t src_x; + int16_t src_y; } xcb_render_composite_glyphs_16_request_t; /** Opcode for xcb_render_composite_glyphs_32. */ @@ -849,17 +887,17 @@ typedef struct xcb_render_composite_glyphs_16_request_t { * @brief xcb_render_composite_glyphs_32_request_t **/ typedef struct xcb_render_composite_glyphs_32_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t op; /**< */ - uint8_t pad0[3]; /**< */ - xcb_render_picture_t src; /**< */ - xcb_render_picture_t dst; /**< */ - xcb_render_pictformat_t mask_format; /**< */ - xcb_render_glyphset_t glyphset; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t op; + uint8_t pad0[3]; + xcb_render_picture_t src; + xcb_render_picture_t dst; + xcb_render_pictformat_t mask_format; + xcb_render_glyphset_t glyphset; + int16_t src_x; + int16_t src_y; } xcb_render_composite_glyphs_32_request_t; /** Opcode for xcb_render_fill_rectangles. */ @@ -869,13 +907,13 @@ typedef struct xcb_render_composite_glyphs_32_request_t { * @brief xcb_render_fill_rectangles_request_t **/ typedef struct xcb_render_fill_rectangles_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t op; /**< */ - uint8_t pad0[3]; /**< */ - xcb_render_picture_t dst; /**< */ - xcb_render_color_t color; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t op; + uint8_t pad0[3]; + xcb_render_picture_t dst; + xcb_render_color_t color; } xcb_render_fill_rectangles_request_t; /** Opcode for xcb_render_create_cursor. */ @@ -885,37 +923,37 @@ typedef struct xcb_render_fill_rectangles_request_t { * @brief xcb_render_create_cursor_request_t **/ typedef struct xcb_render_create_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_cursor_t cid; /**< */ - xcb_render_picture_t source; /**< */ - uint16_t x; /**< */ - uint16_t y; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_cursor_t cid; + xcb_render_picture_t source; + uint16_t x; + uint16_t y; } xcb_render_create_cursor_request_t; /** * @brief xcb_render_transform_t **/ typedef struct xcb_render_transform_t { - xcb_render_fixed_t matrix11; /**< */ - xcb_render_fixed_t matrix12; /**< */ - xcb_render_fixed_t matrix13; /**< */ - xcb_render_fixed_t matrix21; /**< */ - xcb_render_fixed_t matrix22; /**< */ - xcb_render_fixed_t matrix23; /**< */ - xcb_render_fixed_t matrix31; /**< */ - xcb_render_fixed_t matrix32; /**< */ - xcb_render_fixed_t matrix33; /**< */ + xcb_render_fixed_t matrix11; + xcb_render_fixed_t matrix12; + xcb_render_fixed_t matrix13; + xcb_render_fixed_t matrix21; + xcb_render_fixed_t matrix22; + xcb_render_fixed_t matrix23; + xcb_render_fixed_t matrix31; + xcb_render_fixed_t matrix32; + xcb_render_fixed_t matrix33; } xcb_render_transform_t; /** * @brief xcb_render_transform_iterator_t **/ typedef struct xcb_render_transform_iterator_t { - xcb_render_transform_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_transform_t *data; + int rem; + int index; } xcb_render_transform_iterator_t; /** Opcode for xcb_render_set_picture_transform. */ @@ -925,18 +963,18 @@ typedef struct xcb_render_transform_iterator_t { * @brief xcb_render_set_picture_transform_request_t **/ typedef struct xcb_render_set_picture_transform_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ - xcb_render_transform_t transform; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; + xcb_render_transform_t transform; } xcb_render_set_picture_transform_request_t; /** * @brief xcb_render_query_filters_cookie_t **/ typedef struct xcb_render_query_filters_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_render_query_filters_cookie_t; /** Opcode for xcb_render_query_filters. */ @@ -946,23 +984,23 @@ typedef struct xcb_render_query_filters_cookie_t { * @brief xcb_render_query_filters_request_t **/ typedef struct xcb_render_query_filters_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; } xcb_render_query_filters_request_t; /** * @brief xcb_render_query_filters_reply_t **/ typedef struct xcb_render_query_filters_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_aliases; /**< */ - uint32_t num_filters; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_aliases; + uint32_t num_filters; + uint8_t pad1[16]; } xcb_render_query_filters_reply_t; /** Opcode for xcb_render_set_picture_filter. */ @@ -972,29 +1010,29 @@ typedef struct xcb_render_query_filters_reply_t { * @brief xcb_render_set_picture_filter_request_t **/ typedef struct xcb_render_set_picture_filter_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ - uint16_t filter_len; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; + uint16_t filter_len; + uint8_t pad0[2]; } xcb_render_set_picture_filter_request_t; /** * @brief xcb_render_animcursorelt_t **/ typedef struct xcb_render_animcursorelt_t { - xcb_cursor_t cursor; /**< */ - uint32_t delay; /**< */ + xcb_cursor_t cursor; + uint32_t delay; } xcb_render_animcursorelt_t; /** * @brief xcb_render_animcursorelt_iterator_t **/ typedef struct xcb_render_animcursorelt_iterator_t { - xcb_render_animcursorelt_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_animcursorelt_t *data; + int rem; + int index; } xcb_render_animcursorelt_iterator_t; /** Opcode for xcb_render_create_anim_cursor. */ @@ -1004,45 +1042,45 @@ typedef struct xcb_render_animcursorelt_iterator_t { * @brief xcb_render_create_anim_cursor_request_t **/ typedef struct xcb_render_create_anim_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_cursor_t cid; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_cursor_t cid; } xcb_render_create_anim_cursor_request_t; /** * @brief xcb_render_spanfix_t **/ typedef struct xcb_render_spanfix_t { - xcb_render_fixed_t l; /**< */ - xcb_render_fixed_t r; /**< */ - xcb_render_fixed_t y; /**< */ + xcb_render_fixed_t l; + xcb_render_fixed_t r; + xcb_render_fixed_t y; } xcb_render_spanfix_t; /** * @brief xcb_render_spanfix_iterator_t **/ typedef struct xcb_render_spanfix_iterator_t { - xcb_render_spanfix_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_spanfix_t *data; + int rem; + int index; } xcb_render_spanfix_iterator_t; /** * @brief xcb_render_trap_t **/ typedef struct xcb_render_trap_t { - xcb_render_spanfix_t top; /**< */ - xcb_render_spanfix_t bot; /**< */ + xcb_render_spanfix_t top; + xcb_render_spanfix_t bot; } xcb_render_trap_t; /** * @brief xcb_render_trap_iterator_t **/ typedef struct xcb_render_trap_iterator_t { - xcb_render_trap_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_render_trap_t *data; + int rem; + int index; } xcb_render_trap_iterator_t; /** Opcode for xcb_render_add_traps. */ @@ -1052,12 +1090,12 @@ typedef struct xcb_render_trap_iterator_t { * @brief xcb_render_add_traps_request_t **/ typedef struct xcb_render_add_traps_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ - int16_t x_off; /**< */ - int16_t y_off; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; + int16_t x_off; + int16_t y_off; } xcb_render_add_traps_request_t; /** Opcode for xcb_render_create_solid_fill. */ @@ -1067,11 +1105,11 @@ typedef struct xcb_render_add_traps_request_t { * @brief xcb_render_create_solid_fill_request_t **/ typedef struct xcb_render_create_solid_fill_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ - xcb_render_color_t color; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; + xcb_render_color_t color; } xcb_render_create_solid_fill_request_t; /** Opcode for xcb_render_create_linear_gradient. */ @@ -1081,13 +1119,13 @@ typedef struct xcb_render_create_solid_fill_request_t { * @brief xcb_render_create_linear_gradient_request_t **/ typedef struct xcb_render_create_linear_gradient_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ - xcb_render_pointfix_t p1; /**< */ - xcb_render_pointfix_t p2; /**< */ - uint32_t num_stops; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; + xcb_render_pointfix_t p1; + xcb_render_pointfix_t p2; + uint32_t num_stops; } xcb_render_create_linear_gradient_request_t; /** Opcode for xcb_render_create_radial_gradient. */ @@ -1097,15 +1135,15 @@ typedef struct xcb_render_create_linear_gradient_request_t { * @brief xcb_render_create_radial_gradient_request_t **/ typedef struct xcb_render_create_radial_gradient_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ - xcb_render_pointfix_t inner; /**< */ - xcb_render_pointfix_t outer; /**< */ - xcb_render_fixed_t inner_radius; /**< */ - xcb_render_fixed_t outer_radius; /**< */ - uint32_t num_stops; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; + xcb_render_pointfix_t inner; + xcb_render_pointfix_t outer; + xcb_render_fixed_t inner_radius; + xcb_render_fixed_t outer_radius; + uint32_t num_stops; } xcb_render_create_radial_gradient_request_t; /** Opcode for xcb_render_create_conical_gradient. */ @@ -1115,13 +1153,13 @@ typedef struct xcb_render_create_radial_gradient_request_t { * @brief xcb_render_create_conical_gradient_request_t **/ typedef struct xcb_render_create_conical_gradient_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ - xcb_render_pointfix_t center; /**< */ - xcb_render_fixed_t angle; /**< */ - uint32_t num_stops; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; + xcb_render_pointfix_t center; + xcb_render_fixed_t angle; + uint32_t num_stops; } xcb_render_create_conical_gradient_request_t; /** @@ -1133,7 +1171,7 @@ typedef struct xcb_render_create_conical_gradient_request_t { * element. The member index is increased by sizeof(xcb_render_glyph_t) */ void -xcb_render_glyph_next (xcb_render_glyph_iterator_t *i /**< */); +xcb_render_glyph_next (xcb_render_glyph_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1145,7 +1183,7 @@ xcb_render_glyph_next (xcb_render_glyph_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_glyph_end (xcb_render_glyph_iterator_t i /**< */); +xcb_render_glyph_end (xcb_render_glyph_iterator_t i); /** * Get the next element of the iterator @@ -1156,7 +1194,7 @@ xcb_render_glyph_end (xcb_render_glyph_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_glyphset_t) */ void -xcb_render_glyphset_next (xcb_render_glyphset_iterator_t *i /**< */); +xcb_render_glyphset_next (xcb_render_glyphset_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1168,7 +1206,7 @@ xcb_render_glyphset_next (xcb_render_glyphset_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_glyphset_end (xcb_render_glyphset_iterator_t i /**< */); +xcb_render_glyphset_end (xcb_render_glyphset_iterator_t i); /** * Get the next element of the iterator @@ -1179,7 +1217,7 @@ xcb_render_glyphset_end (xcb_render_glyphset_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_picture_t) */ void -xcb_render_picture_next (xcb_render_picture_iterator_t *i /**< */); +xcb_render_picture_next (xcb_render_picture_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1191,7 +1229,7 @@ xcb_render_picture_next (xcb_render_picture_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_picture_end (xcb_render_picture_iterator_t i /**< */); +xcb_render_picture_end (xcb_render_picture_iterator_t i); /** * Get the next element of the iterator @@ -1202,7 +1240,7 @@ xcb_render_picture_end (xcb_render_picture_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_pictformat_t) */ void -xcb_render_pictformat_next (xcb_render_pictformat_iterator_t *i /**< */); +xcb_render_pictformat_next (xcb_render_pictformat_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1214,7 +1252,7 @@ xcb_render_pictformat_next (xcb_render_pictformat_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_pictformat_end (xcb_render_pictformat_iterator_t i /**< */); +xcb_render_pictformat_end (xcb_render_pictformat_iterator_t i); /** * Get the next element of the iterator @@ -1225,7 +1263,7 @@ xcb_render_pictformat_end (xcb_render_pictformat_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_fixed_t) */ void -xcb_render_fixed_next (xcb_render_fixed_iterator_t *i /**< */); +xcb_render_fixed_next (xcb_render_fixed_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1237,7 +1275,7 @@ xcb_render_fixed_next (xcb_render_fixed_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_fixed_end (xcb_render_fixed_iterator_t i /**< */); +xcb_render_fixed_end (xcb_render_fixed_iterator_t i); /** * Get the next element of the iterator @@ -1248,7 +1286,7 @@ xcb_render_fixed_end (xcb_render_fixed_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_directformat_t) */ void -xcb_render_directformat_next (xcb_render_directformat_iterator_t *i /**< */); +xcb_render_directformat_next (xcb_render_directformat_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1260,7 +1298,7 @@ xcb_render_directformat_next (xcb_render_directformat_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_directformat_end (xcb_render_directformat_iterator_t i /**< */); +xcb_render_directformat_end (xcb_render_directformat_iterator_t i); /** * Get the next element of the iterator @@ -1271,7 +1309,7 @@ xcb_render_directformat_end (xcb_render_directformat_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_pictforminfo_t) */ void -xcb_render_pictforminfo_next (xcb_render_pictforminfo_iterator_t *i /**< */); +xcb_render_pictforminfo_next (xcb_render_pictforminfo_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1283,7 +1321,7 @@ xcb_render_pictforminfo_next (xcb_render_pictforminfo_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_pictforminfo_end (xcb_render_pictforminfo_iterator_t i /**< */); +xcb_render_pictforminfo_end (xcb_render_pictforminfo_iterator_t i); /** * Get the next element of the iterator @@ -1294,7 +1332,7 @@ xcb_render_pictforminfo_end (xcb_render_pictforminfo_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_pictvisual_t) */ void -xcb_render_pictvisual_next (xcb_render_pictvisual_iterator_t *i /**< */); +xcb_render_pictvisual_next (xcb_render_pictvisual_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1306,19 +1344,19 @@ xcb_render_pictvisual_next (xcb_render_pictvisual_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_pictvisual_end (xcb_render_pictvisual_iterator_t i /**< */); +xcb_render_pictvisual_end (xcb_render_pictvisual_iterator_t i); int -xcb_render_pictdepth_sizeof (const void *_buffer /**< */); +xcb_render_pictdepth_sizeof (const void *_buffer); xcb_render_pictvisual_t * -xcb_render_pictdepth_visuals (const xcb_render_pictdepth_t *R /**< */); +xcb_render_pictdepth_visuals (const xcb_render_pictdepth_t *R); int -xcb_render_pictdepth_visuals_length (const xcb_render_pictdepth_t *R /**< */); +xcb_render_pictdepth_visuals_length (const xcb_render_pictdepth_t *R); xcb_render_pictvisual_iterator_t -xcb_render_pictdepth_visuals_iterator (const xcb_render_pictdepth_t *R /**< */); +xcb_render_pictdepth_visuals_iterator (const xcb_render_pictdepth_t *R); /** * Get the next element of the iterator @@ -1329,7 +1367,7 @@ xcb_render_pictdepth_visuals_iterator (const xcb_render_pictdepth_t *R /**< */) * element. The member index is increased by sizeof(xcb_render_pictdepth_t) */ void -xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i /**< */); +xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1341,16 +1379,16 @@ xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_pictdepth_end (xcb_render_pictdepth_iterator_t i /**< */); +xcb_render_pictdepth_end (xcb_render_pictdepth_iterator_t i); int -xcb_render_pictscreen_sizeof (const void *_buffer /**< */); +xcb_render_pictscreen_sizeof (const void *_buffer); int -xcb_render_pictscreen_depths_length (const xcb_render_pictscreen_t *R /**< */); +xcb_render_pictscreen_depths_length (const xcb_render_pictscreen_t *R); xcb_render_pictdepth_iterator_t -xcb_render_pictscreen_depths_iterator (const xcb_render_pictscreen_t *R /**< */); +xcb_render_pictscreen_depths_iterator (const xcb_render_pictscreen_t *R); /** * Get the next element of the iterator @@ -1361,7 +1399,7 @@ xcb_render_pictscreen_depths_iterator (const xcb_render_pictscreen_t *R /**< */ * element. The member index is increased by sizeof(xcb_render_pictscreen_t) */ void -xcb_render_pictscreen_next (xcb_render_pictscreen_iterator_t *i /**< */); +xcb_render_pictscreen_next (xcb_render_pictscreen_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1373,7 +1411,7 @@ xcb_render_pictscreen_next (xcb_render_pictscreen_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_pictscreen_end (xcb_render_pictscreen_iterator_t i /**< */); +xcb_render_pictscreen_end (xcb_render_pictscreen_iterator_t i); /** * Get the next element of the iterator @@ -1384,7 +1422,7 @@ xcb_render_pictscreen_end (xcb_render_pictscreen_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_indexvalue_t) */ void -xcb_render_indexvalue_next (xcb_render_indexvalue_iterator_t *i /**< */); +xcb_render_indexvalue_next (xcb_render_indexvalue_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1396,7 +1434,7 @@ xcb_render_indexvalue_next (xcb_render_indexvalue_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_indexvalue_end (xcb_render_indexvalue_iterator_t i /**< */); +xcb_render_indexvalue_end (xcb_render_indexvalue_iterator_t i); /** * Get the next element of the iterator @@ -1407,7 +1445,7 @@ xcb_render_indexvalue_end (xcb_render_indexvalue_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_color_t) */ void -xcb_render_color_next (xcb_render_color_iterator_t *i /**< */); +xcb_render_color_next (xcb_render_color_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1419,7 +1457,7 @@ xcb_render_color_next (xcb_render_color_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_color_end (xcb_render_color_iterator_t i /**< */); +xcb_render_color_end (xcb_render_color_iterator_t i); /** * Get the next element of the iterator @@ -1430,7 +1468,7 @@ xcb_render_color_end (xcb_render_color_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_pointfix_t) */ void -xcb_render_pointfix_next (xcb_render_pointfix_iterator_t *i /**< */); +xcb_render_pointfix_next (xcb_render_pointfix_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1442,7 +1480,7 @@ xcb_render_pointfix_next (xcb_render_pointfix_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_pointfix_end (xcb_render_pointfix_iterator_t i /**< */); +xcb_render_pointfix_end (xcb_render_pointfix_iterator_t i); /** * Get the next element of the iterator @@ -1453,7 +1491,7 @@ xcb_render_pointfix_end (xcb_render_pointfix_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_linefix_t) */ void -xcb_render_linefix_next (xcb_render_linefix_iterator_t *i /**< */); +xcb_render_linefix_next (xcb_render_linefix_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1465,7 +1503,7 @@ xcb_render_linefix_next (xcb_render_linefix_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_linefix_end (xcb_render_linefix_iterator_t i /**< */); +xcb_render_linefix_end (xcb_render_linefix_iterator_t i); /** * Get the next element of the iterator @@ -1476,7 +1514,7 @@ xcb_render_linefix_end (xcb_render_linefix_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_triangle_t) */ void -xcb_render_triangle_next (xcb_render_triangle_iterator_t *i /**< */); +xcb_render_triangle_next (xcb_render_triangle_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1488,7 +1526,7 @@ xcb_render_triangle_next (xcb_render_triangle_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_triangle_end (xcb_render_triangle_iterator_t i /**< */); +xcb_render_triangle_end (xcb_render_triangle_iterator_t i); /** * Get the next element of the iterator @@ -1499,7 +1537,7 @@ xcb_render_triangle_end (xcb_render_triangle_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_trapezoid_t) */ void -xcb_render_trapezoid_next (xcb_render_trapezoid_iterator_t *i /**< */); +xcb_render_trapezoid_next (xcb_render_trapezoid_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1511,7 +1549,7 @@ xcb_render_trapezoid_next (xcb_render_trapezoid_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_trapezoid_end (xcb_render_trapezoid_iterator_t i /**< */); +xcb_render_trapezoid_end (xcb_render_trapezoid_iterator_t i); /** * Get the next element of the iterator @@ -1522,7 +1560,7 @@ xcb_render_trapezoid_end (xcb_render_trapezoid_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_glyphinfo_t) */ void -xcb_render_glyphinfo_next (xcb_render_glyphinfo_iterator_t *i /**< */); +xcb_render_glyphinfo_next (xcb_render_glyphinfo_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1534,7 +1572,7 @@ xcb_render_glyphinfo_next (xcb_render_glyphinfo_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_glyphinfo_end (xcb_render_glyphinfo_iterator_t i /**< */); +xcb_render_glyphinfo_end (xcb_render_glyphinfo_iterator_t i); /** * @@ -1545,9 +1583,9 @@ xcb_render_glyphinfo_end (xcb_render_glyphinfo_iterator_t i /**< */); * */ xcb_render_query_version_cookie_t -xcb_render_query_version (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */); +xcb_render_query_version (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version); /** * @@ -1561,9 +1599,9 @@ xcb_render_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_render_query_version_cookie_t -xcb_render_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */); +xcb_render_query_version_unchecked (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version); /** * Return the reply @@ -1580,12 +1618,12 @@ xcb_render_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_render_query_version_reply_t * -xcb_render_query_version_reply (xcb_connection_t *c /**< */, +xcb_render_query_version_reply (xcb_connection_t *c, xcb_render_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_render_query_pict_formats_sizeof (const void *_buffer /**< */); +xcb_render_query_pict_formats_sizeof (const void *_buffer); /** * @@ -1596,7 +1634,7 @@ xcb_render_query_pict_formats_sizeof (const void *_buffer /**< */); * */ xcb_render_query_pict_formats_cookie_t -xcb_render_query_pict_formats (xcb_connection_t *c /**< */); +xcb_render_query_pict_formats (xcb_connection_t *c); /** * @@ -1610,31 +1648,31 @@ xcb_render_query_pict_formats (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_render_query_pict_formats_cookie_t -xcb_render_query_pict_formats_unchecked (xcb_connection_t *c /**< */); +xcb_render_query_pict_formats_unchecked (xcb_connection_t *c); xcb_render_pictforminfo_t * -xcb_render_query_pict_formats_formats (const xcb_render_query_pict_formats_reply_t *R /**< */); +xcb_render_query_pict_formats_formats (const xcb_render_query_pict_formats_reply_t *R); int -xcb_render_query_pict_formats_formats_length (const xcb_render_query_pict_formats_reply_t *R /**< */); +xcb_render_query_pict_formats_formats_length (const xcb_render_query_pict_formats_reply_t *R); xcb_render_pictforminfo_iterator_t -xcb_render_query_pict_formats_formats_iterator (const xcb_render_query_pict_formats_reply_t *R /**< */); +xcb_render_query_pict_formats_formats_iterator (const xcb_render_query_pict_formats_reply_t *R); int -xcb_render_query_pict_formats_screens_length (const xcb_render_query_pict_formats_reply_t *R /**< */); +xcb_render_query_pict_formats_screens_length (const xcb_render_query_pict_formats_reply_t *R); xcb_render_pictscreen_iterator_t -xcb_render_query_pict_formats_screens_iterator (const xcb_render_query_pict_formats_reply_t *R /**< */); +xcb_render_query_pict_formats_screens_iterator (const xcb_render_query_pict_formats_reply_t *R); uint32_t * -xcb_render_query_pict_formats_subpixels (const xcb_render_query_pict_formats_reply_t *R /**< */); +xcb_render_query_pict_formats_subpixels (const xcb_render_query_pict_formats_reply_t *R); int -xcb_render_query_pict_formats_subpixels_length (const xcb_render_query_pict_formats_reply_t *R /**< */); +xcb_render_query_pict_formats_subpixels_length (const xcb_render_query_pict_formats_reply_t *R); xcb_generic_iterator_t -xcb_render_query_pict_formats_subpixels_end (const xcb_render_query_pict_formats_reply_t *R /**< */); +xcb_render_query_pict_formats_subpixels_end (const xcb_render_query_pict_formats_reply_t *R); /** * Return the reply @@ -1651,12 +1689,12 @@ xcb_render_query_pict_formats_subpixels_end (const xcb_render_query_pict_formats * The returned value must be freed by the caller using free(). */ xcb_render_query_pict_formats_reply_t * -xcb_render_query_pict_formats_reply (xcb_connection_t *c /**< */, +xcb_render_query_pict_formats_reply (xcb_connection_t *c, xcb_render_query_pict_formats_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_render_query_pict_index_values_sizeof (const void *_buffer /**< */); +xcb_render_query_pict_index_values_sizeof (const void *_buffer); /** * @@ -1667,8 +1705,8 @@ xcb_render_query_pict_index_values_sizeof (const void *_buffer /**< */); * */ xcb_render_query_pict_index_values_cookie_t -xcb_render_query_pict_index_values (xcb_connection_t *c /**< */, - xcb_render_pictformat_t format /**< */); +xcb_render_query_pict_index_values (xcb_connection_t *c, + xcb_render_pictformat_t format); /** * @@ -1682,17 +1720,17 @@ xcb_render_query_pict_index_values (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_render_query_pict_index_values_cookie_t -xcb_render_query_pict_index_values_unchecked (xcb_connection_t *c /**< */, - xcb_render_pictformat_t format /**< */); +xcb_render_query_pict_index_values_unchecked (xcb_connection_t *c, + xcb_render_pictformat_t format); xcb_render_indexvalue_t * -xcb_render_query_pict_index_values_values (const xcb_render_query_pict_index_values_reply_t *R /**< */); +xcb_render_query_pict_index_values_values (const xcb_render_query_pict_index_values_reply_t *R); int -xcb_render_query_pict_index_values_values_length (const xcb_render_query_pict_index_values_reply_t *R /**< */); +xcb_render_query_pict_index_values_values_length (const xcb_render_query_pict_index_values_reply_t *R); xcb_render_indexvalue_iterator_t -xcb_render_query_pict_index_values_values_iterator (const xcb_render_query_pict_index_values_reply_t *R /**< */); +xcb_render_query_pict_index_values_values_iterator (const xcb_render_query_pict_index_values_reply_t *R); /** * Return the reply @@ -1709,200 +1747,26 @@ xcb_render_query_pict_index_values_values_iterator (const xcb_render_query_pict_ * The returned value must be freed by the caller using free(). */ xcb_render_query_pict_index_values_reply_t * -xcb_render_query_pict_index_values_reply (xcb_connection_t *c /**< */, +xcb_render_query_pict_index_values_reply (xcb_connection_t *c, xcb_render_query_pict_index_values_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_render_create_picture_sizeof (const void *_buffer /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_create_picture_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t pid /**< */, - xcb_drawable_t drawable /**< */, - xcb_render_pictformat_t format /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_create_picture (xcb_connection_t *c /**< */, - xcb_render_picture_t pid /**< */, - xcb_drawable_t drawable /**< */, - xcb_render_pictformat_t format /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_render_create_picture_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_render_create_picture_value_list_t *_aux); int -xcb_render_change_picture_sizeof (const void *_buffer /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_change_picture_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_change_picture (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_render_create_picture_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_render_create_picture_value_list_t *_aux); int -xcb_render_set_picture_clip_rectangles_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - int16_t clip_x_origin /**< */, - int16_t clip_y_origin /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_set_picture_clip_rectangles (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - int16_t clip_x_origin /**< */, - int16_t clip_y_origin /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_free_picture_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_free_picture (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_composite_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t mask /**< */, - xcb_render_picture_t dst /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t mask_x /**< */, - int16_t mask_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_composite (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t mask /**< */, - xcb_render_picture_t dst /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t mask_x /**< */, - int16_t mask_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_render_create_picture_value_list_sizeof (const void *_buffer, + uint32_t value_mask); int -xcb_render_trapezoids_sizeof (const void *_buffer /**< */, - uint32_t traps_len /**< */); +xcb_render_create_picture_sizeof (const void *_buffer); /** * @@ -1916,15 +1780,12 @@ xcb_render_trapezoids_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_trapezoids_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t traps_len /**< */, - const xcb_render_trapezoid_t *traps /**< */); +xcb_render_create_picture_checked (xcb_connection_t *c, + xcb_render_picture_t pid, + xcb_drawable_t drawable, + xcb_render_pictformat_t format, + uint32_t value_mask, + const void *value_list); /** * @@ -1935,239 +1796,67 @@ xcb_render_trapezoids_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_trapezoids (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t traps_len /**< */, - const xcb_render_trapezoid_t *traps /**< */); +xcb_render_create_picture (xcb_connection_t *c, + xcb_render_picture_t pid, + xcb_drawable_t drawable, + xcb_render_pictformat_t format, + uint32_t value_mask, + const void *value_list); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_create_picture_aux_checked (xcb_connection_t *c, + xcb_render_picture_t pid, + xcb_drawable_t drawable, + xcb_render_pictformat_t format, + uint32_t value_mask, + const xcb_render_create_picture_value_list_t *value_list); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_create_picture_aux (xcb_connection_t *c, + xcb_render_picture_t pid, + xcb_drawable_t drawable, + xcb_render_pictformat_t format, + uint32_t value_mask, + const xcb_render_create_picture_value_list_t *value_list); + +void * +xcb_render_create_picture_value_list (const xcb_render_create_picture_request_t *R); int -xcb_render_triangles_sizeof (const void *_buffer /**< */, - uint32_t triangles_len /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_triangles_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t triangles_len /**< */, - const xcb_render_triangle_t *triangles /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_triangles (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t triangles_len /**< */, - const xcb_render_triangle_t *triangles /**< */); +xcb_render_change_picture_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_render_change_picture_value_list_t *_aux); int -xcb_render_tri_strip_sizeof (const void *_buffer /**< */, - uint32_t points_len /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_tri_strip_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t points_len /**< */, - const xcb_render_pointfix_t *points /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_tri_strip (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t points_len /**< */, - const xcb_render_pointfix_t *points /**< */); +xcb_render_change_picture_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_render_change_picture_value_list_t *_aux); int -xcb_render_tri_fan_sizeof (const void *_buffer /**< */, - uint32_t points_len /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_tri_fan_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t points_len /**< */, - const xcb_render_pointfix_t *points /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_tri_fan (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t points_len /**< */, - const xcb_render_pointfix_t *points /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_create_glyph_set_checked (xcb_connection_t *c /**< */, - xcb_render_glyphset_t gsid /**< */, - xcb_render_pictformat_t format /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_create_glyph_set (xcb_connection_t *c /**< */, - xcb_render_glyphset_t gsid /**< */, - xcb_render_pictformat_t format /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_reference_glyph_set_checked (xcb_connection_t *c /**< */, - xcb_render_glyphset_t gsid /**< */, - xcb_render_glyphset_t existing /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_reference_glyph_set (xcb_connection_t *c /**< */, - xcb_render_glyphset_t gsid /**< */, - xcb_render_glyphset_t existing /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_free_glyph_set_checked (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_free_glyph_set (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */); +xcb_render_change_picture_value_list_sizeof (const void *_buffer, + uint32_t value_mask); int -xcb_render_add_glyphs_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */); +xcb_render_change_picture_sizeof (const void *_buffer); /** * @@ -2181,13 +1870,10 @@ xcb_render_add_glyphs_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_add_glyphs_checked (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */, - uint32_t glyphs_len /**< */, - const uint32_t *glyphids /**< */, - const xcb_render_glyphinfo_t *glyphs /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_render_change_picture_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + uint32_t value_mask, + const void *value_list); /** * @@ -2198,17 +1884,48 @@ xcb_render_add_glyphs_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_add_glyphs (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */, - uint32_t glyphs_len /**< */, - const uint32_t *glyphids /**< */, - const xcb_render_glyphinfo_t *glyphs /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_render_change_picture (xcb_connection_t *c, + xcb_render_picture_t picture, + uint32_t value_mask, + const void *value_list); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_change_picture_aux_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + uint32_t value_mask, + const xcb_render_change_picture_value_list_t *value_list); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_change_picture_aux (xcb_connection_t *c, + xcb_render_picture_t picture, + uint32_t value_mask, + const xcb_render_change_picture_value_list_t *value_list); + +void * +xcb_render_change_picture_value_list (const xcb_render_change_picture_request_t *R); int -xcb_render_free_glyphs_sizeof (const void *_buffer /**< */, - uint32_t glyphs_len /**< */); +xcb_render_set_picture_clip_rectangles_sizeof (const void *_buffer, + uint32_t rectangles_len); /** * @@ -2222,10 +1939,12 @@ xcb_render_free_glyphs_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_free_glyphs_checked (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */, - uint32_t glyphs_len /**< */, - const xcb_render_glyph_t *glyphs /**< */); +xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + int16_t clip_x_origin, + int16_t clip_y_origin, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); /** * @@ -2236,14 +1955,21 @@ xcb_render_free_glyphs_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_free_glyphs (xcb_connection_t *c /**< */, - xcb_render_glyphset_t glyphset /**< */, - uint32_t glyphs_len /**< */, - const xcb_render_glyph_t *glyphs /**< */); +xcb_render_set_picture_clip_rectangles (xcb_connection_t *c, + xcb_render_picture_t picture, + int16_t clip_x_origin, + int16_t clip_y_origin, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); + +xcb_rectangle_t * +xcb_render_set_picture_clip_rectangles_rectangles (const xcb_render_set_picture_clip_rectangles_request_t *R); int -xcb_render_composite_glyphs_8_sizeof (const void *_buffer /**< */, - uint32_t glyphcmds_len /**< */); +xcb_render_set_picture_clip_rectangles_rectangles_length (const xcb_render_set_picture_clip_rectangles_request_t *R); + +xcb_rectangle_iterator_t +xcb_render_set_picture_clip_rectangles_rectangles_iterator (const xcb_render_set_picture_clip_rectangles_request_t *R); /** * @@ -2257,16 +1983,8 @@ xcb_render_composite_glyphs_8_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_composite_glyphs_8_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */); +xcb_render_free_picture_checked (xcb_connection_t *c, + xcb_render_picture_t picture); /** * @@ -2277,20 +1995,61 @@ xcb_render_composite_glyphs_8_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_composite_glyphs_8 (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */); +xcb_render_free_picture (xcb_connection_t *c, + xcb_render_picture_t picture); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_composite_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t mask, + xcb_render_picture_t dst, + int16_t src_x, + int16_t src_y, + int16_t mask_x, + int16_t mask_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_composite (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t mask, + xcb_render_picture_t dst, + int16_t src_x, + int16_t src_y, + int16_t mask_x, + int16_t mask_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height); int -xcb_render_composite_glyphs_16_sizeof (const void *_buffer /**< */, - uint32_t glyphcmds_len /**< */); +xcb_render_trapezoids_sizeof (const void *_buffer, + uint32_t traps_len); /** * @@ -2304,16 +2063,15 @@ xcb_render_composite_glyphs_16_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_composite_glyphs_16_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */); +xcb_render_trapezoids_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t traps_len, + const xcb_render_trapezoid_t *traps); /** * @@ -2324,67 +2082,28 @@ xcb_render_composite_glyphs_16_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_composite_glyphs_16 (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */); +xcb_render_trapezoids (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t traps_len, + const xcb_render_trapezoid_t *traps); + +xcb_render_trapezoid_t * +xcb_render_trapezoids_traps (const xcb_render_trapezoids_request_t *R); int -xcb_render_composite_glyphs_32_sizeof (const void *_buffer /**< */, - uint32_t glyphcmds_len /**< */); +xcb_render_trapezoids_traps_length (const xcb_render_trapezoids_request_t *R); -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_composite_glyphs_32_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_composite_glyphs_32 (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t src /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_pictformat_t mask_format /**< */, - xcb_render_glyphset_t glyphset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint32_t glyphcmds_len /**< */, - const uint8_t *glyphcmds /**< */); +xcb_render_trapezoid_iterator_t +xcb_render_trapezoids_traps_iterator (const xcb_render_trapezoids_request_t *R); int -xcb_render_fill_rectangles_sizeof (const void *_buffer /**< */, - uint32_t rects_len /**< */); +xcb_render_triangles_sizeof (const void *_buffer, + uint32_t triangles_len); /** * @@ -2398,12 +2117,15 @@ xcb_render_fill_rectangles_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_fill_rectangles_checked (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_color_t color /**< */, - uint32_t rects_len /**< */, - const xcb_rectangle_t *rects /**< */); +xcb_render_triangles_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t triangles_len, + const xcb_render_triangle_t *triangles); /** * @@ -2414,12 +2136,28 @@ xcb_render_fill_rectangles_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_fill_rectangles (xcb_connection_t *c /**< */, - uint8_t op /**< */, - xcb_render_picture_t dst /**< */, - xcb_render_color_t color /**< */, - uint32_t rects_len /**< */, - const xcb_rectangle_t *rects /**< */); +xcb_render_triangles (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t triangles_len, + const xcb_render_triangle_t *triangles); + +xcb_render_triangle_t * +xcb_render_triangles_triangles (const xcb_render_triangles_request_t *R); + +int +xcb_render_triangles_triangles_length (const xcb_render_triangles_request_t *R); + +xcb_render_triangle_iterator_t +xcb_render_triangles_triangles_iterator (const xcb_render_triangles_request_t *R); + +int +xcb_render_tri_strip_sizeof (const void *_buffer, + uint32_t points_len); /** * @@ -2433,11 +2171,15 @@ xcb_render_fill_rectangles (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_create_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_render_picture_t source /**< */, - uint16_t x /**< */, - uint16_t y /**< */); +xcb_render_tri_strip_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t points_len, + const xcb_render_pointfix_t *points); /** * @@ -2448,11 +2190,524 @@ xcb_render_create_cursor_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_create_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_render_picture_t source /**< */, - uint16_t x /**< */, - uint16_t y /**< */); +xcb_render_tri_strip (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t points_len, + const xcb_render_pointfix_t *points); + +xcb_render_pointfix_t * +xcb_render_tri_strip_points (const xcb_render_tri_strip_request_t *R); + +int +xcb_render_tri_strip_points_length (const xcb_render_tri_strip_request_t *R); + +xcb_render_pointfix_iterator_t +xcb_render_tri_strip_points_iterator (const xcb_render_tri_strip_request_t *R); + +int +xcb_render_tri_fan_sizeof (const void *_buffer, + uint32_t points_len); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_tri_fan_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t points_len, + const xcb_render_pointfix_t *points); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_tri_fan (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + int16_t src_x, + int16_t src_y, + uint32_t points_len, + const xcb_render_pointfix_t *points); + +xcb_render_pointfix_t * +xcb_render_tri_fan_points (const xcb_render_tri_fan_request_t *R); + +int +xcb_render_tri_fan_points_length (const xcb_render_tri_fan_request_t *R); + +xcb_render_pointfix_iterator_t +xcb_render_tri_fan_points_iterator (const xcb_render_tri_fan_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_create_glyph_set_checked (xcb_connection_t *c, + xcb_render_glyphset_t gsid, + xcb_render_pictformat_t format); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_create_glyph_set (xcb_connection_t *c, + xcb_render_glyphset_t gsid, + xcb_render_pictformat_t format); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_reference_glyph_set_checked (xcb_connection_t *c, + xcb_render_glyphset_t gsid, + xcb_render_glyphset_t existing); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_reference_glyph_set (xcb_connection_t *c, + xcb_render_glyphset_t gsid, + xcb_render_glyphset_t existing); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_free_glyph_set_checked (xcb_connection_t *c, + xcb_render_glyphset_t glyphset); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_free_glyph_set (xcb_connection_t *c, + xcb_render_glyphset_t glyphset); + +int +xcb_render_add_glyphs_sizeof (const void *_buffer, + uint32_t data_len); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_add_glyphs_checked (xcb_connection_t *c, + xcb_render_glyphset_t glyphset, + uint32_t glyphs_len, + const uint32_t *glyphids, + const xcb_render_glyphinfo_t *glyphs, + uint32_t data_len, + const uint8_t *data); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_add_glyphs (xcb_connection_t *c, + xcb_render_glyphset_t glyphset, + uint32_t glyphs_len, + const uint32_t *glyphids, + const xcb_render_glyphinfo_t *glyphs, + uint32_t data_len, + const uint8_t *data); + +uint32_t * +xcb_render_add_glyphs_glyphids (const xcb_render_add_glyphs_request_t *R); + +int +xcb_render_add_glyphs_glyphids_length (const xcb_render_add_glyphs_request_t *R); + +xcb_generic_iterator_t +xcb_render_add_glyphs_glyphids_end (const xcb_render_add_glyphs_request_t *R); + +xcb_render_glyphinfo_t * +xcb_render_add_glyphs_glyphs (const xcb_render_add_glyphs_request_t *R); + +int +xcb_render_add_glyphs_glyphs_length (const xcb_render_add_glyphs_request_t *R); + +xcb_render_glyphinfo_iterator_t +xcb_render_add_glyphs_glyphs_iterator (const xcb_render_add_glyphs_request_t *R); + +uint8_t * +xcb_render_add_glyphs_data (const xcb_render_add_glyphs_request_t *R); + +int +xcb_render_add_glyphs_data_length (const xcb_render_add_glyphs_request_t *R); + +xcb_generic_iterator_t +xcb_render_add_glyphs_data_end (const xcb_render_add_glyphs_request_t *R); + +int +xcb_render_free_glyphs_sizeof (const void *_buffer, + uint32_t glyphs_len); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_free_glyphs_checked (xcb_connection_t *c, + xcb_render_glyphset_t glyphset, + uint32_t glyphs_len, + const xcb_render_glyph_t *glyphs); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_free_glyphs (xcb_connection_t *c, + xcb_render_glyphset_t glyphset, + uint32_t glyphs_len, + const xcb_render_glyph_t *glyphs); + +xcb_render_glyph_t * +xcb_render_free_glyphs_glyphs (const xcb_render_free_glyphs_request_t *R); + +int +xcb_render_free_glyphs_glyphs_length (const xcb_render_free_glyphs_request_t *R); + +xcb_generic_iterator_t +xcb_render_free_glyphs_glyphs_end (const xcb_render_free_glyphs_request_t *R); + +int +xcb_render_composite_glyphs_8_sizeof (const void *_buffer, + uint32_t glyphcmds_len); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_composite_glyphs_8_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_composite_glyphs_8 (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds); + +uint8_t * +xcb_render_composite_glyphs_8_glyphcmds (const xcb_render_composite_glyphs_8_request_t *R); + +int +xcb_render_composite_glyphs_8_glyphcmds_length (const xcb_render_composite_glyphs_8_request_t *R); + +xcb_generic_iterator_t +xcb_render_composite_glyphs_8_glyphcmds_end (const xcb_render_composite_glyphs_8_request_t *R); + +int +xcb_render_composite_glyphs_16_sizeof (const void *_buffer, + uint32_t glyphcmds_len); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_composite_glyphs_16_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_composite_glyphs_16 (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds); + +uint8_t * +xcb_render_composite_glyphs_16_glyphcmds (const xcb_render_composite_glyphs_16_request_t *R); + +int +xcb_render_composite_glyphs_16_glyphcmds_length (const xcb_render_composite_glyphs_16_request_t *R); + +xcb_generic_iterator_t +xcb_render_composite_glyphs_16_glyphcmds_end (const xcb_render_composite_glyphs_16_request_t *R); + +int +xcb_render_composite_glyphs_32_sizeof (const void *_buffer, + uint32_t glyphcmds_len); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_composite_glyphs_32_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_composite_glyphs_32 (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t src, + xcb_render_picture_t dst, + xcb_render_pictformat_t mask_format, + xcb_render_glyphset_t glyphset, + int16_t src_x, + int16_t src_y, + uint32_t glyphcmds_len, + const uint8_t *glyphcmds); + +uint8_t * +xcb_render_composite_glyphs_32_glyphcmds (const xcb_render_composite_glyphs_32_request_t *R); + +int +xcb_render_composite_glyphs_32_glyphcmds_length (const xcb_render_composite_glyphs_32_request_t *R); + +xcb_generic_iterator_t +xcb_render_composite_glyphs_32_glyphcmds_end (const xcb_render_composite_glyphs_32_request_t *R); + +int +xcb_render_fill_rectangles_sizeof (const void *_buffer, + uint32_t rects_len); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_fill_rectangles_checked (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t dst, + xcb_render_color_t color, + uint32_t rects_len, + const xcb_rectangle_t *rects); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_fill_rectangles (xcb_connection_t *c, + uint8_t op, + xcb_render_picture_t dst, + xcb_render_color_t color, + uint32_t rects_len, + const xcb_rectangle_t *rects); + +xcb_rectangle_t * +xcb_render_fill_rectangles_rects (const xcb_render_fill_rectangles_request_t *R); + +int +xcb_render_fill_rectangles_rects_length (const xcb_render_fill_rectangles_request_t *R); + +xcb_rectangle_iterator_t +xcb_render_fill_rectangles_rects_iterator (const xcb_render_fill_rectangles_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_create_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_render_picture_t source, + uint16_t x, + uint16_t y); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_create_cursor (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_render_picture_t source, + uint16_t x, + uint16_t y); /** * Get the next element of the iterator @@ -2463,7 +2718,7 @@ xcb_render_create_cursor (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_render_transform_t) */ void -xcb_render_transform_next (xcb_render_transform_iterator_t *i /**< */); +xcb_render_transform_next (xcb_render_transform_iterator_t *i); /** * Return the iterator pointing to the last element @@ -2475,7 +2730,7 @@ xcb_render_transform_next (xcb_render_transform_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_transform_end (xcb_render_transform_iterator_t i /**< */); +xcb_render_transform_end (xcb_render_transform_iterator_t i); /** * @@ -2489,9 +2744,9 @@ xcb_render_transform_end (xcb_render_transform_iterator_t i /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_set_picture_transform_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_transform_t transform /**< */); +xcb_render_set_picture_transform_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_transform_t transform); /** * @@ -2502,12 +2757,12 @@ xcb_render_set_picture_transform_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_set_picture_transform (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_transform_t transform /**< */); +xcb_render_set_picture_transform (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_transform_t transform); int -xcb_render_query_filters_sizeof (const void *_buffer /**< */); +xcb_render_query_filters_sizeof (const void *_buffer); /** * @@ -2518,8 +2773,8 @@ xcb_render_query_filters_sizeof (const void *_buffer /**< */); * */ xcb_render_query_filters_cookie_t -xcb_render_query_filters (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_render_query_filters (xcb_connection_t *c, + xcb_drawable_t drawable); /** * @@ -2533,23 +2788,23 @@ xcb_render_query_filters (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_render_query_filters_cookie_t -xcb_render_query_filters_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_render_query_filters_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable); uint16_t * -xcb_render_query_filters_aliases (const xcb_render_query_filters_reply_t *R /**< */); +xcb_render_query_filters_aliases (const xcb_render_query_filters_reply_t *R); int -xcb_render_query_filters_aliases_length (const xcb_render_query_filters_reply_t *R /**< */); +xcb_render_query_filters_aliases_length (const xcb_render_query_filters_reply_t *R); xcb_generic_iterator_t -xcb_render_query_filters_aliases_end (const xcb_render_query_filters_reply_t *R /**< */); +xcb_render_query_filters_aliases_end (const xcb_render_query_filters_reply_t *R); int -xcb_render_query_filters_filters_length (const xcb_render_query_filters_reply_t *R /**< */); +xcb_render_query_filters_filters_length (const xcb_render_query_filters_reply_t *R); xcb_str_iterator_t -xcb_render_query_filters_filters_iterator (const xcb_render_query_filters_reply_t *R /**< */); +xcb_render_query_filters_filters_iterator (const xcb_render_query_filters_reply_t *R); /** * Return the reply @@ -2566,13 +2821,13 @@ xcb_render_query_filters_filters_iterator (const xcb_render_query_filters_reply_ * The returned value must be freed by the caller using free(). */ xcb_render_query_filters_reply_t * -xcb_render_query_filters_reply (xcb_connection_t *c /**< */, +xcb_render_query_filters_reply (xcb_connection_t *c, xcb_render_query_filters_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_render_set_picture_filter_sizeof (const void *_buffer /**< */, - uint32_t values_len /**< */); +xcb_render_set_picture_filter_sizeof (const void *_buffer, + uint32_t values_len); /** * @@ -2586,12 +2841,12 @@ xcb_render_set_picture_filter_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_set_picture_filter_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - uint16_t filter_len /**< */, - const char *filter /**< */, - uint32_t values_len /**< */, - const xcb_render_fixed_t *values /**< */); +xcb_render_set_picture_filter_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + uint16_t filter_len, + const char *filter, + uint32_t values_len, + const xcb_render_fixed_t *values); /** * @@ -2602,12 +2857,30 @@ xcb_render_set_picture_filter_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_set_picture_filter (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - uint16_t filter_len /**< */, - const char *filter /**< */, - uint32_t values_len /**< */, - const xcb_render_fixed_t *values /**< */); +xcb_render_set_picture_filter (xcb_connection_t *c, + xcb_render_picture_t picture, + uint16_t filter_len, + const char *filter, + uint32_t values_len, + const xcb_render_fixed_t *values); + +char * +xcb_render_set_picture_filter_filter (const xcb_render_set_picture_filter_request_t *R); + +int +xcb_render_set_picture_filter_filter_length (const xcb_render_set_picture_filter_request_t *R); + +xcb_generic_iterator_t +xcb_render_set_picture_filter_filter_end (const xcb_render_set_picture_filter_request_t *R); + +xcb_render_fixed_t * +xcb_render_set_picture_filter_values (const xcb_render_set_picture_filter_request_t *R); + +int +xcb_render_set_picture_filter_values_length (const xcb_render_set_picture_filter_request_t *R); + +xcb_generic_iterator_t +xcb_render_set_picture_filter_values_end (const xcb_render_set_picture_filter_request_t *R); /** * Get the next element of the iterator @@ -2618,7 +2891,7 @@ xcb_render_set_picture_filter (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_render_animcursorelt_t) */ void -xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i /**< */); +xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i); /** * Return the iterator pointing to the last element @@ -2630,11 +2903,11 @@ xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i /**< */); +xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i); int -xcb_render_create_anim_cursor_sizeof (const void *_buffer /**< */, - uint32_t cursors_len /**< */); +xcb_render_create_anim_cursor_sizeof (const void *_buffer, + uint32_t cursors_len); /** * @@ -2648,10 +2921,10 @@ xcb_render_create_anim_cursor_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_create_anim_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - uint32_t cursors_len /**< */, - const xcb_render_animcursorelt_t *cursors /**< */); +xcb_render_create_anim_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cid, + uint32_t cursors_len, + const xcb_render_animcursorelt_t *cursors); /** * @@ -2662,10 +2935,19 @@ xcb_render_create_anim_cursor_checked (xcb_connection_t *c /**< * */ xcb_void_cookie_t -xcb_render_create_anim_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - uint32_t cursors_len /**< */, - const xcb_render_animcursorelt_t *cursors /**< */); +xcb_render_create_anim_cursor (xcb_connection_t *c, + xcb_cursor_t cid, + uint32_t cursors_len, + const xcb_render_animcursorelt_t *cursors); + +xcb_render_animcursorelt_t * +xcb_render_create_anim_cursor_cursors (const xcb_render_create_anim_cursor_request_t *R); + +int +xcb_render_create_anim_cursor_cursors_length (const xcb_render_create_anim_cursor_request_t *R); + +xcb_render_animcursorelt_iterator_t +xcb_render_create_anim_cursor_cursors_iterator (const xcb_render_create_anim_cursor_request_t *R); /** * Get the next element of the iterator @@ -2676,7 +2958,7 @@ xcb_render_create_anim_cursor (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_render_spanfix_t) */ void -xcb_render_spanfix_next (xcb_render_spanfix_iterator_t *i /**< */); +xcb_render_spanfix_next (xcb_render_spanfix_iterator_t *i); /** * Return the iterator pointing to the last element @@ -2688,7 +2970,7 @@ xcb_render_spanfix_next (xcb_render_spanfix_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_spanfix_end (xcb_render_spanfix_iterator_t i /**< */); +xcb_render_spanfix_end (xcb_render_spanfix_iterator_t i); /** * Get the next element of the iterator @@ -2699,7 +2981,7 @@ xcb_render_spanfix_end (xcb_render_spanfix_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_render_trap_t) */ void -xcb_render_trap_next (xcb_render_trap_iterator_t *i /**< */); +xcb_render_trap_next (xcb_render_trap_iterator_t *i); /** * Return the iterator pointing to the last element @@ -2711,11 +2993,11 @@ xcb_render_trap_next (xcb_render_trap_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_render_trap_end (xcb_render_trap_iterator_t i /**< */); +xcb_render_trap_end (xcb_render_trap_iterator_t i); int -xcb_render_add_traps_sizeof (const void *_buffer /**< */, - uint32_t traps_len /**< */); +xcb_render_add_traps_sizeof (const void *_buffer, + uint32_t traps_len); /** * @@ -2729,12 +3011,12 @@ xcb_render_add_traps_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_add_traps_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - int16_t x_off /**< */, - int16_t y_off /**< */, - uint32_t traps_len /**< */, - const xcb_render_trap_t *traps /**< */); +xcb_render_add_traps_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + int16_t x_off, + int16_t y_off, + uint32_t traps_len, + const xcb_render_trap_t *traps); /** * @@ -2745,44 +3027,21 @@ xcb_render_add_traps_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_add_traps (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - int16_t x_off /**< */, - int16_t y_off /**< */, - uint32_t traps_len /**< */, - const xcb_render_trap_t *traps /**< */); +xcb_render_add_traps (xcb_connection_t *c, + xcb_render_picture_t picture, + int16_t x_off, + int16_t y_off, + uint32_t traps_len, + const xcb_render_trap_t *traps); -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_render_create_solid_fill_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_color_t color /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_render_create_solid_fill (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_color_t color /**< */); +xcb_render_trap_t * +xcb_render_add_traps_traps (const xcb_render_add_traps_request_t *R); int -xcb_render_create_linear_gradient_sizeof (const void *_buffer /**< */); +xcb_render_add_traps_traps_length (const xcb_render_add_traps_request_t *R); + +xcb_render_trap_iterator_t +xcb_render_add_traps_traps_iterator (const xcb_render_add_traps_request_t *R); /** * @@ -2796,13 +3055,9 @@ xcb_render_create_linear_gradient_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_create_linear_gradient_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t p1 /**< */, - xcb_render_pointfix_t p2 /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */); +xcb_render_create_solid_fill_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_color_t color); /** * @@ -2813,16 +3068,12 @@ xcb_render_create_linear_gradient_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_create_linear_gradient (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t p1 /**< */, - xcb_render_pointfix_t p2 /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */); +xcb_render_create_solid_fill (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_color_t color); int -xcb_render_create_radial_gradient_sizeof (const void *_buffer /**< */); +xcb_render_create_linear_gradient_sizeof (const void *_buffer); /** * @@ -2836,15 +3087,13 @@ xcb_render_create_radial_gradient_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_create_radial_gradient_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t inner /**< */, - xcb_render_pointfix_t outer /**< */, - xcb_render_fixed_t inner_radius /**< */, - xcb_render_fixed_t outer_radius /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */); +xcb_render_create_linear_gradient_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t p1, + xcb_render_pointfix_t p2, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors); /** * @@ -2855,18 +3104,34 @@ xcb_render_create_radial_gradient_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_render_create_radial_gradient (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t inner /**< */, - xcb_render_pointfix_t outer /**< */, - xcb_render_fixed_t inner_radius /**< */, - xcb_render_fixed_t outer_radius /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */); +xcb_render_create_linear_gradient (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t p1, + xcb_render_pointfix_t p2, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors); + +xcb_render_fixed_t * +xcb_render_create_linear_gradient_stops (const xcb_render_create_linear_gradient_request_t *R); int -xcb_render_create_conical_gradient_sizeof (const void *_buffer /**< */); +xcb_render_create_linear_gradient_stops_length (const xcb_render_create_linear_gradient_request_t *R); + +xcb_generic_iterator_t +xcb_render_create_linear_gradient_stops_end (const xcb_render_create_linear_gradient_request_t *R); + +xcb_render_color_t * +xcb_render_create_linear_gradient_colors (const xcb_render_create_linear_gradient_request_t *R); + +int +xcb_render_create_linear_gradient_colors_length (const xcb_render_create_linear_gradient_request_t *R); + +xcb_render_color_iterator_t +xcb_render_create_linear_gradient_colors_iterator (const xcb_render_create_linear_gradient_request_t *R); + +int +xcb_render_create_radial_gradient_sizeof (const void *_buffer); /** * @@ -2880,13 +3145,15 @@ xcb_render_create_conical_gradient_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_render_create_conical_gradient_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t center /**< */, - xcb_render_fixed_t angle /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */); +xcb_render_create_radial_gradient_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t inner, + xcb_render_pointfix_t outer, + xcb_render_fixed_t inner_radius, + xcb_render_fixed_t outer_radius, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors); /** * @@ -2897,13 +3164,91 @@ xcb_render_create_conical_gradient_checked (xcb_connection_t *c /**< */ * */ xcb_void_cookie_t -xcb_render_create_conical_gradient (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_render_pointfix_t center /**< */, - xcb_render_fixed_t angle /**< */, - uint32_t num_stops /**< */, - const xcb_render_fixed_t *stops /**< */, - const xcb_render_color_t *colors /**< */); +xcb_render_create_radial_gradient (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t inner, + xcb_render_pointfix_t outer, + xcb_render_fixed_t inner_radius, + xcb_render_fixed_t outer_radius, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors); + +xcb_render_fixed_t * +xcb_render_create_radial_gradient_stops (const xcb_render_create_radial_gradient_request_t *R); + +int +xcb_render_create_radial_gradient_stops_length (const xcb_render_create_radial_gradient_request_t *R); + +xcb_generic_iterator_t +xcb_render_create_radial_gradient_stops_end (const xcb_render_create_radial_gradient_request_t *R); + +xcb_render_color_t * +xcb_render_create_radial_gradient_colors (const xcb_render_create_radial_gradient_request_t *R); + +int +xcb_render_create_radial_gradient_colors_length (const xcb_render_create_radial_gradient_request_t *R); + +xcb_render_color_iterator_t +xcb_render_create_radial_gradient_colors_iterator (const xcb_render_create_radial_gradient_request_t *R); + +int +xcb_render_create_conical_gradient_sizeof (const void *_buffer); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_render_create_conical_gradient_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t center, + xcb_render_fixed_t angle, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_render_create_conical_gradient (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_render_pointfix_t center, + xcb_render_fixed_t angle, + uint32_t num_stops, + const xcb_render_fixed_t *stops, + const xcb_render_color_t *colors); + +xcb_render_fixed_t * +xcb_render_create_conical_gradient_stops (const xcb_render_create_conical_gradient_request_t *R); + +int +xcb_render_create_conical_gradient_stops_length (const xcb_render_create_conical_gradient_request_t *R); + +xcb_generic_iterator_t +xcb_render_create_conical_gradient_stops_end (const xcb_render_create_conical_gradient_request_t *R); + +xcb_render_color_t * +xcb_render_create_conical_gradient_colors (const xcb_render_create_conical_gradient_request_t *R); + +int +xcb_render_create_conical_gradient_colors_length (const xcb_render_create_conical_gradient_request_t *R); + +xcb_render_color_iterator_t +xcb_render_create_conical_gradient_colors_iterator (const xcb_render_create_conical_gradient_request_t *R); #ifdef __cplusplus diff --git a/lib/libxcb/src/res.c b/lib/libxcb/src/res.c index 6f1bba517..9f737ab9f 100644 --- a/lib/libxcb/src/res.c +++ b/lib/libxcb/src/res.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_res_id = { "X-Resource", 0 }; void -xcb_res_client_next (xcb_res_client_iterator_t *i /**< */) +xcb_res_client_next (xcb_res_client_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_res_client_next (xcb_res_client_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_res_client_end (xcb_res_client_iterator_t i /**< */) +xcb_res_client_end (xcb_res_client_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,7 +37,7 @@ xcb_res_client_end (xcb_res_client_iterator_t i /**< */) } void -xcb_res_type_next (xcb_res_type_iterator_t *i /**< */) +xcb_res_type_next (xcb_res_type_iterator_t *i) { --i->rem; ++i->data; @@ -45,7 +45,7 @@ xcb_res_type_next (xcb_res_type_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_res_type_end (xcb_res_type_iterator_t i /**< */) +xcb_res_type_end (xcb_res_type_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -55,7 +55,7 @@ xcb_res_type_end (xcb_res_type_iterator_t i /**< */) } void -xcb_res_client_id_spec_next (xcb_res_client_id_spec_iterator_t *i /**< */) +xcb_res_client_id_spec_next (xcb_res_client_id_spec_iterator_t *i) { --i->rem; ++i->data; @@ -63,7 +63,7 @@ xcb_res_client_id_spec_next (xcb_res_client_id_spec_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_res_client_id_spec_end (xcb_res_client_id_spec_iterator_t i /**< */) +xcb_res_client_id_spec_end (xcb_res_client_id_spec_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -73,7 +73,7 @@ xcb_res_client_id_spec_end (xcb_res_client_id_spec_iterator_t i /**< */) } int -xcb_res_client_id_value_sizeof (const void *_buffer /**< */) +xcb_res_client_id_value_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_res_client_id_value_t *_aux = (xcb_res_client_id_value_t *)_buffer; @@ -104,19 +104,19 @@ xcb_res_client_id_value_sizeof (const void *_buffer /**< */) } uint32_t * -xcb_res_client_id_value_value (const xcb_res_client_id_value_t *R /**< */) +xcb_res_client_id_value_value (const xcb_res_client_id_value_t *R) { return (uint32_t *) (R + 1); } int -xcb_res_client_id_value_value_length (const xcb_res_client_id_value_t *R /**< */) +xcb_res_client_id_value_value_length (const xcb_res_client_id_value_t *R) { return R->length; } xcb_generic_iterator_t -xcb_res_client_id_value_value_end (const xcb_res_client_id_value_t *R /**< */) +xcb_res_client_id_value_value_end (const xcb_res_client_id_value_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->length); @@ -126,7 +126,7 @@ xcb_res_client_id_value_value_end (const xcb_res_client_id_value_t *R /**< */) } void -xcb_res_client_id_value_next (xcb_res_client_id_value_iterator_t *i /**< */) +xcb_res_client_id_value_next (xcb_res_client_id_value_iterator_t *i) { xcb_res_client_id_value_t *R = i->data; xcb_generic_iterator_t child; @@ -137,7 +137,7 @@ xcb_res_client_id_value_next (xcb_res_client_id_value_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_res_client_id_value_end (xcb_res_client_id_value_iterator_t i /**< */) +xcb_res_client_id_value_end (xcb_res_client_id_value_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -149,7 +149,7 @@ xcb_res_client_id_value_end (xcb_res_client_id_value_iterator_t i /**< */) } void -xcb_res_resource_id_spec_next (xcb_res_resource_id_spec_iterator_t *i /**< */) +xcb_res_resource_id_spec_next (xcb_res_resource_id_spec_iterator_t *i) { --i->rem; ++i->data; @@ -157,7 +157,7 @@ xcb_res_resource_id_spec_next (xcb_res_resource_id_spec_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_res_resource_id_spec_end (xcb_res_resource_id_spec_iterator_t i /**< */) +xcb_res_resource_id_spec_end (xcb_res_resource_id_spec_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -167,7 +167,7 @@ xcb_res_resource_id_spec_end (xcb_res_resource_id_spec_iterator_t i /**< */) } void -xcb_res_resource_size_spec_next (xcb_res_resource_size_spec_iterator_t *i /**< */) +xcb_res_resource_size_spec_next (xcb_res_resource_size_spec_iterator_t *i) { --i->rem; ++i->data; @@ -175,7 +175,7 @@ xcb_res_resource_size_spec_next (xcb_res_resource_size_spec_iterator_t *i /**< } xcb_generic_iterator_t -xcb_res_resource_size_spec_end (xcb_res_resource_size_spec_iterator_t i /**< */) +xcb_res_resource_size_spec_end (xcb_res_resource_size_spec_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -185,7 +185,7 @@ xcb_res_resource_size_spec_end (xcb_res_resource_size_spec_iterator_t i /**< */ } int -xcb_res_resource_size_value_sizeof (const void *_buffer /**< */) +xcb_res_resource_size_value_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_res_resource_size_value_t *_aux = (xcb_res_resource_size_value_t *)_buffer; @@ -216,19 +216,19 @@ xcb_res_resource_size_value_sizeof (const void *_buffer /**< */) } xcb_res_resource_size_spec_t * -xcb_res_resource_size_value_cross_references (const xcb_res_resource_size_value_t *R /**< */) +xcb_res_resource_size_value_cross_references (const xcb_res_resource_size_value_t *R) { return (xcb_res_resource_size_spec_t *) (R + 1); } int -xcb_res_resource_size_value_cross_references_length (const xcb_res_resource_size_value_t *R /**< */) +xcb_res_resource_size_value_cross_references_length (const xcb_res_resource_size_value_t *R) { return R->num_cross_references; } xcb_res_resource_size_spec_iterator_t -xcb_res_resource_size_value_cross_references_iterator (const xcb_res_resource_size_value_t *R /**< */) +xcb_res_resource_size_value_cross_references_iterator (const xcb_res_resource_size_value_t *R) { xcb_res_resource_size_spec_iterator_t i; i.data = (xcb_res_resource_size_spec_t *) (R + 1); @@ -238,7 +238,7 @@ xcb_res_resource_size_value_cross_references_iterator (const xcb_res_resource_si } void -xcb_res_resource_size_value_next (xcb_res_resource_size_value_iterator_t *i /**< */) +xcb_res_resource_size_value_next (xcb_res_resource_size_value_iterator_t *i) { xcb_res_resource_size_value_t *R = i->data; xcb_generic_iterator_t child; @@ -249,7 +249,7 @@ xcb_res_resource_size_value_next (xcb_res_resource_size_value_iterator_t *i /** } xcb_generic_iterator_t -xcb_res_resource_size_value_end (xcb_res_resource_size_value_iterator_t i /**< */) +xcb_res_resource_size_value_end (xcb_res_resource_size_value_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -261,15 +261,15 @@ xcb_res_resource_size_value_end (xcb_res_resource_size_value_iterator_t i /**< } xcb_res_query_version_cookie_t -xcb_res_query_version (xcb_connection_t *c /**< */, - uint8_t client_major /**< */, - uint8_t client_minor /**< */) +xcb_res_query_version (xcb_connection_t *c, + uint8_t client_major, + uint8_t client_minor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -289,15 +289,15 @@ xcb_res_query_version (xcb_connection_t *c /**< */, } xcb_res_query_version_cookie_t -xcb_res_query_version_unchecked (xcb_connection_t *c /**< */, - uint8_t client_major /**< */, - uint8_t client_minor /**< */) +xcb_res_query_version_unchecked (xcb_connection_t *c, + uint8_t client_major, + uint8_t client_minor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -317,15 +317,15 @@ xcb_res_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_res_query_version_reply_t * -xcb_res_query_version_reply (xcb_connection_t *c /**< */, +xcb_res_query_version_reply (xcb_connection_t *c, xcb_res_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_res_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_res_query_clients_sizeof (const void *_buffer /**< */) +xcb_res_query_clients_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_res_query_clients_reply_t *_aux = (xcb_res_query_clients_reply_t *)_buffer; @@ -356,13 +356,13 @@ xcb_res_query_clients_sizeof (const void *_buffer /**< */) } xcb_res_query_clients_cookie_t -xcb_res_query_clients (xcb_connection_t *c /**< */) +xcb_res_query_clients (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_CLIENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_CLIENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -380,13 +380,13 @@ xcb_res_query_clients (xcb_connection_t *c /**< */) } xcb_res_query_clients_cookie_t -xcb_res_query_clients_unchecked (xcb_connection_t *c /**< */) +xcb_res_query_clients_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_CLIENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_CLIENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -404,19 +404,19 @@ xcb_res_query_clients_unchecked (xcb_connection_t *c /**< */) } xcb_res_client_t * -xcb_res_query_clients_clients (const xcb_res_query_clients_reply_t *R /**< */) +xcb_res_query_clients_clients (const xcb_res_query_clients_reply_t *R) { return (xcb_res_client_t *) (R + 1); } int -xcb_res_query_clients_clients_length (const xcb_res_query_clients_reply_t *R /**< */) +xcb_res_query_clients_clients_length (const xcb_res_query_clients_reply_t *R) { return R->num_clients; } xcb_res_client_iterator_t -xcb_res_query_clients_clients_iterator (const xcb_res_query_clients_reply_t *R /**< */) +xcb_res_query_clients_clients_iterator (const xcb_res_query_clients_reply_t *R) { xcb_res_client_iterator_t i; i.data = (xcb_res_client_t *) (R + 1); @@ -426,15 +426,15 @@ xcb_res_query_clients_clients_iterator (const xcb_res_query_clients_reply_t *R } xcb_res_query_clients_reply_t * -xcb_res_query_clients_reply (xcb_connection_t *c /**< */, +xcb_res_query_clients_reply (xcb_connection_t *c, xcb_res_query_clients_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_res_query_clients_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_res_query_client_resources_sizeof (const void *_buffer /**< */) +xcb_res_query_client_resources_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_res_query_client_resources_reply_t *_aux = (xcb_res_query_client_resources_reply_t *)_buffer; @@ -465,14 +465,14 @@ xcb_res_query_client_resources_sizeof (const void *_buffer /**< */) } xcb_res_query_client_resources_cookie_t -xcb_res_query_client_resources (xcb_connection_t *c /**< */, - uint32_t xid /**< */) +xcb_res_query_client_resources (xcb_connection_t *c, + uint32_t xid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_CLIENT_RESOURCES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_CLIENT_RESOURCES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -491,14 +491,14 @@ xcb_res_query_client_resources (xcb_connection_t *c /**< */, } xcb_res_query_client_resources_cookie_t -xcb_res_query_client_resources_unchecked (xcb_connection_t *c /**< */, - uint32_t xid /**< */) +xcb_res_query_client_resources_unchecked (xcb_connection_t *c, + uint32_t xid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_CLIENT_RESOURCES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_CLIENT_RESOURCES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -517,19 +517,19 @@ xcb_res_query_client_resources_unchecked (xcb_connection_t *c /**< */, } xcb_res_type_t * -xcb_res_query_client_resources_types (const xcb_res_query_client_resources_reply_t *R /**< */) +xcb_res_query_client_resources_types (const xcb_res_query_client_resources_reply_t *R) { return (xcb_res_type_t *) (R + 1); } int -xcb_res_query_client_resources_types_length (const xcb_res_query_client_resources_reply_t *R /**< */) +xcb_res_query_client_resources_types_length (const xcb_res_query_client_resources_reply_t *R) { return R->num_types; } xcb_res_type_iterator_t -xcb_res_query_client_resources_types_iterator (const xcb_res_query_client_resources_reply_t *R /**< */) +xcb_res_query_client_resources_types_iterator (const xcb_res_query_client_resources_reply_t *R) { xcb_res_type_iterator_t i; i.data = (xcb_res_type_t *) (R + 1); @@ -539,22 +539,22 @@ xcb_res_query_client_resources_types_iterator (const xcb_res_query_client_resour } xcb_res_query_client_resources_reply_t * -xcb_res_query_client_resources_reply (xcb_connection_t *c /**< */, +xcb_res_query_client_resources_reply (xcb_connection_t *c, xcb_res_query_client_resources_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_res_query_client_resources_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_res_query_client_pixmap_bytes_cookie_t -xcb_res_query_client_pixmap_bytes (xcb_connection_t *c /**< */, - uint32_t xid /**< */) +xcb_res_query_client_pixmap_bytes (xcb_connection_t *c, + uint32_t xid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_CLIENT_PIXMAP_BYTES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_CLIENT_PIXMAP_BYTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -573,14 +573,14 @@ xcb_res_query_client_pixmap_bytes (xcb_connection_t *c /**< */, } xcb_res_query_client_pixmap_bytes_cookie_t -xcb_res_query_client_pixmap_bytes_unchecked (xcb_connection_t *c /**< */, - uint32_t xid /**< */) +xcb_res_query_client_pixmap_bytes_unchecked (xcb_connection_t *c, + uint32_t xid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_CLIENT_PIXMAP_BYTES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_CLIENT_PIXMAP_BYTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -599,15 +599,15 @@ xcb_res_query_client_pixmap_bytes_unchecked (xcb_connection_t *c /**< */, } xcb_res_query_client_pixmap_bytes_reply_t * -xcb_res_query_client_pixmap_bytes_reply (xcb_connection_t *c /**< */, +xcb_res_query_client_pixmap_bytes_reply (xcb_connection_t *c, xcb_res_query_client_pixmap_bytes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_res_query_client_pixmap_bytes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_res_query_client_ids_sizeof (const void *_buffer /**< */) +xcb_res_query_client_ids_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_res_query_client_ids_request_t *_aux = (xcb_res_query_client_ids_request_t *)_buffer; @@ -638,15 +638,15 @@ xcb_res_query_client_ids_sizeof (const void *_buffer /**< */) } xcb_res_query_client_ids_cookie_t -xcb_res_query_client_ids (xcb_connection_t *c /**< */, - uint32_t num_specs /**< */, - const xcb_res_client_id_spec_t *specs /**< */) +xcb_res_query_client_ids (xcb_connection_t *c, + uint32_t num_specs, + const xcb_res_client_id_spec_t *specs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_CLIENT_IDS, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_CLIENT_IDS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -670,15 +670,15 @@ xcb_res_query_client_ids (xcb_connection_t *c /**< */, } xcb_res_query_client_ids_cookie_t -xcb_res_query_client_ids_unchecked (xcb_connection_t *c /**< */, - uint32_t num_specs /**< */, - const xcb_res_client_id_spec_t *specs /**< */) +xcb_res_query_client_ids_unchecked (xcb_connection_t *c, + uint32_t num_specs, + const xcb_res_client_id_spec_t *specs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_CLIENT_IDS, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_CLIENT_IDS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -702,13 +702,13 @@ xcb_res_query_client_ids_unchecked (xcb_connection_t *c /**< */, } int -xcb_res_query_client_ids_ids_length (const xcb_res_query_client_ids_reply_t *R /**< */) +xcb_res_query_client_ids_ids_length (const xcb_res_query_client_ids_reply_t *R) { return R->num_ids; } xcb_res_client_id_value_iterator_t -xcb_res_query_client_ids_ids_iterator (const xcb_res_query_client_ids_reply_t *R /**< */) +xcb_res_query_client_ids_ids_iterator (const xcb_res_query_client_ids_reply_t *R) { xcb_res_client_id_value_iterator_t i; i.data = (xcb_res_client_id_value_t *) (R + 1); @@ -718,15 +718,15 @@ xcb_res_query_client_ids_ids_iterator (const xcb_res_query_client_ids_reply_t *R } xcb_res_query_client_ids_reply_t * -xcb_res_query_client_ids_reply (xcb_connection_t *c /**< */, +xcb_res_query_client_ids_reply (xcb_connection_t *c, xcb_res_query_client_ids_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_res_query_client_ids_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_res_query_resource_bytes_sizeof (const void *_buffer /**< */) +xcb_res_query_resource_bytes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_res_query_resource_bytes_request_t *_aux = (xcb_res_query_resource_bytes_request_t *)_buffer; @@ -757,16 +757,16 @@ xcb_res_query_resource_bytes_sizeof (const void *_buffer /**< */) } xcb_res_query_resource_bytes_cookie_t -xcb_res_query_resource_bytes (xcb_connection_t *c /**< */, - uint32_t client /**< */, - uint32_t num_specs /**< */, - const xcb_res_resource_id_spec_t *specs /**< */) +xcb_res_query_resource_bytes (xcb_connection_t *c, + uint32_t client, + uint32_t num_specs, + const xcb_res_resource_id_spec_t *specs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_RESOURCE_BYTES, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_RESOURCE_BYTES, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -791,16 +791,16 @@ xcb_res_query_resource_bytes (xcb_connection_t *c /**< */, } xcb_res_query_resource_bytes_cookie_t -xcb_res_query_resource_bytes_unchecked (xcb_connection_t *c /**< */, - uint32_t client /**< */, - uint32_t num_specs /**< */, - const xcb_res_resource_id_spec_t *specs /**< */) +xcb_res_query_resource_bytes_unchecked (xcb_connection_t *c, + uint32_t client, + uint32_t num_specs, + const xcb_res_resource_id_spec_t *specs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_res_id, - /* opcode */ XCB_RES_QUERY_RESOURCE_BYTES, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_res_id, + .opcode = XCB_RES_QUERY_RESOURCE_BYTES, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -825,13 +825,13 @@ xcb_res_query_resource_bytes_unchecked (xcb_connection_t *c /** } int -xcb_res_query_resource_bytes_sizes_length (const xcb_res_query_resource_bytes_reply_t *R /**< */) +xcb_res_query_resource_bytes_sizes_length (const xcb_res_query_resource_bytes_reply_t *R) { return R->num_sizes; } xcb_res_resource_size_value_iterator_t -xcb_res_query_resource_bytes_sizes_iterator (const xcb_res_query_resource_bytes_reply_t *R /**< */) +xcb_res_query_resource_bytes_sizes_iterator (const xcb_res_query_resource_bytes_reply_t *R) { xcb_res_resource_size_value_iterator_t i; i.data = (xcb_res_resource_size_value_t *) (R + 1); @@ -841,9 +841,9 @@ xcb_res_query_resource_bytes_sizes_iterator (const xcb_res_query_resource_bytes_ } xcb_res_query_resource_bytes_reply_t * -xcb_res_query_resource_bytes_reply (xcb_connection_t *c /**< */, +xcb_res_query_resource_bytes_reply (xcb_connection_t *c, xcb_res_query_resource_bytes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_res_query_resource_bytes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/res.h b/lib/libxcb/src/res.h index 3e641f609..40afb63a1 100644 --- a/lib/libxcb/src/res.h +++ b/lib/libxcb/src/res.h @@ -28,34 +28,34 @@ extern xcb_extension_t xcb_res_id; * @brief xcb_res_client_t **/ typedef struct xcb_res_client_t { - uint32_t resource_base; /**< */ - uint32_t resource_mask; /**< */ + uint32_t resource_base; + uint32_t resource_mask; } xcb_res_client_t; /** * @brief xcb_res_client_iterator_t **/ typedef struct xcb_res_client_iterator_t { - xcb_res_client_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_res_client_t *data; + int rem; + int index; } xcb_res_client_iterator_t; /** * @brief xcb_res_type_t **/ typedef struct xcb_res_type_t { - xcb_atom_t resource_type; /**< */ - uint32_t count; /**< */ + xcb_atom_t resource_type; + uint32_t count; } xcb_res_type_t; /** * @brief xcb_res_type_iterator_t **/ typedef struct xcb_res_type_iterator_t { - xcb_res_type_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_res_type_t *data; + int rem; + int index; } xcb_res_type_iterator_t; typedef enum xcb_res_client_id_mask_t { @@ -67,94 +67,94 @@ typedef enum xcb_res_client_id_mask_t { * @brief xcb_res_client_id_spec_t **/ typedef struct xcb_res_client_id_spec_t { - uint32_t client; /**< */ - uint32_t mask; /**< */ + uint32_t client; + uint32_t mask; } xcb_res_client_id_spec_t; /** * @brief xcb_res_client_id_spec_iterator_t **/ typedef struct xcb_res_client_id_spec_iterator_t { - xcb_res_client_id_spec_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_res_client_id_spec_t *data; + int rem; + int index; } xcb_res_client_id_spec_iterator_t; /** * @brief xcb_res_client_id_value_t **/ typedef struct xcb_res_client_id_value_t { - xcb_res_client_id_spec_t spec; /**< */ - uint32_t length; /**< */ + xcb_res_client_id_spec_t spec; + uint32_t length; } xcb_res_client_id_value_t; /** * @brief xcb_res_client_id_value_iterator_t **/ typedef struct xcb_res_client_id_value_iterator_t { - xcb_res_client_id_value_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_res_client_id_value_t *data; + int rem; + int index; } xcb_res_client_id_value_iterator_t; /** * @brief xcb_res_resource_id_spec_t **/ typedef struct xcb_res_resource_id_spec_t { - uint32_t resource; /**< */ - uint32_t type; /**< */ + uint32_t resource; + uint32_t type; } xcb_res_resource_id_spec_t; /** * @brief xcb_res_resource_id_spec_iterator_t **/ typedef struct xcb_res_resource_id_spec_iterator_t { - xcb_res_resource_id_spec_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_res_resource_id_spec_t *data; + int rem; + int index; } xcb_res_resource_id_spec_iterator_t; /** * @brief xcb_res_resource_size_spec_t **/ typedef struct xcb_res_resource_size_spec_t { - xcb_res_resource_id_spec_t spec; /**< */ - uint32_t bytes; /**< */ - uint32_t ref_count; /**< */ - uint32_t use_count; /**< */ + xcb_res_resource_id_spec_t spec; + uint32_t bytes; + uint32_t ref_count; + uint32_t use_count; } xcb_res_resource_size_spec_t; /** * @brief xcb_res_resource_size_spec_iterator_t **/ typedef struct xcb_res_resource_size_spec_iterator_t { - xcb_res_resource_size_spec_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_res_resource_size_spec_t *data; + int rem; + int index; } xcb_res_resource_size_spec_iterator_t; /** * @brief xcb_res_resource_size_value_t **/ typedef struct xcb_res_resource_size_value_t { - xcb_res_resource_size_spec_t size; /**< */ - uint32_t num_cross_references; /**< */ + xcb_res_resource_size_spec_t size; + uint32_t num_cross_references; } xcb_res_resource_size_value_t; /** * @brief xcb_res_resource_size_value_iterator_t **/ typedef struct xcb_res_resource_size_value_iterator_t { - xcb_res_resource_size_value_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_res_resource_size_value_t *data; + int rem; + int index; } xcb_res_resource_size_value_iterator_t; /** * @brief xcb_res_query_version_cookie_t **/ typedef struct xcb_res_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_res_query_version_cookie_t; /** Opcode for xcb_res_query_version. */ @@ -164,30 +164,30 @@ typedef struct xcb_res_query_version_cookie_t { * @brief xcb_res_query_version_request_t **/ typedef struct xcb_res_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t client_major; /**< */ - uint8_t client_minor; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t client_major; + uint8_t client_minor; } xcb_res_query_version_request_t; /** * @brief xcb_res_query_version_reply_t **/ typedef struct xcb_res_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t server_major; /**< */ - uint16_t server_minor; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t server_major; + uint16_t server_minor; } xcb_res_query_version_reply_t; /** * @brief xcb_res_query_clients_cookie_t **/ typedef struct xcb_res_query_clients_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_res_query_clients_cookie_t; /** Opcode for xcb_res_query_clients. */ @@ -197,28 +197,28 @@ typedef struct xcb_res_query_clients_cookie_t { * @brief xcb_res_query_clients_request_t **/ typedef struct xcb_res_query_clients_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_res_query_clients_request_t; /** * @brief xcb_res_query_clients_reply_t **/ typedef struct xcb_res_query_clients_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_clients; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_clients; + uint8_t pad1[20]; } xcb_res_query_clients_reply_t; /** * @brief xcb_res_query_client_resources_cookie_t **/ typedef struct xcb_res_query_client_resources_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_res_query_client_resources_cookie_t; /** Opcode for xcb_res_query_client_resources. */ @@ -228,29 +228,29 @@ typedef struct xcb_res_query_client_resources_cookie_t { * @brief xcb_res_query_client_resources_request_t **/ typedef struct xcb_res_query_client_resources_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t xid; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t xid; } xcb_res_query_client_resources_request_t; /** * @brief xcb_res_query_client_resources_reply_t **/ typedef struct xcb_res_query_client_resources_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_types; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_types; + uint8_t pad1[20]; } xcb_res_query_client_resources_reply_t; /** * @brief xcb_res_query_client_pixmap_bytes_cookie_t **/ typedef struct xcb_res_query_client_pixmap_bytes_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_res_query_client_pixmap_bytes_cookie_t; /** Opcode for xcb_res_query_client_pixmap_bytes. */ @@ -260,29 +260,29 @@ typedef struct xcb_res_query_client_pixmap_bytes_cookie_t { * @brief xcb_res_query_client_pixmap_bytes_request_t **/ typedef struct xcb_res_query_client_pixmap_bytes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t xid; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t xid; } xcb_res_query_client_pixmap_bytes_request_t; /** * @brief xcb_res_query_client_pixmap_bytes_reply_t **/ typedef struct xcb_res_query_client_pixmap_bytes_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t bytes; /**< */ - uint32_t bytes_overflow; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t bytes; + uint32_t bytes_overflow; } xcb_res_query_client_pixmap_bytes_reply_t; /** * @brief xcb_res_query_client_ids_cookie_t **/ typedef struct xcb_res_query_client_ids_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_res_query_client_ids_cookie_t; /** Opcode for xcb_res_query_client_ids. */ @@ -292,29 +292,29 @@ typedef struct xcb_res_query_client_ids_cookie_t { * @brief xcb_res_query_client_ids_request_t **/ typedef struct xcb_res_query_client_ids_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t num_specs; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t num_specs; } xcb_res_query_client_ids_request_t; /** * @brief xcb_res_query_client_ids_reply_t **/ typedef struct xcb_res_query_client_ids_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_ids; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_ids; + uint8_t pad1[20]; } xcb_res_query_client_ids_reply_t; /** * @brief xcb_res_query_resource_bytes_cookie_t **/ typedef struct xcb_res_query_resource_bytes_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_res_query_resource_bytes_cookie_t; /** Opcode for xcb_res_query_resource_bytes. */ @@ -324,23 +324,23 @@ typedef struct xcb_res_query_resource_bytes_cookie_t { * @brief xcb_res_query_resource_bytes_request_t **/ typedef struct xcb_res_query_resource_bytes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t client; /**< */ - uint32_t num_specs; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t client; + uint32_t num_specs; } xcb_res_query_resource_bytes_request_t; /** * @brief xcb_res_query_resource_bytes_reply_t **/ typedef struct xcb_res_query_resource_bytes_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_sizes; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_sizes; + uint8_t pad1[20]; } xcb_res_query_resource_bytes_reply_t; /** @@ -352,7 +352,7 @@ typedef struct xcb_res_query_resource_bytes_reply_t { * element. The member index is increased by sizeof(xcb_res_client_t) */ void -xcb_res_client_next (xcb_res_client_iterator_t *i /**< */); +xcb_res_client_next (xcb_res_client_iterator_t *i); /** * Return the iterator pointing to the last element @@ -364,7 +364,7 @@ xcb_res_client_next (xcb_res_client_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_res_client_end (xcb_res_client_iterator_t i /**< */); +xcb_res_client_end (xcb_res_client_iterator_t i); /** * Get the next element of the iterator @@ -375,7 +375,7 @@ xcb_res_client_end (xcb_res_client_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_res_type_t) */ void -xcb_res_type_next (xcb_res_type_iterator_t *i /**< */); +xcb_res_type_next (xcb_res_type_iterator_t *i); /** * Return the iterator pointing to the last element @@ -387,7 +387,7 @@ xcb_res_type_next (xcb_res_type_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_res_type_end (xcb_res_type_iterator_t i /**< */); +xcb_res_type_end (xcb_res_type_iterator_t i); /** * Get the next element of the iterator @@ -398,7 +398,7 @@ xcb_res_type_end (xcb_res_type_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_res_client_id_spec_t) */ void -xcb_res_client_id_spec_next (xcb_res_client_id_spec_iterator_t *i /**< */); +xcb_res_client_id_spec_next (xcb_res_client_id_spec_iterator_t *i); /** * Return the iterator pointing to the last element @@ -410,19 +410,19 @@ xcb_res_client_id_spec_next (xcb_res_client_id_spec_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_res_client_id_spec_end (xcb_res_client_id_spec_iterator_t i /**< */); +xcb_res_client_id_spec_end (xcb_res_client_id_spec_iterator_t i); int -xcb_res_client_id_value_sizeof (const void *_buffer /**< */); +xcb_res_client_id_value_sizeof (const void *_buffer); uint32_t * -xcb_res_client_id_value_value (const xcb_res_client_id_value_t *R /**< */); +xcb_res_client_id_value_value (const xcb_res_client_id_value_t *R); int -xcb_res_client_id_value_value_length (const xcb_res_client_id_value_t *R /**< */); +xcb_res_client_id_value_value_length (const xcb_res_client_id_value_t *R); xcb_generic_iterator_t -xcb_res_client_id_value_value_end (const xcb_res_client_id_value_t *R /**< */); +xcb_res_client_id_value_value_end (const xcb_res_client_id_value_t *R); /** * Get the next element of the iterator @@ -433,7 +433,7 @@ xcb_res_client_id_value_value_end (const xcb_res_client_id_value_t *R /**< */); * element. The member index is increased by sizeof(xcb_res_client_id_value_t) */ void -xcb_res_client_id_value_next (xcb_res_client_id_value_iterator_t *i /**< */); +xcb_res_client_id_value_next (xcb_res_client_id_value_iterator_t *i); /** * Return the iterator pointing to the last element @@ -445,7 +445,7 @@ xcb_res_client_id_value_next (xcb_res_client_id_value_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_res_client_id_value_end (xcb_res_client_id_value_iterator_t i /**< */); +xcb_res_client_id_value_end (xcb_res_client_id_value_iterator_t i); /** * Get the next element of the iterator @@ -456,7 +456,7 @@ xcb_res_client_id_value_end (xcb_res_client_id_value_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_res_resource_id_spec_t) */ void -xcb_res_resource_id_spec_next (xcb_res_resource_id_spec_iterator_t *i /**< */); +xcb_res_resource_id_spec_next (xcb_res_resource_id_spec_iterator_t *i); /** * Return the iterator pointing to the last element @@ -468,7 +468,7 @@ xcb_res_resource_id_spec_next (xcb_res_resource_id_spec_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_res_resource_id_spec_end (xcb_res_resource_id_spec_iterator_t i /**< */); +xcb_res_resource_id_spec_end (xcb_res_resource_id_spec_iterator_t i); /** * Get the next element of the iterator @@ -479,7 +479,7 @@ xcb_res_resource_id_spec_end (xcb_res_resource_id_spec_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_res_resource_size_spec_t) */ void -xcb_res_resource_size_spec_next (xcb_res_resource_size_spec_iterator_t *i /**< */); +xcb_res_resource_size_spec_next (xcb_res_resource_size_spec_iterator_t *i); /** * Return the iterator pointing to the last element @@ -491,19 +491,19 @@ xcb_res_resource_size_spec_next (xcb_res_resource_size_spec_iterator_t *i /**< * last element. */ xcb_generic_iterator_t -xcb_res_resource_size_spec_end (xcb_res_resource_size_spec_iterator_t i /**< */); +xcb_res_resource_size_spec_end (xcb_res_resource_size_spec_iterator_t i); int -xcb_res_resource_size_value_sizeof (const void *_buffer /**< */); +xcb_res_resource_size_value_sizeof (const void *_buffer); xcb_res_resource_size_spec_t * -xcb_res_resource_size_value_cross_references (const xcb_res_resource_size_value_t *R /**< */); +xcb_res_resource_size_value_cross_references (const xcb_res_resource_size_value_t *R); int -xcb_res_resource_size_value_cross_references_length (const xcb_res_resource_size_value_t *R /**< */); +xcb_res_resource_size_value_cross_references_length (const xcb_res_resource_size_value_t *R); xcb_res_resource_size_spec_iterator_t -xcb_res_resource_size_value_cross_references_iterator (const xcb_res_resource_size_value_t *R /**< */); +xcb_res_resource_size_value_cross_references_iterator (const xcb_res_resource_size_value_t *R); /** * Get the next element of the iterator @@ -514,7 +514,7 @@ xcb_res_resource_size_value_cross_references_iterator (const xcb_res_resource_si * element. The member index is increased by sizeof(xcb_res_resource_size_value_t) */ void -xcb_res_resource_size_value_next (xcb_res_resource_size_value_iterator_t *i /**< */); +xcb_res_resource_size_value_next (xcb_res_resource_size_value_iterator_t *i); /** * Return the iterator pointing to the last element @@ -526,7 +526,7 @@ xcb_res_resource_size_value_next (xcb_res_resource_size_value_iterator_t *i /** * last element. */ xcb_generic_iterator_t -xcb_res_resource_size_value_end (xcb_res_resource_size_value_iterator_t i /**< */); +xcb_res_resource_size_value_end (xcb_res_resource_size_value_iterator_t i); /** * @@ -537,9 +537,9 @@ xcb_res_resource_size_value_end (xcb_res_resource_size_value_iterator_t i /**< * */ xcb_res_query_version_cookie_t -xcb_res_query_version (xcb_connection_t *c /**< */, - uint8_t client_major /**< */, - uint8_t client_minor /**< */); +xcb_res_query_version (xcb_connection_t *c, + uint8_t client_major, + uint8_t client_minor); /** * @@ -553,9 +553,9 @@ xcb_res_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_res_query_version_cookie_t -xcb_res_query_version_unchecked (xcb_connection_t *c /**< */, - uint8_t client_major /**< */, - uint8_t client_minor /**< */); +xcb_res_query_version_unchecked (xcb_connection_t *c, + uint8_t client_major, + uint8_t client_minor); /** * Return the reply @@ -572,12 +572,12 @@ xcb_res_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_res_query_version_reply_t * -xcb_res_query_version_reply (xcb_connection_t *c /**< */, +xcb_res_query_version_reply (xcb_connection_t *c, xcb_res_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_res_query_clients_sizeof (const void *_buffer /**< */); +xcb_res_query_clients_sizeof (const void *_buffer); /** * @@ -588,7 +588,7 @@ xcb_res_query_clients_sizeof (const void *_buffer /**< */); * */ xcb_res_query_clients_cookie_t -xcb_res_query_clients (xcb_connection_t *c /**< */); +xcb_res_query_clients (xcb_connection_t *c); /** * @@ -602,16 +602,16 @@ xcb_res_query_clients (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_res_query_clients_cookie_t -xcb_res_query_clients_unchecked (xcb_connection_t *c /**< */); +xcb_res_query_clients_unchecked (xcb_connection_t *c); xcb_res_client_t * -xcb_res_query_clients_clients (const xcb_res_query_clients_reply_t *R /**< */); +xcb_res_query_clients_clients (const xcb_res_query_clients_reply_t *R); int -xcb_res_query_clients_clients_length (const xcb_res_query_clients_reply_t *R /**< */); +xcb_res_query_clients_clients_length (const xcb_res_query_clients_reply_t *R); xcb_res_client_iterator_t -xcb_res_query_clients_clients_iterator (const xcb_res_query_clients_reply_t *R /**< */); +xcb_res_query_clients_clients_iterator (const xcb_res_query_clients_reply_t *R); /** * Return the reply @@ -628,12 +628,12 @@ xcb_res_query_clients_clients_iterator (const xcb_res_query_clients_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_res_query_clients_reply_t * -xcb_res_query_clients_reply (xcb_connection_t *c /**< */, +xcb_res_query_clients_reply (xcb_connection_t *c, xcb_res_query_clients_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_res_query_client_resources_sizeof (const void *_buffer /**< */); +xcb_res_query_client_resources_sizeof (const void *_buffer); /** * @@ -644,8 +644,8 @@ xcb_res_query_client_resources_sizeof (const void *_buffer /**< */); * */ xcb_res_query_client_resources_cookie_t -xcb_res_query_client_resources (xcb_connection_t *c /**< */, - uint32_t xid /**< */); +xcb_res_query_client_resources (xcb_connection_t *c, + uint32_t xid); /** * @@ -659,17 +659,17 @@ xcb_res_query_client_resources (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_res_query_client_resources_cookie_t -xcb_res_query_client_resources_unchecked (xcb_connection_t *c /**< */, - uint32_t xid /**< */); +xcb_res_query_client_resources_unchecked (xcb_connection_t *c, + uint32_t xid); xcb_res_type_t * -xcb_res_query_client_resources_types (const xcb_res_query_client_resources_reply_t *R /**< */); +xcb_res_query_client_resources_types (const xcb_res_query_client_resources_reply_t *R); int -xcb_res_query_client_resources_types_length (const xcb_res_query_client_resources_reply_t *R /**< */); +xcb_res_query_client_resources_types_length (const xcb_res_query_client_resources_reply_t *R); xcb_res_type_iterator_t -xcb_res_query_client_resources_types_iterator (const xcb_res_query_client_resources_reply_t *R /**< */); +xcb_res_query_client_resources_types_iterator (const xcb_res_query_client_resources_reply_t *R); /** * Return the reply @@ -686,9 +686,9 @@ xcb_res_query_client_resources_types_iterator (const xcb_res_query_client_resour * The returned value must be freed by the caller using free(). */ xcb_res_query_client_resources_reply_t * -xcb_res_query_client_resources_reply (xcb_connection_t *c /**< */, +xcb_res_query_client_resources_reply (xcb_connection_t *c, xcb_res_query_client_resources_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -699,8 +699,8 @@ xcb_res_query_client_resources_reply (xcb_connection_t * * */ xcb_res_query_client_pixmap_bytes_cookie_t -xcb_res_query_client_pixmap_bytes (xcb_connection_t *c /**< */, - uint32_t xid /**< */); +xcb_res_query_client_pixmap_bytes (xcb_connection_t *c, + uint32_t xid); /** * @@ -714,8 +714,8 @@ xcb_res_query_client_pixmap_bytes (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_res_query_client_pixmap_bytes_cookie_t -xcb_res_query_client_pixmap_bytes_unchecked (xcb_connection_t *c /**< */, - uint32_t xid /**< */); +xcb_res_query_client_pixmap_bytes_unchecked (xcb_connection_t *c, + uint32_t xid); /** * Return the reply @@ -732,12 +732,12 @@ xcb_res_query_client_pixmap_bytes_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_res_query_client_pixmap_bytes_reply_t * -xcb_res_query_client_pixmap_bytes_reply (xcb_connection_t *c /**< */, +xcb_res_query_client_pixmap_bytes_reply (xcb_connection_t *c, xcb_res_query_client_pixmap_bytes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_res_query_client_ids_sizeof (const void *_buffer /**< */); +xcb_res_query_client_ids_sizeof (const void *_buffer); /** * @@ -748,9 +748,9 @@ xcb_res_query_client_ids_sizeof (const void *_buffer /**< */); * */ xcb_res_query_client_ids_cookie_t -xcb_res_query_client_ids (xcb_connection_t *c /**< */, - uint32_t num_specs /**< */, - const xcb_res_client_id_spec_t *specs /**< */); +xcb_res_query_client_ids (xcb_connection_t *c, + uint32_t num_specs, + const xcb_res_client_id_spec_t *specs); /** * @@ -764,15 +764,15 @@ xcb_res_query_client_ids (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_res_query_client_ids_cookie_t -xcb_res_query_client_ids_unchecked (xcb_connection_t *c /**< */, - uint32_t num_specs /**< */, - const xcb_res_client_id_spec_t *specs /**< */); +xcb_res_query_client_ids_unchecked (xcb_connection_t *c, + uint32_t num_specs, + const xcb_res_client_id_spec_t *specs); int -xcb_res_query_client_ids_ids_length (const xcb_res_query_client_ids_reply_t *R /**< */); +xcb_res_query_client_ids_ids_length (const xcb_res_query_client_ids_reply_t *R); xcb_res_client_id_value_iterator_t -xcb_res_query_client_ids_ids_iterator (const xcb_res_query_client_ids_reply_t *R /**< */); +xcb_res_query_client_ids_ids_iterator (const xcb_res_query_client_ids_reply_t *R); /** * Return the reply @@ -789,12 +789,12 @@ xcb_res_query_client_ids_ids_iterator (const xcb_res_query_client_ids_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_res_query_client_ids_reply_t * -xcb_res_query_client_ids_reply (xcb_connection_t *c /**< */, +xcb_res_query_client_ids_reply (xcb_connection_t *c, xcb_res_query_client_ids_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_res_query_resource_bytes_sizeof (const void *_buffer /**< */); +xcb_res_query_resource_bytes_sizeof (const void *_buffer); /** * @@ -805,10 +805,10 @@ xcb_res_query_resource_bytes_sizeof (const void *_buffer /**< */); * */ xcb_res_query_resource_bytes_cookie_t -xcb_res_query_resource_bytes (xcb_connection_t *c /**< */, - uint32_t client /**< */, - uint32_t num_specs /**< */, - const xcb_res_resource_id_spec_t *specs /**< */); +xcb_res_query_resource_bytes (xcb_connection_t *c, + uint32_t client, + uint32_t num_specs, + const xcb_res_resource_id_spec_t *specs); /** * @@ -822,16 +822,16 @@ xcb_res_query_resource_bytes (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_res_query_resource_bytes_cookie_t -xcb_res_query_resource_bytes_unchecked (xcb_connection_t *c /**< */, - uint32_t client /**< */, - uint32_t num_specs /**< */, - const xcb_res_resource_id_spec_t *specs /**< */); +xcb_res_query_resource_bytes_unchecked (xcb_connection_t *c, + uint32_t client, + uint32_t num_specs, + const xcb_res_resource_id_spec_t *specs); int -xcb_res_query_resource_bytes_sizes_length (const xcb_res_query_resource_bytes_reply_t *R /**< */); +xcb_res_query_resource_bytes_sizes_length (const xcb_res_query_resource_bytes_reply_t *R); xcb_res_resource_size_value_iterator_t -xcb_res_query_resource_bytes_sizes_iterator (const xcb_res_query_resource_bytes_reply_t *R /**< */); +xcb_res_query_resource_bytes_sizes_iterator (const xcb_res_query_resource_bytes_reply_t *R); /** * Return the reply @@ -848,9 +848,9 @@ xcb_res_query_resource_bytes_sizes_iterator (const xcb_res_query_resource_bytes_ * The returned value must be freed by the caller using free(). */ xcb_res_query_resource_bytes_reply_t * -xcb_res_query_resource_bytes_reply (xcb_connection_t *c /**< */, +xcb_res_query_resource_bytes_reply (xcb_connection_t *c, xcb_res_query_resource_bytes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/screensaver.c b/lib/libxcb/src/screensaver.c index 8dfa7009e..67d761705 100644 --- a/lib/libxcb/src/screensaver.c +++ b/lib/libxcb/src/screensaver.c @@ -19,15 +19,15 @@ xcb_extension_t xcb_screensaver_id = { "MIT-SCREEN-SAVER", 0 }; xcb_screensaver_query_version_cookie_t -xcb_screensaver_query_version (xcb_connection_t *c /**< */, - uint8_t client_major_version /**< */, - uint8_t client_minor_version /**< */) +xcb_screensaver_query_version (xcb_connection_t *c, + uint8_t client_major_version, + uint8_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -48,15 +48,15 @@ xcb_screensaver_query_version (xcb_connection_t *c /**< */, } xcb_screensaver_query_version_cookie_t -xcb_screensaver_query_version_unchecked (xcb_connection_t *c /**< */, - uint8_t client_major_version /**< */, - uint8_t client_minor_version /**< */) +xcb_screensaver_query_version_unchecked (xcb_connection_t *c, + uint8_t client_major_version, + uint8_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -77,22 +77,22 @@ xcb_screensaver_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_screensaver_query_version_reply_t * -xcb_screensaver_query_version_reply (xcb_connection_t *c /**< */, +xcb_screensaver_query_version_reply (xcb_connection_t *c, xcb_screensaver_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_screensaver_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_screensaver_query_info_cookie_t -xcb_screensaver_query_info (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_screensaver_query_info (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_QUERY_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_QUERY_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -111,14 +111,14 @@ xcb_screensaver_query_info (xcb_connection_t *c /**< */, } xcb_screensaver_query_info_cookie_t -xcb_screensaver_query_info_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_screensaver_query_info_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_QUERY_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_QUERY_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -137,23 +137,23 @@ xcb_screensaver_query_info_unchecked (xcb_connection_t *c /**< */, } xcb_screensaver_query_info_reply_t * -xcb_screensaver_query_info_reply (xcb_connection_t *c /**< */, +xcb_screensaver_query_info_reply (xcb_connection_t *c, xcb_screensaver_query_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_screensaver_query_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_screensaver_select_input_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t event_mask /**< */) +xcb_screensaver_select_input_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_SELECT_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_SELECT_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -173,15 +173,15 @@ xcb_screensaver_select_input_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_screensaver_select_input (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t event_mask /**< */) +xcb_screensaver_select_input (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_SELECT_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_SELECT_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -201,7 +201,313 @@ xcb_screensaver_select_input (xcb_connection_t *c /**< */, } int -xcb_screensaver_set_attributes_sizeof (const void *_buffer /**< */) +xcb_screensaver_set_attributes_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_screensaver_set_attributes_value_list_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[16]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(value_mask & XCB_CW_BACK_PIXMAP) { + /* xcb_screensaver_set_attributes_value_list_t.background_pixmap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixmap; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BACK_PIXEL) { + /* xcb_screensaver_set_attributes_value_list_t.background_pixel */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixel; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BORDER_PIXMAP) { + /* xcb_screensaver_set_attributes_value_list_t.border_pixmap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixmap; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BORDER_PIXEL) { + /* xcb_screensaver_set_attributes_value_list_t.border_pixel */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixel; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BIT_GRAVITY) { + /* xcb_screensaver_set_attributes_value_list_t.bit_gravity */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bit_gravity; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_WIN_GRAVITY) { + /* xcb_screensaver_set_attributes_value_list_t.win_gravity */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->win_gravity; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_STORE) { + /* xcb_screensaver_set_attributes_value_list_t.backing_store */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_store; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PLANES) { + /* xcb_screensaver_set_attributes_value_list_t.backing_planes */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_planes; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PIXEL) { + /* xcb_screensaver_set_attributes_value_list_t.backing_pixel */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_pixel; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_OVERRIDE_REDIRECT) { + /* xcb_screensaver_set_attributes_value_list_t.override_redirect */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->override_redirect; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_SAVE_UNDER) { + /* xcb_screensaver_set_attributes_value_list_t.save_under */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->save_under; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_EVENT_MASK) { + /* xcb_screensaver_set_attributes_value_list_t.event_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_DONT_PROPAGATE) { + /* xcb_screensaver_set_attributes_value_list_t.do_not_propogate_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->do_not_propogate_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_COLORMAP) { + /* xcb_screensaver_set_attributes_value_list_t.colormap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->colormap; + xcb_block_len += sizeof(xcb_colormap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_colormap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_colormap_t); + } + if(value_mask & XCB_CW_CURSOR) { + /* xcb_screensaver_set_attributes_value_list_t.cursor */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cursor; + xcb_block_len += sizeof(xcb_cursor_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_cursor_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_cursor_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ibackground_pixmap = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BACK_PIXEL) { + /* xcb_screensaver_set_attributes_value_list_t.background_pixel */ + _aux->background_pixel = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BORDER_PIXMAP) { + /* xcb_screensaver_set_attributes_value_list_t.border_pixmap */ + _aux->border_pixmap = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BORDER_PIXEL) { + /* xcb_screensaver_set_attributes_value_list_t.border_pixel */ + _aux->border_pixel = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BIT_GRAVITY) { + /* xcb_screensaver_set_attributes_value_list_t.bit_gravity */ + _aux->bit_gravity = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_WIN_GRAVITY) { + /* xcb_screensaver_set_attributes_value_list_t.win_gravity */ + _aux->win_gravity = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_STORE) { + /* xcb_screensaver_set_attributes_value_list_t.backing_store */ + _aux->backing_store = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PLANES) { + /* xcb_screensaver_set_attributes_value_list_t.backing_planes */ + _aux->backing_planes = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PIXEL) { + /* xcb_screensaver_set_attributes_value_list_t.backing_pixel */ + _aux->backing_pixel = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_OVERRIDE_REDIRECT) { + /* xcb_screensaver_set_attributes_value_list_t.override_redirect */ + _aux->override_redirect = *(xcb_bool32_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_tmp += sizeof(xcb_bool32_t); + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_SAVE_UNDER) { + /* xcb_screensaver_set_attributes_value_list_t.save_under */ + _aux->save_under = *(xcb_bool32_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_tmp += sizeof(xcb_bool32_t); + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_EVENT_MASK) { + /* xcb_screensaver_set_attributes_value_list_t.event_mask */ + _aux->event_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_DONT_PROPAGATE) { + /* xcb_screensaver_set_attributes_value_list_t.do_not_propogate_mask */ + _aux->do_not_propogate_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_COLORMAP) { + /* xcb_screensaver_set_attributes_value_list_t.colormap */ + _aux->colormap = *(xcb_colormap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_colormap_t); + xcb_tmp += sizeof(xcb_colormap_t); + xcb_align_to = ALIGNOF(xcb_colormap_t); + } + if(value_mask & XCB_CW_CURSOR) { + /* xcb_screensaver_set_attributes_value_list_t.cursor */ + _aux->cursor = *(xcb_cursor_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_cursor_t); + xcb_tmp += sizeof(xcb_cursor_t); + xcb_align_to = ALIGNOF(xcb_cursor_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; +} + +int +xcb_screensaver_set_attributes_value_list_sizeof (const void *_buffer, + uint32_t value_mask) +{ + xcb_screensaver_set_attributes_value_list_t _aux; + return xcb_screensaver_set_attributes_value_list_unpack(_buffer, value_mask, &_aux); +} + +int +xcb_screensaver_set_attributes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_screensaver_set_attributes_request_t *_aux = (xcb_screensaver_set_attributes_request_t *)_buffer; @@ -216,9 +522,9 @@ xcb_screensaver_set_attributes_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* value_list */ - xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_block_len += xcb_screensaver_set_attributes_value_list_sizeof(xcb_tmp, _aux->value_mask); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -232,27 +538,27 @@ xcb_screensaver_set_attributes_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_screensaver_set_attributes_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t border_width /**< */, - uint8_t _class /**< */, - uint8_t depth /**< */, - xcb_visualid_t visual /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_screensaver_set_attributes_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint8_t _class, + uint8_t depth, + xcb_visualid_t visual, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_SET_ATTRIBUTES, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_screensaver_set_attributes_request_t xcb_out; @@ -271,38 +577,37 @@ xcb_screensaver_set_attributes_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_screensaver_set_attributes_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_screensaver_set_attributes_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_screensaver_set_attributes (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t border_width /**< */, - uint8_t _class /**< */, - uint8_t depth /**< */, - xcb_visualid_t visual /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_screensaver_set_attributes (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint8_t _class, + uint8_t depth, + xcb_visualid_t visual, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_SET_ATTRIBUTES, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_screensaver_set_attributes_request_t xcb_out; @@ -321,25 +626,132 @@ xcb_screensaver_set_attributes (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_screensaver_set_attributes_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_screensaver_set_attributes_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_screensaver_unset_attributes_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_screensaver_set_attributes_aux_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint8_t _class, + uint8_t depth, + xcb_visualid_t visual, + uint32_t value_mask, + const xcb_screensaver_set_attributes_value_list_t *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_UNSET_ATTRIBUTES, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_screensaver_set_attributes_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.drawable = drawable; + xcb_out.x = x; + xcb_out.y = y; + xcb_out.width = width; + xcb_out.height = height; + xcb_out.border_width = border_width; + xcb_out._class = _class; + xcb_out.depth = depth; + xcb_out.visual = visual; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_screensaver_set_attributes_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_screensaver_set_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_screensaver_set_attributes_aux (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint8_t _class, + uint8_t depth, + xcb_visualid_t visual, + uint32_t value_mask, + const xcb_screensaver_set_attributes_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_screensaver_set_attributes_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.drawable = drawable; + xcb_out.x = x; + xcb_out.y = y; + xcb_out.width = width; + xcb_out.height = height; + xcb_out.border_width = border_width; + xcb_out._class = _class; + xcb_out.depth = depth; + xcb_out.visual = visual; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_screensaver_set_attributes_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_screensaver_set_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_screensaver_set_attributes_value_list (const xcb_screensaver_set_attributes_request_t *R) +{ + return (void *) (R + 1); +} + +xcb_void_cookie_t +xcb_screensaver_unset_attributes_checked (xcb_connection_t *c, + xcb_drawable_t drawable) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_UNSET_ATTRIBUTES, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -358,14 +770,14 @@ xcb_screensaver_unset_attributes_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_screensaver_unset_attributes (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_screensaver_unset_attributes (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_UNSET_ATTRIBUTES, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_UNSET_ATTRIBUTES, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -384,14 +796,14 @@ xcb_screensaver_unset_attributes (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_screensaver_suspend_checked (xcb_connection_t *c /**< */, - uint8_t suspend /**< */) +xcb_screensaver_suspend_checked (xcb_connection_t *c, + uint8_t suspend) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_SUSPEND, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_SUSPEND, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -411,14 +823,14 @@ xcb_screensaver_suspend_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_screensaver_suspend (xcb_connection_t *c /**< */, - uint8_t suspend /**< */) +xcb_screensaver_suspend (xcb_connection_t *c, + uint8_t suspend) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_screensaver_id, - /* opcode */ XCB_SCREENSAVER_SUSPEND, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_screensaver_id, + .opcode = XCB_SCREENSAVER_SUSPEND, + .isvoid = 1 }; struct iovec xcb_parts[4]; diff --git a/lib/libxcb/src/screensaver.h b/lib/libxcb/src/screensaver.h index 6846da8e1..1982f21e5 100644 --- a/lib/libxcb/src/screensaver.h +++ b/lib/libxcb/src/screensaver.h @@ -46,7 +46,7 @@ typedef enum xcb_screensaver_state_t { * @brief xcb_screensaver_query_version_cookie_t **/ typedef struct xcb_screensaver_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_screensaver_query_version_cookie_t; /** Opcode for xcb_screensaver_query_version. */ @@ -56,32 +56,32 @@ typedef struct xcb_screensaver_query_version_cookie_t { * @brief xcb_screensaver_query_version_request_t **/ typedef struct xcb_screensaver_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t client_major_version; /**< */ - uint8_t client_minor_version; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t client_major_version; + uint8_t client_minor_version; + uint8_t pad0[2]; } xcb_screensaver_query_version_request_t; /** * @brief xcb_screensaver_query_version_reply_t **/ typedef struct xcb_screensaver_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t server_major_version; /**< */ - uint16_t server_minor_version; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t server_major_version; + uint16_t server_minor_version; + uint8_t pad1[20]; } xcb_screensaver_query_version_reply_t; /** * @brief xcb_screensaver_query_info_cookie_t **/ typedef struct xcb_screensaver_query_info_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_screensaver_query_info_cookie_t; /** Opcode for xcb_screensaver_query_info. */ @@ -91,26 +91,26 @@ typedef struct xcb_screensaver_query_info_cookie_t { * @brief xcb_screensaver_query_info_request_t **/ typedef struct xcb_screensaver_query_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; } xcb_screensaver_query_info_request_t; /** * @brief xcb_screensaver_query_info_reply_t **/ typedef struct xcb_screensaver_query_info_reply_t { - uint8_t response_type; /**< */ - uint8_t state; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t saver_window; /**< */ - uint32_t ms_until_server; /**< */ - uint32_t ms_since_user_input; /**< */ - uint32_t event_mask; /**< */ - uint8_t kind; /**< */ - uint8_t pad0[7]; /**< */ + uint8_t response_type; + uint8_t state; + uint16_t sequence; + uint32_t length; + xcb_window_t saver_window; + uint32_t ms_until_server; + uint32_t ms_since_user_input; + uint32_t event_mask; + uint8_t kind; + uint8_t pad0[7]; } xcb_screensaver_query_info_reply_t; /** Opcode for xcb_screensaver_select_input. */ @@ -120,13 +120,34 @@ typedef struct xcb_screensaver_query_info_reply_t { * @brief xcb_screensaver_select_input_request_t **/ typedef struct xcb_screensaver_select_input_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t event_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t event_mask; } xcb_screensaver_select_input_request_t; +/** + * @brief xcb_screensaver_set_attributes_value_list_t + **/ +typedef struct xcb_screensaver_set_attributes_value_list_t { + xcb_pixmap_t background_pixmap; + uint32_t background_pixel; + xcb_pixmap_t border_pixmap; + uint32_t border_pixel; + uint32_t bit_gravity; + uint32_t win_gravity; + uint32_t backing_store; + uint32_t backing_planes; + uint32_t backing_pixel; + xcb_bool32_t override_redirect; + xcb_bool32_t save_under; + uint32_t event_mask; + uint32_t do_not_propogate_mask; + xcb_colormap_t colormap; + xcb_cursor_t cursor; +} xcb_screensaver_set_attributes_value_list_t; + /** Opcode for xcb_screensaver_set_attributes. */ #define XCB_SCREENSAVER_SET_ATTRIBUTES 3 @@ -134,19 +155,19 @@ typedef struct xcb_screensaver_select_input_request_t { * @brief xcb_screensaver_set_attributes_request_t **/ typedef struct xcb_screensaver_set_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t border_width; /**< */ - uint8_t _class; /**< */ - uint8_t depth; /**< */ - xcb_visualid_t visual; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint8_t _class; + uint8_t depth; + xcb_visualid_t visual; + uint32_t value_mask; } xcb_screensaver_set_attributes_request_t; /** Opcode for xcb_screensaver_unset_attributes. */ @@ -156,10 +177,10 @@ typedef struct xcb_screensaver_set_attributes_request_t { * @brief xcb_screensaver_unset_attributes_request_t **/ typedef struct xcb_screensaver_unset_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; } xcb_screensaver_unset_attributes_request_t; /** Opcode for xcb_screensaver_suspend. */ @@ -169,11 +190,11 @@ typedef struct xcb_screensaver_unset_attributes_request_t { * @brief xcb_screensaver_suspend_request_t **/ typedef struct xcb_screensaver_suspend_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t suspend; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t suspend; + uint8_t pad0[3]; } xcb_screensaver_suspend_request_t; /** Opcode for xcb_screensaver_notify. */ @@ -183,15 +204,15 @@ typedef struct xcb_screensaver_suspend_request_t { * @brief xcb_screensaver_notify_event_t **/ typedef struct xcb_screensaver_notify_event_t { - uint8_t response_type; /**< */ - uint8_t state; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t root; /**< */ - xcb_window_t window; /**< */ - uint8_t kind; /**< */ - uint8_t forced; /**< */ - uint8_t pad0[14]; /**< */ + uint8_t response_type; + uint8_t state; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t window; + uint8_t kind; + uint8_t forced; + uint8_t pad0[14]; } xcb_screensaver_notify_event_t; /** @@ -203,9 +224,9 @@ typedef struct xcb_screensaver_notify_event_t { * */ xcb_screensaver_query_version_cookie_t -xcb_screensaver_query_version (xcb_connection_t *c /**< */, - uint8_t client_major_version /**< */, - uint8_t client_minor_version /**< */); +xcb_screensaver_query_version (xcb_connection_t *c, + uint8_t client_major_version, + uint8_t client_minor_version); /** * @@ -219,9 +240,9 @@ xcb_screensaver_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_screensaver_query_version_cookie_t -xcb_screensaver_query_version_unchecked (xcb_connection_t *c /**< */, - uint8_t client_major_version /**< */, - uint8_t client_minor_version /**< */); +xcb_screensaver_query_version_unchecked (xcb_connection_t *c, + uint8_t client_major_version, + uint8_t client_minor_version); /** * Return the reply @@ -238,9 +259,9 @@ xcb_screensaver_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_screensaver_query_version_reply_t * -xcb_screensaver_query_version_reply (xcb_connection_t *c /**< */, +xcb_screensaver_query_version_reply (xcb_connection_t *c, xcb_screensaver_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -251,8 +272,8 @@ xcb_screensaver_query_version_reply (xcb_connection_t *c * */ xcb_screensaver_query_info_cookie_t -xcb_screensaver_query_info (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_screensaver_query_info (xcb_connection_t *c, + xcb_drawable_t drawable); /** * @@ -266,8 +287,8 @@ xcb_screensaver_query_info (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_screensaver_query_info_cookie_t -xcb_screensaver_query_info_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_screensaver_query_info_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable); /** * Return the reply @@ -284,9 +305,9 @@ xcb_screensaver_query_info_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_screensaver_query_info_reply_t * -xcb_screensaver_query_info_reply (xcb_connection_t *c /**< */, +xcb_screensaver_query_info_reply (xcb_connection_t *c, xcb_screensaver_query_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -300,9 +321,9 @@ xcb_screensaver_query_info_reply (xcb_connection_t *c /**< * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_screensaver_select_input_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t event_mask /**< */); +xcb_screensaver_select_input_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t event_mask); /** * @@ -313,12 +334,26 @@ xcb_screensaver_select_input_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_screensaver_select_input (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t event_mask /**< */); +xcb_screensaver_select_input (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t event_mask); int -xcb_screensaver_set_attributes_sizeof (const void *_buffer /**< */); +xcb_screensaver_set_attributes_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_screensaver_set_attributes_value_list_t *_aux); + +int +xcb_screensaver_set_attributes_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_screensaver_set_attributes_value_list_t *_aux); + +int +xcb_screensaver_set_attributes_value_list_sizeof (const void *_buffer, + uint32_t value_mask); + +int +xcb_screensaver_set_attributes_sizeof (const void *_buffer); /** * @@ -332,18 +367,18 @@ xcb_screensaver_set_attributes_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_screensaver_set_attributes_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t border_width /**< */, - uint8_t _class /**< */, - uint8_t depth /**< */, - xcb_visualid_t visual /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_screensaver_set_attributes_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint8_t _class, + uint8_t depth, + xcb_visualid_t visual, + uint32_t value_mask, + const void *value_list); /** * @@ -354,18 +389,18 @@ xcb_screensaver_set_attributes_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_screensaver_set_attributes (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t border_width /**< */, - uint8_t _class /**< */, - uint8_t depth /**< */, - xcb_visualid_t visual /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_screensaver_set_attributes (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint8_t _class, + uint8_t depth, + xcb_visualid_t visual, + uint32_t value_mask, + const void *value_list); /** * @@ -379,8 +414,18 @@ xcb_screensaver_set_attributes (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_screensaver_unset_attributes_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_screensaver_set_attributes_aux_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint8_t _class, + uint8_t depth, + xcb_visualid_t visual, + uint32_t value_mask, + const xcb_screensaver_set_attributes_value_list_t *value_list); /** * @@ -391,8 +436,21 @@ xcb_screensaver_unset_attributes_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_screensaver_unset_attributes (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_screensaver_set_attributes_aux (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint8_t _class, + uint8_t depth, + xcb_visualid_t visual, + uint32_t value_mask, + const xcb_screensaver_set_attributes_value_list_t *value_list); + +void * +xcb_screensaver_set_attributes_value_list (const xcb_screensaver_set_attributes_request_t *R); /** * @@ -406,8 +464,8 @@ xcb_screensaver_unset_attributes (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_screensaver_suspend_checked (xcb_connection_t *c /**< */, - uint8_t suspend /**< */); +xcb_screensaver_unset_attributes_checked (xcb_connection_t *c, + xcb_drawable_t drawable); /** * @@ -418,8 +476,35 @@ xcb_screensaver_suspend_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_screensaver_suspend (xcb_connection_t *c /**< */, - uint8_t suspend /**< */); +xcb_screensaver_unset_attributes (xcb_connection_t *c, + xcb_drawable_t drawable); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_screensaver_suspend_checked (xcb_connection_t *c, + uint8_t suspend); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_screensaver_suspend (xcb_connection_t *c, + uint8_t suspend); #ifdef __cplusplus diff --git a/lib/libxcb/src/shape.c b/lib/libxcb/src/shape.c index 3a4428ffc..df199f4f3 100644 --- a/lib/libxcb/src/shape.c +++ b/lib/libxcb/src/shape.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_shape_id = { "SHAPE", 0 }; void -xcb_shape_op_next (xcb_shape_op_iterator_t *i /**< */) +xcb_shape_op_next (xcb_shape_op_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_shape_op_next (xcb_shape_op_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_shape_op_end (xcb_shape_op_iterator_t i /**< */) +xcb_shape_op_end (xcb_shape_op_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,7 +37,7 @@ xcb_shape_op_end (xcb_shape_op_iterator_t i /**< */) } void -xcb_shape_kind_next (xcb_shape_kind_iterator_t *i /**< */) +xcb_shape_kind_next (xcb_shape_kind_iterator_t *i) { --i->rem; ++i->data; @@ -45,7 +45,7 @@ xcb_shape_kind_next (xcb_shape_kind_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_shape_kind_end (xcb_shape_kind_iterator_t i /**< */) +xcb_shape_kind_end (xcb_shape_kind_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -55,13 +55,13 @@ xcb_shape_kind_end (xcb_shape_kind_iterator_t i /**< */) } xcb_shape_query_version_cookie_t -xcb_shape_query_version (xcb_connection_t *c /**< */) +xcb_shape_query_version (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -79,13 +79,13 @@ xcb_shape_query_version (xcb_connection_t *c /**< */) } xcb_shape_query_version_cookie_t -xcb_shape_query_version_unchecked (xcb_connection_t *c /**< */) +xcb_shape_query_version_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -103,16 +103,16 @@ xcb_shape_query_version_unchecked (xcb_connection_t *c /**< */) } xcb_shape_query_version_reply_t * -xcb_shape_query_version_reply (xcb_connection_t *c /**< */, +xcb_shape_query_version_reply (xcb_connection_t *c, xcb_shape_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_shape_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_shape_rectangles_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */) +xcb_shape_rectangles_sizeof (const void *_buffer, + uint32_t rectangles_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -142,21 +142,21 @@ xcb_shape_rectangles_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_shape_rectangles_checked (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - uint8_t ordering /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_shape_rectangles_checked (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + uint8_t ordering, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_RECTANGLES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_RECTANGLES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -186,21 +186,21 @@ xcb_shape_rectangles_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shape_rectangles (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - uint8_t ordering /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_shape_rectangles (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + uint8_t ordering, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_RECTANGLES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_RECTANGLES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -229,20 +229,42 @@ xcb_shape_rectangles (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_rectangle_t * +xcb_shape_rectangles_rectangles (const xcb_shape_rectangles_request_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + +int +xcb_shape_rectangles_rectangles_length (const xcb_shape_rectangles_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_shape_rectangles_request_t))/sizeof(xcb_rectangle_t)); +} + +xcb_rectangle_iterator_t +xcb_shape_rectangles_rectangles_iterator (const xcb_shape_rectangles_request_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_shape_rectangles_request_t))/sizeof(xcb_rectangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_shape_mask_checked (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_pixmap_t source_bitmap /**< */) +xcb_shape_mask_checked (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + xcb_pixmap_t source_bitmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_MASK, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_MASK, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -267,19 +289,19 @@ xcb_shape_mask_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shape_mask (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_pixmap_t source_bitmap /**< */) +xcb_shape_mask (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + xcb_pixmap_t source_bitmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_MASK, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_MASK, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -304,20 +326,20 @@ xcb_shape_mask (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shape_combine_checked (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_shape_kind_t source_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_window_t source_window /**< */) +xcb_shape_combine_checked (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + xcb_shape_kind_t source_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + xcb_window_t source_window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_COMBINE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_COMBINE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -343,20 +365,20 @@ xcb_shape_combine_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shape_combine (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_shape_kind_t source_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_window_t source_window /**< */) +xcb_shape_combine (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + xcb_shape_kind_t source_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + xcb_window_t source_window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_COMBINE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_COMBINE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -382,17 +404,17 @@ xcb_shape_combine (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shape_offset_checked (xcb_connection_t *c /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */) +xcb_shape_offset_checked (xcb_connection_t *c, + xcb_shape_kind_t destination_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_OFFSET, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_OFFSET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -415,17 +437,17 @@ xcb_shape_offset_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shape_offset (xcb_connection_t *c /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */) +xcb_shape_offset (xcb_connection_t *c, + xcb_shape_kind_t destination_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_OFFSET, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_OFFSET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -448,14 +470,14 @@ xcb_shape_offset (xcb_connection_t *c /**< */, } xcb_shape_query_extents_cookie_t -xcb_shape_query_extents (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */) +xcb_shape_query_extents (xcb_connection_t *c, + xcb_window_t destination_window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_QUERY_EXTENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_QUERY_EXTENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -474,14 +496,14 @@ xcb_shape_query_extents (xcb_connection_t *c /**< */, } xcb_shape_query_extents_cookie_t -xcb_shape_query_extents_unchecked (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */) +xcb_shape_query_extents_unchecked (xcb_connection_t *c, + xcb_window_t destination_window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_QUERY_EXTENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_QUERY_EXTENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -500,23 +522,23 @@ xcb_shape_query_extents_unchecked (xcb_connection_t *c /**< */, } xcb_shape_query_extents_reply_t * -xcb_shape_query_extents_reply (xcb_connection_t *c /**< */, +xcb_shape_query_extents_reply (xcb_connection_t *c, xcb_shape_query_extents_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_shape_query_extents_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_shape_select_input_checked (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */, - uint8_t enable /**< */) +xcb_shape_select_input_checked (xcb_connection_t *c, + xcb_window_t destination_window, + uint8_t enable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_SELECT_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_SELECT_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -537,15 +559,15 @@ xcb_shape_select_input_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shape_select_input (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */, - uint8_t enable /**< */) +xcb_shape_select_input (xcb_connection_t *c, + xcb_window_t destination_window, + uint8_t enable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_SELECT_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_SELECT_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -566,14 +588,14 @@ xcb_shape_select_input (xcb_connection_t *c /**< */, } xcb_shape_input_selected_cookie_t -xcb_shape_input_selected (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */) +xcb_shape_input_selected (xcb_connection_t *c, + xcb_window_t destination_window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_INPUT_SELECTED, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_INPUT_SELECTED, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -592,14 +614,14 @@ xcb_shape_input_selected (xcb_connection_t *c /**< */, } xcb_shape_input_selected_cookie_t -xcb_shape_input_selected_unchecked (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */) +xcb_shape_input_selected_unchecked (xcb_connection_t *c, + xcb_window_t destination_window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_INPUT_SELECTED, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_INPUT_SELECTED, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -618,15 +640,15 @@ xcb_shape_input_selected_unchecked (xcb_connection_t *c /**< */, } xcb_shape_input_selected_reply_t * -xcb_shape_input_selected_reply (xcb_connection_t *c /**< */, +xcb_shape_input_selected_reply (xcb_connection_t *c, xcb_shape_input_selected_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_shape_input_selected_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_shape_get_rectangles_sizeof (const void *_buffer /**< */) +xcb_shape_get_rectangles_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_shape_get_rectangles_reply_t *_aux = (xcb_shape_get_rectangles_reply_t *)_buffer; @@ -657,15 +679,15 @@ xcb_shape_get_rectangles_sizeof (const void *_buffer /**< */) } xcb_shape_get_rectangles_cookie_t -xcb_shape_get_rectangles (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_shape_kind_t source_kind /**< */) +xcb_shape_get_rectangles (xcb_connection_t *c, + xcb_window_t window, + xcb_shape_kind_t source_kind) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_GET_RECTANGLES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_GET_RECTANGLES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -686,15 +708,15 @@ xcb_shape_get_rectangles (xcb_connection_t *c /**< */, } xcb_shape_get_rectangles_cookie_t -xcb_shape_get_rectangles_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_shape_kind_t source_kind /**< */) +xcb_shape_get_rectangles_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_shape_kind_t source_kind) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shape_id, - /* opcode */ XCB_SHAPE_GET_RECTANGLES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shape_id, + .opcode = XCB_SHAPE_GET_RECTANGLES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -715,19 +737,19 @@ xcb_shape_get_rectangles_unchecked (xcb_connection_t *c /**< */, } xcb_rectangle_t * -xcb_shape_get_rectangles_rectangles (const xcb_shape_get_rectangles_reply_t *R /**< */) +xcb_shape_get_rectangles_rectangles (const xcb_shape_get_rectangles_reply_t *R) { return (xcb_rectangle_t *) (R + 1); } int -xcb_shape_get_rectangles_rectangles_length (const xcb_shape_get_rectangles_reply_t *R /**< */) +xcb_shape_get_rectangles_rectangles_length (const xcb_shape_get_rectangles_reply_t *R) { return R->rectangles_len; } xcb_rectangle_iterator_t -xcb_shape_get_rectangles_rectangles_iterator (const xcb_shape_get_rectangles_reply_t *R /**< */) +xcb_shape_get_rectangles_rectangles_iterator (const xcb_shape_get_rectangles_reply_t *R) { xcb_rectangle_iterator_t i; i.data = (xcb_rectangle_t *) (R + 1); @@ -737,9 +759,9 @@ xcb_shape_get_rectangles_rectangles_iterator (const xcb_shape_get_rectangles_rep } xcb_shape_get_rectangles_reply_t * -xcb_shape_get_rectangles_reply (xcb_connection_t *c /**< */, +xcb_shape_get_rectangles_reply (xcb_connection_t *c, xcb_shape_get_rectangles_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_shape_get_rectangles_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/shape.h b/lib/libxcb/src/shape.h index f37097fee..0b3b75967 100644 --- a/lib/libxcb/src/shape.h +++ b/lib/libxcb/src/shape.h @@ -30,9 +30,9 @@ typedef uint8_t xcb_shape_op_t; * @brief xcb_shape_op_iterator_t **/ typedef struct xcb_shape_op_iterator_t { - xcb_shape_op_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_shape_op_t *data; + int rem; + int index; } xcb_shape_op_iterator_t; typedef uint8_t xcb_shape_kind_t; @@ -41,9 +41,9 @@ typedef uint8_t xcb_shape_kind_t; * @brief xcb_shape_kind_iterator_t **/ typedef struct xcb_shape_kind_iterator_t { - xcb_shape_kind_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_shape_kind_t *data; + int rem; + int index; } xcb_shape_kind_iterator_t; typedef enum xcb_shape_so_t { @@ -67,24 +67,24 @@ typedef enum xcb_shape_sk_t { * @brief xcb_shape_notify_event_t **/ typedef struct xcb_shape_notify_event_t { - uint8_t response_type; /**< */ - xcb_shape_kind_t shape_kind; /**< */ - uint16_t sequence; /**< */ - xcb_window_t affected_window; /**< */ - int16_t extents_x; /**< */ - int16_t extents_y; /**< */ - uint16_t extents_width; /**< */ - uint16_t extents_height; /**< */ - xcb_timestamp_t server_time; /**< */ - uint8_t shaped; /**< */ - uint8_t pad0[11]; /**< */ + uint8_t response_type; + xcb_shape_kind_t shape_kind; + uint16_t sequence; + xcb_window_t affected_window; + int16_t extents_x; + int16_t extents_y; + uint16_t extents_width; + uint16_t extents_height; + xcb_timestamp_t server_time; + uint8_t shaped; + uint8_t pad0[11]; } xcb_shape_notify_event_t; /** * @brief xcb_shape_query_version_cookie_t **/ typedef struct xcb_shape_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_shape_query_version_cookie_t; /** Opcode for xcb_shape_query_version. */ @@ -94,21 +94,21 @@ typedef struct xcb_shape_query_version_cookie_t { * @brief xcb_shape_query_version_request_t **/ typedef struct xcb_shape_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_shape_query_version_request_t; /** * @brief xcb_shape_query_version_reply_t **/ typedef struct xcb_shape_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t major_version; /**< */ - uint16_t minor_version; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t major_version; + uint16_t minor_version; } xcb_shape_query_version_reply_t; /** Opcode for xcb_shape_rectangles. */ @@ -118,16 +118,16 @@ typedef struct xcb_shape_query_version_reply_t { * @brief xcb_shape_rectangles_request_t **/ typedef struct xcb_shape_rectangles_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_shape_op_t operation; /**< */ - xcb_shape_kind_t destination_kind; /**< */ - uint8_t ordering; /**< */ - uint8_t pad0; /**< */ - xcb_window_t destination_window; /**< */ - int16_t x_offset; /**< */ - int16_t y_offset; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_shape_op_t operation; + xcb_shape_kind_t destination_kind; + uint8_t ordering; + uint8_t pad0; + xcb_window_t destination_window; + int16_t x_offset; + int16_t y_offset; } xcb_shape_rectangles_request_t; /** Opcode for xcb_shape_mask. */ @@ -137,16 +137,16 @@ typedef struct xcb_shape_rectangles_request_t { * @brief xcb_shape_mask_request_t **/ typedef struct xcb_shape_mask_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_shape_op_t operation; /**< */ - xcb_shape_kind_t destination_kind; /**< */ - uint8_t pad0[2]; /**< */ - xcb_window_t destination_window; /**< */ - int16_t x_offset; /**< */ - int16_t y_offset; /**< */ - xcb_pixmap_t source_bitmap; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_shape_op_t operation; + xcb_shape_kind_t destination_kind; + uint8_t pad0[2]; + xcb_window_t destination_window; + int16_t x_offset; + int16_t y_offset; + xcb_pixmap_t source_bitmap; } xcb_shape_mask_request_t; /** Opcode for xcb_shape_combine. */ @@ -156,17 +156,17 @@ typedef struct xcb_shape_mask_request_t { * @brief xcb_shape_combine_request_t **/ typedef struct xcb_shape_combine_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_shape_op_t operation; /**< */ - xcb_shape_kind_t destination_kind; /**< */ - xcb_shape_kind_t source_kind; /**< */ - uint8_t pad0; /**< */ - xcb_window_t destination_window; /**< */ - int16_t x_offset; /**< */ - int16_t y_offset; /**< */ - xcb_window_t source_window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_shape_op_t operation; + xcb_shape_kind_t destination_kind; + xcb_shape_kind_t source_kind; + uint8_t pad0; + xcb_window_t destination_window; + int16_t x_offset; + int16_t y_offset; + xcb_window_t source_window; } xcb_shape_combine_request_t; /** Opcode for xcb_shape_offset. */ @@ -176,21 +176,21 @@ typedef struct xcb_shape_combine_request_t { * @brief xcb_shape_offset_request_t **/ typedef struct xcb_shape_offset_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_shape_kind_t destination_kind; /**< */ - uint8_t pad0[3]; /**< */ - xcb_window_t destination_window; /**< */ - int16_t x_offset; /**< */ - int16_t y_offset; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_shape_kind_t destination_kind; + uint8_t pad0[3]; + xcb_window_t destination_window; + int16_t x_offset; + int16_t y_offset; } xcb_shape_offset_request_t; /** * @brief xcb_shape_query_extents_cookie_t **/ typedef struct xcb_shape_query_extents_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_shape_query_extents_cookie_t; /** Opcode for xcb_shape_query_extents. */ @@ -200,31 +200,31 @@ typedef struct xcb_shape_query_extents_cookie_t { * @brief xcb_shape_query_extents_request_t **/ typedef struct xcb_shape_query_extents_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t destination_window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t destination_window; } xcb_shape_query_extents_request_t; /** * @brief xcb_shape_query_extents_reply_t **/ typedef struct xcb_shape_query_extents_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t bounding_shaped; /**< */ - uint8_t clip_shaped; /**< */ - uint8_t pad1[2]; /**< */ - int16_t bounding_shape_extents_x; /**< */ - int16_t bounding_shape_extents_y; /**< */ - uint16_t bounding_shape_extents_width; /**< */ - uint16_t bounding_shape_extents_height; /**< */ - int16_t clip_shape_extents_x; /**< */ - int16_t clip_shape_extents_y; /**< */ - uint16_t clip_shape_extents_width; /**< */ - uint16_t clip_shape_extents_height; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t bounding_shaped; + uint8_t clip_shaped; + uint8_t pad1[2]; + int16_t bounding_shape_extents_x; + int16_t bounding_shape_extents_y; + uint16_t bounding_shape_extents_width; + uint16_t bounding_shape_extents_height; + int16_t clip_shape_extents_x; + int16_t clip_shape_extents_y; + uint16_t clip_shape_extents_width; + uint16_t clip_shape_extents_height; } xcb_shape_query_extents_reply_t; /** Opcode for xcb_shape_select_input. */ @@ -234,19 +234,19 @@ typedef struct xcb_shape_query_extents_reply_t { * @brief xcb_shape_select_input_request_t **/ typedef struct xcb_shape_select_input_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t destination_window; /**< */ - uint8_t enable; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t destination_window; + uint8_t enable; + uint8_t pad0[3]; } xcb_shape_select_input_request_t; /** * @brief xcb_shape_input_selected_cookie_t **/ typedef struct xcb_shape_input_selected_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_shape_input_selected_cookie_t; /** Opcode for xcb_shape_input_selected. */ @@ -256,27 +256,27 @@ typedef struct xcb_shape_input_selected_cookie_t { * @brief xcb_shape_input_selected_request_t **/ typedef struct xcb_shape_input_selected_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t destination_window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t destination_window; } xcb_shape_input_selected_request_t; /** * @brief xcb_shape_input_selected_reply_t **/ typedef struct xcb_shape_input_selected_reply_t { - uint8_t response_type; /**< */ - uint8_t enabled; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ + uint8_t response_type; + uint8_t enabled; + uint16_t sequence; + uint32_t length; } xcb_shape_input_selected_reply_t; /** * @brief xcb_shape_get_rectangles_cookie_t **/ typedef struct xcb_shape_get_rectangles_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_shape_get_rectangles_cookie_t; /** Opcode for xcb_shape_get_rectangles. */ @@ -286,24 +286,24 @@ typedef struct xcb_shape_get_rectangles_cookie_t { * @brief xcb_shape_get_rectangles_request_t **/ typedef struct xcb_shape_get_rectangles_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_shape_kind_t source_kind; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_shape_kind_t source_kind; + uint8_t pad0[3]; } xcb_shape_get_rectangles_request_t; /** * @brief xcb_shape_get_rectangles_reply_t **/ typedef struct xcb_shape_get_rectangles_reply_t { - uint8_t response_type; /**< */ - uint8_t ordering; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t rectangles_len; /**< */ - uint8_t pad0[20]; /**< */ + uint8_t response_type; + uint8_t ordering; + uint16_t sequence; + uint32_t length; + uint32_t rectangles_len; + uint8_t pad0[20]; } xcb_shape_get_rectangles_reply_t; /** @@ -315,7 +315,7 @@ typedef struct xcb_shape_get_rectangles_reply_t { * element. The member index is increased by sizeof(xcb_shape_op_t) */ void -xcb_shape_op_next (xcb_shape_op_iterator_t *i /**< */); +xcb_shape_op_next (xcb_shape_op_iterator_t *i); /** * Return the iterator pointing to the last element @@ -327,7 +327,7 @@ xcb_shape_op_next (xcb_shape_op_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_shape_op_end (xcb_shape_op_iterator_t i /**< */); +xcb_shape_op_end (xcb_shape_op_iterator_t i); /** * Get the next element of the iterator @@ -338,7 +338,7 @@ xcb_shape_op_end (xcb_shape_op_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_shape_kind_t) */ void -xcb_shape_kind_next (xcb_shape_kind_iterator_t *i /**< */); +xcb_shape_kind_next (xcb_shape_kind_iterator_t *i); /** * Return the iterator pointing to the last element @@ -350,7 +350,7 @@ xcb_shape_kind_next (xcb_shape_kind_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_shape_kind_end (xcb_shape_kind_iterator_t i /**< */); +xcb_shape_kind_end (xcb_shape_kind_iterator_t i); /** * @@ -361,7 +361,7 @@ xcb_shape_kind_end (xcb_shape_kind_iterator_t i /**< */); * */ xcb_shape_query_version_cookie_t -xcb_shape_query_version (xcb_connection_t *c /**< */); +xcb_shape_query_version (xcb_connection_t *c); /** * @@ -375,7 +375,7 @@ xcb_shape_query_version (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_shape_query_version_cookie_t -xcb_shape_query_version_unchecked (xcb_connection_t *c /**< */); +xcb_shape_query_version_unchecked (xcb_connection_t *c); /** * Return the reply @@ -392,13 +392,13 @@ xcb_shape_query_version_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_shape_query_version_reply_t * -xcb_shape_query_version_reply (xcb_connection_t *c /**< */, +xcb_shape_query_version_reply (xcb_connection_t *c, xcb_shape_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_shape_rectangles_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */); +xcb_shape_rectangles_sizeof (const void *_buffer, + uint32_t rectangles_len); /** * @@ -412,15 +412,15 @@ xcb_shape_rectangles_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_shape_rectangles_checked (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - uint8_t ordering /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_shape_rectangles_checked (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + uint8_t ordering, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); /** * @@ -431,15 +431,24 @@ xcb_shape_rectangles_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_shape_rectangles (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - uint8_t ordering /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_shape_rectangles (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + uint8_t ordering, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); + +xcb_rectangle_t * +xcb_shape_rectangles_rectangles (const xcb_shape_rectangles_request_t *R); + +int +xcb_shape_rectangles_rectangles_length (const xcb_shape_rectangles_request_t *R); + +xcb_rectangle_iterator_t +xcb_shape_rectangles_rectangles_iterator (const xcb_shape_rectangles_request_t *R); /** * @@ -453,13 +462,13 @@ xcb_shape_rectangles (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_shape_mask_checked (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_pixmap_t source_bitmap /**< */); +xcb_shape_mask_checked (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + xcb_pixmap_t source_bitmap); /** * @@ -470,13 +479,13 @@ xcb_shape_mask_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_shape_mask (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_pixmap_t source_bitmap /**< */); +xcb_shape_mask (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + xcb_pixmap_t source_bitmap); /** * @@ -490,14 +499,14 @@ xcb_shape_mask (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_shape_combine_checked (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_shape_kind_t source_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_window_t source_window /**< */); +xcb_shape_combine_checked (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + xcb_shape_kind_t source_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + xcb_window_t source_window); /** * @@ -508,14 +517,14 @@ xcb_shape_combine_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_shape_combine (xcb_connection_t *c /**< */, - xcb_shape_op_t operation /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_shape_kind_t source_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_window_t source_window /**< */); +xcb_shape_combine (xcb_connection_t *c, + xcb_shape_op_t operation, + xcb_shape_kind_t destination_kind, + xcb_shape_kind_t source_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset, + xcb_window_t source_window); /** * @@ -529,11 +538,11 @@ xcb_shape_combine (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_shape_offset_checked (xcb_connection_t *c /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */); +xcb_shape_offset_checked (xcb_connection_t *c, + xcb_shape_kind_t destination_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset); /** * @@ -544,11 +553,11 @@ xcb_shape_offset_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_shape_offset (xcb_connection_t *c /**< */, - xcb_shape_kind_t destination_kind /**< */, - xcb_window_t destination_window /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */); +xcb_shape_offset (xcb_connection_t *c, + xcb_shape_kind_t destination_kind, + xcb_window_t destination_window, + int16_t x_offset, + int16_t y_offset); /** * @@ -559,8 +568,8 @@ xcb_shape_offset (xcb_connection_t *c /**< */, * */ xcb_shape_query_extents_cookie_t -xcb_shape_query_extents (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */); +xcb_shape_query_extents (xcb_connection_t *c, + xcb_window_t destination_window); /** * @@ -574,8 +583,8 @@ xcb_shape_query_extents (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_shape_query_extents_cookie_t -xcb_shape_query_extents_unchecked (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */); +xcb_shape_query_extents_unchecked (xcb_connection_t *c, + xcb_window_t destination_window); /** * Return the reply @@ -592,9 +601,9 @@ xcb_shape_query_extents_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_shape_query_extents_reply_t * -xcb_shape_query_extents_reply (xcb_connection_t *c /**< */, +xcb_shape_query_extents_reply (xcb_connection_t *c, xcb_shape_query_extents_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -608,9 +617,9 @@ xcb_shape_query_extents_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_shape_select_input_checked (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */, - uint8_t enable /**< */); +xcb_shape_select_input_checked (xcb_connection_t *c, + xcb_window_t destination_window, + uint8_t enable); /** * @@ -621,9 +630,9 @@ xcb_shape_select_input_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_shape_select_input (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */, - uint8_t enable /**< */); +xcb_shape_select_input (xcb_connection_t *c, + xcb_window_t destination_window, + uint8_t enable); /** * @@ -634,8 +643,8 @@ xcb_shape_select_input (xcb_connection_t *c /**< */, * */ xcb_shape_input_selected_cookie_t -xcb_shape_input_selected (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */); +xcb_shape_input_selected (xcb_connection_t *c, + xcb_window_t destination_window); /** * @@ -649,8 +658,8 @@ xcb_shape_input_selected (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_shape_input_selected_cookie_t -xcb_shape_input_selected_unchecked (xcb_connection_t *c /**< */, - xcb_window_t destination_window /**< */); +xcb_shape_input_selected_unchecked (xcb_connection_t *c, + xcb_window_t destination_window); /** * Return the reply @@ -667,12 +676,12 @@ xcb_shape_input_selected_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_shape_input_selected_reply_t * -xcb_shape_input_selected_reply (xcb_connection_t *c /**< */, +xcb_shape_input_selected_reply (xcb_connection_t *c, xcb_shape_input_selected_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_shape_get_rectangles_sizeof (const void *_buffer /**< */); +xcb_shape_get_rectangles_sizeof (const void *_buffer); /** * @@ -683,9 +692,9 @@ xcb_shape_get_rectangles_sizeof (const void *_buffer /**< */); * */ xcb_shape_get_rectangles_cookie_t -xcb_shape_get_rectangles (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_shape_kind_t source_kind /**< */); +xcb_shape_get_rectangles (xcb_connection_t *c, + xcb_window_t window, + xcb_shape_kind_t source_kind); /** * @@ -699,18 +708,18 @@ xcb_shape_get_rectangles (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_shape_get_rectangles_cookie_t -xcb_shape_get_rectangles_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_shape_kind_t source_kind /**< */); +xcb_shape_get_rectangles_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_shape_kind_t source_kind); xcb_rectangle_t * -xcb_shape_get_rectangles_rectangles (const xcb_shape_get_rectangles_reply_t *R /**< */); +xcb_shape_get_rectangles_rectangles (const xcb_shape_get_rectangles_reply_t *R); int -xcb_shape_get_rectangles_rectangles_length (const xcb_shape_get_rectangles_reply_t *R /**< */); +xcb_shape_get_rectangles_rectangles_length (const xcb_shape_get_rectangles_reply_t *R); xcb_rectangle_iterator_t -xcb_shape_get_rectangles_rectangles_iterator (const xcb_shape_get_rectangles_reply_t *R /**< */); +xcb_shape_get_rectangles_rectangles_iterator (const xcb_shape_get_rectangles_reply_t *R); /** * Return the reply @@ -727,9 +736,9 @@ xcb_shape_get_rectangles_rectangles_iterator (const xcb_shape_get_rectangles_rep * The returned value must be freed by the caller using free(). */ xcb_shape_get_rectangles_reply_t * -xcb_shape_get_rectangles_reply (xcb_connection_t *c /**< */, +xcb_shape_get_rectangles_reply (xcb_connection_t *c, xcb_shape_get_rectangles_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/shm.c b/lib/libxcb/src/shm.c index 366e4827b..eb4c8d480 100644 --- a/lib/libxcb/src/shm.c +++ b/lib/libxcb/src/shm.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_shm_id = { "MIT-SHM", 0 }; void -xcb_shm_seg_next (xcb_shm_seg_iterator_t *i /**< */) +xcb_shm_seg_next (xcb_shm_seg_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_shm_seg_next (xcb_shm_seg_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_shm_seg_end (xcb_shm_seg_iterator_t i /**< */) +xcb_shm_seg_end (xcb_shm_seg_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,13 +37,13 @@ xcb_shm_seg_end (xcb_shm_seg_iterator_t i /**< */) } xcb_shm_query_version_cookie_t -xcb_shm_query_version (xcb_connection_t *c /**< */) +xcb_shm_query_version (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -61,13 +61,13 @@ xcb_shm_query_version (xcb_connection_t *c /**< */) } xcb_shm_query_version_cookie_t -xcb_shm_query_version_unchecked (xcb_connection_t *c /**< */) +xcb_shm_query_version_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -85,24 +85,24 @@ xcb_shm_query_version_unchecked (xcb_connection_t *c /**< */) } xcb_shm_query_version_reply_t * -xcb_shm_query_version_reply (xcb_connection_t *c /**< */, +xcb_shm_query_version_reply (xcb_connection_t *c, xcb_shm_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_shm_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_shm_attach_checked (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t shmid /**< */, - uint8_t read_only /**< */) +xcb_shm_attach_checked (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + uint32_t shmid, + uint8_t read_only) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_ATTACH, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_ATTACH, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -124,16 +124,16 @@ xcb_shm_attach_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shm_attach (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t shmid /**< */, - uint8_t read_only /**< */) +xcb_shm_attach (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + uint32_t shmid, + uint8_t read_only) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_ATTACH, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_ATTACH, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -155,14 +155,14 @@ xcb_shm_attach (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shm_detach_checked (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */) +xcb_shm_detach_checked (xcb_connection_t *c, + xcb_shm_seg_t shmseg) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_DETACH, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_DETACH, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -181,14 +181,14 @@ xcb_shm_detach_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shm_detach (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */) +xcb_shm_detach (xcb_connection_t *c, + xcb_shm_seg_t shmseg) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_DETACH, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_DETACH, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -207,28 +207,28 @@ xcb_shm_detach (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shm_put_image_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint16_t total_width /**< */, - uint16_t total_height /**< */, - uint16_t src_x /**< */, - uint16_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint8_t depth /**< */, - uint8_t format /**< */, - uint8_t send_event /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */) +xcb_shm_put_image_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint16_t total_width, + uint16_t total_height, + uint16_t src_x, + uint16_t src_y, + uint16_t src_width, + uint16_t src_height, + int16_t dst_x, + int16_t dst_y, + uint8_t depth, + uint8_t format, + uint8_t send_event, + xcb_shm_seg_t shmseg, + uint32_t offset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_PUT_IMAGE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_PUT_IMAGE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -262,28 +262,28 @@ xcb_shm_put_image_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shm_put_image (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint16_t total_width /**< */, - uint16_t total_height /**< */, - uint16_t src_x /**< */, - uint16_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint8_t depth /**< */, - uint8_t format /**< */, - uint8_t send_event /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */) +xcb_shm_put_image (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint16_t total_width, + uint16_t total_height, + uint16_t src_x, + uint16_t src_y, + uint16_t src_width, + uint16_t src_height, + int16_t dst_x, + int16_t dst_y, + uint8_t depth, + uint8_t format, + uint8_t send_event, + xcb_shm_seg_t shmseg, + uint32_t offset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_PUT_IMAGE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_PUT_IMAGE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -317,22 +317,22 @@ xcb_shm_put_image (xcb_connection_t *c /**< */, } xcb_shm_get_image_cookie_t -xcb_shm_get_image (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t plane_mask /**< */, - uint8_t format /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */) +xcb_shm_get_image (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint32_t plane_mask, + uint8_t format, + xcb_shm_seg_t shmseg, + uint32_t offset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_GET_IMAGE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_GET_IMAGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -360,22 +360,22 @@ xcb_shm_get_image (xcb_connection_t *c /**< */, } xcb_shm_get_image_cookie_t -xcb_shm_get_image_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t plane_mask /**< */, - uint8_t format /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */) +xcb_shm_get_image_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint32_t plane_mask, + uint8_t format, + xcb_shm_seg_t shmseg, + uint32_t offset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_GET_IMAGE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_GET_IMAGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -403,28 +403,28 @@ xcb_shm_get_image_unchecked (xcb_connection_t *c /**< */, } xcb_shm_get_image_reply_t * -xcb_shm_get_image_reply (xcb_connection_t *c /**< */, +xcb_shm_get_image_reply (xcb_connection_t *c, xcb_shm_get_image_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_shm_get_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_shm_create_pixmap_checked (xcb_connection_t *c /**< */, - xcb_pixmap_t pid /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint8_t depth /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */) +xcb_shm_create_pixmap_checked (xcb_connection_t *c, + xcb_pixmap_t pid, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height, + uint8_t depth, + xcb_shm_seg_t shmseg, + uint32_t offset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_CREATE_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_CREATE_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -450,20 +450,20 @@ xcb_shm_create_pixmap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shm_create_pixmap (xcb_connection_t *c /**< */, - xcb_pixmap_t pid /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint8_t depth /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */) +xcb_shm_create_pixmap (xcb_connection_t *c, + xcb_pixmap_t pid, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height, + uint8_t depth, + xcb_shm_seg_t shmseg, + uint32_t offset) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_CREATE_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_CREATE_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -489,21 +489,22 @@ xcb_shm_create_pixmap (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_shm_attach_fd_checked (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - int32_t shm_fd /**< */, - uint8_t read_only /**< */) +xcb_shm_attach_fd_checked (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + int32_t shm_fd, + uint8_t read_only) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_ATTACH_FD, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_ATTACH_FD, + .isvoid = 1 }; struct iovec xcb_parts[4]; xcb_void_cookie_t xcb_ret; xcb_shm_attach_fd_request_t xcb_out; + int fds[1]; xcb_out.shmseg = shmseg; xcb_out.read_only = read_only; @@ -514,27 +515,28 @@ xcb_shm_attach_fd_checked (xcb_connection_t *c /**< */, xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - xcb_send_fd(c, shm_fd); - xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + fds[0] = shm_fd; + xcb_ret.sequence = xcb_send_request_with_fds(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req, 1, fds); return xcb_ret; } xcb_void_cookie_t -xcb_shm_attach_fd (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - int32_t shm_fd /**< */, - uint8_t read_only /**< */) +xcb_shm_attach_fd (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + int32_t shm_fd, + uint8_t read_only) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_ATTACH_FD, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_ATTACH_FD, + .isvoid = 1 }; struct iovec xcb_parts[4]; xcb_void_cookie_t xcb_ret; xcb_shm_attach_fd_request_t xcb_out; + int fds[1]; xcb_out.shmseg = shmseg; xcb_out.read_only = read_only; @@ -545,22 +547,22 @@ xcb_shm_attach_fd (xcb_connection_t *c /**< */, xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - xcb_send_fd(c, shm_fd); - xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + fds[0] = shm_fd; + xcb_ret.sequence = xcb_send_request_with_fds(c, 0, xcb_parts + 2, &xcb_req, 1, fds); return xcb_ret; } xcb_shm_create_segment_cookie_t -xcb_shm_create_segment (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t size /**< */, - uint8_t read_only /**< */) +xcb_shm_create_segment (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + uint32_t size, + uint8_t read_only) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_CREATE_SEGMENT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_CREATE_SEGMENT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -582,16 +584,16 @@ xcb_shm_create_segment (xcb_connection_t *c /**< */, } xcb_shm_create_segment_cookie_t -xcb_shm_create_segment_unchecked (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t size /**< */, - uint8_t read_only /**< */) +xcb_shm_create_segment_unchecked (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + uint32_t size, + uint8_t read_only) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_shm_id, - /* opcode */ XCB_SHM_CREATE_SEGMENT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_shm_id, + .opcode = XCB_SHM_CREATE_SEGMENT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -613,16 +615,16 @@ xcb_shm_create_segment_unchecked (xcb_connection_t *c /**< */, } xcb_shm_create_segment_reply_t * -xcb_shm_create_segment_reply (xcb_connection_t *c /**< */, +xcb_shm_create_segment_reply (xcb_connection_t *c, xcb_shm_create_segment_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_shm_create_segment_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int * xcb_shm_create_segment_reply_fds (xcb_connection_t *c /**< */, - xcb_shm_create_segment_reply_t *reply /**< */) + xcb_shm_create_segment_reply_t *reply) { return xcb_get_reply_fds(c, reply, sizeof(xcb_shm_create_segment_reply_t) + 4 * reply->length); } diff --git a/lib/libxcb/src/shm.h b/lib/libxcb/src/shm.h index 459236733..eba700239 100644 --- a/lib/libxcb/src/shm.h +++ b/lib/libxcb/src/shm.h @@ -30,9 +30,9 @@ typedef uint32_t xcb_shm_seg_t; * @brief xcb_shm_seg_iterator_t **/ typedef struct xcb_shm_seg_iterator_t { - xcb_shm_seg_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_shm_seg_t *data; + int rem; + int index; } xcb_shm_seg_iterator_t; /** Opcode for xcb_shm_completion. */ @@ -42,15 +42,15 @@ typedef struct xcb_shm_seg_iterator_t { * @brief xcb_shm_completion_event_t **/ typedef struct xcb_shm_completion_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_drawable_t drawable; /**< */ - uint16_t minor_event; /**< */ - uint8_t major_event; /**< */ - uint8_t pad1; /**< */ - xcb_shm_seg_t shmseg; /**< */ - uint32_t offset; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_drawable_t drawable; + uint16_t minor_event; + uint8_t major_event; + uint8_t pad1; + xcb_shm_seg_t shmseg; + uint32_t offset; } xcb_shm_completion_event_t; /** Opcode for xcb_shm_bad_seg. */ @@ -62,7 +62,7 @@ typedef xcb_value_error_t xcb_shm_bad_seg_error_t; * @brief xcb_shm_query_version_cookie_t **/ typedef struct xcb_shm_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_shm_query_version_cookie_t; /** Opcode for xcb_shm_query_version. */ @@ -72,25 +72,25 @@ typedef struct xcb_shm_query_version_cookie_t { * @brief xcb_shm_query_version_request_t **/ typedef struct xcb_shm_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_shm_query_version_request_t; /** * @brief xcb_shm_query_version_reply_t **/ typedef struct xcb_shm_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t shared_pixmaps; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t major_version; /**< */ - uint16_t minor_version; /**< */ - uint16_t uid; /**< */ - uint16_t gid; /**< */ - uint8_t pixmap_format; /**< */ - uint8_t pad0[15]; /**< */ + uint8_t response_type; + uint8_t shared_pixmaps; + uint16_t sequence; + uint32_t length; + uint16_t major_version; + uint16_t minor_version; + uint16_t uid; + uint16_t gid; + uint8_t pixmap_format; + uint8_t pad0[15]; } xcb_shm_query_version_reply_t; /** Opcode for xcb_shm_attach. */ @@ -100,13 +100,13 @@ typedef struct xcb_shm_query_version_reply_t { * @brief xcb_shm_attach_request_t **/ typedef struct xcb_shm_attach_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_shm_seg_t shmseg; /**< */ - uint32_t shmid; /**< */ - uint8_t read_only; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_shm_seg_t shmseg; + uint32_t shmid; + uint8_t read_only; + uint8_t pad0[3]; } xcb_shm_attach_request_t; /** Opcode for xcb_shm_detach. */ @@ -116,10 +116,10 @@ typedef struct xcb_shm_attach_request_t { * @brief xcb_shm_detach_request_t **/ typedef struct xcb_shm_detach_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_shm_seg_t shmseg; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_shm_seg_t shmseg; } xcb_shm_detach_request_t; /** Opcode for xcb_shm_put_image. */ @@ -129,32 +129,32 @@ typedef struct xcb_shm_detach_request_t { * @brief xcb_shm_put_image_request_t **/ typedef struct xcb_shm_put_image_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - uint16_t total_width; /**< */ - uint16_t total_height; /**< */ - uint16_t src_x; /**< */ - uint16_t src_y; /**< */ - uint16_t src_width; /**< */ - uint16_t src_height; /**< */ - int16_t dst_x; /**< */ - int16_t dst_y; /**< */ - uint8_t depth; /**< */ - uint8_t format; /**< */ - uint8_t send_event; /**< */ - uint8_t pad0; /**< */ - xcb_shm_seg_t shmseg; /**< */ - uint32_t offset; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + uint16_t total_width; + uint16_t total_height; + uint16_t src_x; + uint16_t src_y; + uint16_t src_width; + uint16_t src_height; + int16_t dst_x; + int16_t dst_y; + uint8_t depth; + uint8_t format; + uint8_t send_event; + uint8_t pad0; + xcb_shm_seg_t shmseg; + uint32_t offset; } xcb_shm_put_image_request_t; /** * @brief xcb_shm_get_image_cookie_t **/ typedef struct xcb_shm_get_image_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_shm_get_image_cookie_t; /** Opcode for xcb_shm_get_image. */ @@ -164,31 +164,31 @@ typedef struct xcb_shm_get_image_cookie_t { * @brief xcb_shm_get_image_request_t **/ typedef struct xcb_shm_get_image_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint32_t plane_mask; /**< */ - uint8_t format; /**< */ - uint8_t pad0[3]; /**< */ - xcb_shm_seg_t shmseg; /**< */ - uint32_t offset; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint32_t plane_mask; + uint8_t format; + uint8_t pad0[3]; + xcb_shm_seg_t shmseg; + uint32_t offset; } xcb_shm_get_image_request_t; /** * @brief xcb_shm_get_image_reply_t **/ typedef struct xcb_shm_get_image_reply_t { - uint8_t response_type; /**< */ - uint8_t depth; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_visualid_t visual; /**< */ - uint32_t size; /**< */ + uint8_t response_type; + uint8_t depth; + uint16_t sequence; + uint32_t length; + xcb_visualid_t visual; + uint32_t size; } xcb_shm_get_image_reply_t; /** Opcode for xcb_shm_create_pixmap. */ @@ -198,17 +198,17 @@ typedef struct xcb_shm_get_image_reply_t { * @brief xcb_shm_create_pixmap_request_t **/ typedef struct xcb_shm_create_pixmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_pixmap_t pid; /**< */ - xcb_drawable_t drawable; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint8_t depth; /**< */ - uint8_t pad0[3]; /**< */ - xcb_shm_seg_t shmseg; /**< */ - uint32_t offset; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_pixmap_t pid; + xcb_drawable_t drawable; + uint16_t width; + uint16_t height; + uint8_t depth; + uint8_t pad0[3]; + xcb_shm_seg_t shmseg; + uint32_t offset; } xcb_shm_create_pixmap_request_t; /** Opcode for xcb_shm_attach_fd. */ @@ -218,19 +218,19 @@ typedef struct xcb_shm_create_pixmap_request_t { * @brief xcb_shm_attach_fd_request_t **/ typedef struct xcb_shm_attach_fd_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_shm_seg_t shmseg; /**< */ - uint8_t read_only; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_shm_seg_t shmseg; + uint8_t read_only; + uint8_t pad0[3]; } xcb_shm_attach_fd_request_t; /** * @brief xcb_shm_create_segment_cookie_t **/ typedef struct xcb_shm_create_segment_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_shm_create_segment_cookie_t; /** Opcode for xcb_shm_create_segment. */ @@ -240,24 +240,24 @@ typedef struct xcb_shm_create_segment_cookie_t { * @brief xcb_shm_create_segment_request_t **/ typedef struct xcb_shm_create_segment_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_shm_seg_t shmseg; /**< */ - uint32_t size; /**< */ - uint8_t read_only; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_shm_seg_t shmseg; + uint32_t size; + uint8_t read_only; + uint8_t pad0[3]; } xcb_shm_create_segment_request_t; /** * @brief xcb_shm_create_segment_reply_t **/ typedef struct xcb_shm_create_segment_reply_t { - uint8_t response_type; /**< */ - uint8_t nfd; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad0[24]; /**< */ + uint8_t response_type; + uint8_t nfd; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; } xcb_shm_create_segment_reply_t; /** @@ -269,7 +269,7 @@ typedef struct xcb_shm_create_segment_reply_t { * element. The member index is increased by sizeof(xcb_shm_seg_t) */ void -xcb_shm_seg_next (xcb_shm_seg_iterator_t *i /**< */); +xcb_shm_seg_next (xcb_shm_seg_iterator_t *i); /** * Return the iterator pointing to the last element @@ -281,7 +281,7 @@ xcb_shm_seg_next (xcb_shm_seg_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_shm_seg_end (xcb_shm_seg_iterator_t i /**< */); +xcb_shm_seg_end (xcb_shm_seg_iterator_t i); /** * @@ -292,7 +292,7 @@ xcb_shm_seg_end (xcb_shm_seg_iterator_t i /**< */); * */ xcb_shm_query_version_cookie_t -xcb_shm_query_version (xcb_connection_t *c /**< */); +xcb_shm_query_version (xcb_connection_t *c); /** * @@ -306,7 +306,7 @@ xcb_shm_query_version (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_shm_query_version_cookie_t -xcb_shm_query_version_unchecked (xcb_connection_t *c /**< */); +xcb_shm_query_version_unchecked (xcb_connection_t *c); /** * Return the reply @@ -323,9 +323,9 @@ xcb_shm_query_version_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_shm_query_version_reply_t * -xcb_shm_query_version_reply (xcb_connection_t *c /**< */, +xcb_shm_query_version_reply (xcb_connection_t *c, xcb_shm_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -339,10 +339,10 @@ xcb_shm_query_version_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_shm_attach_checked (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t shmid /**< */, - uint8_t read_only /**< */); +xcb_shm_attach_checked (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + uint32_t shmid, + uint8_t read_only); /** * @@ -353,10 +353,10 @@ xcb_shm_attach_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_shm_attach (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t shmid /**< */, - uint8_t read_only /**< */); +xcb_shm_attach (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + uint32_t shmid, + uint8_t read_only); /** * @@ -370,8 +370,8 @@ xcb_shm_attach (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_shm_detach_checked (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */); +xcb_shm_detach_checked (xcb_connection_t *c, + xcb_shm_seg_t shmseg); /** * @@ -382,8 +382,8 @@ xcb_shm_detach_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_shm_detach (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */); +xcb_shm_detach (xcb_connection_t *c, + xcb_shm_seg_t shmseg); /** * @@ -397,22 +397,22 @@ xcb_shm_detach (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_shm_put_image_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint16_t total_width /**< */, - uint16_t total_height /**< */, - uint16_t src_x /**< */, - uint16_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint8_t depth /**< */, - uint8_t format /**< */, - uint8_t send_event /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */); +xcb_shm_put_image_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint16_t total_width, + uint16_t total_height, + uint16_t src_x, + uint16_t src_y, + uint16_t src_width, + uint16_t src_height, + int16_t dst_x, + int16_t dst_y, + uint8_t depth, + uint8_t format, + uint8_t send_event, + xcb_shm_seg_t shmseg, + uint32_t offset); /** * @@ -423,22 +423,22 @@ xcb_shm_put_image_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_shm_put_image (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint16_t total_width /**< */, - uint16_t total_height /**< */, - uint16_t src_x /**< */, - uint16_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint8_t depth /**< */, - uint8_t format /**< */, - uint8_t send_event /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */); +xcb_shm_put_image (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint16_t total_width, + uint16_t total_height, + uint16_t src_x, + uint16_t src_y, + uint16_t src_width, + uint16_t src_height, + int16_t dst_x, + int16_t dst_y, + uint8_t depth, + uint8_t format, + uint8_t send_event, + xcb_shm_seg_t shmseg, + uint32_t offset); /** * @@ -449,16 +449,16 @@ xcb_shm_put_image (xcb_connection_t *c /**< */, * */ xcb_shm_get_image_cookie_t -xcb_shm_get_image (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t plane_mask /**< */, - uint8_t format /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */); +xcb_shm_get_image (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint32_t plane_mask, + uint8_t format, + xcb_shm_seg_t shmseg, + uint32_t offset); /** * @@ -472,16 +472,16 @@ xcb_shm_get_image (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_shm_get_image_cookie_t -xcb_shm_get_image_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t plane_mask /**< */, - uint8_t format /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */); +xcb_shm_get_image_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint32_t plane_mask, + uint8_t format, + xcb_shm_seg_t shmseg, + uint32_t offset); /** * Return the reply @@ -498,9 +498,9 @@ xcb_shm_get_image_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_shm_get_image_reply_t * -xcb_shm_get_image_reply (xcb_connection_t *c /**< */, +xcb_shm_get_image_reply (xcb_connection_t *c, xcb_shm_get_image_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -514,14 +514,14 @@ xcb_shm_get_image_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_shm_create_pixmap_checked (xcb_connection_t *c /**< */, - xcb_pixmap_t pid /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint8_t depth /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */); +xcb_shm_create_pixmap_checked (xcb_connection_t *c, + xcb_pixmap_t pid, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height, + uint8_t depth, + xcb_shm_seg_t shmseg, + uint32_t offset); /** * @@ -532,14 +532,14 @@ xcb_shm_create_pixmap_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_shm_create_pixmap (xcb_connection_t *c /**< */, - xcb_pixmap_t pid /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint8_t depth /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t offset /**< */); +xcb_shm_create_pixmap (xcb_connection_t *c, + xcb_pixmap_t pid, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height, + uint8_t depth, + xcb_shm_seg_t shmseg, + uint32_t offset); /** * @@ -553,10 +553,10 @@ xcb_shm_create_pixmap (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_shm_attach_fd_checked (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - int32_t shm_fd /**< */, - uint8_t read_only /**< */); +xcb_shm_attach_fd_checked (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + int32_t shm_fd, + uint8_t read_only); /** * @@ -567,10 +567,10 @@ xcb_shm_attach_fd_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_shm_attach_fd (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - int32_t shm_fd /**< */, - uint8_t read_only /**< */); +xcb_shm_attach_fd (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + int32_t shm_fd, + uint8_t read_only); /** * @@ -581,10 +581,10 @@ xcb_shm_attach_fd (xcb_connection_t *c /**< */, * */ xcb_shm_create_segment_cookie_t -xcb_shm_create_segment (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t size /**< */, - uint8_t read_only /**< */); +xcb_shm_create_segment (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + uint32_t size, + uint8_t read_only); /** * @@ -598,10 +598,10 @@ xcb_shm_create_segment (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_shm_create_segment_cookie_t -xcb_shm_create_segment_unchecked (xcb_connection_t *c /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t size /**< */, - uint8_t read_only /**< */); +xcb_shm_create_segment_unchecked (xcb_connection_t *c, + xcb_shm_seg_t shmseg, + uint32_t size, + uint8_t read_only); /** * Return the reply @@ -618,9 +618,9 @@ xcb_shm_create_segment_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_shm_create_segment_reply_t * -xcb_shm_create_segment_reply (xcb_connection_t *c /**< */, +xcb_shm_create_segment_reply (xcb_connection_t *c, xcb_shm_create_segment_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Return the reply fds @@ -633,7 +633,7 @@ xcb_shm_create_segment_reply (xcb_connection_t *c /**< */, */ int * xcb_shm_create_segment_reply_fds (xcb_connection_t *c /**< */, - xcb_shm_create_segment_reply_t *reply /**< */); + xcb_shm_create_segment_reply_t *reply); #ifdef __cplusplus diff --git a/lib/libxcb/src/sync.c b/lib/libxcb/src/sync.c index 96ba34be6..c19e05178 100644 --- a/lib/libxcb/src/sync.c +++ b/lib/libxcb/src/sync.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_sync_id = { "SYNC", 0 }; void -xcb_sync_alarm_next (xcb_sync_alarm_iterator_t *i /**< */) +xcb_sync_alarm_next (xcb_sync_alarm_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_sync_alarm_next (xcb_sync_alarm_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_sync_alarm_end (xcb_sync_alarm_iterator_t i /**< */) +xcb_sync_alarm_end (xcb_sync_alarm_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,7 +37,7 @@ xcb_sync_alarm_end (xcb_sync_alarm_iterator_t i /**< */) } void -xcb_sync_counter_next (xcb_sync_counter_iterator_t *i /**< */) +xcb_sync_counter_next (xcb_sync_counter_iterator_t *i) { --i->rem; ++i->data; @@ -45,7 +45,7 @@ xcb_sync_counter_next (xcb_sync_counter_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_sync_counter_end (xcb_sync_counter_iterator_t i /**< */) +xcb_sync_counter_end (xcb_sync_counter_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -55,7 +55,7 @@ xcb_sync_counter_end (xcb_sync_counter_iterator_t i /**< */) } void -xcb_sync_fence_next (xcb_sync_fence_iterator_t *i /**< */) +xcb_sync_fence_next (xcb_sync_fence_iterator_t *i) { --i->rem; ++i->data; @@ -63,7 +63,7 @@ xcb_sync_fence_next (xcb_sync_fence_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_sync_fence_end (xcb_sync_fence_iterator_t i /**< */) +xcb_sync_fence_end (xcb_sync_fence_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -73,7 +73,7 @@ xcb_sync_fence_end (xcb_sync_fence_iterator_t i /**< */) } void -xcb_sync_int64_next (xcb_sync_int64_iterator_t *i /**< */) +xcb_sync_int64_next (xcb_sync_int64_iterator_t *i) { --i->rem; ++i->data; @@ -81,7 +81,7 @@ xcb_sync_int64_next (xcb_sync_int64_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_sync_int64_end (xcb_sync_int64_iterator_t i /**< */) +xcb_sync_int64_end (xcb_sync_int64_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -91,7 +91,7 @@ xcb_sync_int64_end (xcb_sync_int64_iterator_t i /**< */) } int -xcb_sync_systemcounter_sizeof (const void *_buffer /**< */) +xcb_sync_systemcounter_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_sync_systemcounter_t *_aux = (xcb_sync_systemcounter_t *)_buffer; @@ -109,6 +109,15 @@ xcb_sync_systemcounter_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->name_len * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -122,19 +131,19 @@ xcb_sync_systemcounter_sizeof (const void *_buffer /**< */) } char * -xcb_sync_systemcounter_name (const xcb_sync_systemcounter_t *R /**< */) +xcb_sync_systemcounter_name (const xcb_sync_systemcounter_t *R) { return (char *) (R + 1); } int -xcb_sync_systemcounter_name_length (const xcb_sync_systemcounter_t *R /**< */) +xcb_sync_systemcounter_name_length (const xcb_sync_systemcounter_t *R) { return R->name_len; } xcb_generic_iterator_t -xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R /**< */) +xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->name_len); @@ -144,7 +153,7 @@ xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R /**< */) } void -xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i /**< */) +xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i) { xcb_sync_systemcounter_t *R = i->data; xcb_generic_iterator_t child; @@ -155,7 +164,7 @@ xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i /**< */) +xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -167,7 +176,7 @@ xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i /**< */) } void -xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i /**< */) +xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i) { --i->rem; ++i->data; @@ -175,7 +184,7 @@ xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i /**< */) +xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -185,7 +194,7 @@ xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i /**< */) } void -xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i /**< */) +xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i) { --i->rem; ++i->data; @@ -193,7 +202,7 @@ xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i /**< */) +xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -203,15 +212,15 @@ xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i /**< */) } xcb_sync_initialize_cookie_t -xcb_sync_initialize (xcb_connection_t *c /**< */, - uint8_t desired_major_version /**< */, - uint8_t desired_minor_version /**< */) +xcb_sync_initialize (xcb_connection_t *c, + uint8_t desired_major_version, + uint8_t desired_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_INITIALIZE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_INITIALIZE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -231,15 +240,15 @@ xcb_sync_initialize (xcb_connection_t *c /**< */, } xcb_sync_initialize_cookie_t -xcb_sync_initialize_unchecked (xcb_connection_t *c /**< */, - uint8_t desired_major_version /**< */, - uint8_t desired_minor_version /**< */) +xcb_sync_initialize_unchecked (xcb_connection_t *c, + uint8_t desired_major_version, + uint8_t desired_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_INITIALIZE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_INITIALIZE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -259,15 +268,15 @@ xcb_sync_initialize_unchecked (xcb_connection_t *c /**< */, } xcb_sync_initialize_reply_t * -xcb_sync_initialize_reply (xcb_connection_t *c /**< */, +xcb_sync_initialize_reply (xcb_connection_t *c, xcb_sync_initialize_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_sync_initialize_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_sync_list_system_counters_sizeof (const void *_buffer /**< */) +xcb_sync_list_system_counters_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_sync_list_system_counters_reply_t *_aux = (xcb_sync_list_system_counters_reply_t *)_buffer; @@ -303,13 +312,13 @@ xcb_sync_list_system_counters_sizeof (const void *_buffer /**< */) } xcb_sync_list_system_counters_cookie_t -xcb_sync_list_system_counters (xcb_connection_t *c /**< */) +xcb_sync_list_system_counters (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_LIST_SYSTEM_COUNTERS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_LIST_SYSTEM_COUNTERS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -327,13 +336,13 @@ xcb_sync_list_system_counters (xcb_connection_t *c /**< */) } xcb_sync_list_system_counters_cookie_t -xcb_sync_list_system_counters_unchecked (xcb_connection_t *c /**< */) +xcb_sync_list_system_counters_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_LIST_SYSTEM_COUNTERS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_LIST_SYSTEM_COUNTERS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -351,13 +360,13 @@ xcb_sync_list_system_counters_unchecked (xcb_connection_t *c /**< */) } int -xcb_sync_list_system_counters_counters_length (const xcb_sync_list_system_counters_reply_t *R /**< */) +xcb_sync_list_system_counters_counters_length (const xcb_sync_list_system_counters_reply_t *R) { return R->counters_len; } xcb_sync_systemcounter_iterator_t -xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_counters_reply_t *R /**< */) +xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_counters_reply_t *R) { xcb_sync_systemcounter_iterator_t i; i.data = (xcb_sync_systemcounter_t *) (R + 1); @@ -367,23 +376,23 @@ xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_coun } xcb_sync_list_system_counters_reply_t * -xcb_sync_list_system_counters_reply (xcb_connection_t *c /**< */, +xcb_sync_list_system_counters_reply (xcb_connection_t *c, xcb_sync_list_system_counters_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_sync_list_system_counters_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_sync_create_counter_checked (xcb_connection_t *c /**< */, - xcb_sync_counter_t id /**< */, - xcb_sync_int64_t initial_value /**< */) +xcb_sync_create_counter_checked (xcb_connection_t *c, + xcb_sync_counter_t id, + xcb_sync_int64_t initial_value) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CREATE_COUNTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CREATE_COUNTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -403,15 +412,15 @@ xcb_sync_create_counter_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_create_counter (xcb_connection_t *c /**< */, - xcb_sync_counter_t id /**< */, - xcb_sync_int64_t initial_value /**< */) +xcb_sync_create_counter (xcb_connection_t *c, + xcb_sync_counter_t id, + xcb_sync_int64_t initial_value) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CREATE_COUNTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CREATE_COUNTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -431,14 +440,14 @@ xcb_sync_create_counter (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_destroy_counter_checked (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */) +xcb_sync_destroy_counter_checked (xcb_connection_t *c, + xcb_sync_counter_t counter) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_DESTROY_COUNTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_DESTROY_COUNTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -457,14 +466,14 @@ xcb_sync_destroy_counter_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_destroy_counter (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */) +xcb_sync_destroy_counter (xcb_connection_t *c, + xcb_sync_counter_t counter) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_DESTROY_COUNTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_DESTROY_COUNTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -483,14 +492,14 @@ xcb_sync_destroy_counter (xcb_connection_t *c /**< */, } xcb_sync_query_counter_cookie_t -xcb_sync_query_counter (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */) +xcb_sync_query_counter (xcb_connection_t *c, + xcb_sync_counter_t counter) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_QUERY_COUNTER, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_QUERY_COUNTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -509,14 +518,14 @@ xcb_sync_query_counter (xcb_connection_t *c /**< */, } xcb_sync_query_counter_cookie_t -xcb_sync_query_counter_unchecked (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */) +xcb_sync_query_counter_unchecked (xcb_connection_t *c, + xcb_sync_counter_t counter) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_QUERY_COUNTER, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_QUERY_COUNTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -535,16 +544,16 @@ xcb_sync_query_counter_unchecked (xcb_connection_t *c /**< */, } xcb_sync_query_counter_reply_t * -xcb_sync_query_counter_reply (xcb_connection_t *c /**< */, +xcb_sync_query_counter_reply (xcb_connection_t *c, xcb_sync_query_counter_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_sync_query_counter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_sync_await_sizeof (const void *_buffer /**< */, - uint32_t wait_list_len /**< */) +xcb_sync_await_sizeof (const void *_buffer, + uint32_t wait_list_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -574,15 +583,15 @@ xcb_sync_await_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_sync_await_checked (xcb_connection_t *c /**< */, - uint32_t wait_list_len /**< */, - const xcb_sync_waitcondition_t *wait_list /**< */) +xcb_sync_await_checked (xcb_connection_t *c, + uint32_t wait_list_len, + const xcb_sync_waitcondition_t *wait_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_AWAIT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_AWAIT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -605,15 +614,15 @@ xcb_sync_await_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_await (xcb_connection_t *c /**< */, - uint32_t wait_list_len /**< */, - const xcb_sync_waitcondition_t *wait_list /**< */) +xcb_sync_await (xcb_connection_t *c, + uint32_t wait_list_len, + const xcb_sync_waitcondition_t *wait_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_AWAIT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_AWAIT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -635,16 +644,38 @@ xcb_sync_await (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_sync_waitcondition_t * +xcb_sync_await_wait_list (const xcb_sync_await_request_t *R) +{ + return (xcb_sync_waitcondition_t *) (R + 1); +} + +int +xcb_sync_await_wait_list_length (const xcb_sync_await_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_sync_await_request_t))/sizeof(xcb_sync_waitcondition_t)); +} + +xcb_sync_waitcondition_iterator_t +xcb_sync_await_wait_list_iterator (const xcb_sync_await_request_t *R) +{ + xcb_sync_waitcondition_iterator_t i; + i.data = (xcb_sync_waitcondition_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_sync_await_request_t))/sizeof(xcb_sync_waitcondition_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_sync_change_counter_checked (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */, - xcb_sync_int64_t amount /**< */) +xcb_sync_change_counter_checked (xcb_connection_t *c, + xcb_sync_counter_t counter, + xcb_sync_int64_t amount) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CHANGE_COUNTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CHANGE_COUNTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -664,15 +695,15 @@ xcb_sync_change_counter_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_change_counter (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */, - xcb_sync_int64_t amount /**< */) +xcb_sync_change_counter (xcb_connection_t *c, + xcb_sync_counter_t counter, + xcb_sync_int64_t amount) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CHANGE_COUNTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CHANGE_COUNTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -692,15 +723,15 @@ xcb_sync_change_counter (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_set_counter_checked (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */, - xcb_sync_int64_t value /**< */) +xcb_sync_set_counter_checked (xcb_connection_t *c, + xcb_sync_counter_t counter, + xcb_sync_int64_t value) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_SET_COUNTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_SET_COUNTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -720,15 +751,15 @@ xcb_sync_set_counter_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_set_counter (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */, - xcb_sync_int64_t value /**< */) +xcb_sync_set_counter (xcb_connection_t *c, + xcb_sync_counter_t counter, + xcb_sync_int64_t value) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_SET_COUNTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_SET_COUNTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -748,13 +779,14 @@ xcb_sync_set_counter (xcb_connection_t *c /**< */, } int -xcb_sync_create_alarm_value_list_serialize (void **_buffer /**< */, - uint32_t value_mask /**< */, - const xcb_sync_create_alarm_value_list_t *_aux /**< */) +xcb_sync_create_alarm_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_sync_create_alarm_value_list_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; @@ -813,7 +845,7 @@ xcb_sync_create_alarm_value_list_serialize (void xcb_align_to = ALIGNOF(uint32_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -822,6 +854,7 @@ xcb_sync_create_alarm_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -841,15 +874,16 @@ xcb_sync_create_alarm_value_list_serialize (void } int -xcb_sync_create_alarm_value_list_unpack (const void *_buffer /**< */, - uint32_t value_mask /**< */, - xcb_sync_create_alarm_value_list_t *_aux /**< */) +xcb_sync_create_alarm_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_sync_create_alarm_value_list_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; if(value_mask & XCB_SYNC_CA_COUNTER) { @@ -895,36 +929,68 @@ xcb_sync_create_alarm_value_list_unpack (const void *_b xcb_align_to = ALIGNOF(uint32_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; } int -xcb_sync_create_alarm_value_list_sizeof (const void *_buffer /**< */, - uint32_t value_mask /**< */) +xcb_sync_create_alarm_value_list_sizeof (const void *_buffer, + uint32_t value_mask) { xcb_sync_create_alarm_value_list_t _aux; return xcb_sync_create_alarm_value_list_unpack(_buffer, value_mask, &_aux); } +int +xcb_sync_create_alarm_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_sync_create_alarm_request_t *_aux = (xcb_sync_create_alarm_request_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; + + + xcb_block_len += sizeof(xcb_sync_create_alarm_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* value_list */ + xcb_block_len += xcb_sync_create_alarm_value_list_sizeof(xcb_tmp, _aux->value_mask); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; + + return xcb_buffer_len; +} + xcb_void_cookie_t -xcb_sync_create_alarm_checked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const void *value_list /**< */) +xcb_sync_create_alarm_checked (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CREATE_ALARM, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CREATE_ALARM, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -948,16 +1014,16 @@ xcb_sync_create_alarm_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_create_alarm (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const void *value_list /**< */) +xcb_sync_create_alarm (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CREATE_ALARM, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CREATE_ALARM, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -981,16 +1047,16 @@ xcb_sync_create_alarm (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_create_alarm_aux_checked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const xcb_sync_create_alarm_value_list_t *value_list /**< */) +xcb_sync_create_alarm_aux_checked (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const xcb_sync_create_alarm_value_list_t *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CREATE_ALARM, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CREATE_ALARM, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -1016,16 +1082,16 @@ xcb_sync_create_alarm_aux_checked (xcb_connection_t *c } xcb_void_cookie_t -xcb_sync_create_alarm_aux (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const xcb_sync_create_alarm_value_list_t *value_list /**< */) +xcb_sync_create_alarm_aux (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const xcb_sync_create_alarm_value_list_t *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CREATE_ALARM, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CREATE_ALARM, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -1050,14 +1116,21 @@ xcb_sync_create_alarm_aux (xcb_connection_t *c /**< */, return xcb_ret; } +void * +xcb_sync_create_alarm_value_list (const xcb_sync_create_alarm_request_t *R) +{ + return (void *) (R + 1); +} + int -xcb_sync_change_alarm_value_list_serialize (void **_buffer /**< */, - uint32_t value_mask /**< */, - const xcb_sync_change_alarm_value_list_t *_aux /**< */) +xcb_sync_change_alarm_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_sync_change_alarm_value_list_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; @@ -1116,7 +1189,7 @@ xcb_sync_change_alarm_value_list_serialize (void xcb_align_to = ALIGNOF(uint32_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -1125,6 +1198,7 @@ xcb_sync_change_alarm_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -1144,15 +1218,16 @@ xcb_sync_change_alarm_value_list_serialize (void } int -xcb_sync_change_alarm_value_list_unpack (const void *_buffer /**< */, - uint32_t value_mask /**< */, - xcb_sync_change_alarm_value_list_t *_aux /**< */) +xcb_sync_change_alarm_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_sync_change_alarm_value_list_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; if(value_mask & XCB_SYNC_CA_COUNTER) { @@ -1198,6 +1273,46 @@ xcb_sync_change_alarm_value_list_unpack (const void *_b xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_sync_change_alarm_value_list_sizeof (const void *_buffer, + uint32_t value_mask) +{ + xcb_sync_change_alarm_value_list_t _aux; + return xcb_sync_change_alarm_value_list_unpack(_buffer, value_mask, &_aux); +} + +int +xcb_sync_change_alarm_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_sync_change_alarm_request_t *_aux = (xcb_sync_change_alarm_request_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; + + + xcb_block_len += sizeof(xcb_sync_change_alarm_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* value_list */ + xcb_block_len += xcb_sync_change_alarm_value_list_sizeof(xcb_tmp, _aux->value_mask); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -1209,25 +1324,17 @@ xcb_sync_change_alarm_value_list_unpack (const void *_b return xcb_buffer_len; } -int -xcb_sync_change_alarm_value_list_sizeof (const void *_buffer /**< */, - uint32_t value_mask /**< */) -{ - xcb_sync_change_alarm_value_list_t _aux; - return xcb_sync_change_alarm_value_list_unpack(_buffer, value_mask, &_aux); -} - xcb_void_cookie_t -xcb_sync_change_alarm_checked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const void *value_list /**< */) +xcb_sync_change_alarm_checked (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CHANGE_ALARM, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CHANGE_ALARM, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -1251,16 +1358,16 @@ xcb_sync_change_alarm_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_change_alarm (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const void *value_list /**< */) +xcb_sync_change_alarm (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CHANGE_ALARM, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CHANGE_ALARM, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -1284,16 +1391,16 @@ xcb_sync_change_alarm (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_change_alarm_aux_checked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const xcb_sync_change_alarm_value_list_t *value_list /**< */) +xcb_sync_change_alarm_aux_checked (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const xcb_sync_change_alarm_value_list_t *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CHANGE_ALARM, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CHANGE_ALARM, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -1319,16 +1426,16 @@ xcb_sync_change_alarm_aux_checked (xcb_connection_t *c } xcb_void_cookie_t -xcb_sync_change_alarm_aux (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const xcb_sync_change_alarm_value_list_t *value_list /**< */) +xcb_sync_change_alarm_aux (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const xcb_sync_change_alarm_value_list_t *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CHANGE_ALARM, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CHANGE_ALARM, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -1353,15 +1460,21 @@ xcb_sync_change_alarm_aux (xcb_connection_t *c /**< */, return xcb_ret; } +void * +xcb_sync_change_alarm_value_list (const xcb_sync_change_alarm_request_t *R) +{ + return (void *) (R + 1); +} + xcb_void_cookie_t -xcb_sync_destroy_alarm_checked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t alarm /**< */) +xcb_sync_destroy_alarm_checked (xcb_connection_t *c, + xcb_sync_alarm_t alarm) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_DESTROY_ALARM, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_DESTROY_ALARM, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1380,14 +1493,14 @@ xcb_sync_destroy_alarm_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_destroy_alarm (xcb_connection_t *c /**< */, - xcb_sync_alarm_t alarm /**< */) +xcb_sync_destroy_alarm (xcb_connection_t *c, + xcb_sync_alarm_t alarm) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_DESTROY_ALARM, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_DESTROY_ALARM, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1406,14 +1519,14 @@ xcb_sync_destroy_alarm (xcb_connection_t *c /**< */, } xcb_sync_query_alarm_cookie_t -xcb_sync_query_alarm (xcb_connection_t *c /**< */, - xcb_sync_alarm_t alarm /**< */) +xcb_sync_query_alarm (xcb_connection_t *c, + xcb_sync_alarm_t alarm) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_QUERY_ALARM, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_QUERY_ALARM, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1432,14 +1545,14 @@ xcb_sync_query_alarm (xcb_connection_t *c /**< */, } xcb_sync_query_alarm_cookie_t -xcb_sync_query_alarm_unchecked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t alarm /**< */) +xcb_sync_query_alarm_unchecked (xcb_connection_t *c, + xcb_sync_alarm_t alarm) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_QUERY_ALARM, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_QUERY_ALARM, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1458,23 +1571,23 @@ xcb_sync_query_alarm_unchecked (xcb_connection_t *c /**< */, } xcb_sync_query_alarm_reply_t * -xcb_sync_query_alarm_reply (xcb_connection_t *c /**< */, +xcb_sync_query_alarm_reply (xcb_connection_t *c, xcb_sync_query_alarm_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_sync_query_alarm_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_sync_set_priority_checked (xcb_connection_t *c /**< */, - uint32_t id /**< */, - int32_t priority /**< */) +xcb_sync_set_priority_checked (xcb_connection_t *c, + uint32_t id, + int32_t priority) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_SET_PRIORITY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_SET_PRIORITY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1494,15 +1607,15 @@ xcb_sync_set_priority_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_set_priority (xcb_connection_t *c /**< */, - uint32_t id /**< */, - int32_t priority /**< */) +xcb_sync_set_priority (xcb_connection_t *c, + uint32_t id, + int32_t priority) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_SET_PRIORITY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_SET_PRIORITY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1522,14 +1635,14 @@ xcb_sync_set_priority (xcb_connection_t *c /**< */, } xcb_sync_get_priority_cookie_t -xcb_sync_get_priority (xcb_connection_t *c /**< */, - uint32_t id /**< */) +xcb_sync_get_priority (xcb_connection_t *c, + uint32_t id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_GET_PRIORITY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_GET_PRIORITY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1548,14 +1661,14 @@ xcb_sync_get_priority (xcb_connection_t *c /**< */, } xcb_sync_get_priority_cookie_t -xcb_sync_get_priority_unchecked (xcb_connection_t *c /**< */, - uint32_t id /**< */) +xcb_sync_get_priority_unchecked (xcb_connection_t *c, + uint32_t id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_GET_PRIORITY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_GET_PRIORITY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1574,24 +1687,24 @@ xcb_sync_get_priority_unchecked (xcb_connection_t *c /**< */, } xcb_sync_get_priority_reply_t * -xcb_sync_get_priority_reply (xcb_connection_t *c /**< */, +xcb_sync_get_priority_reply (xcb_connection_t *c, xcb_sync_get_priority_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_sync_get_priority_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_sync_create_fence_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_sync_fence_t fence /**< */, - uint8_t initially_triggered /**< */) +xcb_sync_create_fence_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_sync_fence_t fence, + uint8_t initially_triggered) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CREATE_FENCE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CREATE_FENCE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1612,16 +1725,16 @@ xcb_sync_create_fence_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_create_fence (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_sync_fence_t fence /**< */, - uint8_t initially_triggered /**< */) +xcb_sync_create_fence (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_sync_fence_t fence, + uint8_t initially_triggered) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_CREATE_FENCE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_CREATE_FENCE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1642,14 +1755,14 @@ xcb_sync_create_fence (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_trigger_fence_checked (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */) +xcb_sync_trigger_fence_checked (xcb_connection_t *c, + xcb_sync_fence_t fence) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_TRIGGER_FENCE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_TRIGGER_FENCE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1668,14 +1781,14 @@ xcb_sync_trigger_fence_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_trigger_fence (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */) +xcb_sync_trigger_fence (xcb_connection_t *c, + xcb_sync_fence_t fence) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_TRIGGER_FENCE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_TRIGGER_FENCE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1694,14 +1807,14 @@ xcb_sync_trigger_fence (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_reset_fence_checked (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */) +xcb_sync_reset_fence_checked (xcb_connection_t *c, + xcb_sync_fence_t fence) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_RESET_FENCE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_RESET_FENCE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1720,14 +1833,14 @@ xcb_sync_reset_fence_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_reset_fence (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */) +xcb_sync_reset_fence (xcb_connection_t *c, + xcb_sync_fence_t fence) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_RESET_FENCE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_RESET_FENCE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1746,14 +1859,14 @@ xcb_sync_reset_fence (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_destroy_fence_checked (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */) +xcb_sync_destroy_fence_checked (xcb_connection_t *c, + xcb_sync_fence_t fence) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_DESTROY_FENCE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_DESTROY_FENCE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1772,14 +1885,14 @@ xcb_sync_destroy_fence_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_destroy_fence (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */) +xcb_sync_destroy_fence (xcb_connection_t *c, + xcb_sync_fence_t fence) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_DESTROY_FENCE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_DESTROY_FENCE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1798,14 +1911,14 @@ xcb_sync_destroy_fence (xcb_connection_t *c /**< */, } xcb_sync_query_fence_cookie_t -xcb_sync_query_fence (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */) +xcb_sync_query_fence (xcb_connection_t *c, + xcb_sync_fence_t fence) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_QUERY_FENCE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_QUERY_FENCE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1824,14 +1937,14 @@ xcb_sync_query_fence (xcb_connection_t *c /**< */, } xcb_sync_query_fence_cookie_t -xcb_sync_query_fence_unchecked (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */) +xcb_sync_query_fence_unchecked (xcb_connection_t *c, + xcb_sync_fence_t fence) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_QUERY_FENCE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_QUERY_FENCE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1850,16 +1963,16 @@ xcb_sync_query_fence_unchecked (xcb_connection_t *c /**< */, } xcb_sync_query_fence_reply_t * -xcb_sync_query_fence_reply (xcb_connection_t *c /**< */, +xcb_sync_query_fence_reply (xcb_connection_t *c, xcb_sync_query_fence_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_sync_query_fence_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_sync_await_fence_sizeof (const void *_buffer /**< */, - uint32_t fence_list_len /**< */) +xcb_sync_await_fence_sizeof (const void *_buffer, + uint32_t fence_list_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -1889,15 +2002,15 @@ xcb_sync_await_fence_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_sync_await_fence_checked (xcb_connection_t *c /**< */, - uint32_t fence_list_len /**< */, - const xcb_sync_fence_t *fence_list /**< */) +xcb_sync_await_fence_checked (xcb_connection_t *c, + uint32_t fence_list_len, + const xcb_sync_fence_t *fence_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_AWAIT_FENCE, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_AWAIT_FENCE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1920,15 +2033,15 @@ xcb_sync_await_fence_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_sync_await_fence (xcb_connection_t *c /**< */, - uint32_t fence_list_len /**< */, - const xcb_sync_fence_t *fence_list /**< */) +xcb_sync_await_fence (xcb_connection_t *c, + uint32_t fence_list_len, + const xcb_sync_fence_t *fence_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_sync_id, - /* opcode */ XCB_SYNC_AWAIT_FENCE, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_sync_id, + .opcode = XCB_SYNC_AWAIT_FENCE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1950,3 +2063,25 @@ xcb_sync_await_fence (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_sync_fence_t * +xcb_sync_await_fence_fence_list (const xcb_sync_await_fence_request_t *R) +{ + return (xcb_sync_fence_t *) (R + 1); +} + +int +xcb_sync_await_fence_fence_list_length (const xcb_sync_await_fence_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_sync_await_fence_request_t))/sizeof(xcb_sync_fence_t)); +} + +xcb_generic_iterator_t +xcb_sync_await_fence_fence_list_end (const xcb_sync_await_fence_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_sync_fence_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_sync_await_fence_request_t))/sizeof(xcb_sync_fence_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + diff --git a/lib/libxcb/src/sync.h b/lib/libxcb/src/sync.h index a21969c63..47796e94c 100644 --- a/lib/libxcb/src/sync.h +++ b/lib/libxcb/src/sync.h @@ -30,9 +30,9 @@ typedef uint32_t xcb_sync_alarm_t; * @brief xcb_sync_alarm_iterator_t **/ typedef struct xcb_sync_alarm_iterator_t { - xcb_sync_alarm_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_sync_alarm_t *data; + int rem; + int index; } xcb_sync_alarm_iterator_t; typedef enum xcb_sync_alarmstate_t { @@ -47,9 +47,9 @@ typedef uint32_t xcb_sync_counter_t; * @brief xcb_sync_counter_iterator_t **/ typedef struct xcb_sync_counter_iterator_t { - xcb_sync_counter_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_sync_counter_t *data; + int rem; + int index; } xcb_sync_counter_iterator_t; typedef uint32_t xcb_sync_fence_t; @@ -58,9 +58,9 @@ typedef uint32_t xcb_sync_fence_t; * @brief xcb_sync_fence_iterator_t **/ typedef struct xcb_sync_fence_iterator_t { - xcb_sync_fence_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_sync_fence_t *data; + int rem; + int index; } xcb_sync_fence_iterator_t; typedef enum xcb_sync_testtype_t { @@ -88,71 +88,71 @@ typedef enum xcb_sync_ca_t { * @brief xcb_sync_int64_t **/ typedef struct xcb_sync_int64_t { - int32_t hi; /**< */ - uint32_t lo; /**< */ + int32_t hi; + uint32_t lo; } xcb_sync_int64_t; /** * @brief xcb_sync_int64_iterator_t **/ typedef struct xcb_sync_int64_iterator_t { - xcb_sync_int64_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_sync_int64_t *data; + int rem; + int index; } xcb_sync_int64_iterator_t; /** * @brief xcb_sync_systemcounter_t **/ typedef struct xcb_sync_systemcounter_t { - xcb_sync_counter_t counter; /**< */ - xcb_sync_int64_t resolution; /**< */ - uint16_t name_len; /**< */ + xcb_sync_counter_t counter; + xcb_sync_int64_t resolution; + uint16_t name_len; } xcb_sync_systemcounter_t; /** * @brief xcb_sync_systemcounter_iterator_t **/ typedef struct xcb_sync_systemcounter_iterator_t { - xcb_sync_systemcounter_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_sync_systemcounter_t *data; + int rem; + int index; } xcb_sync_systemcounter_iterator_t; /** * @brief xcb_sync_trigger_t **/ typedef struct xcb_sync_trigger_t { - xcb_sync_counter_t counter; /**< */ - uint32_t wait_type; /**< */ - xcb_sync_int64_t wait_value; /**< */ - uint32_t test_type; /**< */ + xcb_sync_counter_t counter; + uint32_t wait_type; + xcb_sync_int64_t wait_value; + uint32_t test_type; } xcb_sync_trigger_t; /** * @brief xcb_sync_trigger_iterator_t **/ typedef struct xcb_sync_trigger_iterator_t { - xcb_sync_trigger_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_sync_trigger_t *data; + int rem; + int index; } xcb_sync_trigger_iterator_t; /** * @brief xcb_sync_waitcondition_t **/ typedef struct xcb_sync_waitcondition_t { - xcb_sync_trigger_t trigger; /**< */ - xcb_sync_int64_t event_threshold; /**< */ + xcb_sync_trigger_t trigger; + xcb_sync_int64_t event_threshold; } xcb_sync_waitcondition_t; /** * @brief xcb_sync_waitcondition_iterator_t **/ typedef struct xcb_sync_waitcondition_iterator_t { - xcb_sync_waitcondition_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_sync_waitcondition_t *data; + int rem; + int index; } xcb_sync_waitcondition_iterator_t; /** Opcode for xcb_sync_counter. */ @@ -162,12 +162,12 @@ typedef struct xcb_sync_waitcondition_iterator_t { * @brief xcb_sync_counter_error_t **/ typedef struct xcb_sync_counter_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ - uint32_t bad_counter; /**< */ - uint16_t minor_opcode; /**< */ - uint8_t major_opcode; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; + uint32_t bad_counter; + uint16_t minor_opcode; + uint8_t major_opcode; } xcb_sync_counter_error_t; /** Opcode for xcb_sync_alarm. */ @@ -177,19 +177,19 @@ typedef struct xcb_sync_counter_error_t { * @brief xcb_sync_alarm_error_t **/ typedef struct xcb_sync_alarm_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ - uint32_t bad_alarm; /**< */ - uint16_t minor_opcode; /**< */ - uint8_t major_opcode; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; + uint32_t bad_alarm; + uint16_t minor_opcode; + uint8_t major_opcode; } xcb_sync_alarm_error_t; /** * @brief xcb_sync_initialize_cookie_t **/ typedef struct xcb_sync_initialize_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_sync_initialize_cookie_t; /** Opcode for xcb_sync_initialize. */ @@ -199,31 +199,31 @@ typedef struct xcb_sync_initialize_cookie_t { * @brief xcb_sync_initialize_request_t **/ typedef struct xcb_sync_initialize_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t desired_major_version; /**< */ - uint8_t desired_minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t desired_major_version; + uint8_t desired_minor_version; } xcb_sync_initialize_request_t; /** * @brief xcb_sync_initialize_reply_t **/ typedef struct xcb_sync_initialize_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t major_version; /**< */ - uint8_t minor_version; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t major_version; + uint8_t minor_version; + uint8_t pad1[22]; } xcb_sync_initialize_reply_t; /** * @brief xcb_sync_list_system_counters_cookie_t **/ typedef struct xcb_sync_list_system_counters_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_sync_list_system_counters_cookie_t; /** Opcode for xcb_sync_list_system_counters. */ @@ -233,21 +233,21 @@ typedef struct xcb_sync_list_system_counters_cookie_t { * @brief xcb_sync_list_system_counters_request_t **/ typedef struct xcb_sync_list_system_counters_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_sync_list_system_counters_request_t; /** * @brief xcb_sync_list_system_counters_reply_t **/ typedef struct xcb_sync_list_system_counters_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t counters_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t counters_len; + uint8_t pad1[20]; } xcb_sync_list_system_counters_reply_t; /** Opcode for xcb_sync_create_counter. */ @@ -257,11 +257,11 @@ typedef struct xcb_sync_list_system_counters_reply_t { * @brief xcb_sync_create_counter_request_t **/ typedef struct xcb_sync_create_counter_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_counter_t id; /**< */ - xcb_sync_int64_t initial_value; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_counter_t id; + xcb_sync_int64_t initial_value; } xcb_sync_create_counter_request_t; /** Opcode for xcb_sync_destroy_counter. */ @@ -271,17 +271,17 @@ typedef struct xcb_sync_create_counter_request_t { * @brief xcb_sync_destroy_counter_request_t **/ typedef struct xcb_sync_destroy_counter_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_counter_t counter; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_counter_t counter; } xcb_sync_destroy_counter_request_t; /** * @brief xcb_sync_query_counter_cookie_t **/ typedef struct xcb_sync_query_counter_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_sync_query_counter_cookie_t; /** Opcode for xcb_sync_query_counter. */ @@ -291,21 +291,21 @@ typedef struct xcb_sync_query_counter_cookie_t { * @brief xcb_sync_query_counter_request_t **/ typedef struct xcb_sync_query_counter_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_counter_t counter; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_counter_t counter; } xcb_sync_query_counter_request_t; /** * @brief xcb_sync_query_counter_reply_t **/ typedef struct xcb_sync_query_counter_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_sync_int64_t counter_value; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_sync_int64_t counter_value; } xcb_sync_query_counter_reply_t; /** Opcode for xcb_sync_await. */ @@ -315,9 +315,9 @@ typedef struct xcb_sync_query_counter_reply_t { * @brief xcb_sync_await_request_t **/ typedef struct xcb_sync_await_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_sync_await_request_t; /** Opcode for xcb_sync_change_counter. */ @@ -327,11 +327,11 @@ typedef struct xcb_sync_await_request_t { * @brief xcb_sync_change_counter_request_t **/ typedef struct xcb_sync_change_counter_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_counter_t counter; /**< */ - xcb_sync_int64_t amount; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_counter_t counter; + xcb_sync_int64_t amount; } xcb_sync_change_counter_request_t; /** Opcode for xcb_sync_set_counter. */ @@ -341,23 +341,23 @@ typedef struct xcb_sync_change_counter_request_t { * @brief xcb_sync_set_counter_request_t **/ typedef struct xcb_sync_set_counter_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_counter_t counter; /**< */ - xcb_sync_int64_t value; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_counter_t counter; + xcb_sync_int64_t value; } xcb_sync_set_counter_request_t; /** * @brief xcb_sync_create_alarm_value_list_t **/ typedef struct xcb_sync_create_alarm_value_list_t { - xcb_sync_counter_t counter; /**< */ - uint32_t valueType; /**< */ - xcb_sync_int64_t value; /**< */ - uint32_t testType; /**< */ - xcb_sync_int64_t delta; /**< */ - uint32_t events; /**< */ + xcb_sync_counter_t counter; + uint32_t valueType; + xcb_sync_int64_t value; + uint32_t testType; + xcb_sync_int64_t delta; + uint32_t events; } xcb_sync_create_alarm_value_list_t; /** Opcode for xcb_sync_create_alarm. */ @@ -367,23 +367,23 @@ typedef struct xcb_sync_create_alarm_value_list_t { * @brief xcb_sync_create_alarm_request_t **/ typedef struct xcb_sync_create_alarm_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_alarm_t id; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_alarm_t id; + uint32_t value_mask; } xcb_sync_create_alarm_request_t; /** * @brief xcb_sync_change_alarm_value_list_t **/ typedef struct xcb_sync_change_alarm_value_list_t { - xcb_sync_counter_t counter; /**< */ - uint32_t valueType; /**< */ - xcb_sync_int64_t value; /**< */ - uint32_t testType; /**< */ - xcb_sync_int64_t delta; /**< */ - uint32_t events; /**< */ + xcb_sync_counter_t counter; + uint32_t valueType; + xcb_sync_int64_t value; + uint32_t testType; + xcb_sync_int64_t delta; + uint32_t events; } xcb_sync_change_alarm_value_list_t; /** Opcode for xcb_sync_change_alarm. */ @@ -393,11 +393,11 @@ typedef struct xcb_sync_change_alarm_value_list_t { * @brief xcb_sync_change_alarm_request_t **/ typedef struct xcb_sync_change_alarm_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_alarm_t id; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_alarm_t id; + uint32_t value_mask; } xcb_sync_change_alarm_request_t; /** Opcode for xcb_sync_destroy_alarm. */ @@ -407,17 +407,17 @@ typedef struct xcb_sync_change_alarm_request_t { * @brief xcb_sync_destroy_alarm_request_t **/ typedef struct xcb_sync_destroy_alarm_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_alarm_t alarm; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_alarm_t alarm; } xcb_sync_destroy_alarm_request_t; /** * @brief xcb_sync_query_alarm_cookie_t **/ typedef struct xcb_sync_query_alarm_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_sync_query_alarm_cookie_t; /** Opcode for xcb_sync_query_alarm. */ @@ -427,25 +427,25 @@ typedef struct xcb_sync_query_alarm_cookie_t { * @brief xcb_sync_query_alarm_request_t **/ typedef struct xcb_sync_query_alarm_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_alarm_t alarm; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_alarm_t alarm; } xcb_sync_query_alarm_request_t; /** * @brief xcb_sync_query_alarm_reply_t **/ typedef struct xcb_sync_query_alarm_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_sync_trigger_t trigger; /**< */ - xcb_sync_int64_t delta; /**< */ - uint8_t events; /**< */ - uint8_t state; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_sync_trigger_t trigger; + xcb_sync_int64_t delta; + uint8_t events; + uint8_t state; + uint8_t pad1[2]; } xcb_sync_query_alarm_reply_t; /** Opcode for xcb_sync_set_priority. */ @@ -455,18 +455,18 @@ typedef struct xcb_sync_query_alarm_reply_t { * @brief xcb_sync_set_priority_request_t **/ typedef struct xcb_sync_set_priority_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t id; /**< */ - int32_t priority; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t id; + int32_t priority; } xcb_sync_set_priority_request_t; /** * @brief xcb_sync_get_priority_cookie_t **/ typedef struct xcb_sync_get_priority_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_sync_get_priority_cookie_t; /** Opcode for xcb_sync_get_priority. */ @@ -476,21 +476,21 @@ typedef struct xcb_sync_get_priority_cookie_t { * @brief xcb_sync_get_priority_request_t **/ typedef struct xcb_sync_get_priority_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t id; } xcb_sync_get_priority_request_t; /** * @brief xcb_sync_get_priority_reply_t **/ typedef struct xcb_sync_get_priority_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - int32_t priority; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + int32_t priority; } xcb_sync_get_priority_reply_t; /** Opcode for xcb_sync_create_fence. */ @@ -500,12 +500,12 @@ typedef struct xcb_sync_get_priority_reply_t { * @brief xcb_sync_create_fence_request_t **/ typedef struct xcb_sync_create_fence_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_sync_fence_t fence; /**< */ - uint8_t initially_triggered; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + xcb_sync_fence_t fence; + uint8_t initially_triggered; } xcb_sync_create_fence_request_t; /** Opcode for xcb_sync_trigger_fence. */ @@ -515,10 +515,10 @@ typedef struct xcb_sync_create_fence_request_t { * @brief xcb_sync_trigger_fence_request_t **/ typedef struct xcb_sync_trigger_fence_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_fence_t fence; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_fence_t fence; } xcb_sync_trigger_fence_request_t; /** Opcode for xcb_sync_reset_fence. */ @@ -528,10 +528,10 @@ typedef struct xcb_sync_trigger_fence_request_t { * @brief xcb_sync_reset_fence_request_t **/ typedef struct xcb_sync_reset_fence_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_fence_t fence; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_fence_t fence; } xcb_sync_reset_fence_request_t; /** Opcode for xcb_sync_destroy_fence. */ @@ -541,17 +541,17 @@ typedef struct xcb_sync_reset_fence_request_t { * @brief xcb_sync_destroy_fence_request_t **/ typedef struct xcb_sync_destroy_fence_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_fence_t fence; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_fence_t fence; } xcb_sync_destroy_fence_request_t; /** * @brief xcb_sync_query_fence_cookie_t **/ typedef struct xcb_sync_query_fence_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_sync_query_fence_cookie_t; /** Opcode for xcb_sync_query_fence. */ @@ -561,22 +561,22 @@ typedef struct xcb_sync_query_fence_cookie_t { * @brief xcb_sync_query_fence_request_t **/ typedef struct xcb_sync_query_fence_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_sync_fence_t fence; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_sync_fence_t fence; } xcb_sync_query_fence_request_t; /** * @brief xcb_sync_query_fence_reply_t **/ typedef struct xcb_sync_query_fence_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t triggered; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t triggered; + uint8_t pad1[23]; } xcb_sync_query_fence_reply_t; /** Opcode for xcb_sync_await_fence. */ @@ -586,9 +586,9 @@ typedef struct xcb_sync_query_fence_reply_t { * @brief xcb_sync_await_fence_request_t **/ typedef struct xcb_sync_await_fence_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_sync_await_fence_request_t; /** Opcode for xcb_sync_counter_notify. */ @@ -598,16 +598,16 @@ typedef struct xcb_sync_await_fence_request_t { * @brief xcb_sync_counter_notify_event_t **/ typedef struct xcb_sync_counter_notify_event_t { - uint8_t response_type; /**< */ - uint8_t kind; /**< */ - uint16_t sequence; /**< */ - xcb_sync_counter_t counter; /**< */ - xcb_sync_int64_t wait_value; /**< */ - xcb_sync_int64_t counter_value; /**< */ - xcb_timestamp_t timestamp; /**< */ - uint16_t count; /**< */ - uint8_t destroyed; /**< */ - uint8_t pad0; /**< */ + uint8_t response_type; + uint8_t kind; + uint16_t sequence; + xcb_sync_counter_t counter; + xcb_sync_int64_t wait_value; + xcb_sync_int64_t counter_value; + xcb_timestamp_t timestamp; + uint16_t count; + uint8_t destroyed; + uint8_t pad0; } xcb_sync_counter_notify_event_t; /** Opcode for xcb_sync_alarm_notify. */ @@ -617,15 +617,15 @@ typedef struct xcb_sync_counter_notify_event_t { * @brief xcb_sync_alarm_notify_event_t **/ typedef struct xcb_sync_alarm_notify_event_t { - uint8_t response_type; /**< */ - uint8_t kind; /**< */ - uint16_t sequence; /**< */ - xcb_sync_alarm_t alarm; /**< */ - xcb_sync_int64_t counter_value; /**< */ - xcb_sync_int64_t alarm_value; /**< */ - xcb_timestamp_t timestamp; /**< */ - uint8_t state; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t response_type; + uint8_t kind; + uint16_t sequence; + xcb_sync_alarm_t alarm; + xcb_sync_int64_t counter_value; + xcb_sync_int64_t alarm_value; + xcb_timestamp_t timestamp; + uint8_t state; + uint8_t pad0[3]; } xcb_sync_alarm_notify_event_t; /** @@ -637,7 +637,7 @@ typedef struct xcb_sync_alarm_notify_event_t { * element. The member index is increased by sizeof(xcb_sync_alarm_t) */ void -xcb_sync_alarm_next (xcb_sync_alarm_iterator_t *i /**< */); +xcb_sync_alarm_next (xcb_sync_alarm_iterator_t *i); /** * Return the iterator pointing to the last element @@ -649,7 +649,7 @@ xcb_sync_alarm_next (xcb_sync_alarm_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_sync_alarm_end (xcb_sync_alarm_iterator_t i /**< */); +xcb_sync_alarm_end (xcb_sync_alarm_iterator_t i); /** * Get the next element of the iterator @@ -660,7 +660,7 @@ xcb_sync_alarm_end (xcb_sync_alarm_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_sync_counter_t) */ void -xcb_sync_counter_next (xcb_sync_counter_iterator_t *i /**< */); +xcb_sync_counter_next (xcb_sync_counter_iterator_t *i); /** * Return the iterator pointing to the last element @@ -672,7 +672,7 @@ xcb_sync_counter_next (xcb_sync_counter_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_sync_counter_end (xcb_sync_counter_iterator_t i /**< */); +xcb_sync_counter_end (xcb_sync_counter_iterator_t i); /** * Get the next element of the iterator @@ -683,7 +683,7 @@ xcb_sync_counter_end (xcb_sync_counter_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_sync_fence_t) */ void -xcb_sync_fence_next (xcb_sync_fence_iterator_t *i /**< */); +xcb_sync_fence_next (xcb_sync_fence_iterator_t *i); /** * Return the iterator pointing to the last element @@ -695,7 +695,7 @@ xcb_sync_fence_next (xcb_sync_fence_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_sync_fence_end (xcb_sync_fence_iterator_t i /**< */); +xcb_sync_fence_end (xcb_sync_fence_iterator_t i); /** * Get the next element of the iterator @@ -706,7 +706,7 @@ xcb_sync_fence_end (xcb_sync_fence_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_sync_int64_t) */ void -xcb_sync_int64_next (xcb_sync_int64_iterator_t *i /**< */); +xcb_sync_int64_next (xcb_sync_int64_iterator_t *i); /** * Return the iterator pointing to the last element @@ -718,19 +718,19 @@ xcb_sync_int64_next (xcb_sync_int64_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_sync_int64_end (xcb_sync_int64_iterator_t i /**< */); +xcb_sync_int64_end (xcb_sync_int64_iterator_t i); int -xcb_sync_systemcounter_sizeof (const void *_buffer /**< */); +xcb_sync_systemcounter_sizeof (const void *_buffer); char * -xcb_sync_systemcounter_name (const xcb_sync_systemcounter_t *R /**< */); +xcb_sync_systemcounter_name (const xcb_sync_systemcounter_t *R); int -xcb_sync_systemcounter_name_length (const xcb_sync_systemcounter_t *R /**< */); +xcb_sync_systemcounter_name_length (const xcb_sync_systemcounter_t *R); xcb_generic_iterator_t -xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R /**< */); +xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R); /** * Get the next element of the iterator @@ -741,7 +741,7 @@ xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R /**< */); * element. The member index is increased by sizeof(xcb_sync_systemcounter_t) */ void -xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i /**< */); +xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i); /** * Return the iterator pointing to the last element @@ -753,7 +753,7 @@ xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i /**< */); +xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i); /** * Get the next element of the iterator @@ -764,7 +764,7 @@ xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_sync_trigger_t) */ void -xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i /**< */); +xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i); /** * Return the iterator pointing to the last element @@ -776,7 +776,7 @@ xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i /**< */); +xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i); /** * Get the next element of the iterator @@ -787,7 +787,7 @@ xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_sync_waitcondition_t) */ void -xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i /**< */); +xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i); /** * Return the iterator pointing to the last element @@ -799,7 +799,7 @@ xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i /**< */); +xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i); /** * @@ -810,9 +810,9 @@ xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i /**< */); * */ xcb_sync_initialize_cookie_t -xcb_sync_initialize (xcb_connection_t *c /**< */, - uint8_t desired_major_version /**< */, - uint8_t desired_minor_version /**< */); +xcb_sync_initialize (xcb_connection_t *c, + uint8_t desired_major_version, + uint8_t desired_minor_version); /** * @@ -826,9 +826,9 @@ xcb_sync_initialize (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_sync_initialize_cookie_t -xcb_sync_initialize_unchecked (xcb_connection_t *c /**< */, - uint8_t desired_major_version /**< */, - uint8_t desired_minor_version /**< */); +xcb_sync_initialize_unchecked (xcb_connection_t *c, + uint8_t desired_major_version, + uint8_t desired_minor_version); /** * Return the reply @@ -845,12 +845,12 @@ xcb_sync_initialize_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_sync_initialize_reply_t * -xcb_sync_initialize_reply (xcb_connection_t *c /**< */, +xcb_sync_initialize_reply (xcb_connection_t *c, xcb_sync_initialize_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_sync_list_system_counters_sizeof (const void *_buffer /**< */); +xcb_sync_list_system_counters_sizeof (const void *_buffer); /** * @@ -861,7 +861,7 @@ xcb_sync_list_system_counters_sizeof (const void *_buffer /**< */); * */ xcb_sync_list_system_counters_cookie_t -xcb_sync_list_system_counters (xcb_connection_t *c /**< */); +xcb_sync_list_system_counters (xcb_connection_t *c); /** * @@ -875,13 +875,13 @@ xcb_sync_list_system_counters (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_sync_list_system_counters_cookie_t -xcb_sync_list_system_counters_unchecked (xcb_connection_t *c /**< */); +xcb_sync_list_system_counters_unchecked (xcb_connection_t *c); int -xcb_sync_list_system_counters_counters_length (const xcb_sync_list_system_counters_reply_t *R /**< */); +xcb_sync_list_system_counters_counters_length (const xcb_sync_list_system_counters_reply_t *R); xcb_sync_systemcounter_iterator_t -xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_counters_reply_t *R /**< */); +xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_counters_reply_t *R); /** * Return the reply @@ -898,9 +898,9 @@ xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_coun * The returned value must be freed by the caller using free(). */ xcb_sync_list_system_counters_reply_t * -xcb_sync_list_system_counters_reply (xcb_connection_t *c /**< */, +xcb_sync_list_system_counters_reply (xcb_connection_t *c, xcb_sync_list_system_counters_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -914,9 +914,9 @@ xcb_sync_list_system_counters_reply (xcb_connection_t *c * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_create_counter_checked (xcb_connection_t *c /**< */, - xcb_sync_counter_t id /**< */, - xcb_sync_int64_t initial_value /**< */); +xcb_sync_create_counter_checked (xcb_connection_t *c, + xcb_sync_counter_t id, + xcb_sync_int64_t initial_value); /** * @@ -927,9 +927,9 @@ xcb_sync_create_counter_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_create_counter (xcb_connection_t *c /**< */, - xcb_sync_counter_t id /**< */, - xcb_sync_int64_t initial_value /**< */); +xcb_sync_create_counter (xcb_connection_t *c, + xcb_sync_counter_t id, + xcb_sync_int64_t initial_value); /** * @@ -943,8 +943,8 @@ xcb_sync_create_counter (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_destroy_counter_checked (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */); +xcb_sync_destroy_counter_checked (xcb_connection_t *c, + xcb_sync_counter_t counter); /** * @@ -955,8 +955,8 @@ xcb_sync_destroy_counter_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_destroy_counter (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */); +xcb_sync_destroy_counter (xcb_connection_t *c, + xcb_sync_counter_t counter); /** * @@ -967,8 +967,8 @@ xcb_sync_destroy_counter (xcb_connection_t *c /**< */, * */ xcb_sync_query_counter_cookie_t -xcb_sync_query_counter (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */); +xcb_sync_query_counter (xcb_connection_t *c, + xcb_sync_counter_t counter); /** * @@ -982,8 +982,8 @@ xcb_sync_query_counter (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_sync_query_counter_cookie_t -xcb_sync_query_counter_unchecked (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */); +xcb_sync_query_counter_unchecked (xcb_connection_t *c, + xcb_sync_counter_t counter); /** * Return the reply @@ -1000,13 +1000,13 @@ xcb_sync_query_counter_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_sync_query_counter_reply_t * -xcb_sync_query_counter_reply (xcb_connection_t *c /**< */, +xcb_sync_query_counter_reply (xcb_connection_t *c, xcb_sync_query_counter_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_sync_await_sizeof (const void *_buffer /**< */, - uint32_t wait_list_len /**< */); +xcb_sync_await_sizeof (const void *_buffer, + uint32_t wait_list_len); /** * @@ -1020,9 +1020,9 @@ xcb_sync_await_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_await_checked (xcb_connection_t *c /**< */, - uint32_t wait_list_len /**< */, - const xcb_sync_waitcondition_t *wait_list /**< */); +xcb_sync_await_checked (xcb_connection_t *c, + uint32_t wait_list_len, + const xcb_sync_waitcondition_t *wait_list); /** * @@ -1033,81 +1033,18 @@ xcb_sync_await_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_await (xcb_connection_t *c /**< */, - uint32_t wait_list_len /**< */, - const xcb_sync_waitcondition_t *wait_list /**< */); +xcb_sync_await (xcb_connection_t *c, + uint32_t wait_list_len, + const xcb_sync_waitcondition_t *wait_list); -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_sync_change_counter_checked (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */, - xcb_sync_int64_t amount /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_sync_change_counter (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */, - xcb_sync_int64_t amount /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_sync_set_counter_checked (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */, - xcb_sync_int64_t value /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_sync_set_counter (xcb_connection_t *c /**< */, - xcb_sync_counter_t counter /**< */, - xcb_sync_int64_t value /**< */); +xcb_sync_waitcondition_t * +xcb_sync_await_wait_list (const xcb_sync_await_request_t *R); int -xcb_sync_create_alarm_value_list_serialize (void **_buffer /**< */, - uint32_t value_mask /**< */, - const xcb_sync_create_alarm_value_list_t *_aux /**< */); +xcb_sync_await_wait_list_length (const xcb_sync_await_request_t *R); -int -xcb_sync_create_alarm_value_list_unpack (const void *_buffer /**< */, - uint32_t value_mask /**< */, - xcb_sync_create_alarm_value_list_t *_aux /**< */); - -int -xcb_sync_create_alarm_value_list_sizeof (const void *_buffer /**< */, - uint32_t value_mask /**< */); +xcb_sync_waitcondition_iterator_t +xcb_sync_await_wait_list_iterator (const xcb_sync_await_request_t *R); /** * @@ -1121,10 +1058,9 @@ xcb_sync_create_alarm_value_list_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_create_alarm_checked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const void *value_list /**< */); +xcb_sync_change_counter_checked (xcb_connection_t *c, + xcb_sync_counter_t counter, + xcb_sync_int64_t amount); /** * @@ -1135,10 +1071,9 @@ xcb_sync_create_alarm_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_create_alarm (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const void *value_list /**< */); +xcb_sync_change_counter (xcb_connection_t *c, + xcb_sync_counter_t counter, + xcb_sync_int64_t amount); /** * @@ -1152,10 +1087,9 @@ xcb_sync_create_alarm (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_create_alarm_aux_checked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const xcb_sync_create_alarm_value_list_t *value_list /**< */); +xcb_sync_set_counter_checked (xcb_connection_t *c, + xcb_sync_counter_t counter, + xcb_sync_int64_t value); /** * @@ -1166,24 +1100,26 @@ xcb_sync_create_alarm_aux_checked (xcb_connection_t *c * */ xcb_void_cookie_t -xcb_sync_create_alarm_aux (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const xcb_sync_create_alarm_value_list_t *value_list /**< */); +xcb_sync_set_counter (xcb_connection_t *c, + xcb_sync_counter_t counter, + xcb_sync_int64_t value); int -xcb_sync_change_alarm_value_list_serialize (void **_buffer /**< */, - uint32_t value_mask /**< */, - const xcb_sync_change_alarm_value_list_t *_aux /**< */); +xcb_sync_create_alarm_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_sync_create_alarm_value_list_t *_aux); int -xcb_sync_change_alarm_value_list_unpack (const void *_buffer /**< */, - uint32_t value_mask /**< */, - xcb_sync_change_alarm_value_list_t *_aux /**< */); +xcb_sync_create_alarm_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_sync_create_alarm_value_list_t *_aux); int -xcb_sync_change_alarm_value_list_sizeof (const void *_buffer /**< */, - uint32_t value_mask /**< */); +xcb_sync_create_alarm_value_list_sizeof (const void *_buffer, + uint32_t value_mask); + +int +xcb_sync_create_alarm_sizeof (const void *_buffer); /** * @@ -1197,10 +1133,10 @@ xcb_sync_change_alarm_value_list_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_change_alarm_checked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const void *value_list /**< */); +xcb_sync_create_alarm_checked (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const void *value_list); /** * @@ -1211,10 +1147,10 @@ xcb_sync_change_alarm_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_change_alarm (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const void *value_list /**< */); +xcb_sync_create_alarm (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const void *value_list); /** * @@ -1228,10 +1164,10 @@ xcb_sync_change_alarm (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_change_alarm_aux_checked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const xcb_sync_change_alarm_value_list_t *value_list /**< */); +xcb_sync_create_alarm_aux_checked (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const xcb_sync_create_alarm_value_list_t *value_list); /** * @@ -1242,10 +1178,30 @@ xcb_sync_change_alarm_aux_checked (xcb_connection_t *c * */ xcb_void_cookie_t -xcb_sync_change_alarm_aux (xcb_connection_t *c /**< */, - xcb_sync_alarm_t id /**< */, - uint32_t value_mask /**< */, - const xcb_sync_change_alarm_value_list_t *value_list /**< */); +xcb_sync_create_alarm_aux (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const xcb_sync_create_alarm_value_list_t *value_list); + +void * +xcb_sync_create_alarm_value_list (const xcb_sync_create_alarm_request_t *R); + +int +xcb_sync_change_alarm_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_sync_change_alarm_value_list_t *_aux); + +int +xcb_sync_change_alarm_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_sync_change_alarm_value_list_t *_aux); + +int +xcb_sync_change_alarm_value_list_sizeof (const void *_buffer, + uint32_t value_mask); + +int +xcb_sync_change_alarm_sizeof (const void *_buffer); /** * @@ -1259,8 +1215,10 @@ xcb_sync_change_alarm_aux (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_destroy_alarm_checked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t alarm /**< */); +xcb_sync_change_alarm_checked (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const void *value_list); /** * @@ -1271,8 +1229,71 @@ xcb_sync_destroy_alarm_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_destroy_alarm (xcb_connection_t *c /**< */, - xcb_sync_alarm_t alarm /**< */); +xcb_sync_change_alarm (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const void *value_list); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_sync_change_alarm_aux_checked (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const xcb_sync_change_alarm_value_list_t *value_list); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_sync_change_alarm_aux (xcb_connection_t *c, + xcb_sync_alarm_t id, + uint32_t value_mask, + const xcb_sync_change_alarm_value_list_t *value_list); + +void * +xcb_sync_change_alarm_value_list (const xcb_sync_change_alarm_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_sync_destroy_alarm_checked (xcb_connection_t *c, + xcb_sync_alarm_t alarm); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_sync_destroy_alarm (xcb_connection_t *c, + xcb_sync_alarm_t alarm); /** * @@ -1283,8 +1304,8 @@ xcb_sync_destroy_alarm (xcb_connection_t *c /**< */, * */ xcb_sync_query_alarm_cookie_t -xcb_sync_query_alarm (xcb_connection_t *c /**< */, - xcb_sync_alarm_t alarm /**< */); +xcb_sync_query_alarm (xcb_connection_t *c, + xcb_sync_alarm_t alarm); /** * @@ -1298,8 +1319,8 @@ xcb_sync_query_alarm (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_sync_query_alarm_cookie_t -xcb_sync_query_alarm_unchecked (xcb_connection_t *c /**< */, - xcb_sync_alarm_t alarm /**< */); +xcb_sync_query_alarm_unchecked (xcb_connection_t *c, + xcb_sync_alarm_t alarm); /** * Return the reply @@ -1316,9 +1337,9 @@ xcb_sync_query_alarm_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_sync_query_alarm_reply_t * -xcb_sync_query_alarm_reply (xcb_connection_t *c /**< */, +xcb_sync_query_alarm_reply (xcb_connection_t *c, xcb_sync_query_alarm_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1332,9 +1353,9 @@ xcb_sync_query_alarm_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_set_priority_checked (xcb_connection_t *c /**< */, - uint32_t id /**< */, - int32_t priority /**< */); +xcb_sync_set_priority_checked (xcb_connection_t *c, + uint32_t id, + int32_t priority); /** * @@ -1345,9 +1366,9 @@ xcb_sync_set_priority_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_set_priority (xcb_connection_t *c /**< */, - uint32_t id /**< */, - int32_t priority /**< */); +xcb_sync_set_priority (xcb_connection_t *c, + uint32_t id, + int32_t priority); /** * @@ -1358,8 +1379,8 @@ xcb_sync_set_priority (xcb_connection_t *c /**< */, * */ xcb_sync_get_priority_cookie_t -xcb_sync_get_priority (xcb_connection_t *c /**< */, - uint32_t id /**< */); +xcb_sync_get_priority (xcb_connection_t *c, + uint32_t id); /** * @@ -1373,8 +1394,8 @@ xcb_sync_get_priority (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_sync_get_priority_cookie_t -xcb_sync_get_priority_unchecked (xcb_connection_t *c /**< */, - uint32_t id /**< */); +xcb_sync_get_priority_unchecked (xcb_connection_t *c, + uint32_t id); /** * Return the reply @@ -1391,9 +1412,9 @@ xcb_sync_get_priority_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_sync_get_priority_reply_t * -xcb_sync_get_priority_reply (xcb_connection_t *c /**< */, +xcb_sync_get_priority_reply (xcb_connection_t *c, xcb_sync_get_priority_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1407,10 +1428,10 @@ xcb_sync_get_priority_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_create_fence_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_sync_fence_t fence /**< */, - uint8_t initially_triggered /**< */); +xcb_sync_create_fence_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_sync_fence_t fence, + uint8_t initially_triggered); /** * @@ -1421,10 +1442,10 @@ xcb_sync_create_fence_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_create_fence (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_sync_fence_t fence /**< */, - uint8_t initially_triggered /**< */); +xcb_sync_create_fence (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_sync_fence_t fence, + uint8_t initially_triggered); /** * @@ -1438,8 +1459,8 @@ xcb_sync_create_fence (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_trigger_fence_checked (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */); +xcb_sync_trigger_fence_checked (xcb_connection_t *c, + xcb_sync_fence_t fence); /** * @@ -1450,8 +1471,8 @@ xcb_sync_trigger_fence_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_trigger_fence (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */); +xcb_sync_trigger_fence (xcb_connection_t *c, + xcb_sync_fence_t fence); /** * @@ -1465,8 +1486,8 @@ xcb_sync_trigger_fence (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_reset_fence_checked (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */); +xcb_sync_reset_fence_checked (xcb_connection_t *c, + xcb_sync_fence_t fence); /** * @@ -1477,8 +1498,8 @@ xcb_sync_reset_fence_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_reset_fence (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */); +xcb_sync_reset_fence (xcb_connection_t *c, + xcb_sync_fence_t fence); /** * @@ -1492,8 +1513,8 @@ xcb_sync_reset_fence (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_destroy_fence_checked (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */); +xcb_sync_destroy_fence_checked (xcb_connection_t *c, + xcb_sync_fence_t fence); /** * @@ -1504,8 +1525,8 @@ xcb_sync_destroy_fence_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_destroy_fence (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */); +xcb_sync_destroy_fence (xcb_connection_t *c, + xcb_sync_fence_t fence); /** * @@ -1516,8 +1537,8 @@ xcb_sync_destroy_fence (xcb_connection_t *c /**< */, * */ xcb_sync_query_fence_cookie_t -xcb_sync_query_fence (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */); +xcb_sync_query_fence (xcb_connection_t *c, + xcb_sync_fence_t fence); /** * @@ -1531,8 +1552,8 @@ xcb_sync_query_fence (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_sync_query_fence_cookie_t -xcb_sync_query_fence_unchecked (xcb_connection_t *c /**< */, - xcb_sync_fence_t fence /**< */); +xcb_sync_query_fence_unchecked (xcb_connection_t *c, + xcb_sync_fence_t fence); /** * Return the reply @@ -1549,13 +1570,13 @@ xcb_sync_query_fence_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_sync_query_fence_reply_t * -xcb_sync_query_fence_reply (xcb_connection_t *c /**< */, +xcb_sync_query_fence_reply (xcb_connection_t *c, xcb_sync_query_fence_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_sync_await_fence_sizeof (const void *_buffer /**< */, - uint32_t fence_list_len /**< */); +xcb_sync_await_fence_sizeof (const void *_buffer, + uint32_t fence_list_len); /** * @@ -1569,9 +1590,9 @@ xcb_sync_await_fence_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_sync_await_fence_checked (xcb_connection_t *c /**< */, - uint32_t fence_list_len /**< */, - const xcb_sync_fence_t *fence_list /**< */); +xcb_sync_await_fence_checked (xcb_connection_t *c, + uint32_t fence_list_len, + const xcb_sync_fence_t *fence_list); /** * @@ -1582,9 +1603,18 @@ xcb_sync_await_fence_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_sync_await_fence (xcb_connection_t *c /**< */, - uint32_t fence_list_len /**< */, - const xcb_sync_fence_t *fence_list /**< */); +xcb_sync_await_fence (xcb_connection_t *c, + uint32_t fence_list_len, + const xcb_sync_fence_t *fence_list); + +xcb_sync_fence_t * +xcb_sync_await_fence_fence_list (const xcb_sync_await_fence_request_t *R); + +int +xcb_sync_await_fence_fence_list_length (const xcb_sync_await_fence_request_t *R); + +xcb_generic_iterator_t +xcb_sync_await_fence_fence_list_end (const xcb_sync_await_fence_request_t *R); #ifdef __cplusplus diff --git a/lib/libxcb/src/xc_misc.c b/lib/libxcb/src/xc_misc.c index 06e71fac5..2ce38b670 100644 --- a/lib/libxcb/src/xc_misc.c +++ b/lib/libxcb/src/xc_misc.c @@ -18,15 +18,15 @@ xcb_extension_t xcb_xc_misc_id = { "XC-MISC", 0 }; xcb_xc_misc_get_version_cookie_t -xcb_xc_misc_get_version (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */) +xcb_xc_misc_get_version (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xc_misc_id, - /* opcode */ XCB_XC_MISC_GET_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xc_misc_id, + .opcode = XCB_XC_MISC_GET_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -46,15 +46,15 @@ xcb_xc_misc_get_version (xcb_connection_t *c /**< */, } xcb_xc_misc_get_version_cookie_t -xcb_xc_misc_get_version_unchecked (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */) +xcb_xc_misc_get_version_unchecked (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xc_misc_id, - /* opcode */ XCB_XC_MISC_GET_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xc_misc_id, + .opcode = XCB_XC_MISC_GET_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -74,21 +74,21 @@ xcb_xc_misc_get_version_unchecked (xcb_connection_t *c /**< */, } xcb_xc_misc_get_version_reply_t * -xcb_xc_misc_get_version_reply (xcb_connection_t *c /**< */, +xcb_xc_misc_get_version_reply (xcb_connection_t *c, xcb_xc_misc_get_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xc_misc_get_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xc_misc_get_xid_range_cookie_t -xcb_xc_misc_get_xid_range (xcb_connection_t *c /**< */) +xcb_xc_misc_get_xid_range (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xc_misc_id, - /* opcode */ XCB_XC_MISC_GET_XID_RANGE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xc_misc_id, + .opcode = XCB_XC_MISC_GET_XID_RANGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -106,13 +106,13 @@ xcb_xc_misc_get_xid_range (xcb_connection_t *c /**< */) } xcb_xc_misc_get_xid_range_cookie_t -xcb_xc_misc_get_xid_range_unchecked (xcb_connection_t *c /**< */) +xcb_xc_misc_get_xid_range_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xc_misc_id, - /* opcode */ XCB_XC_MISC_GET_XID_RANGE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xc_misc_id, + .opcode = XCB_XC_MISC_GET_XID_RANGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -130,15 +130,15 @@ xcb_xc_misc_get_xid_range_unchecked (xcb_connection_t *c /**< */) } xcb_xc_misc_get_xid_range_reply_t * -xcb_xc_misc_get_xid_range_reply (xcb_connection_t *c /**< */, +xcb_xc_misc_get_xid_range_reply (xcb_connection_t *c, xcb_xc_misc_get_xid_range_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xc_misc_get_xid_range_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xc_misc_get_xid_list_sizeof (const void *_buffer /**< */) +xcb_xc_misc_get_xid_list_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xc_misc_get_xid_list_reply_t *_aux = (xcb_xc_misc_get_xid_list_reply_t *)_buffer; @@ -169,14 +169,14 @@ xcb_xc_misc_get_xid_list_sizeof (const void *_buffer /**< */) } xcb_xc_misc_get_xid_list_cookie_t -xcb_xc_misc_get_xid_list (xcb_connection_t *c /**< */, - uint32_t count /**< */) +xcb_xc_misc_get_xid_list (xcb_connection_t *c, + uint32_t count) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xc_misc_id, - /* opcode */ XCB_XC_MISC_GET_XID_LIST, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xc_misc_id, + .opcode = XCB_XC_MISC_GET_XID_LIST, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -195,14 +195,14 @@ xcb_xc_misc_get_xid_list (xcb_connection_t *c /**< */, } xcb_xc_misc_get_xid_list_cookie_t -xcb_xc_misc_get_xid_list_unchecked (xcb_connection_t *c /**< */, - uint32_t count /**< */) +xcb_xc_misc_get_xid_list_unchecked (xcb_connection_t *c, + uint32_t count) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xc_misc_id, - /* opcode */ XCB_XC_MISC_GET_XID_LIST, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xc_misc_id, + .opcode = XCB_XC_MISC_GET_XID_LIST, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -221,19 +221,19 @@ xcb_xc_misc_get_xid_list_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_xc_misc_get_xid_list_ids (const xcb_xc_misc_get_xid_list_reply_t *R /**< */) +xcb_xc_misc_get_xid_list_ids (const xcb_xc_misc_get_xid_list_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_xc_misc_get_xid_list_ids_length (const xcb_xc_misc_get_xid_list_reply_t *R /**< */) +xcb_xc_misc_get_xid_list_ids_length (const xcb_xc_misc_get_xid_list_reply_t *R) { return R->ids_len; } xcb_generic_iterator_t -xcb_xc_misc_get_xid_list_ids_end (const xcb_xc_misc_get_xid_list_reply_t *R /**< */) +xcb_xc_misc_get_xid_list_ids_end (const xcb_xc_misc_get_xid_list_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->ids_len); @@ -243,9 +243,9 @@ xcb_xc_misc_get_xid_list_ids_end (const xcb_xc_misc_get_xid_list_reply_t *R /** } xcb_xc_misc_get_xid_list_reply_t * -xcb_xc_misc_get_xid_list_reply (xcb_connection_t *c /**< */, +xcb_xc_misc_get_xid_list_reply (xcb_connection_t *c, xcb_xc_misc_get_xid_list_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xc_misc_get_xid_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/xc_misc.h b/lib/libxcb/src/xc_misc.h index 5df599f96..866c87977 100644 --- a/lib/libxcb/src/xc_misc.h +++ b/lib/libxcb/src/xc_misc.h @@ -27,7 +27,7 @@ extern xcb_extension_t xcb_xc_misc_id; * @brief xcb_xc_misc_get_version_cookie_t **/ typedef struct xcb_xc_misc_get_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xc_misc_get_version_cookie_t; /** Opcode for xcb_xc_misc_get_version. */ @@ -37,30 +37,30 @@ typedef struct xcb_xc_misc_get_version_cookie_t { * @brief xcb_xc_misc_get_version_request_t **/ typedef struct xcb_xc_misc_get_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t client_major_version; /**< */ - uint16_t client_minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t client_major_version; + uint16_t client_minor_version; } xcb_xc_misc_get_version_request_t; /** * @brief xcb_xc_misc_get_version_reply_t **/ typedef struct xcb_xc_misc_get_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t server_major_version; /**< */ - uint16_t server_minor_version; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t server_major_version; + uint16_t server_minor_version; } xcb_xc_misc_get_version_reply_t; /** * @brief xcb_xc_misc_get_xid_range_cookie_t **/ typedef struct xcb_xc_misc_get_xid_range_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xc_misc_get_xid_range_cookie_t; /** Opcode for xcb_xc_misc_get_xid_range. */ @@ -70,28 +70,28 @@ typedef struct xcb_xc_misc_get_xid_range_cookie_t { * @brief xcb_xc_misc_get_xid_range_request_t **/ typedef struct xcb_xc_misc_get_xid_range_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_xc_misc_get_xid_range_request_t; /** * @brief xcb_xc_misc_get_xid_range_reply_t **/ typedef struct xcb_xc_misc_get_xid_range_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t start_id; /**< */ - uint32_t count; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t start_id; + uint32_t count; } xcb_xc_misc_get_xid_range_reply_t; /** * @brief xcb_xc_misc_get_xid_list_cookie_t **/ typedef struct xcb_xc_misc_get_xid_list_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xc_misc_get_xid_list_cookie_t; /** Opcode for xcb_xc_misc_get_xid_list. */ @@ -101,22 +101,22 @@ typedef struct xcb_xc_misc_get_xid_list_cookie_t { * @brief xcb_xc_misc_get_xid_list_request_t **/ typedef struct xcb_xc_misc_get_xid_list_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t count; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t count; } xcb_xc_misc_get_xid_list_request_t; /** * @brief xcb_xc_misc_get_xid_list_reply_t **/ typedef struct xcb_xc_misc_get_xid_list_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t ids_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t ids_len; + uint8_t pad1[20]; } xcb_xc_misc_get_xid_list_reply_t; /** @@ -128,9 +128,9 @@ typedef struct xcb_xc_misc_get_xid_list_reply_t { * */ xcb_xc_misc_get_version_cookie_t -xcb_xc_misc_get_version (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */); +xcb_xc_misc_get_version (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version); /** * @@ -144,9 +144,9 @@ xcb_xc_misc_get_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xc_misc_get_version_cookie_t -xcb_xc_misc_get_version_unchecked (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */); +xcb_xc_misc_get_version_unchecked (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version); /** * Return the reply @@ -163,9 +163,9 @@ xcb_xc_misc_get_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xc_misc_get_version_reply_t * -xcb_xc_misc_get_version_reply (xcb_connection_t *c /**< */, +xcb_xc_misc_get_version_reply (xcb_connection_t *c, xcb_xc_misc_get_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -176,7 +176,7 @@ xcb_xc_misc_get_version_reply (xcb_connection_t *c /**< */, * */ xcb_xc_misc_get_xid_range_cookie_t -xcb_xc_misc_get_xid_range (xcb_connection_t *c /**< */); +xcb_xc_misc_get_xid_range (xcb_connection_t *c); /** * @@ -190,7 +190,7 @@ xcb_xc_misc_get_xid_range (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_xc_misc_get_xid_range_cookie_t -xcb_xc_misc_get_xid_range_unchecked (xcb_connection_t *c /**< */); +xcb_xc_misc_get_xid_range_unchecked (xcb_connection_t *c); /** * Return the reply @@ -207,12 +207,12 @@ xcb_xc_misc_get_xid_range_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_xc_misc_get_xid_range_reply_t * -xcb_xc_misc_get_xid_range_reply (xcb_connection_t *c /**< */, +xcb_xc_misc_get_xid_range_reply (xcb_connection_t *c, xcb_xc_misc_get_xid_range_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xc_misc_get_xid_list_sizeof (const void *_buffer /**< */); +xcb_xc_misc_get_xid_list_sizeof (const void *_buffer); /** * @@ -223,8 +223,8 @@ xcb_xc_misc_get_xid_list_sizeof (const void *_buffer /**< */); * */ xcb_xc_misc_get_xid_list_cookie_t -xcb_xc_misc_get_xid_list (xcb_connection_t *c /**< */, - uint32_t count /**< */); +xcb_xc_misc_get_xid_list (xcb_connection_t *c, + uint32_t count); /** * @@ -238,17 +238,17 @@ xcb_xc_misc_get_xid_list (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xc_misc_get_xid_list_cookie_t -xcb_xc_misc_get_xid_list_unchecked (xcb_connection_t *c /**< */, - uint32_t count /**< */); +xcb_xc_misc_get_xid_list_unchecked (xcb_connection_t *c, + uint32_t count); uint32_t * -xcb_xc_misc_get_xid_list_ids (const xcb_xc_misc_get_xid_list_reply_t *R /**< */); +xcb_xc_misc_get_xid_list_ids (const xcb_xc_misc_get_xid_list_reply_t *R); int -xcb_xc_misc_get_xid_list_ids_length (const xcb_xc_misc_get_xid_list_reply_t *R /**< */); +xcb_xc_misc_get_xid_list_ids_length (const xcb_xc_misc_get_xid_list_reply_t *R); xcb_generic_iterator_t -xcb_xc_misc_get_xid_list_ids_end (const xcb_xc_misc_get_xid_list_reply_t *R /**< */); +xcb_xc_misc_get_xid_list_ids_end (const xcb_xc_misc_get_xid_list_reply_t *R); /** * Return the reply @@ -265,9 +265,9 @@ xcb_xc_misc_get_xid_list_ids_end (const xcb_xc_misc_get_xid_list_reply_t *R /** * The returned value must be freed by the caller using free(). */ xcb_xc_misc_get_xid_list_reply_t * -xcb_xc_misc_get_xid_list_reply (xcb_connection_t *c /**< */, +xcb_xc_misc_get_xid_list_reply (xcb_connection_t *c, xcb_xc_misc_get_xid_list_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/xevie.c b/lib/libxcb/src/xevie.c index 708882df6..0adbf03d0 100644 --- a/lib/libxcb/src/xevie.c +++ b/lib/libxcb/src/xevie.c @@ -18,15 +18,15 @@ xcb_extension_t xcb_xevie_id = { "XEVIE", 0 }; xcb_xevie_query_version_cookie_t -xcb_xevie_query_version (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */) +xcb_xevie_query_version (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xevie_id, - /* opcode */ XCB_XEVIE_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xevie_id, + .opcode = XCB_XEVIE_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -46,15 +46,15 @@ xcb_xevie_query_version (xcb_connection_t *c /**< */, } xcb_xevie_query_version_cookie_t -xcb_xevie_query_version_unchecked (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */) +xcb_xevie_query_version_unchecked (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xevie_id, - /* opcode */ XCB_XEVIE_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xevie_id, + .opcode = XCB_XEVIE_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -74,22 +74,22 @@ xcb_xevie_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_xevie_query_version_reply_t * -xcb_xevie_query_version_reply (xcb_connection_t *c /**< */, +xcb_xevie_query_version_reply (xcb_connection_t *c, xcb_xevie_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xevie_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xevie_start_cookie_t -xcb_xevie_start (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xevie_start (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xevie_id, - /* opcode */ XCB_XEVIE_START, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xevie_id, + .opcode = XCB_XEVIE_START, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -108,14 +108,14 @@ xcb_xevie_start (xcb_connection_t *c /**< */, } xcb_xevie_start_cookie_t -xcb_xevie_start_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xevie_start_unchecked (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xevie_id, - /* opcode */ XCB_XEVIE_START, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xevie_id, + .opcode = XCB_XEVIE_START, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -134,22 +134,22 @@ xcb_xevie_start_unchecked (xcb_connection_t *c /**< */, } xcb_xevie_start_reply_t * -xcb_xevie_start_reply (xcb_connection_t *c /**< */, +xcb_xevie_start_reply (xcb_connection_t *c, xcb_xevie_start_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xevie_start_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xevie_end_cookie_t -xcb_xevie_end (xcb_connection_t *c /**< */, - uint32_t cmap /**< */) +xcb_xevie_end (xcb_connection_t *c, + uint32_t cmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xevie_id, - /* opcode */ XCB_XEVIE_END, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xevie_id, + .opcode = XCB_XEVIE_END, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -168,14 +168,14 @@ xcb_xevie_end (xcb_connection_t *c /**< */, } xcb_xevie_end_cookie_t -xcb_xevie_end_unchecked (xcb_connection_t *c /**< */, - uint32_t cmap /**< */) +xcb_xevie_end_unchecked (xcb_connection_t *c, + uint32_t cmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xevie_id, - /* opcode */ XCB_XEVIE_END, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xevie_id, + .opcode = XCB_XEVIE_END, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -194,15 +194,15 @@ xcb_xevie_end_unchecked (xcb_connection_t *c /**< */, } xcb_xevie_end_reply_t * -xcb_xevie_end_reply (xcb_connection_t *c /**< */, +xcb_xevie_end_reply (xcb_connection_t *c, xcb_xevie_end_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xevie_end_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } void -xcb_xevie_event_next (xcb_xevie_event_iterator_t *i /**< */) +xcb_xevie_event_next (xcb_xevie_event_iterator_t *i) { --i->rem; ++i->data; @@ -210,7 +210,7 @@ xcb_xevie_event_next (xcb_xevie_event_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xevie_event_end (xcb_xevie_event_iterator_t i /**< */) +xcb_xevie_event_end (xcb_xevie_event_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -220,15 +220,15 @@ xcb_xevie_event_end (xcb_xevie_event_iterator_t i /**< */) } xcb_xevie_send_cookie_t -xcb_xevie_send (xcb_connection_t *c /**< */, - xcb_xevie_event_t event /**< */, - uint32_t data_type /**< */) +xcb_xevie_send (xcb_connection_t *c, + xcb_xevie_event_t event, + uint32_t data_type) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xevie_id, - /* opcode */ XCB_XEVIE_SEND, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xevie_id, + .opcode = XCB_XEVIE_SEND, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -249,15 +249,15 @@ xcb_xevie_send (xcb_connection_t *c /**< */, } xcb_xevie_send_cookie_t -xcb_xevie_send_unchecked (xcb_connection_t *c /**< */, - xcb_xevie_event_t event /**< */, - uint32_t data_type /**< */) +xcb_xevie_send_unchecked (xcb_connection_t *c, + xcb_xevie_event_t event, + uint32_t data_type) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xevie_id, - /* opcode */ XCB_XEVIE_SEND, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xevie_id, + .opcode = XCB_XEVIE_SEND, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -278,22 +278,22 @@ xcb_xevie_send_unchecked (xcb_connection_t *c /**< */, } xcb_xevie_send_reply_t * -xcb_xevie_send_reply (xcb_connection_t *c /**< */, +xcb_xevie_send_reply (xcb_connection_t *c, xcb_xevie_send_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xevie_send_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xevie_select_input_cookie_t -xcb_xevie_select_input (xcb_connection_t *c /**< */, - uint32_t event_mask /**< */) +xcb_xevie_select_input (xcb_connection_t *c, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xevie_id, - /* opcode */ XCB_XEVIE_SELECT_INPUT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xevie_id, + .opcode = XCB_XEVIE_SELECT_INPUT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -312,14 +312,14 @@ xcb_xevie_select_input (xcb_connection_t *c /**< */, } xcb_xevie_select_input_cookie_t -xcb_xevie_select_input_unchecked (xcb_connection_t *c /**< */, - uint32_t event_mask /**< */) +xcb_xevie_select_input_unchecked (xcb_connection_t *c, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xevie_id, - /* opcode */ XCB_XEVIE_SELECT_INPUT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xevie_id, + .opcode = XCB_XEVIE_SELECT_INPUT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -338,9 +338,9 @@ xcb_xevie_select_input_unchecked (xcb_connection_t *c /**< */, } xcb_xevie_select_input_reply_t * -xcb_xevie_select_input_reply (xcb_connection_t *c /**< */, +xcb_xevie_select_input_reply (xcb_connection_t *c, xcb_xevie_select_input_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xevie_select_input_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/xevie.h b/lib/libxcb/src/xevie.h index 7d386f3ca..d6b78253c 100644 --- a/lib/libxcb/src/xevie.h +++ b/lib/libxcb/src/xevie.h @@ -27,7 +27,7 @@ extern xcb_extension_t xcb_xevie_id; * @brief xcb_xevie_query_version_cookie_t **/ typedef struct xcb_xevie_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xevie_query_version_cookie_t; /** Opcode for xcb_xevie_query_version. */ @@ -37,31 +37,31 @@ typedef struct xcb_xevie_query_version_cookie_t { * @brief xcb_xevie_query_version_request_t **/ typedef struct xcb_xevie_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t client_major_version; /**< */ - uint16_t client_minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t client_major_version; + uint16_t client_minor_version; } xcb_xevie_query_version_request_t; /** * @brief xcb_xevie_query_version_reply_t **/ typedef struct xcb_xevie_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t server_major_version; /**< */ - uint16_t server_minor_version; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t server_major_version; + uint16_t server_minor_version; + uint8_t pad1[20]; } xcb_xevie_query_version_reply_t; /** * @brief xcb_xevie_start_cookie_t **/ typedef struct xcb_xevie_start_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xevie_start_cookie_t; /** Opcode for xcb_xevie_start. */ @@ -71,28 +71,28 @@ typedef struct xcb_xevie_start_cookie_t { * @brief xcb_xevie_start_request_t **/ typedef struct xcb_xevie_start_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; } xcb_xevie_start_request_t; /** * @brief xcb_xevie_start_reply_t **/ typedef struct xcb_xevie_start_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_xevie_start_reply_t; /** * @brief xcb_xevie_end_cookie_t **/ typedef struct xcb_xevie_end_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xevie_end_cookie_t; /** Opcode for xcb_xevie_end. */ @@ -102,21 +102,21 @@ typedef struct xcb_xevie_end_cookie_t { * @brief xcb_xevie_end_request_t **/ typedef struct xcb_xevie_end_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t cmap; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t cmap; } xcb_xevie_end_request_t; /** * @brief xcb_xevie_end_reply_t **/ typedef struct xcb_xevie_end_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_xevie_end_reply_t; typedef enum xcb_xevie_datatype_t { @@ -128,23 +128,23 @@ typedef enum xcb_xevie_datatype_t { * @brief xcb_xevie_event_t **/ typedef struct xcb_xevie_event_t { - uint8_t pad0[32]; /**< */ + uint8_t pad0[32]; } xcb_xevie_event_t; /** * @brief xcb_xevie_event_iterator_t **/ typedef struct xcb_xevie_event_iterator_t { - xcb_xevie_event_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xevie_event_t *data; + int rem; + int index; } xcb_xevie_event_iterator_t; /** * @brief xcb_xevie_send_cookie_t **/ typedef struct xcb_xevie_send_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xevie_send_cookie_t; /** Opcode for xcb_xevie_send. */ @@ -154,30 +154,30 @@ typedef struct xcb_xevie_send_cookie_t { * @brief xcb_xevie_send_request_t **/ typedef struct xcb_xevie_send_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xevie_event_t event; /**< */ - uint32_t data_type; /**< */ - uint8_t pad0[64]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xevie_event_t event; + uint32_t data_type; + uint8_t pad0[64]; } xcb_xevie_send_request_t; /** * @brief xcb_xevie_send_reply_t **/ typedef struct xcb_xevie_send_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_xevie_send_reply_t; /** * @brief xcb_xevie_select_input_cookie_t **/ typedef struct xcb_xevie_select_input_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xevie_select_input_cookie_t; /** Opcode for xcb_xevie_select_input. */ @@ -187,21 +187,21 @@ typedef struct xcb_xevie_select_input_cookie_t { * @brief xcb_xevie_select_input_request_t **/ typedef struct xcb_xevie_select_input_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t event_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t event_mask; } xcb_xevie_select_input_request_t; /** * @brief xcb_xevie_select_input_reply_t **/ typedef struct xcb_xevie_select_input_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_xevie_select_input_reply_t; /** @@ -213,9 +213,9 @@ typedef struct xcb_xevie_select_input_reply_t { * */ xcb_xevie_query_version_cookie_t -xcb_xevie_query_version (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */); +xcb_xevie_query_version (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version); /** * @@ -229,9 +229,9 @@ xcb_xevie_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xevie_query_version_cookie_t -xcb_xevie_query_version_unchecked (xcb_connection_t *c /**< */, - uint16_t client_major_version /**< */, - uint16_t client_minor_version /**< */); +xcb_xevie_query_version_unchecked (xcb_connection_t *c, + uint16_t client_major_version, + uint16_t client_minor_version); /** * Return the reply @@ -248,9 +248,9 @@ xcb_xevie_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xevie_query_version_reply_t * -xcb_xevie_query_version_reply (xcb_connection_t *c /**< */, +xcb_xevie_query_version_reply (xcb_connection_t *c, xcb_xevie_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -261,8 +261,8 @@ xcb_xevie_query_version_reply (xcb_connection_t *c /**< */, * */ xcb_xevie_start_cookie_t -xcb_xevie_start (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xevie_start (xcb_connection_t *c, + uint32_t screen); /** * @@ -276,8 +276,8 @@ xcb_xevie_start (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xevie_start_cookie_t -xcb_xevie_start_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xevie_start_unchecked (xcb_connection_t *c, + uint32_t screen); /** * Return the reply @@ -294,9 +294,9 @@ xcb_xevie_start_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xevie_start_reply_t * -xcb_xevie_start_reply (xcb_connection_t *c /**< */, +xcb_xevie_start_reply (xcb_connection_t *c, xcb_xevie_start_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -307,8 +307,8 @@ xcb_xevie_start_reply (xcb_connection_t *c /**< */, * */ xcb_xevie_end_cookie_t -xcb_xevie_end (xcb_connection_t *c /**< */, - uint32_t cmap /**< */); +xcb_xevie_end (xcb_connection_t *c, + uint32_t cmap); /** * @@ -322,8 +322,8 @@ xcb_xevie_end (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xevie_end_cookie_t -xcb_xevie_end_unchecked (xcb_connection_t *c /**< */, - uint32_t cmap /**< */); +xcb_xevie_end_unchecked (xcb_connection_t *c, + uint32_t cmap); /** * Return the reply @@ -340,9 +340,9 @@ xcb_xevie_end_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xevie_end_reply_t * -xcb_xevie_end_reply (xcb_connection_t *c /**< */, +xcb_xevie_end_reply (xcb_connection_t *c, xcb_xevie_end_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Get the next element of the iterator @@ -353,7 +353,7 @@ xcb_xevie_end_reply (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_xevie_event_t) */ void -xcb_xevie_event_next (xcb_xevie_event_iterator_t *i /**< */); +xcb_xevie_event_next (xcb_xevie_event_iterator_t *i); /** * Return the iterator pointing to the last element @@ -365,7 +365,7 @@ xcb_xevie_event_next (xcb_xevie_event_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xevie_event_end (xcb_xevie_event_iterator_t i /**< */); +xcb_xevie_event_end (xcb_xevie_event_iterator_t i); /** * @@ -376,9 +376,9 @@ xcb_xevie_event_end (xcb_xevie_event_iterator_t i /**< */); * */ xcb_xevie_send_cookie_t -xcb_xevie_send (xcb_connection_t *c /**< */, - xcb_xevie_event_t event /**< */, - uint32_t data_type /**< */); +xcb_xevie_send (xcb_connection_t *c, + xcb_xevie_event_t event, + uint32_t data_type); /** * @@ -392,9 +392,9 @@ xcb_xevie_send (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xevie_send_cookie_t -xcb_xevie_send_unchecked (xcb_connection_t *c /**< */, - xcb_xevie_event_t event /**< */, - uint32_t data_type /**< */); +xcb_xevie_send_unchecked (xcb_connection_t *c, + xcb_xevie_event_t event, + uint32_t data_type); /** * Return the reply @@ -411,9 +411,9 @@ xcb_xevie_send_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xevie_send_reply_t * -xcb_xevie_send_reply (xcb_connection_t *c /**< */, +xcb_xevie_send_reply (xcb_connection_t *c, xcb_xevie_send_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -424,8 +424,8 @@ xcb_xevie_send_reply (xcb_connection_t *c /**< */, * */ xcb_xevie_select_input_cookie_t -xcb_xevie_select_input (xcb_connection_t *c /**< */, - uint32_t event_mask /**< */); +xcb_xevie_select_input (xcb_connection_t *c, + uint32_t event_mask); /** * @@ -439,8 +439,8 @@ xcb_xevie_select_input (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xevie_select_input_cookie_t -xcb_xevie_select_input_unchecked (xcb_connection_t *c /**< */, - uint32_t event_mask /**< */); +xcb_xevie_select_input_unchecked (xcb_connection_t *c, + uint32_t event_mask); /** * Return the reply @@ -457,9 +457,9 @@ xcb_xevie_select_input_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xevie_select_input_reply_t * -xcb_xevie_select_input_reply (xcb_connection_t *c /**< */, +xcb_xevie_select_input_reply (xcb_connection_t *c, xcb_xevie_select_input_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/xf86dri.c b/lib/libxcb/src/xf86dri.c index bf59d3ebd..7d48d44b0 100644 --- a/lib/libxcb/src/xf86dri.c +++ b/lib/libxcb/src/xf86dri.c @@ -18,7 +18,7 @@ xcb_extension_t xcb_xf86dri_id = { "XFree86-DRI", 0 }; void -xcb_xf86dri_drm_clip_rect_next (xcb_xf86dri_drm_clip_rect_iterator_t *i /**< */) +xcb_xf86dri_drm_clip_rect_next (xcb_xf86dri_drm_clip_rect_iterator_t *i) { --i->rem; ++i->data; @@ -26,7 +26,7 @@ xcb_xf86dri_drm_clip_rect_next (xcb_xf86dri_drm_clip_rect_iterator_t *i /**< */ } xcb_generic_iterator_t -xcb_xf86dri_drm_clip_rect_end (xcb_xf86dri_drm_clip_rect_iterator_t i /**< */) +xcb_xf86dri_drm_clip_rect_end (xcb_xf86dri_drm_clip_rect_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -36,13 +36,13 @@ xcb_xf86dri_drm_clip_rect_end (xcb_xf86dri_drm_clip_rect_iterator_t i /**< */) } xcb_xf86dri_query_version_cookie_t -xcb_xf86dri_query_version (xcb_connection_t *c /**< */) +xcb_xf86dri_query_version (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -60,13 +60,13 @@ xcb_xf86dri_query_version (xcb_connection_t *c /**< */) } xcb_xf86dri_query_version_cookie_t -xcb_xf86dri_query_version_unchecked (xcb_connection_t *c /**< */) +xcb_xf86dri_query_version_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -84,22 +84,22 @@ xcb_xf86dri_query_version_unchecked (xcb_connection_t *c /**< */) } xcb_xf86dri_query_version_reply_t * -xcb_xf86dri_query_version_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_query_version_reply (xcb_connection_t *c, xcb_xf86dri_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xf86dri_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xf86dri_query_direct_rendering_capable_cookie_t -xcb_xf86dri_query_direct_rendering_capable (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xf86dri_query_direct_rendering_capable (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_QUERY_DIRECT_RENDERING_CAPABLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_QUERY_DIRECT_RENDERING_CAPABLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -118,14 +118,14 @@ xcb_xf86dri_query_direct_rendering_capable (xcb_connection_t *c /**< */, } xcb_xf86dri_query_direct_rendering_capable_cookie_t -xcb_xf86dri_query_direct_rendering_capable_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xf86dri_query_direct_rendering_capable_unchecked (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_QUERY_DIRECT_RENDERING_CAPABLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_QUERY_DIRECT_RENDERING_CAPABLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -144,15 +144,15 @@ xcb_xf86dri_query_direct_rendering_capable_unchecked (xcb_connection_t *c /**< } xcb_xf86dri_query_direct_rendering_capable_reply_t * -xcb_xf86dri_query_direct_rendering_capable_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_query_direct_rendering_capable_reply (xcb_connection_t *c, xcb_xf86dri_query_direct_rendering_capable_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xf86dri_query_direct_rendering_capable_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xf86dri_open_connection_sizeof (const void *_buffer /**< */) +xcb_xf86dri_open_connection_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xf86dri_open_connection_reply_t *_aux = (xcb_xf86dri_open_connection_reply_t *)_buffer; @@ -183,14 +183,14 @@ xcb_xf86dri_open_connection_sizeof (const void *_buffer /**< */) } xcb_xf86dri_open_connection_cookie_t -xcb_xf86dri_open_connection (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xf86dri_open_connection (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_OPEN_CONNECTION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_OPEN_CONNECTION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -209,14 +209,14 @@ xcb_xf86dri_open_connection (xcb_connection_t *c /**< */, } xcb_xf86dri_open_connection_cookie_t -xcb_xf86dri_open_connection_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xf86dri_open_connection_unchecked (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_OPEN_CONNECTION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_OPEN_CONNECTION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -235,19 +235,19 @@ xcb_xf86dri_open_connection_unchecked (xcb_connection_t *c /**< */, } char * -xcb_xf86dri_open_connection_bus_id (const xcb_xf86dri_open_connection_reply_t *R /**< */) +xcb_xf86dri_open_connection_bus_id (const xcb_xf86dri_open_connection_reply_t *R) { return (char *) (R + 1); } int -xcb_xf86dri_open_connection_bus_id_length (const xcb_xf86dri_open_connection_reply_t *R /**< */) +xcb_xf86dri_open_connection_bus_id_length (const xcb_xf86dri_open_connection_reply_t *R) { return R->bus_id_len; } xcb_generic_iterator_t -xcb_xf86dri_open_connection_bus_id_end (const xcb_xf86dri_open_connection_reply_t *R /**< */) +xcb_xf86dri_open_connection_bus_id_end (const xcb_xf86dri_open_connection_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->bus_id_len); @@ -257,22 +257,22 @@ xcb_xf86dri_open_connection_bus_id_end (const xcb_xf86dri_open_connection_reply_ } xcb_xf86dri_open_connection_reply_t * -xcb_xf86dri_open_connection_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_open_connection_reply (xcb_connection_t *c, xcb_xf86dri_open_connection_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xf86dri_open_connection_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xf86dri_close_connection_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xf86dri_close_connection_checked (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_CLOSE_CONNECTION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_CLOSE_CONNECTION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -291,14 +291,14 @@ xcb_xf86dri_close_connection_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xf86dri_close_connection (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xf86dri_close_connection (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_CLOSE_CONNECTION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_CLOSE_CONNECTION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -317,7 +317,7 @@ xcb_xf86dri_close_connection (xcb_connection_t *c /**< */, } int -xcb_xf86dri_get_client_driver_name_sizeof (const void *_buffer /**< */) +xcb_xf86dri_get_client_driver_name_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xf86dri_get_client_driver_name_reply_t *_aux = (xcb_xf86dri_get_client_driver_name_reply_t *)_buffer; @@ -348,14 +348,14 @@ xcb_xf86dri_get_client_driver_name_sizeof (const void *_buffer /**< */) } xcb_xf86dri_get_client_driver_name_cookie_t -xcb_xf86dri_get_client_driver_name (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xf86dri_get_client_driver_name (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_GET_CLIENT_DRIVER_NAME, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_GET_CLIENT_DRIVER_NAME, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -374,14 +374,14 @@ xcb_xf86dri_get_client_driver_name (xcb_connection_t *c /**< */, } xcb_xf86dri_get_client_driver_name_cookie_t -xcb_xf86dri_get_client_driver_name_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xf86dri_get_client_driver_name_unchecked (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_GET_CLIENT_DRIVER_NAME, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_GET_CLIENT_DRIVER_NAME, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -400,19 +400,19 @@ xcb_xf86dri_get_client_driver_name_unchecked (xcb_connection_t *c /**< */, } char * -xcb_xf86dri_get_client_driver_name_client_driver_name (const xcb_xf86dri_get_client_driver_name_reply_t *R /**< */) +xcb_xf86dri_get_client_driver_name_client_driver_name (const xcb_xf86dri_get_client_driver_name_reply_t *R) { return (char *) (R + 1); } int -xcb_xf86dri_get_client_driver_name_client_driver_name_length (const xcb_xf86dri_get_client_driver_name_reply_t *R /**< */) +xcb_xf86dri_get_client_driver_name_client_driver_name_length (const xcb_xf86dri_get_client_driver_name_reply_t *R) { return R->client_driver_name_len; } xcb_generic_iterator_t -xcb_xf86dri_get_client_driver_name_client_driver_name_end (const xcb_xf86dri_get_client_driver_name_reply_t *R /**< */) +xcb_xf86dri_get_client_driver_name_client_driver_name_end (const xcb_xf86dri_get_client_driver_name_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->client_driver_name_len); @@ -422,24 +422,24 @@ xcb_xf86dri_get_client_driver_name_client_driver_name_end (const xcb_xf86dri_get } xcb_xf86dri_get_client_driver_name_reply_t * -xcb_xf86dri_get_client_driver_name_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_get_client_driver_name_reply (xcb_connection_t *c, xcb_xf86dri_get_client_driver_name_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xf86dri_get_client_driver_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xf86dri_create_context_cookie_t -xcb_xf86dri_create_context (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t visual /**< */, - uint32_t context /**< */) +xcb_xf86dri_create_context (xcb_connection_t *c, + uint32_t screen, + uint32_t visual, + uint32_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -460,16 +460,16 @@ xcb_xf86dri_create_context (xcb_connection_t *c /**< */, } xcb_xf86dri_create_context_cookie_t -xcb_xf86dri_create_context_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t visual /**< */, - uint32_t context /**< */) +xcb_xf86dri_create_context_unchecked (xcb_connection_t *c, + uint32_t screen, + uint32_t visual, + uint32_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -490,23 +490,23 @@ xcb_xf86dri_create_context_unchecked (xcb_connection_t *c /**< */, } xcb_xf86dri_create_context_reply_t * -xcb_xf86dri_create_context_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_create_context_reply (xcb_connection_t *c, xcb_xf86dri_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xf86dri_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xf86dri_destroy_context_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t context /**< */) +xcb_xf86dri_destroy_context_checked (xcb_connection_t *c, + uint32_t screen, + uint32_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_DESTROY_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_DESTROY_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -526,15 +526,15 @@ xcb_xf86dri_destroy_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xf86dri_destroy_context (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t context /**< */) +xcb_xf86dri_destroy_context (xcb_connection_t *c, + uint32_t screen, + uint32_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_DESTROY_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_DESTROY_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -554,15 +554,15 @@ xcb_xf86dri_destroy_context (xcb_connection_t *c /**< */, } xcb_xf86dri_create_drawable_cookie_t -xcb_xf86dri_create_drawable (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */) +xcb_xf86dri_create_drawable (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_CREATE_DRAWABLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_CREATE_DRAWABLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -582,15 +582,15 @@ xcb_xf86dri_create_drawable (xcb_connection_t *c /**< */, } xcb_xf86dri_create_drawable_cookie_t -xcb_xf86dri_create_drawable_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */) +xcb_xf86dri_create_drawable_unchecked (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_CREATE_DRAWABLE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_CREATE_DRAWABLE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -610,23 +610,23 @@ xcb_xf86dri_create_drawable_unchecked (xcb_connection_t *c /**< */, } xcb_xf86dri_create_drawable_reply_t * -xcb_xf86dri_create_drawable_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_create_drawable_reply (xcb_connection_t *c, xcb_xf86dri_create_drawable_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xf86dri_create_drawable_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xf86dri_destroy_drawable_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */) +xcb_xf86dri_destroy_drawable_checked (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_DESTROY_DRAWABLE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_DESTROY_DRAWABLE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -646,15 +646,15 @@ xcb_xf86dri_destroy_drawable_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xf86dri_destroy_drawable (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */) +xcb_xf86dri_destroy_drawable (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_DESTROY_DRAWABLE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_DESTROY_DRAWABLE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -674,7 +674,7 @@ xcb_xf86dri_destroy_drawable (xcb_connection_t *c /**< */, } int -xcb_xf86dri_get_drawable_info_sizeof (const void *_buffer /**< */) +xcb_xf86dri_get_drawable_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xf86dri_get_drawable_info_reply_t *_aux = (xcb_xf86dri_get_drawable_info_reply_t *)_buffer; @@ -717,15 +717,15 @@ xcb_xf86dri_get_drawable_info_sizeof (const void *_buffer /**< */) } xcb_xf86dri_get_drawable_info_cookie_t -xcb_xf86dri_get_drawable_info (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */) +xcb_xf86dri_get_drawable_info (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_GET_DRAWABLE_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_GET_DRAWABLE_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -745,15 +745,15 @@ xcb_xf86dri_get_drawable_info (xcb_connection_t *c /**< */, } xcb_xf86dri_get_drawable_info_cookie_t -xcb_xf86dri_get_drawable_info_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */) +xcb_xf86dri_get_drawable_info_unchecked (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_GET_DRAWABLE_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_GET_DRAWABLE_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -773,19 +773,19 @@ xcb_xf86dri_get_drawable_info_unchecked (xcb_connection_t *c /**< */, } xcb_xf86dri_drm_clip_rect_t * -xcb_xf86dri_get_drawable_info_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */) +xcb_xf86dri_get_drawable_info_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R) { return (xcb_xf86dri_drm_clip_rect_t *) (R + 1); } int -xcb_xf86dri_get_drawable_info_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */) +xcb_xf86dri_get_drawable_info_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R) { return R->num_clip_rects; } xcb_xf86dri_drm_clip_rect_iterator_t -xcb_xf86dri_get_drawable_info_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */) +xcb_xf86dri_get_drawable_info_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R) { xcb_xf86dri_drm_clip_rect_iterator_t i; i.data = (xcb_xf86dri_drm_clip_rect_t *) (R + 1); @@ -795,20 +795,20 @@ xcb_xf86dri_get_drawable_info_clip_rects_iterator (const xcb_xf86dri_get_drawabl } xcb_xf86dri_drm_clip_rect_t * -xcb_xf86dri_get_drawable_info_back_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */) +xcb_xf86dri_get_drawable_info_back_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_xf86dri_drm_clip_rect_end(xcb_xf86dri_get_drawable_info_clip_rects_iterator(R)); return (xcb_xf86dri_drm_clip_rect_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xf86dri_drm_clip_rect_t, prev.index) + 0); } int -xcb_xf86dri_get_drawable_info_back_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */) +xcb_xf86dri_get_drawable_info_back_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R) { return R->num_back_clip_rects; } xcb_xf86dri_drm_clip_rect_iterator_t -xcb_xf86dri_get_drawable_info_back_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */) +xcb_xf86dri_get_drawable_info_back_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R) { xcb_xf86dri_drm_clip_rect_iterator_t i; xcb_generic_iterator_t prev = xcb_xf86dri_drm_clip_rect_end(xcb_xf86dri_get_drawable_info_clip_rects_iterator(R)); @@ -819,15 +819,15 @@ xcb_xf86dri_get_drawable_info_back_clip_rects_iterator (const xcb_xf86dri_get_dr } xcb_xf86dri_get_drawable_info_reply_t * -xcb_xf86dri_get_drawable_info_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_get_drawable_info_reply (xcb_connection_t *c, xcb_xf86dri_get_drawable_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xf86dri_get_drawable_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xf86dri_get_device_info_sizeof (const void *_buffer /**< */) +xcb_xf86dri_get_device_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xf86dri_get_device_info_reply_t *_aux = (xcb_xf86dri_get_device_info_reply_t *)_buffer; @@ -858,14 +858,14 @@ xcb_xf86dri_get_device_info_sizeof (const void *_buffer /**< */) } xcb_xf86dri_get_device_info_cookie_t -xcb_xf86dri_get_device_info (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xf86dri_get_device_info (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_GET_DEVICE_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_GET_DEVICE_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -884,14 +884,14 @@ xcb_xf86dri_get_device_info (xcb_connection_t *c /**< */, } xcb_xf86dri_get_device_info_cookie_t -xcb_xf86dri_get_device_info_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */) +xcb_xf86dri_get_device_info_unchecked (xcb_connection_t *c, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_GET_DEVICE_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_GET_DEVICE_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -910,19 +910,19 @@ xcb_xf86dri_get_device_info_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_xf86dri_get_device_info_device_private (const xcb_xf86dri_get_device_info_reply_t *R /**< */) +xcb_xf86dri_get_device_info_device_private (const xcb_xf86dri_get_device_info_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_xf86dri_get_device_info_device_private_length (const xcb_xf86dri_get_device_info_reply_t *R /**< */) +xcb_xf86dri_get_device_info_device_private_length (const xcb_xf86dri_get_device_info_reply_t *R) { return R->device_private_size; } xcb_generic_iterator_t -xcb_xf86dri_get_device_info_device_private_end (const xcb_xf86dri_get_device_info_reply_t *R /**< */) +xcb_xf86dri_get_device_info_device_private_end (const xcb_xf86dri_get_device_info_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->device_private_size); @@ -932,23 +932,23 @@ xcb_xf86dri_get_device_info_device_private_end (const xcb_xf86dri_get_device_inf } xcb_xf86dri_get_device_info_reply_t * -xcb_xf86dri_get_device_info_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_get_device_info_reply (xcb_connection_t *c, xcb_xf86dri_get_device_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xf86dri_get_device_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xf86dri_auth_connection_cookie_t -xcb_xf86dri_auth_connection (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t magic /**< */) +xcb_xf86dri_auth_connection (xcb_connection_t *c, + uint32_t screen, + uint32_t magic) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_AUTH_CONNECTION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_AUTH_CONNECTION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -968,15 +968,15 @@ xcb_xf86dri_auth_connection (xcb_connection_t *c /**< */, } xcb_xf86dri_auth_connection_cookie_t -xcb_xf86dri_auth_connection_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t magic /**< */) +xcb_xf86dri_auth_connection_unchecked (xcb_connection_t *c, + uint32_t screen, + uint32_t magic) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xf86dri_id, - /* opcode */ XCB_XF86DRI_AUTH_CONNECTION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xf86dri_id, + .opcode = XCB_XF86DRI_AUTH_CONNECTION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -996,9 +996,9 @@ xcb_xf86dri_auth_connection_unchecked (xcb_connection_t *c /**< */, } xcb_xf86dri_auth_connection_reply_t * -xcb_xf86dri_auth_connection_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_auth_connection_reply (xcb_connection_t *c, xcb_xf86dri_auth_connection_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xf86dri_auth_connection_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/xf86dri.h b/lib/libxcb/src/xf86dri.h index da7716194..fbe1b0e1b 100644 --- a/lib/libxcb/src/xf86dri.h +++ b/lib/libxcb/src/xf86dri.h @@ -27,26 +27,26 @@ extern xcb_extension_t xcb_xf86dri_id; * @brief xcb_xf86dri_drm_clip_rect_t **/ typedef struct xcb_xf86dri_drm_clip_rect_t { - int16_t x1; /**< */ - int16_t y1; /**< */ - int16_t x2; /**< */ - int16_t x3; /**< */ + int16_t x1; + int16_t y1; + int16_t x2; + int16_t x3; } xcb_xf86dri_drm_clip_rect_t; /** * @brief xcb_xf86dri_drm_clip_rect_iterator_t **/ typedef struct xcb_xf86dri_drm_clip_rect_iterator_t { - xcb_xf86dri_drm_clip_rect_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xf86dri_drm_clip_rect_t *data; + int rem; + int index; } xcb_xf86dri_drm_clip_rect_iterator_t; /** * @brief xcb_xf86dri_query_version_cookie_t **/ typedef struct xcb_xf86dri_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xf86dri_query_version_cookie_t; /** Opcode for xcb_xf86dri_query_version. */ @@ -56,29 +56,29 @@ typedef struct xcb_xf86dri_query_version_cookie_t { * @brief xcb_xf86dri_query_version_request_t **/ typedef struct xcb_xf86dri_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_xf86dri_query_version_request_t; /** * @brief xcb_xf86dri_query_version_reply_t **/ typedef struct xcb_xf86dri_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t dri_major_version; /**< */ - uint16_t dri_minor_version; /**< */ - uint32_t dri_minor_patch; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t dri_major_version; + uint16_t dri_minor_version; + uint32_t dri_minor_patch; } xcb_xf86dri_query_version_reply_t; /** * @brief xcb_xf86dri_query_direct_rendering_capable_cookie_t **/ typedef struct xcb_xf86dri_query_direct_rendering_capable_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xf86dri_query_direct_rendering_capable_cookie_t; /** Opcode for xcb_xf86dri_query_direct_rendering_capable. */ @@ -88,28 +88,28 @@ typedef struct xcb_xf86dri_query_direct_rendering_capable_cookie_t { * @brief xcb_xf86dri_query_direct_rendering_capable_request_t **/ typedef struct xcb_xf86dri_query_direct_rendering_capable_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; } xcb_xf86dri_query_direct_rendering_capable_request_t; /** * @brief xcb_xf86dri_query_direct_rendering_capable_reply_t **/ typedef struct xcb_xf86dri_query_direct_rendering_capable_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t is_capable; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t is_capable; } xcb_xf86dri_query_direct_rendering_capable_reply_t; /** * @brief xcb_xf86dri_open_connection_cookie_t **/ typedef struct xcb_xf86dri_open_connection_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xf86dri_open_connection_cookie_t; /** Opcode for xcb_xf86dri_open_connection. */ @@ -119,24 +119,24 @@ typedef struct xcb_xf86dri_open_connection_cookie_t { * @brief xcb_xf86dri_open_connection_request_t **/ typedef struct xcb_xf86dri_open_connection_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; } xcb_xf86dri_open_connection_request_t; /** * @brief xcb_xf86dri_open_connection_reply_t **/ typedef struct xcb_xf86dri_open_connection_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t sarea_handle_low; /**< */ - uint32_t sarea_handle_high; /**< */ - uint32_t bus_id_len; /**< */ - uint8_t pad1[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t sarea_handle_low; + uint32_t sarea_handle_high; + uint32_t bus_id_len; + uint8_t pad1[12]; } xcb_xf86dri_open_connection_reply_t; /** Opcode for xcb_xf86dri_close_connection. */ @@ -146,17 +146,17 @@ typedef struct xcb_xf86dri_open_connection_reply_t { * @brief xcb_xf86dri_close_connection_request_t **/ typedef struct xcb_xf86dri_close_connection_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; } xcb_xf86dri_close_connection_request_t; /** * @brief xcb_xf86dri_get_client_driver_name_cookie_t **/ typedef struct xcb_xf86dri_get_client_driver_name_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xf86dri_get_client_driver_name_cookie_t; /** Opcode for xcb_xf86dri_get_client_driver_name. */ @@ -166,32 +166,32 @@ typedef struct xcb_xf86dri_get_client_driver_name_cookie_t { * @brief xcb_xf86dri_get_client_driver_name_request_t **/ typedef struct xcb_xf86dri_get_client_driver_name_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; } xcb_xf86dri_get_client_driver_name_request_t; /** * @brief xcb_xf86dri_get_client_driver_name_reply_t **/ typedef struct xcb_xf86dri_get_client_driver_name_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t client_driver_major_version; /**< */ - uint32_t client_driver_minor_version; /**< */ - uint32_t client_driver_patch_version; /**< */ - uint32_t client_driver_name_len; /**< */ - uint8_t pad1[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t client_driver_major_version; + uint32_t client_driver_minor_version; + uint32_t client_driver_patch_version; + uint32_t client_driver_name_len; + uint8_t pad1[8]; } xcb_xf86dri_get_client_driver_name_reply_t; /** * @brief xcb_xf86dri_create_context_cookie_t **/ typedef struct xcb_xf86dri_create_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xf86dri_create_context_cookie_t; /** Opcode for xcb_xf86dri_create_context. */ @@ -201,23 +201,23 @@ typedef struct xcb_xf86dri_create_context_cookie_t { * @brief xcb_xf86dri_create_context_request_t **/ typedef struct xcb_xf86dri_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - uint32_t visual; /**< */ - uint32_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + uint32_t visual; + uint32_t context; } xcb_xf86dri_create_context_request_t; /** * @brief xcb_xf86dri_create_context_reply_t **/ typedef struct xcb_xf86dri_create_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t hw_context; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t hw_context; } xcb_xf86dri_create_context_reply_t; /** Opcode for xcb_xf86dri_destroy_context. */ @@ -227,18 +227,18 @@ typedef struct xcb_xf86dri_create_context_reply_t { * @brief xcb_xf86dri_destroy_context_request_t **/ typedef struct xcb_xf86dri_destroy_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - uint32_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + uint32_t context; } xcb_xf86dri_destroy_context_request_t; /** * @brief xcb_xf86dri_create_drawable_cookie_t **/ typedef struct xcb_xf86dri_create_drawable_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xf86dri_create_drawable_cookie_t; /** Opcode for xcb_xf86dri_create_drawable. */ @@ -248,22 +248,22 @@ typedef struct xcb_xf86dri_create_drawable_cookie_t { * @brief xcb_xf86dri_create_drawable_request_t **/ typedef struct xcb_xf86dri_create_drawable_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - uint32_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + uint32_t drawable; } xcb_xf86dri_create_drawable_request_t; /** * @brief xcb_xf86dri_create_drawable_reply_t **/ typedef struct xcb_xf86dri_create_drawable_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t hw_drawable_handle; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t hw_drawable_handle; } xcb_xf86dri_create_drawable_reply_t; /** Opcode for xcb_xf86dri_destroy_drawable. */ @@ -273,18 +273,18 @@ typedef struct xcb_xf86dri_create_drawable_reply_t { * @brief xcb_xf86dri_destroy_drawable_request_t **/ typedef struct xcb_xf86dri_destroy_drawable_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - uint32_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + uint32_t drawable; } xcb_xf86dri_destroy_drawable_request_t; /** * @brief xcb_xf86dri_get_drawable_info_cookie_t **/ typedef struct xcb_xf86dri_get_drawable_info_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xf86dri_get_drawable_info_cookie_t; /** Opcode for xcb_xf86dri_get_drawable_info. */ @@ -294,38 +294,38 @@ typedef struct xcb_xf86dri_get_drawable_info_cookie_t { * @brief xcb_xf86dri_get_drawable_info_request_t **/ typedef struct xcb_xf86dri_get_drawable_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - uint32_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + uint32_t drawable; } xcb_xf86dri_get_drawable_info_request_t; /** * @brief xcb_xf86dri_get_drawable_info_reply_t **/ typedef struct xcb_xf86dri_get_drawable_info_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t drawable_table_index; /**< */ - uint32_t drawable_table_stamp; /**< */ - int16_t drawable_origin_X; /**< */ - int16_t drawable_origin_Y; /**< */ - int16_t drawable_size_W; /**< */ - int16_t drawable_size_H; /**< */ - uint32_t num_clip_rects; /**< */ - int16_t back_x; /**< */ - int16_t back_y; /**< */ - uint32_t num_back_clip_rects; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t drawable_table_index; + uint32_t drawable_table_stamp; + int16_t drawable_origin_X; + int16_t drawable_origin_Y; + int16_t drawable_size_W; + int16_t drawable_size_H; + uint32_t num_clip_rects; + int16_t back_x; + int16_t back_y; + uint32_t num_back_clip_rects; } xcb_xf86dri_get_drawable_info_reply_t; /** * @brief xcb_xf86dri_get_device_info_cookie_t **/ typedef struct xcb_xf86dri_get_device_info_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xf86dri_get_device_info_cookie_t; /** Opcode for xcb_xf86dri_get_device_info. */ @@ -335,33 +335,33 @@ typedef struct xcb_xf86dri_get_device_info_cookie_t { * @brief xcb_xf86dri_get_device_info_request_t **/ typedef struct xcb_xf86dri_get_device_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; } xcb_xf86dri_get_device_info_request_t; /** * @brief xcb_xf86dri_get_device_info_reply_t **/ typedef struct xcb_xf86dri_get_device_info_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t framebuffer_handle_low; /**< */ - uint32_t framebuffer_handle_high; /**< */ - uint32_t framebuffer_origin_offset; /**< */ - uint32_t framebuffer_size; /**< */ - uint32_t framebuffer_stride; /**< */ - uint32_t device_private_size; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t framebuffer_handle_low; + uint32_t framebuffer_handle_high; + uint32_t framebuffer_origin_offset; + uint32_t framebuffer_size; + uint32_t framebuffer_stride; + uint32_t device_private_size; } xcb_xf86dri_get_device_info_reply_t; /** * @brief xcb_xf86dri_auth_connection_cookie_t **/ typedef struct xcb_xf86dri_auth_connection_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xf86dri_auth_connection_cookie_t; /** Opcode for xcb_xf86dri_auth_connection. */ @@ -371,22 +371,22 @@ typedef struct xcb_xf86dri_auth_connection_cookie_t { * @brief xcb_xf86dri_auth_connection_request_t **/ typedef struct xcb_xf86dri_auth_connection_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t screen; /**< */ - uint32_t magic; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t screen; + uint32_t magic; } xcb_xf86dri_auth_connection_request_t; /** * @brief xcb_xf86dri_auth_connection_reply_t **/ typedef struct xcb_xf86dri_auth_connection_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t authenticated; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t authenticated; } xcb_xf86dri_auth_connection_reply_t; /** @@ -398,7 +398,7 @@ typedef struct xcb_xf86dri_auth_connection_reply_t { * element. The member index is increased by sizeof(xcb_xf86dri_drm_clip_rect_t) */ void -xcb_xf86dri_drm_clip_rect_next (xcb_xf86dri_drm_clip_rect_iterator_t *i /**< */); +xcb_xf86dri_drm_clip_rect_next (xcb_xf86dri_drm_clip_rect_iterator_t *i); /** * Return the iterator pointing to the last element @@ -410,7 +410,7 @@ xcb_xf86dri_drm_clip_rect_next (xcb_xf86dri_drm_clip_rect_iterator_t *i /**< */ * last element. */ xcb_generic_iterator_t -xcb_xf86dri_drm_clip_rect_end (xcb_xf86dri_drm_clip_rect_iterator_t i /**< */); +xcb_xf86dri_drm_clip_rect_end (xcb_xf86dri_drm_clip_rect_iterator_t i); /** * @@ -421,7 +421,7 @@ xcb_xf86dri_drm_clip_rect_end (xcb_xf86dri_drm_clip_rect_iterator_t i /**< */); * */ xcb_xf86dri_query_version_cookie_t -xcb_xf86dri_query_version (xcb_connection_t *c /**< */); +xcb_xf86dri_query_version (xcb_connection_t *c); /** * @@ -435,7 +435,7 @@ xcb_xf86dri_query_version (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_xf86dri_query_version_cookie_t -xcb_xf86dri_query_version_unchecked (xcb_connection_t *c /**< */); +xcb_xf86dri_query_version_unchecked (xcb_connection_t *c); /** * Return the reply @@ -452,9 +452,9 @@ xcb_xf86dri_query_version_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_xf86dri_query_version_reply_t * -xcb_xf86dri_query_version_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_query_version_reply (xcb_connection_t *c, xcb_xf86dri_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -465,8 +465,8 @@ xcb_xf86dri_query_version_reply (xcb_connection_t *c /**< */ * */ xcb_xf86dri_query_direct_rendering_capable_cookie_t -xcb_xf86dri_query_direct_rendering_capable (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xf86dri_query_direct_rendering_capable (xcb_connection_t *c, + uint32_t screen); /** * @@ -480,8 +480,8 @@ xcb_xf86dri_query_direct_rendering_capable (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xf86dri_query_direct_rendering_capable_cookie_t -xcb_xf86dri_query_direct_rendering_capable_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xf86dri_query_direct_rendering_capable_unchecked (xcb_connection_t *c, + uint32_t screen); /** * Return the reply @@ -498,12 +498,12 @@ xcb_xf86dri_query_direct_rendering_capable_unchecked (xcb_connection_t *c /**< * The returned value must be freed by the caller using free(). */ xcb_xf86dri_query_direct_rendering_capable_reply_t * -xcb_xf86dri_query_direct_rendering_capable_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_query_direct_rendering_capable_reply (xcb_connection_t *c, xcb_xf86dri_query_direct_rendering_capable_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xf86dri_open_connection_sizeof (const void *_buffer /**< */); +xcb_xf86dri_open_connection_sizeof (const void *_buffer); /** * @@ -514,8 +514,8 @@ xcb_xf86dri_open_connection_sizeof (const void *_buffer /**< */); * */ xcb_xf86dri_open_connection_cookie_t -xcb_xf86dri_open_connection (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xf86dri_open_connection (xcb_connection_t *c, + uint32_t screen); /** * @@ -529,17 +529,17 @@ xcb_xf86dri_open_connection (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xf86dri_open_connection_cookie_t -xcb_xf86dri_open_connection_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xf86dri_open_connection_unchecked (xcb_connection_t *c, + uint32_t screen); char * -xcb_xf86dri_open_connection_bus_id (const xcb_xf86dri_open_connection_reply_t *R /**< */); +xcb_xf86dri_open_connection_bus_id (const xcb_xf86dri_open_connection_reply_t *R); int -xcb_xf86dri_open_connection_bus_id_length (const xcb_xf86dri_open_connection_reply_t *R /**< */); +xcb_xf86dri_open_connection_bus_id_length (const xcb_xf86dri_open_connection_reply_t *R); xcb_generic_iterator_t -xcb_xf86dri_open_connection_bus_id_end (const xcb_xf86dri_open_connection_reply_t *R /**< */); +xcb_xf86dri_open_connection_bus_id_end (const xcb_xf86dri_open_connection_reply_t *R); /** * Return the reply @@ -556,9 +556,9 @@ xcb_xf86dri_open_connection_bus_id_end (const xcb_xf86dri_open_connection_reply_ * The returned value must be freed by the caller using free(). */ xcb_xf86dri_open_connection_reply_t * -xcb_xf86dri_open_connection_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_open_connection_reply (xcb_connection_t *c, xcb_xf86dri_open_connection_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -572,8 +572,8 @@ xcb_xf86dri_open_connection_reply (xcb_connection_t *c /** * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xf86dri_close_connection_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xf86dri_close_connection_checked (xcb_connection_t *c, + uint32_t screen); /** * @@ -584,11 +584,11 @@ xcb_xf86dri_close_connection_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xf86dri_close_connection (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xf86dri_close_connection (xcb_connection_t *c, + uint32_t screen); int -xcb_xf86dri_get_client_driver_name_sizeof (const void *_buffer /**< */); +xcb_xf86dri_get_client_driver_name_sizeof (const void *_buffer); /** * @@ -599,8 +599,8 @@ xcb_xf86dri_get_client_driver_name_sizeof (const void *_buffer /**< */); * */ xcb_xf86dri_get_client_driver_name_cookie_t -xcb_xf86dri_get_client_driver_name (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xf86dri_get_client_driver_name (xcb_connection_t *c, + uint32_t screen); /** * @@ -614,17 +614,17 @@ xcb_xf86dri_get_client_driver_name (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xf86dri_get_client_driver_name_cookie_t -xcb_xf86dri_get_client_driver_name_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xf86dri_get_client_driver_name_unchecked (xcb_connection_t *c, + uint32_t screen); char * -xcb_xf86dri_get_client_driver_name_client_driver_name (const xcb_xf86dri_get_client_driver_name_reply_t *R /**< */); +xcb_xf86dri_get_client_driver_name_client_driver_name (const xcb_xf86dri_get_client_driver_name_reply_t *R); int -xcb_xf86dri_get_client_driver_name_client_driver_name_length (const xcb_xf86dri_get_client_driver_name_reply_t *R /**< */); +xcb_xf86dri_get_client_driver_name_client_driver_name_length (const xcb_xf86dri_get_client_driver_name_reply_t *R); xcb_generic_iterator_t -xcb_xf86dri_get_client_driver_name_client_driver_name_end (const xcb_xf86dri_get_client_driver_name_reply_t *R /**< */); +xcb_xf86dri_get_client_driver_name_client_driver_name_end (const xcb_xf86dri_get_client_driver_name_reply_t *R); /** * Return the reply @@ -641,9 +641,9 @@ xcb_xf86dri_get_client_driver_name_client_driver_name_end (const xcb_xf86dri_get * The returned value must be freed by the caller using free(). */ xcb_xf86dri_get_client_driver_name_reply_t * -xcb_xf86dri_get_client_driver_name_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_get_client_driver_name_reply (xcb_connection_t *c, xcb_xf86dri_get_client_driver_name_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -654,10 +654,10 @@ xcb_xf86dri_get_client_driver_name_reply (xcb_connection_t * */ xcb_xf86dri_create_context_cookie_t -xcb_xf86dri_create_context (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t visual /**< */, - uint32_t context /**< */); +xcb_xf86dri_create_context (xcb_connection_t *c, + uint32_t screen, + uint32_t visual, + uint32_t context); /** * @@ -671,10 +671,10 @@ xcb_xf86dri_create_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xf86dri_create_context_cookie_t -xcb_xf86dri_create_context_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t visual /**< */, - uint32_t context /**< */); +xcb_xf86dri_create_context_unchecked (xcb_connection_t *c, + uint32_t screen, + uint32_t visual, + uint32_t context); /** * Return the reply @@ -691,9 +691,9 @@ xcb_xf86dri_create_context_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xf86dri_create_context_reply_t * -xcb_xf86dri_create_context_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_create_context_reply (xcb_connection_t *c, xcb_xf86dri_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -707,9 +707,9 @@ xcb_xf86dri_create_context_reply (xcb_connection_t *c /**< * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xf86dri_destroy_context_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t context /**< */); +xcb_xf86dri_destroy_context_checked (xcb_connection_t *c, + uint32_t screen, + uint32_t context); /** * @@ -720,9 +720,9 @@ xcb_xf86dri_destroy_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xf86dri_destroy_context (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t context /**< */); +xcb_xf86dri_destroy_context (xcb_connection_t *c, + uint32_t screen, + uint32_t context); /** * @@ -733,9 +733,9 @@ xcb_xf86dri_destroy_context (xcb_connection_t *c /**< */, * */ xcb_xf86dri_create_drawable_cookie_t -xcb_xf86dri_create_drawable (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */); +xcb_xf86dri_create_drawable (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable); /** * @@ -749,9 +749,9 @@ xcb_xf86dri_create_drawable (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xf86dri_create_drawable_cookie_t -xcb_xf86dri_create_drawable_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */); +xcb_xf86dri_create_drawable_unchecked (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable); /** * Return the reply @@ -768,9 +768,9 @@ xcb_xf86dri_create_drawable_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xf86dri_create_drawable_reply_t * -xcb_xf86dri_create_drawable_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_create_drawable_reply (xcb_connection_t *c, xcb_xf86dri_create_drawable_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -784,9 +784,9 @@ xcb_xf86dri_create_drawable_reply (xcb_connection_t *c /** * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xf86dri_destroy_drawable_checked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */); +xcb_xf86dri_destroy_drawable_checked (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable); /** * @@ -797,12 +797,12 @@ xcb_xf86dri_destroy_drawable_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xf86dri_destroy_drawable (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */); +xcb_xf86dri_destroy_drawable (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable); int -xcb_xf86dri_get_drawable_info_sizeof (const void *_buffer /**< */); +xcb_xf86dri_get_drawable_info_sizeof (const void *_buffer); /** * @@ -813,9 +813,9 @@ xcb_xf86dri_get_drawable_info_sizeof (const void *_buffer /**< */); * */ xcb_xf86dri_get_drawable_info_cookie_t -xcb_xf86dri_get_drawable_info (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */); +xcb_xf86dri_get_drawable_info (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable); /** * @@ -829,27 +829,27 @@ xcb_xf86dri_get_drawable_info (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xf86dri_get_drawable_info_cookie_t -xcb_xf86dri_get_drawable_info_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t drawable /**< */); +xcb_xf86dri_get_drawable_info_unchecked (xcb_connection_t *c, + uint32_t screen, + uint32_t drawable); xcb_xf86dri_drm_clip_rect_t * -xcb_xf86dri_get_drawable_info_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */); +xcb_xf86dri_get_drawable_info_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R); int -xcb_xf86dri_get_drawable_info_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */); +xcb_xf86dri_get_drawable_info_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R); xcb_xf86dri_drm_clip_rect_iterator_t -xcb_xf86dri_get_drawable_info_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */); +xcb_xf86dri_get_drawable_info_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R); xcb_xf86dri_drm_clip_rect_t * -xcb_xf86dri_get_drawable_info_back_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */); +xcb_xf86dri_get_drawable_info_back_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R); int -xcb_xf86dri_get_drawable_info_back_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */); +xcb_xf86dri_get_drawable_info_back_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R); xcb_xf86dri_drm_clip_rect_iterator_t -xcb_xf86dri_get_drawable_info_back_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R /**< */); +xcb_xf86dri_get_drawable_info_back_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R); /** * Return the reply @@ -866,12 +866,12 @@ xcb_xf86dri_get_drawable_info_back_clip_rects_iterator (const xcb_xf86dri_get_dr * The returned value must be freed by the caller using free(). */ xcb_xf86dri_get_drawable_info_reply_t * -xcb_xf86dri_get_drawable_info_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_get_drawable_info_reply (xcb_connection_t *c, xcb_xf86dri_get_drawable_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xf86dri_get_device_info_sizeof (const void *_buffer /**< */); +xcb_xf86dri_get_device_info_sizeof (const void *_buffer); /** * @@ -882,8 +882,8 @@ xcb_xf86dri_get_device_info_sizeof (const void *_buffer /**< */); * */ xcb_xf86dri_get_device_info_cookie_t -xcb_xf86dri_get_device_info (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xf86dri_get_device_info (xcb_connection_t *c, + uint32_t screen); /** * @@ -897,17 +897,17 @@ xcb_xf86dri_get_device_info (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xf86dri_get_device_info_cookie_t -xcb_xf86dri_get_device_info_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */); +xcb_xf86dri_get_device_info_unchecked (xcb_connection_t *c, + uint32_t screen); uint32_t * -xcb_xf86dri_get_device_info_device_private (const xcb_xf86dri_get_device_info_reply_t *R /**< */); +xcb_xf86dri_get_device_info_device_private (const xcb_xf86dri_get_device_info_reply_t *R); int -xcb_xf86dri_get_device_info_device_private_length (const xcb_xf86dri_get_device_info_reply_t *R /**< */); +xcb_xf86dri_get_device_info_device_private_length (const xcb_xf86dri_get_device_info_reply_t *R); xcb_generic_iterator_t -xcb_xf86dri_get_device_info_device_private_end (const xcb_xf86dri_get_device_info_reply_t *R /**< */); +xcb_xf86dri_get_device_info_device_private_end (const xcb_xf86dri_get_device_info_reply_t *R); /** * Return the reply @@ -924,9 +924,9 @@ xcb_xf86dri_get_device_info_device_private_end (const xcb_xf86dri_get_device_inf * The returned value must be freed by the caller using free(). */ xcb_xf86dri_get_device_info_reply_t * -xcb_xf86dri_get_device_info_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_get_device_info_reply (xcb_connection_t *c, xcb_xf86dri_get_device_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -937,9 +937,9 @@ xcb_xf86dri_get_device_info_reply (xcb_connection_t *c /** * */ xcb_xf86dri_auth_connection_cookie_t -xcb_xf86dri_auth_connection (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t magic /**< */); +xcb_xf86dri_auth_connection (xcb_connection_t *c, + uint32_t screen, + uint32_t magic); /** * @@ -953,9 +953,9 @@ xcb_xf86dri_auth_connection (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xf86dri_auth_connection_cookie_t -xcb_xf86dri_auth_connection_unchecked (xcb_connection_t *c /**< */, - uint32_t screen /**< */, - uint32_t magic /**< */); +xcb_xf86dri_auth_connection_unchecked (xcb_connection_t *c, + uint32_t screen, + uint32_t magic); /** * Return the reply @@ -972,9 +972,9 @@ xcb_xf86dri_auth_connection_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xf86dri_auth_connection_reply_t * -xcb_xf86dri_auth_connection_reply (xcb_connection_t *c /**< */, +xcb_xf86dri_auth_connection_reply (xcb_connection_t *c, xcb_xf86dri_auth_connection_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/xfixes.c b/lib/libxcb/src/xfixes.c index a10868c44..cc1642aa5 100644 --- a/lib/libxcb/src/xfixes.c +++ b/lib/libxcb/src/xfixes.c @@ -21,15 +21,15 @@ xcb_extension_t xcb_xfixes_id = { "XFIXES", 0 }; xcb_xfixes_query_version_cookie_t -xcb_xfixes_query_version (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */) +xcb_xfixes_query_version (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -49,15 +49,15 @@ xcb_xfixes_query_version (xcb_connection_t *c /**< */, } xcb_xfixes_query_version_cookie_t -xcb_xfixes_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */) +xcb_xfixes_query_version_unchecked (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -77,25 +77,25 @@ xcb_xfixes_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_xfixes_query_version_reply_t * -xcb_xfixes_query_version_reply (xcb_connection_t *c /**< */, +xcb_xfixes_query_version_reply (xcb_connection_t *c, xcb_xfixes_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xfixes_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xfixes_change_save_set_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - uint8_t target /**< */, - uint8_t map /**< */, - xcb_window_t window /**< */) +xcb_xfixes_change_save_set_checked (xcb_connection_t *c, + uint8_t mode, + uint8_t target, + uint8_t map, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CHANGE_SAVE_SET, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_SAVE_SET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -118,17 +118,17 @@ xcb_xfixes_change_save_set_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_change_save_set (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - uint8_t target /**< */, - uint8_t map /**< */, - xcb_window_t window /**< */) +xcb_xfixes_change_save_set (xcb_connection_t *c, + uint8_t mode, + uint8_t target, + uint8_t map, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CHANGE_SAVE_SET, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_SAVE_SET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -151,16 +151,16 @@ xcb_xfixes_change_save_set (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_select_selection_input_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t selection /**< */, - uint32_t event_mask /**< */) +xcb_xfixes_select_selection_input_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t selection, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SELECT_SELECTION_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SELECT_SELECTION_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -181,16 +181,16 @@ xcb_xfixes_select_selection_input_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_select_selection_input (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t selection /**< */, - uint32_t event_mask /**< */) +xcb_xfixes_select_selection_input (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t selection, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SELECT_SELECTION_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SELECT_SELECTION_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -211,15 +211,15 @@ xcb_xfixes_select_selection_input (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t event_mask /**< */) +xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c, + xcb_window_t window, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SELECT_CURSOR_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SELECT_CURSOR_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -239,15 +239,15 @@ xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_select_cursor_input (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t event_mask /**< */) +xcb_xfixes_select_cursor_input (xcb_connection_t *c, + xcb_window_t window, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SELECT_CURSOR_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SELECT_CURSOR_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -267,7 +267,7 @@ xcb_xfixes_select_cursor_input (xcb_connection_t *c /**< */, } int -xcb_xfixes_get_cursor_image_sizeof (const void *_buffer /**< */) +xcb_xfixes_get_cursor_image_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xfixes_get_cursor_image_reply_t *_aux = (xcb_xfixes_get_cursor_image_reply_t *)_buffer; @@ -298,13 +298,13 @@ xcb_xfixes_get_cursor_image_sizeof (const void *_buffer /**< */) } xcb_xfixes_get_cursor_image_cookie_t -xcb_xfixes_get_cursor_image (xcb_connection_t *c /**< */) +xcb_xfixes_get_cursor_image (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_GET_CURSOR_IMAGE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_IMAGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -322,13 +322,13 @@ xcb_xfixes_get_cursor_image (xcb_connection_t *c /**< */) } xcb_xfixes_get_cursor_image_cookie_t -xcb_xfixes_get_cursor_image_unchecked (xcb_connection_t *c /**< */) +xcb_xfixes_get_cursor_image_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_GET_CURSOR_IMAGE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_IMAGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -346,19 +346,19 @@ xcb_xfixes_get_cursor_image_unchecked (xcb_connection_t *c /**< */) } uint32_t * -xcb_xfixes_get_cursor_image_cursor_image (const xcb_xfixes_get_cursor_image_reply_t *R /**< */) +xcb_xfixes_get_cursor_image_cursor_image (const xcb_xfixes_get_cursor_image_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_xfixes_get_cursor_image_cursor_image_length (const xcb_xfixes_get_cursor_image_reply_t *R /**< */) +xcb_xfixes_get_cursor_image_cursor_image_length (const xcb_xfixes_get_cursor_image_reply_t *R) { return (R->width * R->height); } xcb_generic_iterator_t -xcb_xfixes_get_cursor_image_cursor_image_end (const xcb_xfixes_get_cursor_image_reply_t *R /**< */) +xcb_xfixes_get_cursor_image_cursor_image_end (const xcb_xfixes_get_cursor_image_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + ((R->width * R->height)); @@ -368,15 +368,15 @@ xcb_xfixes_get_cursor_image_cursor_image_end (const xcb_xfixes_get_cursor_image_ } xcb_xfixes_get_cursor_image_reply_t * -xcb_xfixes_get_cursor_image_reply (xcb_connection_t *c /**< */, +xcb_xfixes_get_cursor_image_reply (xcb_connection_t *c, xcb_xfixes_get_cursor_image_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xfixes_get_cursor_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } void -xcb_xfixes_region_next (xcb_xfixes_region_iterator_t *i /**< */) +xcb_xfixes_region_next (xcb_xfixes_region_iterator_t *i) { --i->rem; ++i->data; @@ -384,7 +384,7 @@ xcb_xfixes_region_next (xcb_xfixes_region_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xfixes_region_end (xcb_xfixes_region_iterator_t i /**< */) +xcb_xfixes_region_end (xcb_xfixes_region_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -394,8 +394,8 @@ xcb_xfixes_region_end (xcb_xfixes_region_iterator_t i /**< */) } int -xcb_xfixes_create_region_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */) +xcb_xfixes_create_region_sizeof (const void *_buffer, + uint32_t rectangles_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -425,16 +425,16 @@ xcb_xfixes_create_region_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_xfixes_create_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_xfixes_create_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_REGION, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -458,16 +458,16 @@ xcb_xfixes_create_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_create_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_xfixes_create_region (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_REGION, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -490,16 +490,38 @@ xcb_xfixes_create_region (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_rectangle_t * +xcb_xfixes_create_region_rectangles (const xcb_xfixes_create_region_request_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + +int +xcb_xfixes_create_region_rectangles_length (const xcb_xfixes_create_region_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_xfixes_create_region_request_t))/sizeof(xcb_rectangle_t)); +} + +xcb_rectangle_iterator_t +xcb_xfixes_create_region_rectangles_iterator (const xcb_xfixes_create_region_request_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_xfixes_create_region_request_t))/sizeof(xcb_rectangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_xfixes_create_region_from_bitmap_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_pixmap_t bitmap /**< */) +xcb_xfixes_create_region_from_bitmap_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_pixmap_t bitmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_REGION_FROM_BITMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_BITMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -519,15 +541,15 @@ xcb_xfixes_create_region_from_bitmap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_create_region_from_bitmap (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_pixmap_t bitmap /**< */) +xcb_xfixes_create_region_from_bitmap (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_pixmap_t bitmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_REGION_FROM_BITMAP, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_BITMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -547,16 +569,16 @@ xcb_xfixes_create_region_from_bitmap (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_create_region_from_window_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_window_t window /**< */, - xcb_shape_kind_t kind /**< */) +xcb_xfixes_create_region_from_window_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_window_t window, + xcb_shape_kind_t kind) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_REGION_FROM_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -578,16 +600,16 @@ xcb_xfixes_create_region_from_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_create_region_from_window (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_window_t window /**< */, - xcb_shape_kind_t kind /**< */) +xcb_xfixes_create_region_from_window (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_window_t window, + xcb_shape_kind_t kind) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_REGION_FROM_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -609,15 +631,15 @@ xcb_xfixes_create_region_from_window (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_create_region_from_gc_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_gcontext_t gc /**< */) +xcb_xfixes_create_region_from_gc_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_gcontext_t gc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_REGION_FROM_GC, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_GC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -637,15 +659,15 @@ xcb_xfixes_create_region_from_gc_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_create_region_from_gc (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_gcontext_t gc /**< */) +xcb_xfixes_create_region_from_gc (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_gcontext_t gc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_REGION_FROM_GC, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_GC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -665,15 +687,15 @@ xcb_xfixes_create_region_from_gc (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_create_region_from_picture_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_render_picture_t picture /**< */) +xcb_xfixes_create_region_from_picture_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_render_picture_t picture) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_REGION_FROM_PICTURE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_PICTURE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -693,15 +715,15 @@ xcb_xfixes_create_region_from_picture_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_create_region_from_picture (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_render_picture_t picture /**< */) +xcb_xfixes_create_region_from_picture (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_render_picture_t picture) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_REGION_FROM_PICTURE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_PICTURE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -721,14 +743,14 @@ xcb_xfixes_create_region_from_picture (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_destroy_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */) +xcb_xfixes_destroy_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_DESTROY_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_DESTROY_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -747,14 +769,14 @@ xcb_xfixes_destroy_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_destroy_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */) +xcb_xfixes_destroy_region (xcb_connection_t *c, + xcb_xfixes_region_t region) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_DESTROY_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_DESTROY_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -773,8 +795,8 @@ xcb_xfixes_destroy_region (xcb_connection_t *c /**< */, } int -xcb_xfixes_set_region_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */) +xcb_xfixes_set_region_sizeof (const void *_buffer, + uint32_t rectangles_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -804,16 +826,16 @@ xcb_xfixes_set_region_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_xfixes_set_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_xfixes_set_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SET_REGION, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_REGION, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -837,16 +859,16 @@ xcb_xfixes_set_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_set_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_xfixes_set_region (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SET_REGION, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_REGION, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -869,16 +891,38 @@ xcb_xfixes_set_region (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_rectangle_t * +xcb_xfixes_set_region_rectangles (const xcb_xfixes_set_region_request_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + +int +xcb_xfixes_set_region_rectangles_length (const xcb_xfixes_set_region_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_xfixes_set_region_request_t))/sizeof(xcb_rectangle_t)); +} + +xcb_rectangle_iterator_t +xcb_xfixes_set_region_rectangles_iterator (const xcb_xfixes_set_region_request_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_xfixes_set_region_request_t))/sizeof(xcb_rectangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_xfixes_copy_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_copy_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_COPY_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_COPY_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -898,15 +942,15 @@ xcb_xfixes_copy_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_copy_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_copy_region (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_COPY_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_COPY_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -926,16 +970,16 @@ xcb_xfixes_copy_region (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_union_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_union_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_UNION_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_UNION_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -956,16 +1000,16 @@ xcb_xfixes_union_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_union_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_union_region (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_UNION_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_UNION_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -986,16 +1030,16 @@ xcb_xfixes_union_region (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_intersect_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_intersect_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_INTERSECT_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_INTERSECT_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1016,16 +1060,16 @@ xcb_xfixes_intersect_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_intersect_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_intersect_region (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_INTERSECT_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_INTERSECT_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1046,16 +1090,16 @@ xcb_xfixes_intersect_region (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_subtract_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_subtract_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SUBTRACT_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SUBTRACT_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1076,16 +1120,16 @@ xcb_xfixes_subtract_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_subtract_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_subtract_region (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SUBTRACT_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SUBTRACT_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1106,16 +1150,16 @@ xcb_xfixes_subtract_region (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_invert_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_rectangle_t bounds /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_invert_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_rectangle_t bounds, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_INVERT_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_INVERT_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1136,16 +1180,16 @@ xcb_xfixes_invert_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_invert_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_rectangle_t bounds /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_invert_region (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_rectangle_t bounds, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_INVERT_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_INVERT_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1166,16 +1210,16 @@ xcb_xfixes_invert_region (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_translate_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - int16_t dx /**< */, - int16_t dy /**< */) +xcb_xfixes_translate_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + int16_t dx, + int16_t dy) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_TRANSLATE_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_TRANSLATE_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1196,16 +1240,16 @@ xcb_xfixes_translate_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_translate_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - int16_t dx /**< */, - int16_t dy /**< */) +xcb_xfixes_translate_region (xcb_connection_t *c, + xcb_xfixes_region_t region, + int16_t dx, + int16_t dy) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_TRANSLATE_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_TRANSLATE_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1226,15 +1270,15 @@ xcb_xfixes_translate_region (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_region_extents_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_region_extents_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_REGION_EXTENTS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_REGION_EXTENTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1254,15 +1298,15 @@ xcb_xfixes_region_extents_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_region_extents (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */) +xcb_xfixes_region_extents (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_REGION_EXTENTS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_REGION_EXTENTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1282,7 +1326,7 @@ xcb_xfixes_region_extents (xcb_connection_t *c /**< */, } int -xcb_xfixes_fetch_region_sizeof (const void *_buffer /**< */) +xcb_xfixes_fetch_region_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xfixes_fetch_region_reply_t *_aux = (xcb_xfixes_fetch_region_reply_t *)_buffer; @@ -1313,14 +1357,14 @@ xcb_xfixes_fetch_region_sizeof (const void *_buffer /**< */) } xcb_xfixes_fetch_region_cookie_t -xcb_xfixes_fetch_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */) +xcb_xfixes_fetch_region (xcb_connection_t *c, + xcb_xfixes_region_t region) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_FETCH_REGION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_FETCH_REGION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1339,14 +1383,14 @@ xcb_xfixes_fetch_region (xcb_connection_t *c /**< */, } xcb_xfixes_fetch_region_cookie_t -xcb_xfixes_fetch_region_unchecked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */) +xcb_xfixes_fetch_region_unchecked (xcb_connection_t *c, + xcb_xfixes_region_t region) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_FETCH_REGION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_FETCH_REGION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1365,19 +1409,19 @@ xcb_xfixes_fetch_region_unchecked (xcb_connection_t *c /**< */, } xcb_rectangle_t * -xcb_xfixes_fetch_region_rectangles (const xcb_xfixes_fetch_region_reply_t *R /**< */) +xcb_xfixes_fetch_region_rectangles (const xcb_xfixes_fetch_region_reply_t *R) { return (xcb_rectangle_t *) (R + 1); } int -xcb_xfixes_fetch_region_rectangles_length (const xcb_xfixes_fetch_region_reply_t *R /**< */) +xcb_xfixes_fetch_region_rectangles_length (const xcb_xfixes_fetch_region_reply_t *R) { return (R->length / 2); } xcb_rectangle_iterator_t -xcb_xfixes_fetch_region_rectangles_iterator (const xcb_xfixes_fetch_region_reply_t *R /**< */) +xcb_xfixes_fetch_region_rectangles_iterator (const xcb_xfixes_fetch_region_reply_t *R) { xcb_rectangle_iterator_t i; i.data = (xcb_rectangle_t *) (R + 1); @@ -1387,25 +1431,25 @@ xcb_xfixes_fetch_region_rectangles_iterator (const xcb_xfixes_fetch_region_reply } xcb_xfixes_fetch_region_reply_t * -xcb_xfixes_fetch_region_reply (xcb_connection_t *c /**< */, +xcb_xfixes_fetch_region_reply (xcb_connection_t *c, xcb_xfixes_fetch_region_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xfixes_fetch_region_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - xcb_xfixes_region_t region /**< */, - int16_t x_origin /**< */, - int16_t y_origin /**< */) +xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t *c, + xcb_gcontext_t gc, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SET_GC_CLIP_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_GC_CLIP_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1427,17 +1471,17 @@ xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_set_gc_clip_region (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - xcb_xfixes_region_t region /**< */, - int16_t x_origin /**< */, - int16_t y_origin /**< */) +xcb_xfixes_set_gc_clip_region (xcb_connection_t *c, + xcb_gcontext_t gc, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SET_GC_CLIP_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_GC_CLIP_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1459,18 +1503,18 @@ xcb_xfixes_set_gc_clip_region (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_set_window_shape_region_checked (xcb_connection_t *c /**< */, - xcb_window_t dest /**< */, - xcb_shape_kind_t dest_kind /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_xfixes_region_t region /**< */) +xcb_xfixes_set_window_shape_region_checked (xcb_connection_t *c, + xcb_window_t dest, + xcb_shape_kind_t dest_kind, + int16_t x_offset, + int16_t y_offset, + xcb_xfixes_region_t region) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SET_WINDOW_SHAPE_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_WINDOW_SHAPE_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1494,18 +1538,18 @@ xcb_xfixes_set_window_shape_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_set_window_shape_region (xcb_connection_t *c /**< */, - xcb_window_t dest /**< */, - xcb_shape_kind_t dest_kind /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_xfixes_region_t region /**< */) +xcb_xfixes_set_window_shape_region (xcb_connection_t *c, + xcb_window_t dest, + xcb_shape_kind_t dest_kind, + int16_t x_offset, + int16_t y_offset, + xcb_xfixes_region_t region) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SET_WINDOW_SHAPE_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_WINDOW_SHAPE_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1529,17 +1573,17 @@ xcb_xfixes_set_window_shape_region (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_xfixes_region_t region /**< */, - int16_t x_origin /**< */, - int16_t y_origin /**< */) +xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SET_PICTURE_CLIP_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_PICTURE_CLIP_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1561,17 +1605,17 @@ xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_set_picture_clip_region (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_xfixes_region_t region /**< */, - int16_t x_origin /**< */, - int16_t y_origin /**< */) +xcb_xfixes_set_picture_clip_region (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SET_PICTURE_CLIP_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_PICTURE_CLIP_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1593,7 +1637,7 @@ xcb_xfixes_set_picture_clip_region (xcb_connection_t *c /**< */, } int -xcb_xfixes_set_cursor_name_sizeof (const void *_buffer /**< */) +xcb_xfixes_set_cursor_name_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xfixes_set_cursor_name_request_t *_aux = (xcb_xfixes_set_cursor_name_request_t *)_buffer; @@ -1624,16 +1668,16 @@ xcb_xfixes_set_cursor_name_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - uint16_t nbytes /**< */, - const char *name /**< */) +xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c, + xcb_cursor_t cursor, + uint16_t nbytes, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SET_CURSOR_NAME, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_CURSOR_NAME, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1659,16 +1703,16 @@ xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_set_cursor_name (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - uint16_t nbytes /**< */, - const char *name /**< */) +xcb_xfixes_set_cursor_name (xcb_connection_t *c, + xcb_cursor_t cursor, + uint16_t nbytes, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SET_CURSOR_NAME, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_CURSOR_NAME, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1693,8 +1737,30 @@ xcb_xfixes_set_cursor_name (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_xfixes_set_cursor_name_name (const xcb_xfixes_set_cursor_name_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_xfixes_get_cursor_name_sizeof (const void *_buffer /**< */) +xcb_xfixes_set_cursor_name_name_length (const xcb_xfixes_set_cursor_name_request_t *R) +{ + return R->nbytes; +} + +xcb_generic_iterator_t +xcb_xfixes_set_cursor_name_name_end (const xcb_xfixes_set_cursor_name_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->nbytes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_xfixes_get_cursor_name_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xfixes_get_cursor_name_reply_t *_aux = (xcb_xfixes_get_cursor_name_reply_t *)_buffer; @@ -1725,14 +1791,14 @@ xcb_xfixes_get_cursor_name_sizeof (const void *_buffer /**< */) } xcb_xfixes_get_cursor_name_cookie_t -xcb_xfixes_get_cursor_name (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */) +xcb_xfixes_get_cursor_name (xcb_connection_t *c, + xcb_cursor_t cursor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_GET_CURSOR_NAME, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_NAME, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1751,14 +1817,14 @@ xcb_xfixes_get_cursor_name (xcb_connection_t *c /**< */, } xcb_xfixes_get_cursor_name_cookie_t -xcb_xfixes_get_cursor_name_unchecked (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */) +xcb_xfixes_get_cursor_name_unchecked (xcb_connection_t *c, + xcb_cursor_t cursor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_GET_CURSOR_NAME, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_NAME, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1777,19 +1843,19 @@ xcb_xfixes_get_cursor_name_unchecked (xcb_connection_t *c /**< */, } char * -xcb_xfixes_get_cursor_name_name (const xcb_xfixes_get_cursor_name_reply_t *R /**< */) +xcb_xfixes_get_cursor_name_name (const xcb_xfixes_get_cursor_name_reply_t *R) { return (char *) (R + 1); } int -xcb_xfixes_get_cursor_name_name_length (const xcb_xfixes_get_cursor_name_reply_t *R /**< */) +xcb_xfixes_get_cursor_name_name_length (const xcb_xfixes_get_cursor_name_reply_t *R) { return R->nbytes; } xcb_generic_iterator_t -xcb_xfixes_get_cursor_name_name_end (const xcb_xfixes_get_cursor_name_reply_t *R /**< */) +xcb_xfixes_get_cursor_name_name_end (const xcb_xfixes_get_cursor_name_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->nbytes); @@ -1799,15 +1865,15 @@ xcb_xfixes_get_cursor_name_name_end (const xcb_xfixes_get_cursor_name_reply_t *R } xcb_xfixes_get_cursor_name_reply_t * -xcb_xfixes_get_cursor_name_reply (xcb_connection_t *c /**< */, +xcb_xfixes_get_cursor_name_reply (xcb_connection_t *c, xcb_xfixes_get_cursor_name_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xfixes_get_cursor_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer /**< */) +xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xfixes_get_cursor_image_and_name_reply_t *_aux = (xcb_xfixes_get_cursor_image_and_name_reply_t *)_buffer; @@ -1821,10 +1887,10 @@ xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer /**< */) xcb_tmp += xcb_block_len; xcb_buffer_len += xcb_block_len; xcb_block_len = 0; - /* name */ - xcb_block_len += _aux->nbytes * sizeof(char); + /* cursor_image */ + xcb_block_len += (_aux->width * _aux->height) * sizeof(uint32_t); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(char); + xcb_align_to = ALIGNOF(uint32_t); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -1833,10 +1899,10 @@ xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer /**< */) xcb_pad = 0; } xcb_block_len = 0; - /* cursor_image */ - xcb_block_len += (_aux->width * _aux->height) * sizeof(uint32_t); + /* name */ + xcb_block_len += _aux->nbytes * sizeof(char); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -1850,13 +1916,13 @@ xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer /**< */) } xcb_xfixes_get_cursor_image_and_name_cookie_t -xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c /**< */) +xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_GET_CURSOR_IMAGE_AND_NAME, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_IMAGE_AND_NAME, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1874,13 +1940,13 @@ xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c /**< */) } xcb_xfixes_get_cursor_image_and_name_cookie_t -xcb_xfixes_get_cursor_image_and_name_unchecked (xcb_connection_t *c /**< */) +xcb_xfixes_get_cursor_image_and_name_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_GET_CURSOR_IMAGE_AND_NAME, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_IMAGE_AND_NAME, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1897,70 +1963,70 @@ xcb_xfixes_get_cursor_image_and_name_unchecked (xcb_connection_t *c /**< */) return xcb_ret; } -char * -xcb_xfixes_get_cursor_image_and_name_name (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */) -{ - return (char *) (R + 1); -} - -int -xcb_xfixes_get_cursor_image_and_name_name_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */) -{ - return R->nbytes; -} - -xcb_generic_iterator_t -xcb_xfixes_get_cursor_image_and_name_name_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */) -{ - xcb_generic_iterator_t i; - i.data = ((char *) (R + 1)) + (R->nbytes); - i.rem = 0; - i.index = (char *) i.data - (char *) R; - return i; -} - uint32_t * -xcb_xfixes_get_cursor_image_and_name_cursor_image (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */) +xcb_xfixes_get_cursor_image_and_name_cursor_image (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) { - xcb_generic_iterator_t prev = xcb_xfixes_get_cursor_image_and_name_name_end(R); - return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); + return (uint32_t *) (R + 1); } int -xcb_xfixes_get_cursor_image_and_name_cursor_image_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */) +xcb_xfixes_get_cursor_image_and_name_cursor_image_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) { return (R->width * R->height); } xcb_generic_iterator_t -xcb_xfixes_get_cursor_image_and_name_cursor_image_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */) +xcb_xfixes_get_cursor_image_and_name_cursor_image_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_xfixes_get_cursor_image_and_name_name_end(R); - i.data = ((uint32_t *) child.data) + ((R->width * R->height)); + i.data = ((uint32_t *) (R + 1)) + ((R->width * R->height)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +char * +xcb_xfixes_get_cursor_image_and_name_name (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) +{ + xcb_generic_iterator_t prev = xcb_xfixes_get_cursor_image_and_name_cursor_image_end(R); + return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); +} + +int +xcb_xfixes_get_cursor_image_and_name_name_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) +{ + return R->nbytes; +} + +xcb_generic_iterator_t +xcb_xfixes_get_cursor_image_and_name_name_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_xfixes_get_cursor_image_and_name_cursor_image_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->nbytes); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_xfixes_get_cursor_image_and_name_reply_t * -xcb_xfixes_get_cursor_image_and_name_reply (xcb_connection_t *c /**< */, +xcb_xfixes_get_cursor_image_and_name_reply (xcb_connection_t *c, xcb_xfixes_get_cursor_image_and_name_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xfixes_get_cursor_image_and_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xfixes_change_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t source /**< */, - xcb_cursor_t destination /**< */) +xcb_xfixes_change_cursor_checked (xcb_connection_t *c, + xcb_cursor_t source, + xcb_cursor_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CHANGE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1980,15 +2046,15 @@ xcb_xfixes_change_cursor_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_change_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t source /**< */, - xcb_cursor_t destination /**< */) +xcb_xfixes_change_cursor (xcb_connection_t *c, + xcb_cursor_t source, + xcb_cursor_t destination) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CHANGE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2008,7 +2074,7 @@ xcb_xfixes_change_cursor (xcb_connection_t *c /**< */, } int -xcb_xfixes_change_cursor_by_name_sizeof (const void *_buffer /**< */) +xcb_xfixes_change_cursor_by_name_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xfixes_change_cursor_by_name_request_t *_aux = (xcb_xfixes_change_cursor_by_name_request_t *)_buffer; @@ -2039,16 +2105,16 @@ xcb_xfixes_change_cursor_by_name_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c /**< */, - xcb_cursor_t src /**< */, - uint16_t nbytes /**< */, - const char *name /**< */) +xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c, + xcb_cursor_t src, + uint16_t nbytes, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CHANGE_CURSOR_BY_NAME, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_CURSOR_BY_NAME, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2074,16 +2140,16 @@ xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_change_cursor_by_name (xcb_connection_t *c /**< */, - xcb_cursor_t src /**< */, - uint16_t nbytes /**< */, - const char *name /**< */) +xcb_xfixes_change_cursor_by_name (xcb_connection_t *c, + xcb_cursor_t src, + uint16_t nbytes, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CHANGE_CURSOR_BY_NAME, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_CURSOR_BY_NAME, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2108,20 +2174,42 @@ xcb_xfixes_change_cursor_by_name (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_xfixes_change_cursor_by_name_name (const xcb_xfixes_change_cursor_by_name_request_t *R) +{ + return (char *) (R + 1); +} + +int +xcb_xfixes_change_cursor_by_name_name_length (const xcb_xfixes_change_cursor_by_name_request_t *R) +{ + return R->nbytes; +} + +xcb_generic_iterator_t +xcb_xfixes_change_cursor_by_name_name_end (const xcb_xfixes_change_cursor_by_name_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->nbytes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_xfixes_expand_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */, - uint16_t left /**< */, - uint16_t right /**< */, - uint16_t top /**< */, - uint16_t bottom /**< */) +xcb_xfixes_expand_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination, + uint16_t left, + uint16_t right, + uint16_t top, + uint16_t bottom) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_EXPAND_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_EXPAND_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2145,19 +2233,19 @@ xcb_xfixes_expand_region_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_expand_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */, - uint16_t left /**< */, - uint16_t right /**< */, - uint16_t top /**< */, - uint16_t bottom /**< */) +xcb_xfixes_expand_region (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination, + uint16_t left, + uint16_t right, + uint16_t top, + uint16_t bottom) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_EXPAND_REGION, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_EXPAND_REGION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2181,14 +2269,14 @@ xcb_xfixes_expand_region (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_hide_cursor_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_xfixes_hide_cursor_checked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_HIDE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_HIDE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2207,14 +2295,14 @@ xcb_xfixes_hide_cursor_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_hide_cursor (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_xfixes_hide_cursor (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_HIDE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_HIDE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2233,14 +2321,14 @@ xcb_xfixes_hide_cursor (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_show_cursor_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_xfixes_show_cursor_checked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SHOW_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SHOW_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2259,14 +2347,14 @@ xcb_xfixes_show_cursor_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_show_cursor (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_xfixes_show_cursor (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_SHOW_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SHOW_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2285,7 +2373,7 @@ xcb_xfixes_show_cursor (xcb_connection_t *c /**< */, } void -xcb_xfixes_barrier_next (xcb_xfixes_barrier_iterator_t *i /**< */) +xcb_xfixes_barrier_next (xcb_xfixes_barrier_iterator_t *i) { --i->rem; ++i->data; @@ -2293,7 +2381,7 @@ xcb_xfixes_barrier_next (xcb_xfixes_barrier_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xfixes_barrier_end (xcb_xfixes_barrier_iterator_t i /**< */) +xcb_xfixes_barrier_end (xcb_xfixes_barrier_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2303,7 +2391,7 @@ xcb_xfixes_barrier_end (xcb_xfixes_barrier_iterator_t i /**< */) } int -xcb_xfixes_create_pointer_barrier_sizeof (const void *_buffer /**< */) +xcb_xfixes_create_pointer_barrier_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xfixes_create_pointer_barrier_request_t *_aux = (xcb_xfixes_create_pointer_barrier_request_t *)_buffer; @@ -2334,22 +2422,22 @@ xcb_xfixes_create_pointer_barrier_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_xfixes_create_pointer_barrier_checked (xcb_connection_t *c /**< */, - xcb_xfixes_barrier_t barrier /**< */, - xcb_window_t window /**< */, - uint16_t x1 /**< */, - uint16_t y1 /**< */, - uint16_t x2 /**< */, - uint16_t y2 /**< */, - uint32_t directions /**< */, - uint16_t num_devices /**< */, - const uint16_t *devices /**< */) +xcb_xfixes_create_pointer_barrier_checked (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier, + xcb_window_t window, + uint16_t x1, + uint16_t y1, + uint16_t x2, + uint16_t y2, + uint32_t directions, + uint16_t num_devices, + const uint16_t *devices) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_POINTER_BARRIER, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_POINTER_BARRIER, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2381,22 +2469,22 @@ xcb_xfixes_create_pointer_barrier_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_create_pointer_barrier (xcb_connection_t *c /**< */, - xcb_xfixes_barrier_t barrier /**< */, - xcb_window_t window /**< */, - uint16_t x1 /**< */, - uint16_t y1 /**< */, - uint16_t x2 /**< */, - uint16_t y2 /**< */, - uint32_t directions /**< */, - uint16_t num_devices /**< */, - const uint16_t *devices /**< */) +xcb_xfixes_create_pointer_barrier (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier, + xcb_window_t window, + uint16_t x1, + uint16_t y1, + uint16_t x2, + uint16_t y2, + uint32_t directions, + uint16_t num_devices, + const uint16_t *devices) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_CREATE_POINTER_BARRIER, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_POINTER_BARRIER, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2427,15 +2515,37 @@ xcb_xfixes_create_pointer_barrier (xcb_connection_t *c /**< */, return xcb_ret; } +uint16_t * +xcb_xfixes_create_pointer_barrier_devices (const xcb_xfixes_create_pointer_barrier_request_t *R) +{ + return (uint16_t *) (R + 1); +} + +int +xcb_xfixes_create_pointer_barrier_devices_length (const xcb_xfixes_create_pointer_barrier_request_t *R) +{ + return R->num_devices; +} + +xcb_generic_iterator_t +xcb_xfixes_create_pointer_barrier_devices_end (const xcb_xfixes_create_pointer_barrier_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint16_t *) (R + 1)) + (R->num_devices); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_xfixes_delete_pointer_barrier_checked (xcb_connection_t *c /**< */, - xcb_xfixes_barrier_t barrier /**< */) +xcb_xfixes_delete_pointer_barrier_checked (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_DELETE_POINTER_BARRIER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_DELETE_POINTER_BARRIER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2454,14 +2564,14 @@ xcb_xfixes_delete_pointer_barrier_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xfixes_delete_pointer_barrier (xcb_connection_t *c /**< */, - xcb_xfixes_barrier_t barrier /**< */) +xcb_xfixes_delete_pointer_barrier (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xfixes_id, - /* opcode */ XCB_XFIXES_DELETE_POINTER_BARRIER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_DELETE_POINTER_BARRIER, + .isvoid = 1 }; struct iovec xcb_parts[4]; diff --git a/lib/libxcb/src/xfixes.h b/lib/libxcb/src/xfixes.h index 1752ebb3f..358bdb575 100644 --- a/lib/libxcb/src/xfixes.h +++ b/lib/libxcb/src/xfixes.h @@ -30,7 +30,7 @@ extern xcb_extension_t xcb_xfixes_id; * @brief xcb_xfixes_query_version_cookie_t **/ typedef struct xcb_xfixes_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xfixes_query_version_cookie_t; /** Opcode for xcb_xfixes_query_version. */ @@ -40,24 +40,24 @@ typedef struct xcb_xfixes_query_version_cookie_t { * @brief xcb_xfixes_query_version_request_t **/ typedef struct xcb_xfixes_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t client_major_version; /**< */ - uint32_t client_minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t client_major_version; + uint32_t client_minor_version; } xcb_xfixes_query_version_request_t; /** * @brief xcb_xfixes_query_version_reply_t **/ typedef struct xcb_xfixes_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t major_version; /**< */ - uint32_t minor_version; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t major_version; + uint32_t minor_version; + uint8_t pad1[16]; } xcb_xfixes_query_version_reply_t; typedef enum xcb_xfixes_save_set_mode_t { @@ -82,14 +82,14 @@ typedef enum xcb_xfixes_save_set_mapping_t { * @brief xcb_xfixes_change_save_set_request_t **/ typedef struct xcb_xfixes_change_save_set_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t mode; /**< */ - uint8_t target; /**< */ - uint8_t map; /**< */ - uint8_t pad0; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t mode; + uint8_t target; + uint8_t map; + uint8_t pad0; + xcb_window_t window; } xcb_xfixes_change_save_set_request_t; typedef enum xcb_xfixes_selection_event_t { @@ -111,15 +111,15 @@ typedef enum xcb_xfixes_selection_event_mask_t { * @brief xcb_xfixes_selection_notify_event_t **/ typedef struct xcb_xfixes_selection_notify_event_t { - uint8_t response_type; /**< */ - uint8_t subtype; /**< */ - uint16_t sequence; /**< */ - xcb_window_t window; /**< */ - xcb_window_t owner; /**< */ - xcb_atom_t selection; /**< */ - xcb_timestamp_t timestamp; /**< */ - xcb_timestamp_t selection_timestamp; /**< */ - uint8_t pad0[8]; /**< */ + uint8_t response_type; + uint8_t subtype; + uint16_t sequence; + xcb_window_t window; + xcb_window_t owner; + xcb_atom_t selection; + xcb_timestamp_t timestamp; + xcb_timestamp_t selection_timestamp; + uint8_t pad0[8]; } xcb_xfixes_selection_notify_event_t; /** Opcode for xcb_xfixes_select_selection_input. */ @@ -129,12 +129,12 @@ typedef struct xcb_xfixes_selection_notify_event_t { * @brief xcb_xfixes_select_selection_input_request_t **/ typedef struct xcb_xfixes_select_selection_input_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_atom_t selection; /**< */ - uint32_t event_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_atom_t selection; + uint32_t event_mask; } xcb_xfixes_select_selection_input_request_t; typedef enum xcb_xfixes_cursor_notify_t { @@ -152,14 +152,14 @@ typedef enum xcb_xfixes_cursor_notify_mask_t { * @brief xcb_xfixes_cursor_notify_event_t **/ typedef struct xcb_xfixes_cursor_notify_event_t { - uint8_t response_type; /**< */ - uint8_t subtype; /**< */ - uint16_t sequence; /**< */ - xcb_window_t window; /**< */ - uint32_t cursor_serial; /**< */ - xcb_timestamp_t timestamp; /**< */ - xcb_atom_t name; /**< */ - uint8_t pad0[12]; /**< */ + uint8_t response_type; + uint8_t subtype; + uint16_t sequence; + xcb_window_t window; + uint32_t cursor_serial; + xcb_timestamp_t timestamp; + xcb_atom_t name; + uint8_t pad0[12]; } xcb_xfixes_cursor_notify_event_t; /** Opcode for xcb_xfixes_select_cursor_input. */ @@ -169,18 +169,18 @@ typedef struct xcb_xfixes_cursor_notify_event_t { * @brief xcb_xfixes_select_cursor_input_request_t **/ typedef struct xcb_xfixes_select_cursor_input_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint32_t event_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint32_t event_mask; } xcb_xfixes_select_cursor_input_request_t; /** * @brief xcb_xfixes_get_cursor_image_cookie_t **/ typedef struct xcb_xfixes_get_cursor_image_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xfixes_get_cursor_image_cookie_t; /** Opcode for xcb_xfixes_get_cursor_image. */ @@ -190,27 +190,27 @@ typedef struct xcb_xfixes_get_cursor_image_cookie_t { * @brief xcb_xfixes_get_cursor_image_request_t **/ typedef struct xcb_xfixes_get_cursor_image_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_xfixes_get_cursor_image_request_t; /** * @brief xcb_xfixes_get_cursor_image_reply_t **/ typedef struct xcb_xfixes_get_cursor_image_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t xhot; /**< */ - uint16_t yhot; /**< */ - uint32_t cursor_serial; /**< */ - uint8_t pad1[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t xhot; + uint16_t yhot; + uint32_t cursor_serial; + uint8_t pad1[8]; } xcb_xfixes_get_cursor_image_reply_t; typedef uint32_t xcb_xfixes_region_t; @@ -219,9 +219,9 @@ typedef uint32_t xcb_xfixes_region_t; * @brief xcb_xfixes_region_iterator_t **/ typedef struct xcb_xfixes_region_iterator_t { - xcb_xfixes_region_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xfixes_region_t *data; + int rem; + int index; } xcb_xfixes_region_iterator_t; /** Opcode for xcb_xfixes_bad_region. */ @@ -231,9 +231,9 @@ typedef struct xcb_xfixes_region_iterator_t { * @brief xcb_xfixes_bad_region_error_t **/ typedef struct xcb_xfixes_bad_region_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_xfixes_bad_region_error_t; typedef enum xcb_xfixes_region_enum_t { @@ -247,10 +247,10 @@ typedef enum xcb_xfixes_region_enum_t { * @brief xcb_xfixes_create_region_request_t **/ typedef struct xcb_xfixes_create_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t region; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t region; } xcb_xfixes_create_region_request_t; /** Opcode for xcb_xfixes_create_region_from_bitmap. */ @@ -260,11 +260,11 @@ typedef struct xcb_xfixes_create_region_request_t { * @brief xcb_xfixes_create_region_from_bitmap_request_t **/ typedef struct xcb_xfixes_create_region_from_bitmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t region; /**< */ - xcb_pixmap_t bitmap; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t region; + xcb_pixmap_t bitmap; } xcb_xfixes_create_region_from_bitmap_request_t; /** Opcode for xcb_xfixes_create_region_from_window. */ @@ -274,13 +274,13 @@ typedef struct xcb_xfixes_create_region_from_bitmap_request_t { * @brief xcb_xfixes_create_region_from_window_request_t **/ typedef struct xcb_xfixes_create_region_from_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t region; /**< */ - xcb_window_t window; /**< */ - xcb_shape_kind_t kind; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t region; + xcb_window_t window; + xcb_shape_kind_t kind; + uint8_t pad0[3]; } xcb_xfixes_create_region_from_window_request_t; /** Opcode for xcb_xfixes_create_region_from_gc. */ @@ -290,11 +290,11 @@ typedef struct xcb_xfixes_create_region_from_window_request_t { * @brief xcb_xfixes_create_region_from_gc_request_t **/ typedef struct xcb_xfixes_create_region_from_gc_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t region; /**< */ - xcb_gcontext_t gc; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t region; + xcb_gcontext_t gc; } xcb_xfixes_create_region_from_gc_request_t; /** Opcode for xcb_xfixes_create_region_from_picture. */ @@ -304,11 +304,11 @@ typedef struct xcb_xfixes_create_region_from_gc_request_t { * @brief xcb_xfixes_create_region_from_picture_request_t **/ typedef struct xcb_xfixes_create_region_from_picture_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t region; /**< */ - xcb_render_picture_t picture; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t region; + xcb_render_picture_t picture; } xcb_xfixes_create_region_from_picture_request_t; /** Opcode for xcb_xfixes_destroy_region. */ @@ -318,10 +318,10 @@ typedef struct xcb_xfixes_create_region_from_picture_request_t { * @brief xcb_xfixes_destroy_region_request_t **/ typedef struct xcb_xfixes_destroy_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t region; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t region; } xcb_xfixes_destroy_region_request_t; /** Opcode for xcb_xfixes_set_region. */ @@ -331,10 +331,10 @@ typedef struct xcb_xfixes_destroy_region_request_t { * @brief xcb_xfixes_set_region_request_t **/ typedef struct xcb_xfixes_set_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t region; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t region; } xcb_xfixes_set_region_request_t; /** Opcode for xcb_xfixes_copy_region. */ @@ -344,11 +344,11 @@ typedef struct xcb_xfixes_set_region_request_t { * @brief xcb_xfixes_copy_region_request_t **/ typedef struct xcb_xfixes_copy_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t source; /**< */ - xcb_xfixes_region_t destination; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t source; + xcb_xfixes_region_t destination; } xcb_xfixes_copy_region_request_t; /** Opcode for xcb_xfixes_union_region. */ @@ -358,12 +358,12 @@ typedef struct xcb_xfixes_copy_region_request_t { * @brief xcb_xfixes_union_region_request_t **/ typedef struct xcb_xfixes_union_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t source1; /**< */ - xcb_xfixes_region_t source2; /**< */ - xcb_xfixes_region_t destination; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t source1; + xcb_xfixes_region_t source2; + xcb_xfixes_region_t destination; } xcb_xfixes_union_region_request_t; /** Opcode for xcb_xfixes_intersect_region. */ @@ -373,12 +373,12 @@ typedef struct xcb_xfixes_union_region_request_t { * @brief xcb_xfixes_intersect_region_request_t **/ typedef struct xcb_xfixes_intersect_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t source1; /**< */ - xcb_xfixes_region_t source2; /**< */ - xcb_xfixes_region_t destination; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t source1; + xcb_xfixes_region_t source2; + xcb_xfixes_region_t destination; } xcb_xfixes_intersect_region_request_t; /** Opcode for xcb_xfixes_subtract_region. */ @@ -388,12 +388,12 @@ typedef struct xcb_xfixes_intersect_region_request_t { * @brief xcb_xfixes_subtract_region_request_t **/ typedef struct xcb_xfixes_subtract_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t source1; /**< */ - xcb_xfixes_region_t source2; /**< */ - xcb_xfixes_region_t destination; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t source1; + xcb_xfixes_region_t source2; + xcb_xfixes_region_t destination; } xcb_xfixes_subtract_region_request_t; /** Opcode for xcb_xfixes_invert_region. */ @@ -403,12 +403,12 @@ typedef struct xcb_xfixes_subtract_region_request_t { * @brief xcb_xfixes_invert_region_request_t **/ typedef struct xcb_xfixes_invert_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t source; /**< */ - xcb_rectangle_t bounds; /**< */ - xcb_xfixes_region_t destination; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t source; + xcb_rectangle_t bounds; + xcb_xfixes_region_t destination; } xcb_xfixes_invert_region_request_t; /** Opcode for xcb_xfixes_translate_region. */ @@ -418,12 +418,12 @@ typedef struct xcb_xfixes_invert_region_request_t { * @brief xcb_xfixes_translate_region_request_t **/ typedef struct xcb_xfixes_translate_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t region; /**< */ - int16_t dx; /**< */ - int16_t dy; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t region; + int16_t dx; + int16_t dy; } xcb_xfixes_translate_region_request_t; /** Opcode for xcb_xfixes_region_extents. */ @@ -433,18 +433,18 @@ typedef struct xcb_xfixes_translate_region_request_t { * @brief xcb_xfixes_region_extents_request_t **/ typedef struct xcb_xfixes_region_extents_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t source; /**< */ - xcb_xfixes_region_t destination; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t source; + xcb_xfixes_region_t destination; } xcb_xfixes_region_extents_request_t; /** * @brief xcb_xfixes_fetch_region_cookie_t **/ typedef struct xcb_xfixes_fetch_region_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xfixes_fetch_region_cookie_t; /** Opcode for xcb_xfixes_fetch_region. */ @@ -454,22 +454,22 @@ typedef struct xcb_xfixes_fetch_region_cookie_t { * @brief xcb_xfixes_fetch_region_request_t **/ typedef struct xcb_xfixes_fetch_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t region; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t region; } xcb_xfixes_fetch_region_request_t; /** * @brief xcb_xfixes_fetch_region_reply_t **/ typedef struct xcb_xfixes_fetch_region_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_rectangle_t extents; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_rectangle_t extents; + uint8_t pad1[16]; } xcb_xfixes_fetch_region_reply_t; /** Opcode for xcb_xfixes_set_gc_clip_region. */ @@ -479,13 +479,13 @@ typedef struct xcb_xfixes_fetch_region_reply_t { * @brief xcb_xfixes_set_gc_clip_region_request_t **/ typedef struct xcb_xfixes_set_gc_clip_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_gcontext_t gc; /**< */ - xcb_xfixes_region_t region; /**< */ - int16_t x_origin; /**< */ - int16_t y_origin; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_gcontext_t gc; + xcb_xfixes_region_t region; + int16_t x_origin; + int16_t y_origin; } xcb_xfixes_set_gc_clip_region_request_t; /** Opcode for xcb_xfixes_set_window_shape_region. */ @@ -495,15 +495,15 @@ typedef struct xcb_xfixes_set_gc_clip_region_request_t { * @brief xcb_xfixes_set_window_shape_region_request_t **/ typedef struct xcb_xfixes_set_window_shape_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t dest; /**< */ - xcb_shape_kind_t dest_kind; /**< */ - uint8_t pad0[3]; /**< */ - int16_t x_offset; /**< */ - int16_t y_offset; /**< */ - xcb_xfixes_region_t region; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t dest; + xcb_shape_kind_t dest_kind; + uint8_t pad0[3]; + int16_t x_offset; + int16_t y_offset; + xcb_xfixes_region_t region; } xcb_xfixes_set_window_shape_region_request_t; /** Opcode for xcb_xfixes_set_picture_clip_region. */ @@ -513,13 +513,13 @@ typedef struct xcb_xfixes_set_window_shape_region_request_t { * @brief xcb_xfixes_set_picture_clip_region_request_t **/ typedef struct xcb_xfixes_set_picture_clip_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_render_picture_t picture; /**< */ - xcb_xfixes_region_t region; /**< */ - int16_t x_origin; /**< */ - int16_t y_origin; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_render_picture_t picture; + xcb_xfixes_region_t region; + int16_t x_origin; + int16_t y_origin; } xcb_xfixes_set_picture_clip_region_request_t; /** Opcode for xcb_xfixes_set_cursor_name. */ @@ -529,19 +529,19 @@ typedef struct xcb_xfixes_set_picture_clip_region_request_t { * @brief xcb_xfixes_set_cursor_name_request_t **/ typedef struct xcb_xfixes_set_cursor_name_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_cursor_t cursor; /**< */ - uint16_t nbytes; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_cursor_t cursor; + uint16_t nbytes; + uint8_t pad0[2]; } xcb_xfixes_set_cursor_name_request_t; /** * @brief xcb_xfixes_get_cursor_name_cookie_t **/ typedef struct xcb_xfixes_get_cursor_name_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xfixes_get_cursor_name_cookie_t; /** Opcode for xcb_xfixes_get_cursor_name. */ @@ -551,30 +551,30 @@ typedef struct xcb_xfixes_get_cursor_name_cookie_t { * @brief xcb_xfixes_get_cursor_name_request_t **/ typedef struct xcb_xfixes_get_cursor_name_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_cursor_t cursor; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_cursor_t cursor; } xcb_xfixes_get_cursor_name_request_t; /** * @brief xcb_xfixes_get_cursor_name_reply_t **/ typedef struct xcb_xfixes_get_cursor_name_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_atom_t atom; /**< */ - uint16_t nbytes; /**< */ - uint8_t pad1[18]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_atom_t atom; + uint16_t nbytes; + uint8_t pad1[18]; } xcb_xfixes_get_cursor_name_reply_t; /** * @brief xcb_xfixes_get_cursor_image_and_name_cookie_t **/ typedef struct xcb_xfixes_get_cursor_image_and_name_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xfixes_get_cursor_image_and_name_cookie_t; /** Opcode for xcb_xfixes_get_cursor_image_and_name. */ @@ -584,29 +584,29 @@ typedef struct xcb_xfixes_get_cursor_image_and_name_cookie_t { * @brief xcb_xfixes_get_cursor_image_and_name_request_t **/ typedef struct xcb_xfixes_get_cursor_image_and_name_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_xfixes_get_cursor_image_and_name_request_t; /** * @brief xcb_xfixes_get_cursor_image_and_name_reply_t **/ typedef struct xcb_xfixes_get_cursor_image_and_name_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t xhot; /**< */ - uint16_t yhot; /**< */ - uint32_t cursor_serial; /**< */ - xcb_atom_t cursor_atom; /**< */ - uint16_t nbytes; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t xhot; + uint16_t yhot; + uint32_t cursor_serial; + xcb_atom_t cursor_atom; + uint16_t nbytes; + uint8_t pad1[2]; } xcb_xfixes_get_cursor_image_and_name_reply_t; /** Opcode for xcb_xfixes_change_cursor. */ @@ -616,11 +616,11 @@ typedef struct xcb_xfixes_get_cursor_image_and_name_reply_t { * @brief xcb_xfixes_change_cursor_request_t **/ typedef struct xcb_xfixes_change_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_cursor_t source; /**< */ - xcb_cursor_t destination; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_cursor_t source; + xcb_cursor_t destination; } xcb_xfixes_change_cursor_request_t; /** Opcode for xcb_xfixes_change_cursor_by_name. */ @@ -630,12 +630,12 @@ typedef struct xcb_xfixes_change_cursor_request_t { * @brief xcb_xfixes_change_cursor_by_name_request_t **/ typedef struct xcb_xfixes_change_cursor_by_name_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_cursor_t src; /**< */ - uint16_t nbytes; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_cursor_t src; + uint16_t nbytes; + uint8_t pad0[2]; } xcb_xfixes_change_cursor_by_name_request_t; /** Opcode for xcb_xfixes_expand_region. */ @@ -645,15 +645,15 @@ typedef struct xcb_xfixes_change_cursor_by_name_request_t { * @brief xcb_xfixes_expand_region_request_t **/ typedef struct xcb_xfixes_expand_region_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_region_t source; /**< */ - xcb_xfixes_region_t destination; /**< */ - uint16_t left; /**< */ - uint16_t right; /**< */ - uint16_t top; /**< */ - uint16_t bottom; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_region_t source; + xcb_xfixes_region_t destination; + uint16_t left; + uint16_t right; + uint16_t top; + uint16_t bottom; } xcb_xfixes_expand_region_request_t; /** Opcode for xcb_xfixes_hide_cursor. */ @@ -663,10 +663,10 @@ typedef struct xcb_xfixes_expand_region_request_t { * @brief xcb_xfixes_hide_cursor_request_t **/ typedef struct xcb_xfixes_hide_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_xfixes_hide_cursor_request_t; /** Opcode for xcb_xfixes_show_cursor. */ @@ -676,10 +676,10 @@ typedef struct xcb_xfixes_hide_cursor_request_t { * @brief xcb_xfixes_show_cursor_request_t **/ typedef struct xcb_xfixes_show_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_xfixes_show_cursor_request_t; typedef uint32_t xcb_xfixes_barrier_t; @@ -688,9 +688,9 @@ typedef uint32_t xcb_xfixes_barrier_t; * @brief xcb_xfixes_barrier_iterator_t **/ typedef struct xcb_xfixes_barrier_iterator_t { - xcb_xfixes_barrier_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xfixes_barrier_t *data; + int rem; + int index; } xcb_xfixes_barrier_iterator_t; typedef enum xcb_xfixes_barrier_directions_t { @@ -707,18 +707,18 @@ typedef enum xcb_xfixes_barrier_directions_t { * @brief xcb_xfixes_create_pointer_barrier_request_t **/ typedef struct xcb_xfixes_create_pointer_barrier_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_barrier_t barrier; /**< */ - xcb_window_t window; /**< */ - uint16_t x1; /**< */ - uint16_t y1; /**< */ - uint16_t x2; /**< */ - uint16_t y2; /**< */ - uint32_t directions; /**< */ - uint8_t pad0[2]; /**< */ - uint16_t num_devices; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_barrier_t barrier; + xcb_window_t window; + uint16_t x1; + uint16_t y1; + uint16_t x2; + uint16_t y2; + uint32_t directions; + uint8_t pad0[2]; + uint16_t num_devices; } xcb_xfixes_create_pointer_barrier_request_t; /** Opcode for xcb_xfixes_delete_pointer_barrier. */ @@ -728,10 +728,10 @@ typedef struct xcb_xfixes_create_pointer_barrier_request_t { * @brief xcb_xfixes_delete_pointer_barrier_request_t **/ typedef struct xcb_xfixes_delete_pointer_barrier_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xfixes_barrier_t barrier; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xfixes_barrier_t barrier; } xcb_xfixes_delete_pointer_barrier_request_t; /** @@ -743,9 +743,9 @@ typedef struct xcb_xfixes_delete_pointer_barrier_request_t { * */ xcb_xfixes_query_version_cookie_t -xcb_xfixes_query_version (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */); +xcb_xfixes_query_version (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version); /** * @@ -759,9 +759,9 @@ xcb_xfixes_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xfixes_query_version_cookie_t -xcb_xfixes_query_version_unchecked (xcb_connection_t *c /**< */, - uint32_t client_major_version /**< */, - uint32_t client_minor_version /**< */); +xcb_xfixes_query_version_unchecked (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version); /** * Return the reply @@ -778,9 +778,9 @@ xcb_xfixes_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xfixes_query_version_reply_t * -xcb_xfixes_query_version_reply (xcb_connection_t *c /**< */, +xcb_xfixes_query_version_reply (xcb_connection_t *c, xcb_xfixes_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -794,11 +794,11 @@ xcb_xfixes_query_version_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_change_save_set_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - uint8_t target /**< */, - uint8_t map /**< */, - xcb_window_t window /**< */); +xcb_xfixes_change_save_set_checked (xcb_connection_t *c, + uint8_t mode, + uint8_t target, + uint8_t map, + xcb_window_t window); /** * @@ -809,11 +809,11 @@ xcb_xfixes_change_save_set_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_change_save_set (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - uint8_t target /**< */, - uint8_t map /**< */, - xcb_window_t window /**< */); +xcb_xfixes_change_save_set (xcb_connection_t *c, + uint8_t mode, + uint8_t target, + uint8_t map, + xcb_window_t window); /** * @@ -827,10 +827,10 @@ xcb_xfixes_change_save_set (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_select_selection_input_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t selection /**< */, - uint32_t event_mask /**< */); +xcb_xfixes_select_selection_input_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t selection, + uint32_t event_mask); /** * @@ -841,10 +841,10 @@ xcb_xfixes_select_selection_input_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_select_selection_input (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t selection /**< */, - uint32_t event_mask /**< */); +xcb_xfixes_select_selection_input (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t selection, + uint32_t event_mask); /** * @@ -858,9 +858,9 @@ xcb_xfixes_select_selection_input (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t event_mask /**< */); +xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c, + xcb_window_t window, + uint32_t event_mask); /** * @@ -871,12 +871,12 @@ xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_select_cursor_input (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t event_mask /**< */); +xcb_xfixes_select_cursor_input (xcb_connection_t *c, + xcb_window_t window, + uint32_t event_mask); int -xcb_xfixes_get_cursor_image_sizeof (const void *_buffer /**< */); +xcb_xfixes_get_cursor_image_sizeof (const void *_buffer); /** * @@ -887,7 +887,7 @@ xcb_xfixes_get_cursor_image_sizeof (const void *_buffer /**< */); * */ xcb_xfixes_get_cursor_image_cookie_t -xcb_xfixes_get_cursor_image (xcb_connection_t *c /**< */); +xcb_xfixes_get_cursor_image (xcb_connection_t *c); /** * @@ -901,16 +901,16 @@ xcb_xfixes_get_cursor_image (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_xfixes_get_cursor_image_cookie_t -xcb_xfixes_get_cursor_image_unchecked (xcb_connection_t *c /**< */); +xcb_xfixes_get_cursor_image_unchecked (xcb_connection_t *c); uint32_t * -xcb_xfixes_get_cursor_image_cursor_image (const xcb_xfixes_get_cursor_image_reply_t *R /**< */); +xcb_xfixes_get_cursor_image_cursor_image (const xcb_xfixes_get_cursor_image_reply_t *R); int -xcb_xfixes_get_cursor_image_cursor_image_length (const xcb_xfixes_get_cursor_image_reply_t *R /**< */); +xcb_xfixes_get_cursor_image_cursor_image_length (const xcb_xfixes_get_cursor_image_reply_t *R); xcb_generic_iterator_t -xcb_xfixes_get_cursor_image_cursor_image_end (const xcb_xfixes_get_cursor_image_reply_t *R /**< */); +xcb_xfixes_get_cursor_image_cursor_image_end (const xcb_xfixes_get_cursor_image_reply_t *R); /** * Return the reply @@ -927,9 +927,9 @@ xcb_xfixes_get_cursor_image_cursor_image_end (const xcb_xfixes_get_cursor_image_ * The returned value must be freed by the caller using free(). */ xcb_xfixes_get_cursor_image_reply_t * -xcb_xfixes_get_cursor_image_reply (xcb_connection_t *c /**< */, +xcb_xfixes_get_cursor_image_reply (xcb_connection_t *c, xcb_xfixes_get_cursor_image_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Get the next element of the iterator @@ -940,7 +940,7 @@ xcb_xfixes_get_cursor_image_reply (xcb_connection_t *c /** * element. The member index is increased by sizeof(xcb_xfixes_region_t) */ void -xcb_xfixes_region_next (xcb_xfixes_region_iterator_t *i /**< */); +xcb_xfixes_region_next (xcb_xfixes_region_iterator_t *i); /** * Return the iterator pointing to the last element @@ -952,11 +952,11 @@ xcb_xfixes_region_next (xcb_xfixes_region_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xfixes_region_end (xcb_xfixes_region_iterator_t i /**< */); +xcb_xfixes_region_end (xcb_xfixes_region_iterator_t i); int -xcb_xfixes_create_region_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */); +xcb_xfixes_create_region_sizeof (const void *_buffer, + uint32_t rectangles_len); /** * @@ -970,10 +970,10 @@ xcb_xfixes_create_region_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_create_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_xfixes_create_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); /** * @@ -984,159 +984,19 @@ xcb_xfixes_create_region_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_create_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_xfixes_create_region (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_xfixes_create_region_from_bitmap_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_pixmap_t bitmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_xfixes_create_region_from_bitmap (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_pixmap_t bitmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_xfixes_create_region_from_window_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_window_t window /**< */, - xcb_shape_kind_t kind /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_xfixes_create_region_from_window (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_window_t window /**< */, - xcb_shape_kind_t kind /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_xfixes_create_region_from_gc_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_gcontext_t gc /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_xfixes_create_region_from_gc (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_gcontext_t gc /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_xfixes_create_region_from_picture_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_render_picture_t picture /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_xfixes_create_region_from_picture (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - xcb_render_picture_t picture /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_xfixes_destroy_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_xfixes_destroy_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */); +xcb_rectangle_t * +xcb_xfixes_create_region_rectangles (const xcb_xfixes_create_region_request_t *R); int -xcb_xfixes_set_region_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */); +xcb_xfixes_create_region_rectangles_length (const xcb_xfixes_create_region_request_t *R); + +xcb_rectangle_iterator_t +xcb_xfixes_create_region_rectangles_iterator (const xcb_xfixes_create_region_request_t *R); /** * @@ -1150,10 +1010,9 @@ xcb_xfixes_set_region_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_set_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_xfixes_create_region_from_bitmap_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_pixmap_t bitmap); /** * @@ -1164,10 +1023,9 @@ xcb_xfixes_set_region_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_set_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_xfixes_create_region_from_bitmap (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_pixmap_t bitmap); /** * @@ -1181,9 +1039,10 @@ xcb_xfixes_set_region (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_copy_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */); +xcb_xfixes_create_region_from_window_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_window_t window, + xcb_shape_kind_t kind); /** * @@ -1194,9 +1053,10 @@ xcb_xfixes_copy_region_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_copy_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */); +xcb_xfixes_create_region_from_window (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_window_t window, + xcb_shape_kind_t kind); /** * @@ -1210,10 +1070,9 @@ xcb_xfixes_copy_region (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_union_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */); +xcb_xfixes_create_region_from_gc_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_gcontext_t gc); /** * @@ -1224,10 +1083,9 @@ xcb_xfixes_union_region_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_union_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */); +xcb_xfixes_create_region_from_gc (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_gcontext_t gc); /** * @@ -1241,10 +1099,9 @@ xcb_xfixes_union_region (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_intersect_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */); +xcb_xfixes_create_region_from_picture_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_render_picture_t picture); /** * @@ -1255,10 +1112,9 @@ xcb_xfixes_intersect_region_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_intersect_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */); +xcb_xfixes_create_region_from_picture (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_render_picture_t picture); /** * @@ -1272,10 +1128,8 @@ xcb_xfixes_intersect_region (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_subtract_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */); +xcb_xfixes_destroy_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region); /** * @@ -1286,104 +1140,268 @@ xcb_xfixes_subtract_region_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_subtract_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source1 /**< */, - xcb_xfixes_region_t source2 /**< */, - xcb_xfixes_region_t destination /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_xfixes_invert_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_rectangle_t bounds /**< */, - xcb_xfixes_region_t destination /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_xfixes_invert_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_rectangle_t bounds /**< */, - xcb_xfixes_region_t destination /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_xfixes_translate_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - int16_t dx /**< */, - int16_t dy /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_xfixes_translate_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */, - int16_t dx /**< */, - int16_t dy /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_xfixes_region_extents_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_xfixes_region_extents (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */); +xcb_xfixes_destroy_region (xcb_connection_t *c, + xcb_xfixes_region_t region); int -xcb_xfixes_fetch_region_sizeof (const void *_buffer /**< */); +xcb_xfixes_set_region_sizeof (const void *_buffer, + uint32_t rectangles_len); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_xfixes_set_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_xfixes_set_region (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); + +xcb_rectangle_t * +xcb_xfixes_set_region_rectangles (const xcb_xfixes_set_region_request_t *R); + +int +xcb_xfixes_set_region_rectangles_length (const xcb_xfixes_set_region_request_t *R); + +xcb_rectangle_iterator_t +xcb_xfixes_set_region_rectangles_iterator (const xcb_xfixes_set_region_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_xfixes_copy_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_xfixes_copy_region (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_xfixes_union_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_xfixes_union_region (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_xfixes_intersect_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_xfixes_intersect_region (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_xfixes_subtract_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_xfixes_subtract_region (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_xfixes_invert_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_rectangle_t bounds, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_xfixes_invert_region (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_rectangle_t bounds, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_xfixes_translate_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + int16_t dx, + int16_t dy); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_xfixes_translate_region (xcb_connection_t *c, + xcb_xfixes_region_t region, + int16_t dx, + int16_t dy); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_xfixes_region_extents_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_xfixes_region_extents (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination); + +int +xcb_xfixes_fetch_region_sizeof (const void *_buffer); /** * @@ -1394,8 +1412,8 @@ xcb_xfixes_fetch_region_sizeof (const void *_buffer /**< */); * */ xcb_xfixes_fetch_region_cookie_t -xcb_xfixes_fetch_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */); +xcb_xfixes_fetch_region (xcb_connection_t *c, + xcb_xfixes_region_t region); /** * @@ -1409,17 +1427,17 @@ xcb_xfixes_fetch_region (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xfixes_fetch_region_cookie_t -xcb_xfixes_fetch_region_unchecked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t region /**< */); +xcb_xfixes_fetch_region_unchecked (xcb_connection_t *c, + xcb_xfixes_region_t region); xcb_rectangle_t * -xcb_xfixes_fetch_region_rectangles (const xcb_xfixes_fetch_region_reply_t *R /**< */); +xcb_xfixes_fetch_region_rectangles (const xcb_xfixes_fetch_region_reply_t *R); int -xcb_xfixes_fetch_region_rectangles_length (const xcb_xfixes_fetch_region_reply_t *R /**< */); +xcb_xfixes_fetch_region_rectangles_length (const xcb_xfixes_fetch_region_reply_t *R); xcb_rectangle_iterator_t -xcb_xfixes_fetch_region_rectangles_iterator (const xcb_xfixes_fetch_region_reply_t *R /**< */); +xcb_xfixes_fetch_region_rectangles_iterator (const xcb_xfixes_fetch_region_reply_t *R); /** * Return the reply @@ -1436,9 +1454,9 @@ xcb_xfixes_fetch_region_rectangles_iterator (const xcb_xfixes_fetch_region_reply * The returned value must be freed by the caller using free(). */ xcb_xfixes_fetch_region_reply_t * -xcb_xfixes_fetch_region_reply (xcb_connection_t *c /**< */, +xcb_xfixes_fetch_region_reply (xcb_connection_t *c, xcb_xfixes_fetch_region_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1452,11 +1470,11 @@ xcb_xfixes_fetch_region_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - xcb_xfixes_region_t region /**< */, - int16_t x_origin /**< */, - int16_t y_origin /**< */); +xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t *c, + xcb_gcontext_t gc, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin); /** * @@ -1467,11 +1485,11 @@ xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_set_gc_clip_region (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - xcb_xfixes_region_t region /**< */, - int16_t x_origin /**< */, - int16_t y_origin /**< */); +xcb_xfixes_set_gc_clip_region (xcb_connection_t *c, + xcb_gcontext_t gc, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin); /** * @@ -1485,12 +1503,12 @@ xcb_xfixes_set_gc_clip_region (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_set_window_shape_region_checked (xcb_connection_t *c /**< */, - xcb_window_t dest /**< */, - xcb_shape_kind_t dest_kind /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_xfixes_region_t region /**< */); +xcb_xfixes_set_window_shape_region_checked (xcb_connection_t *c, + xcb_window_t dest, + xcb_shape_kind_t dest_kind, + int16_t x_offset, + int16_t y_offset, + xcb_xfixes_region_t region); /** * @@ -1501,12 +1519,12 @@ xcb_xfixes_set_window_shape_region_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_set_window_shape_region (xcb_connection_t *c /**< */, - xcb_window_t dest /**< */, - xcb_shape_kind_t dest_kind /**< */, - int16_t x_offset /**< */, - int16_t y_offset /**< */, - xcb_xfixes_region_t region /**< */); +xcb_xfixes_set_window_shape_region (xcb_connection_t *c, + xcb_window_t dest, + xcb_shape_kind_t dest_kind, + int16_t x_offset, + int16_t y_offset, + xcb_xfixes_region_t region); /** * @@ -1520,11 +1538,11 @@ xcb_xfixes_set_window_shape_region (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_xfixes_region_t region /**< */, - int16_t x_origin /**< */, - int16_t y_origin /**< */); +xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin); /** * @@ -1535,14 +1553,14 @@ xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_set_picture_clip_region (xcb_connection_t *c /**< */, - xcb_render_picture_t picture /**< */, - xcb_xfixes_region_t region /**< */, - int16_t x_origin /**< */, - int16_t y_origin /**< */); +xcb_xfixes_set_picture_clip_region (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin); int -xcb_xfixes_set_cursor_name_sizeof (const void *_buffer /**< */); +xcb_xfixes_set_cursor_name_sizeof (const void *_buffer); /** * @@ -1556,10 +1574,10 @@ xcb_xfixes_set_cursor_name_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - uint16_t nbytes /**< */, - const char *name /**< */); +xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c, + xcb_cursor_t cursor, + uint16_t nbytes, + const char *name); /** * @@ -1570,13 +1588,22 @@ xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_set_cursor_name (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - uint16_t nbytes /**< */, - const char *name /**< */); +xcb_xfixes_set_cursor_name (xcb_connection_t *c, + xcb_cursor_t cursor, + uint16_t nbytes, + const char *name); + +char * +xcb_xfixes_set_cursor_name_name (const xcb_xfixes_set_cursor_name_request_t *R); int -xcb_xfixes_get_cursor_name_sizeof (const void *_buffer /**< */); +xcb_xfixes_set_cursor_name_name_length (const xcb_xfixes_set_cursor_name_request_t *R); + +xcb_generic_iterator_t +xcb_xfixes_set_cursor_name_name_end (const xcb_xfixes_set_cursor_name_request_t *R); + +int +xcb_xfixes_get_cursor_name_sizeof (const void *_buffer); /** * @@ -1587,8 +1614,8 @@ xcb_xfixes_get_cursor_name_sizeof (const void *_buffer /**< */); * */ xcb_xfixes_get_cursor_name_cookie_t -xcb_xfixes_get_cursor_name (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */); +xcb_xfixes_get_cursor_name (xcb_connection_t *c, + xcb_cursor_t cursor); /** * @@ -1602,17 +1629,17 @@ xcb_xfixes_get_cursor_name (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xfixes_get_cursor_name_cookie_t -xcb_xfixes_get_cursor_name_unchecked (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */); +xcb_xfixes_get_cursor_name_unchecked (xcb_connection_t *c, + xcb_cursor_t cursor); char * -xcb_xfixes_get_cursor_name_name (const xcb_xfixes_get_cursor_name_reply_t *R /**< */); +xcb_xfixes_get_cursor_name_name (const xcb_xfixes_get_cursor_name_reply_t *R); int -xcb_xfixes_get_cursor_name_name_length (const xcb_xfixes_get_cursor_name_reply_t *R /**< */); +xcb_xfixes_get_cursor_name_name_length (const xcb_xfixes_get_cursor_name_reply_t *R); xcb_generic_iterator_t -xcb_xfixes_get_cursor_name_name_end (const xcb_xfixes_get_cursor_name_reply_t *R /**< */); +xcb_xfixes_get_cursor_name_name_end (const xcb_xfixes_get_cursor_name_reply_t *R); /** * Return the reply @@ -1629,12 +1656,12 @@ xcb_xfixes_get_cursor_name_name_end (const xcb_xfixes_get_cursor_name_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_xfixes_get_cursor_name_reply_t * -xcb_xfixes_get_cursor_name_reply (xcb_connection_t *c /**< */, +xcb_xfixes_get_cursor_name_reply (xcb_connection_t *c, xcb_xfixes_get_cursor_name_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer /**< */); +xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer); /** * @@ -1645,7 +1672,7 @@ xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer /**< */); * */ xcb_xfixes_get_cursor_image_and_name_cookie_t -xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c /**< */); +xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c); /** * @@ -1659,25 +1686,25 @@ xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_xfixes_get_cursor_image_and_name_cookie_t -xcb_xfixes_get_cursor_image_and_name_unchecked (xcb_connection_t *c /**< */); - -char * -xcb_xfixes_get_cursor_image_and_name_name (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */); - -int -xcb_xfixes_get_cursor_image_and_name_name_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */); - -xcb_generic_iterator_t -xcb_xfixes_get_cursor_image_and_name_name_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */); +xcb_xfixes_get_cursor_image_and_name_unchecked (xcb_connection_t *c); uint32_t * -xcb_xfixes_get_cursor_image_and_name_cursor_image (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */); +xcb_xfixes_get_cursor_image_and_name_cursor_image (const xcb_xfixes_get_cursor_image_and_name_reply_t *R); int -xcb_xfixes_get_cursor_image_and_name_cursor_image_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */); +xcb_xfixes_get_cursor_image_and_name_cursor_image_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R); xcb_generic_iterator_t -xcb_xfixes_get_cursor_image_and_name_cursor_image_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R /**< */); +xcb_xfixes_get_cursor_image_and_name_cursor_image_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R); + +char * +xcb_xfixes_get_cursor_image_and_name_name (const xcb_xfixes_get_cursor_image_and_name_reply_t *R); + +int +xcb_xfixes_get_cursor_image_and_name_name_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R); + +xcb_generic_iterator_t +xcb_xfixes_get_cursor_image_and_name_name_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R); /** * Return the reply @@ -1694,9 +1721,9 @@ xcb_xfixes_get_cursor_image_and_name_cursor_image_end (const xcb_xfixes_get_curs * The returned value must be freed by the caller using free(). */ xcb_xfixes_get_cursor_image_and_name_reply_t * -xcb_xfixes_get_cursor_image_and_name_reply (xcb_connection_t *c /**< */, +xcb_xfixes_get_cursor_image_and_name_reply (xcb_connection_t *c, xcb_xfixes_get_cursor_image_and_name_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1710,9 +1737,9 @@ xcb_xfixes_get_cursor_image_and_name_reply (xcb_connection_t * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_change_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t source /**< */, - xcb_cursor_t destination /**< */); +xcb_xfixes_change_cursor_checked (xcb_connection_t *c, + xcb_cursor_t source, + xcb_cursor_t destination); /** * @@ -1723,12 +1750,12 @@ xcb_xfixes_change_cursor_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_change_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t source /**< */, - xcb_cursor_t destination /**< */); +xcb_xfixes_change_cursor (xcb_connection_t *c, + xcb_cursor_t source, + xcb_cursor_t destination); int -xcb_xfixes_change_cursor_by_name_sizeof (const void *_buffer /**< */); +xcb_xfixes_change_cursor_by_name_sizeof (const void *_buffer); /** * @@ -1742,10 +1769,10 @@ xcb_xfixes_change_cursor_by_name_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c /**< */, - xcb_cursor_t src /**< */, - uint16_t nbytes /**< */, - const char *name /**< */); +xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c, + xcb_cursor_t src, + uint16_t nbytes, + const char *name); /** * @@ -1756,10 +1783,19 @@ xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_change_cursor_by_name (xcb_connection_t *c /**< */, - xcb_cursor_t src /**< */, - uint16_t nbytes /**< */, - const char *name /**< */); +xcb_xfixes_change_cursor_by_name (xcb_connection_t *c, + xcb_cursor_t src, + uint16_t nbytes, + const char *name); + +char * +xcb_xfixes_change_cursor_by_name_name (const xcb_xfixes_change_cursor_by_name_request_t *R); + +int +xcb_xfixes_change_cursor_by_name_name_length (const xcb_xfixes_change_cursor_by_name_request_t *R); + +xcb_generic_iterator_t +xcb_xfixes_change_cursor_by_name_name_end (const xcb_xfixes_change_cursor_by_name_request_t *R); /** * @@ -1773,13 +1809,13 @@ xcb_xfixes_change_cursor_by_name (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_expand_region_checked (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */, - uint16_t left /**< */, - uint16_t right /**< */, - uint16_t top /**< */, - uint16_t bottom /**< */); +xcb_xfixes_expand_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination, + uint16_t left, + uint16_t right, + uint16_t top, + uint16_t bottom); /** * @@ -1790,13 +1826,13 @@ xcb_xfixes_expand_region_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_expand_region (xcb_connection_t *c /**< */, - xcb_xfixes_region_t source /**< */, - xcb_xfixes_region_t destination /**< */, - uint16_t left /**< */, - uint16_t right /**< */, - uint16_t top /**< */, - uint16_t bottom /**< */); +xcb_xfixes_expand_region (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination, + uint16_t left, + uint16_t right, + uint16_t top, + uint16_t bottom); /** * @@ -1810,8 +1846,8 @@ xcb_xfixes_expand_region (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_hide_cursor_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_xfixes_hide_cursor_checked (xcb_connection_t *c, + xcb_window_t window); /** * @@ -1822,8 +1858,8 @@ xcb_xfixes_hide_cursor_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_hide_cursor (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_xfixes_hide_cursor (xcb_connection_t *c, + xcb_window_t window); /** * @@ -1837,8 +1873,8 @@ xcb_xfixes_hide_cursor (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_show_cursor_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_xfixes_show_cursor_checked (xcb_connection_t *c, + xcb_window_t window); /** * @@ -1849,8 +1885,8 @@ xcb_xfixes_show_cursor_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_show_cursor (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_xfixes_show_cursor (xcb_connection_t *c, + xcb_window_t window); /** * Get the next element of the iterator @@ -1861,7 +1897,7 @@ xcb_xfixes_show_cursor (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_xfixes_barrier_t) */ void -xcb_xfixes_barrier_next (xcb_xfixes_barrier_iterator_t *i /**< */); +xcb_xfixes_barrier_next (xcb_xfixes_barrier_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1873,10 +1909,10 @@ xcb_xfixes_barrier_next (xcb_xfixes_barrier_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xfixes_barrier_end (xcb_xfixes_barrier_iterator_t i /**< */); +xcb_xfixes_barrier_end (xcb_xfixes_barrier_iterator_t i); int -xcb_xfixes_create_pointer_barrier_sizeof (const void *_buffer /**< */); +xcb_xfixes_create_pointer_barrier_sizeof (const void *_buffer); /** * @@ -1890,16 +1926,16 @@ xcb_xfixes_create_pointer_barrier_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_create_pointer_barrier_checked (xcb_connection_t *c /**< */, - xcb_xfixes_barrier_t barrier /**< */, - xcb_window_t window /**< */, - uint16_t x1 /**< */, - uint16_t y1 /**< */, - uint16_t x2 /**< */, - uint16_t y2 /**< */, - uint32_t directions /**< */, - uint16_t num_devices /**< */, - const uint16_t *devices /**< */); +xcb_xfixes_create_pointer_barrier_checked (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier, + xcb_window_t window, + uint16_t x1, + uint16_t y1, + uint16_t x2, + uint16_t y2, + uint32_t directions, + uint16_t num_devices, + const uint16_t *devices); /** * @@ -1910,16 +1946,25 @@ xcb_xfixes_create_pointer_barrier_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_create_pointer_barrier (xcb_connection_t *c /**< */, - xcb_xfixes_barrier_t barrier /**< */, - xcb_window_t window /**< */, - uint16_t x1 /**< */, - uint16_t y1 /**< */, - uint16_t x2 /**< */, - uint16_t y2 /**< */, - uint32_t directions /**< */, - uint16_t num_devices /**< */, - const uint16_t *devices /**< */); +xcb_xfixes_create_pointer_barrier (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier, + xcb_window_t window, + uint16_t x1, + uint16_t y1, + uint16_t x2, + uint16_t y2, + uint32_t directions, + uint16_t num_devices, + const uint16_t *devices); + +uint16_t * +xcb_xfixes_create_pointer_barrier_devices (const xcb_xfixes_create_pointer_barrier_request_t *R); + +int +xcb_xfixes_create_pointer_barrier_devices_length (const xcb_xfixes_create_pointer_barrier_request_t *R); + +xcb_generic_iterator_t +xcb_xfixes_create_pointer_barrier_devices_end (const xcb_xfixes_create_pointer_barrier_request_t *R); /** * @@ -1933,8 +1978,8 @@ xcb_xfixes_create_pointer_barrier (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xfixes_delete_pointer_barrier_checked (xcb_connection_t *c /**< */, - xcb_xfixes_barrier_t barrier /**< */); +xcb_xfixes_delete_pointer_barrier_checked (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier); /** * @@ -1945,8 +1990,8 @@ xcb_xfixes_delete_pointer_barrier_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xfixes_delete_pointer_barrier (xcb_connection_t *c /**< */, - xcb_xfixes_barrier_t barrier /**< */); +xcb_xfixes_delete_pointer_barrier (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier); #ifdef __cplusplus diff --git a/lib/libxcb/src/xinerama.c b/lib/libxcb/src/xinerama.c index 8c3dc9284..2f236768f 100644 --- a/lib/libxcb/src/xinerama.c +++ b/lib/libxcb/src/xinerama.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_xinerama_id = { "XINERAMA", 0 }; void -xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i /**< */) +xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i /**< */) +xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,15 +37,15 @@ xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i /**< */) } xcb_xinerama_query_version_cookie_t -xcb_xinerama_query_version (xcb_connection_t *c /**< */, - uint8_t major /**< */, - uint8_t minor /**< */) +xcb_xinerama_query_version (xcb_connection_t *c, + uint8_t major, + uint8_t minor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -65,15 +65,15 @@ xcb_xinerama_query_version (xcb_connection_t *c /**< */, } xcb_xinerama_query_version_cookie_t -xcb_xinerama_query_version_unchecked (xcb_connection_t *c /**< */, - uint8_t major /**< */, - uint8_t minor /**< */) +xcb_xinerama_query_version_unchecked (xcb_connection_t *c, + uint8_t major, + uint8_t minor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -93,22 +93,22 @@ xcb_xinerama_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_xinerama_query_version_reply_t * -xcb_xinerama_query_version_reply (xcb_connection_t *c /**< */, +xcb_xinerama_query_version_reply (xcb_connection_t *c, xcb_xinerama_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xinerama_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xinerama_get_state_cookie_t -xcb_xinerama_get_state (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_xinerama_get_state (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_GET_STATE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_GET_STATE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -127,14 +127,14 @@ xcb_xinerama_get_state (xcb_connection_t *c /**< */, } xcb_xinerama_get_state_cookie_t -xcb_xinerama_get_state_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_xinerama_get_state_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_GET_STATE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_GET_STATE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -153,22 +153,22 @@ xcb_xinerama_get_state_unchecked (xcb_connection_t *c /**< */, } xcb_xinerama_get_state_reply_t * -xcb_xinerama_get_state_reply (xcb_connection_t *c /**< */, +xcb_xinerama_get_state_reply (xcb_connection_t *c, xcb_xinerama_get_state_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xinerama_get_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xinerama_get_screen_count_cookie_t -xcb_xinerama_get_screen_count (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_xinerama_get_screen_count (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_GET_SCREEN_COUNT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_GET_SCREEN_COUNT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -187,14 +187,14 @@ xcb_xinerama_get_screen_count (xcb_connection_t *c /**< */, } xcb_xinerama_get_screen_count_cookie_t -xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_GET_SCREEN_COUNT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_GET_SCREEN_COUNT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -213,23 +213,23 @@ xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c /**< */, } xcb_xinerama_get_screen_count_reply_t * -xcb_xinerama_get_screen_count_reply (xcb_connection_t *c /**< */, +xcb_xinerama_get_screen_count_reply (xcb_connection_t *c, xcb_xinerama_get_screen_count_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xinerama_get_screen_count_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xinerama_get_screen_size_cookie_t -xcb_xinerama_get_screen_size (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t screen /**< */) +xcb_xinerama_get_screen_size (xcb_connection_t *c, + xcb_window_t window, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_GET_SCREEN_SIZE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_GET_SCREEN_SIZE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -249,15 +249,15 @@ xcb_xinerama_get_screen_size (xcb_connection_t *c /**< */, } xcb_xinerama_get_screen_size_cookie_t -xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t screen /**< */) +xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c, + xcb_window_t window, + uint32_t screen) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_GET_SCREEN_SIZE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_GET_SCREEN_SIZE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -277,21 +277,21 @@ xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c /**< */, } xcb_xinerama_get_screen_size_reply_t * -xcb_xinerama_get_screen_size_reply (xcb_connection_t *c /**< */, +xcb_xinerama_get_screen_size_reply (xcb_connection_t *c, xcb_xinerama_get_screen_size_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xinerama_get_screen_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xinerama_is_active_cookie_t -xcb_xinerama_is_active (xcb_connection_t *c /**< */) +xcb_xinerama_is_active (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_IS_ACTIVE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_IS_ACTIVE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -309,13 +309,13 @@ xcb_xinerama_is_active (xcb_connection_t *c /**< */) } xcb_xinerama_is_active_cookie_t -xcb_xinerama_is_active_unchecked (xcb_connection_t *c /**< */) +xcb_xinerama_is_active_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_IS_ACTIVE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_IS_ACTIVE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -333,15 +333,15 @@ xcb_xinerama_is_active_unchecked (xcb_connection_t *c /**< */) } xcb_xinerama_is_active_reply_t * -xcb_xinerama_is_active_reply (xcb_connection_t *c /**< */, +xcb_xinerama_is_active_reply (xcb_connection_t *c, xcb_xinerama_is_active_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xinerama_is_active_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xinerama_query_screens_sizeof (const void *_buffer /**< */) +xcb_xinerama_query_screens_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xinerama_query_screens_reply_t *_aux = (xcb_xinerama_query_screens_reply_t *)_buffer; @@ -372,13 +372,13 @@ xcb_xinerama_query_screens_sizeof (const void *_buffer /**< */) } xcb_xinerama_query_screens_cookie_t -xcb_xinerama_query_screens (xcb_connection_t *c /**< */) +xcb_xinerama_query_screens (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_QUERY_SCREENS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_QUERY_SCREENS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -396,13 +396,13 @@ xcb_xinerama_query_screens (xcb_connection_t *c /**< */) } xcb_xinerama_query_screens_cookie_t -xcb_xinerama_query_screens_unchecked (xcb_connection_t *c /**< */) +xcb_xinerama_query_screens_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xinerama_id, - /* opcode */ XCB_XINERAMA_QUERY_SCREENS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xinerama_id, + .opcode = XCB_XINERAMA_QUERY_SCREENS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -420,19 +420,19 @@ xcb_xinerama_query_screens_unchecked (xcb_connection_t *c /**< */) } xcb_xinerama_screen_info_t * -xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t *R /**< */) +xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t *R) { return (xcb_xinerama_screen_info_t *) (R + 1); } int -xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_reply_t *R /**< */) +xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_reply_t *R) { return R->number; } xcb_xinerama_screen_info_iterator_t -xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screens_reply_t *R /**< */) +xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screens_reply_t *R) { xcb_xinerama_screen_info_iterator_t i; i.data = (xcb_xinerama_screen_info_t *) (R + 1); @@ -442,9 +442,9 @@ xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screen } xcb_xinerama_query_screens_reply_t * -xcb_xinerama_query_screens_reply (xcb_connection_t *c /**< */, +xcb_xinerama_query_screens_reply (xcb_connection_t *c, xcb_xinerama_query_screens_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xinerama_query_screens_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/xinerama.h b/lib/libxcb/src/xinerama.h index 3c75c60f8..17a82128c 100644 --- a/lib/libxcb/src/xinerama.h +++ b/lib/libxcb/src/xinerama.h @@ -28,26 +28,26 @@ extern xcb_extension_t xcb_xinerama_id; * @brief xcb_xinerama_screen_info_t **/ typedef struct xcb_xinerama_screen_info_t { - int16_t x_org; /**< */ - int16_t y_org; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + int16_t x_org; + int16_t y_org; + uint16_t width; + uint16_t height; } xcb_xinerama_screen_info_t; /** * @brief xcb_xinerama_screen_info_iterator_t **/ typedef struct xcb_xinerama_screen_info_iterator_t { - xcb_xinerama_screen_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xinerama_screen_info_t *data; + int rem; + int index; } xcb_xinerama_screen_info_iterator_t; /** * @brief xcb_xinerama_query_version_cookie_t **/ typedef struct xcb_xinerama_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xinerama_query_version_cookie_t; /** Opcode for xcb_xinerama_query_version. */ @@ -57,30 +57,30 @@ typedef struct xcb_xinerama_query_version_cookie_t { * @brief xcb_xinerama_query_version_request_t **/ typedef struct xcb_xinerama_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t major; /**< */ - uint8_t minor; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t major; + uint8_t minor; } xcb_xinerama_query_version_request_t; /** * @brief xcb_xinerama_query_version_reply_t **/ typedef struct xcb_xinerama_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t major; /**< */ - uint16_t minor; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t major; + uint16_t minor; } xcb_xinerama_query_version_reply_t; /** * @brief xcb_xinerama_get_state_cookie_t **/ typedef struct xcb_xinerama_get_state_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xinerama_get_state_cookie_t; /** Opcode for xcb_xinerama_get_state. */ @@ -90,28 +90,28 @@ typedef struct xcb_xinerama_get_state_cookie_t { * @brief xcb_xinerama_get_state_request_t **/ typedef struct xcb_xinerama_get_state_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_xinerama_get_state_request_t; /** * @brief xcb_xinerama_get_state_reply_t **/ typedef struct xcb_xinerama_get_state_reply_t { - uint8_t response_type; /**< */ - uint8_t state; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t response_type; + uint8_t state; + uint16_t sequence; + uint32_t length; + xcb_window_t window; } xcb_xinerama_get_state_reply_t; /** * @brief xcb_xinerama_get_screen_count_cookie_t **/ typedef struct xcb_xinerama_get_screen_count_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xinerama_get_screen_count_cookie_t; /** Opcode for xcb_xinerama_get_screen_count. */ @@ -121,28 +121,28 @@ typedef struct xcb_xinerama_get_screen_count_cookie_t { * @brief xcb_xinerama_get_screen_count_request_t **/ typedef struct xcb_xinerama_get_screen_count_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_xinerama_get_screen_count_request_t; /** * @brief xcb_xinerama_get_screen_count_reply_t **/ typedef struct xcb_xinerama_get_screen_count_reply_t { - uint8_t response_type; /**< */ - uint8_t screen_count; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t response_type; + uint8_t screen_count; + uint16_t sequence; + uint32_t length; + xcb_window_t window; } xcb_xinerama_get_screen_count_reply_t; /** * @brief xcb_xinerama_get_screen_size_cookie_t **/ typedef struct xcb_xinerama_get_screen_size_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xinerama_get_screen_size_cookie_t; /** Opcode for xcb_xinerama_get_screen_size. */ @@ -152,32 +152,32 @@ typedef struct xcb_xinerama_get_screen_size_cookie_t { * @brief xcb_xinerama_get_screen_size_request_t **/ typedef struct xcb_xinerama_get_screen_size_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint32_t screen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint32_t screen; } xcb_xinerama_get_screen_size_request_t; /** * @brief xcb_xinerama_get_screen_size_reply_t **/ typedef struct xcb_xinerama_get_screen_size_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t width; /**< */ - uint32_t height; /**< */ - xcb_window_t window; /**< */ - uint32_t screen; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t width; + uint32_t height; + xcb_window_t window; + uint32_t screen; } xcb_xinerama_get_screen_size_reply_t; /** * @brief xcb_xinerama_is_active_cookie_t **/ typedef struct xcb_xinerama_is_active_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xinerama_is_active_cookie_t; /** Opcode for xcb_xinerama_is_active. */ @@ -187,27 +187,27 @@ typedef struct xcb_xinerama_is_active_cookie_t { * @brief xcb_xinerama_is_active_request_t **/ typedef struct xcb_xinerama_is_active_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_xinerama_is_active_request_t; /** * @brief xcb_xinerama_is_active_reply_t **/ typedef struct xcb_xinerama_is_active_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t state; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t state; } xcb_xinerama_is_active_reply_t; /** * @brief xcb_xinerama_query_screens_cookie_t **/ typedef struct xcb_xinerama_query_screens_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xinerama_query_screens_cookie_t; /** Opcode for xcb_xinerama_query_screens. */ @@ -217,21 +217,21 @@ typedef struct xcb_xinerama_query_screens_cookie_t { * @brief xcb_xinerama_query_screens_request_t **/ typedef struct xcb_xinerama_query_screens_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_xinerama_query_screens_request_t; /** * @brief xcb_xinerama_query_screens_reply_t **/ typedef struct xcb_xinerama_query_screens_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t number; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t number; + uint8_t pad1[20]; } xcb_xinerama_query_screens_reply_t; /** @@ -243,7 +243,7 @@ typedef struct xcb_xinerama_query_screens_reply_t { * element. The member index is increased by sizeof(xcb_xinerama_screen_info_t) */ void -xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i /**< */); +xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -255,7 +255,7 @@ xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i /**< */); +xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i); /** * @@ -266,9 +266,9 @@ xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i /**< */); * */ xcb_xinerama_query_version_cookie_t -xcb_xinerama_query_version (xcb_connection_t *c /**< */, - uint8_t major /**< */, - uint8_t minor /**< */); +xcb_xinerama_query_version (xcb_connection_t *c, + uint8_t major, + uint8_t minor); /** * @@ -282,9 +282,9 @@ xcb_xinerama_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xinerama_query_version_cookie_t -xcb_xinerama_query_version_unchecked (xcb_connection_t *c /**< */, - uint8_t major /**< */, - uint8_t minor /**< */); +xcb_xinerama_query_version_unchecked (xcb_connection_t *c, + uint8_t major, + uint8_t minor); /** * Return the reply @@ -301,9 +301,9 @@ xcb_xinerama_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xinerama_query_version_reply_t * -xcb_xinerama_query_version_reply (xcb_connection_t *c /**< */, +xcb_xinerama_query_version_reply (xcb_connection_t *c, xcb_xinerama_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -314,8 +314,8 @@ xcb_xinerama_query_version_reply (xcb_connection_t *c /**< * */ xcb_xinerama_get_state_cookie_t -xcb_xinerama_get_state (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_xinerama_get_state (xcb_connection_t *c, + xcb_window_t window); /** * @@ -329,8 +329,8 @@ xcb_xinerama_get_state (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xinerama_get_state_cookie_t -xcb_xinerama_get_state_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_xinerama_get_state_unchecked (xcb_connection_t *c, + xcb_window_t window); /** * Return the reply @@ -347,9 +347,9 @@ xcb_xinerama_get_state_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xinerama_get_state_reply_t * -xcb_xinerama_get_state_reply (xcb_connection_t *c /**< */, +xcb_xinerama_get_state_reply (xcb_connection_t *c, xcb_xinerama_get_state_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -360,8 +360,8 @@ xcb_xinerama_get_state_reply (xcb_connection_t *c /**< */, * */ xcb_xinerama_get_screen_count_cookie_t -xcb_xinerama_get_screen_count (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_xinerama_get_screen_count (xcb_connection_t *c, + xcb_window_t window); /** * @@ -375,8 +375,8 @@ xcb_xinerama_get_screen_count (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xinerama_get_screen_count_cookie_t -xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c, + xcb_window_t window); /** * Return the reply @@ -393,9 +393,9 @@ xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xinerama_get_screen_count_reply_t * -xcb_xinerama_get_screen_count_reply (xcb_connection_t *c /**< */, +xcb_xinerama_get_screen_count_reply (xcb_connection_t *c, xcb_xinerama_get_screen_count_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -406,9 +406,9 @@ xcb_xinerama_get_screen_count_reply (xcb_connection_t *c * */ xcb_xinerama_get_screen_size_cookie_t -xcb_xinerama_get_screen_size (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t screen /**< */); +xcb_xinerama_get_screen_size (xcb_connection_t *c, + xcb_window_t window, + uint32_t screen); /** * @@ -422,9 +422,9 @@ xcb_xinerama_get_screen_size (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xinerama_get_screen_size_cookie_t -xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t screen /**< */); +xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c, + xcb_window_t window, + uint32_t screen); /** * Return the reply @@ -441,9 +441,9 @@ xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xinerama_get_screen_size_reply_t * -xcb_xinerama_get_screen_size_reply (xcb_connection_t *c /**< */, +xcb_xinerama_get_screen_size_reply (xcb_connection_t *c, xcb_xinerama_get_screen_size_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -454,7 +454,7 @@ xcb_xinerama_get_screen_size_reply (xcb_connection_t *c / * */ xcb_xinerama_is_active_cookie_t -xcb_xinerama_is_active (xcb_connection_t *c /**< */); +xcb_xinerama_is_active (xcb_connection_t *c); /** * @@ -468,7 +468,7 @@ xcb_xinerama_is_active (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_xinerama_is_active_cookie_t -xcb_xinerama_is_active_unchecked (xcb_connection_t *c /**< */); +xcb_xinerama_is_active_unchecked (xcb_connection_t *c); /** * Return the reply @@ -485,12 +485,12 @@ xcb_xinerama_is_active_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_xinerama_is_active_reply_t * -xcb_xinerama_is_active_reply (xcb_connection_t *c /**< */, +xcb_xinerama_is_active_reply (xcb_connection_t *c, xcb_xinerama_is_active_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xinerama_query_screens_sizeof (const void *_buffer /**< */); +xcb_xinerama_query_screens_sizeof (const void *_buffer); /** * @@ -501,7 +501,7 @@ xcb_xinerama_query_screens_sizeof (const void *_buffer /**< */); * */ xcb_xinerama_query_screens_cookie_t -xcb_xinerama_query_screens (xcb_connection_t *c /**< */); +xcb_xinerama_query_screens (xcb_connection_t *c); /** * @@ -515,16 +515,16 @@ xcb_xinerama_query_screens (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_xinerama_query_screens_cookie_t -xcb_xinerama_query_screens_unchecked (xcb_connection_t *c /**< */); +xcb_xinerama_query_screens_unchecked (xcb_connection_t *c); xcb_xinerama_screen_info_t * -xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t *R /**< */); +xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t *R); int -xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_reply_t *R /**< */); +xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_reply_t *R); xcb_xinerama_screen_info_iterator_t -xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screens_reply_t *R /**< */); +xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screens_reply_t *R); /** * Return the reply @@ -541,9 +541,9 @@ xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screen * The returned value must be freed by the caller using free(). */ xcb_xinerama_query_screens_reply_t * -xcb_xinerama_query_screens_reply (xcb_connection_t *c /**< */, +xcb_xinerama_query_screens_reply (xcb_connection_t *c, xcb_xinerama_query_screens_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/xinput.c b/lib/libxcb/src/xinput.c index 620ac6a08..5ec5b637b 100644 --- a/lib/libxcb/src/xinput.c +++ b/lib/libxcb/src/xinput.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_input_id = { "XInputExtension", 0 }; void -xcb_input_event_class_next (xcb_input_event_class_iterator_t *i /**< */) +xcb_input_event_class_next (xcb_input_event_class_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_input_event_class_next (xcb_input_event_class_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_event_class_end (xcb_input_event_class_iterator_t i /**< */) +xcb_input_event_class_end (xcb_input_event_class_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,7 +37,7 @@ xcb_input_event_class_end (xcb_input_event_class_iterator_t i /**< */) } void -xcb_input_key_code_next (xcb_input_key_code_iterator_t *i /**< */) +xcb_input_key_code_next (xcb_input_key_code_iterator_t *i) { --i->rem; ++i->data; @@ -45,7 +45,7 @@ xcb_input_key_code_next (xcb_input_key_code_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_key_code_end (xcb_input_key_code_iterator_t i /**< */) +xcb_input_key_code_end (xcb_input_key_code_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -55,7 +55,7 @@ xcb_input_key_code_end (xcb_input_key_code_iterator_t i /**< */) } void -xcb_input_device_id_next (xcb_input_device_id_iterator_t *i /**< */) +xcb_input_device_id_next (xcb_input_device_id_iterator_t *i) { --i->rem; ++i->data; @@ -63,7 +63,7 @@ xcb_input_device_id_next (xcb_input_device_id_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_device_id_end (xcb_input_device_id_iterator_t i /**< */) +xcb_input_device_id_end (xcb_input_device_id_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -73,7 +73,7 @@ xcb_input_device_id_end (xcb_input_device_id_iterator_t i /**< */) } void -xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i /**< */) +xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i) { --i->rem; ++i->data; @@ -81,7 +81,7 @@ xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i /**< */) +xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -91,7 +91,7 @@ xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i /**< */) } void -xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i /**< */) +xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i) { --i->rem; ++i->data; @@ -99,7 +99,7 @@ xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_fp3232_end (xcb_input_fp3232_iterator_t i /**< */) +xcb_input_fp3232_end (xcb_input_fp3232_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -109,7 +109,7 @@ xcb_input_fp3232_end (xcb_input_fp3232_iterator_t i /**< */) } int -xcb_input_get_extension_version_sizeof (const void *_buffer /**< */) +xcb_input_get_extension_version_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_get_extension_version_request_t *_aux = (xcb_input_get_extension_version_request_t *)_buffer; @@ -140,15 +140,15 @@ xcb_input_get_extension_version_sizeof (const void *_buffer /**< */) } xcb_input_get_extension_version_cookie_t -xcb_input_get_extension_version (xcb_connection_t *c /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_input_get_extension_version (xcb_connection_t *c, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_EXTENSION_VERSION, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_EXTENSION_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -173,15 +173,15 @@ xcb_input_get_extension_version (xcb_connection_t *c /**< */, } xcb_input_get_extension_version_cookie_t -xcb_input_get_extension_version_unchecked (xcb_connection_t *c /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_input_get_extension_version_unchecked (xcb_connection_t *c, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_EXTENSION_VERSION, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_EXTENSION_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -206,15 +206,15 @@ xcb_input_get_extension_version_unchecked (xcb_connection_t *c /**< */, } xcb_input_get_extension_version_reply_t * -xcb_input_get_extension_version_reply (xcb_connection_t *c /**< */, +xcb_input_get_extension_version_reply (xcb_connection_t *c, xcb_input_get_extension_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_extension_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } void -xcb_input_device_info_next (xcb_input_device_info_iterator_t *i /**< */) +xcb_input_device_info_next (xcb_input_device_info_iterator_t *i) { --i->rem; ++i->data; @@ -222,7 +222,7 @@ xcb_input_device_info_next (xcb_input_device_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_device_info_end (xcb_input_device_info_iterator_t i /**< */) +xcb_input_device_info_end (xcb_input_device_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -232,7 +232,7 @@ xcb_input_device_info_end (xcb_input_device_info_iterator_t i /**< */) } void -xcb_input_key_info_next (xcb_input_key_info_iterator_t *i /**< */) +xcb_input_key_info_next (xcb_input_key_info_iterator_t *i) { --i->rem; ++i->data; @@ -240,7 +240,7 @@ xcb_input_key_info_next (xcb_input_key_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_key_info_end (xcb_input_key_info_iterator_t i /**< */) +xcb_input_key_info_end (xcb_input_key_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -250,7 +250,7 @@ xcb_input_key_info_end (xcb_input_key_info_iterator_t i /**< */) } void -xcb_input_button_info_next (xcb_input_button_info_iterator_t *i /**< */) +xcb_input_button_info_next (xcb_input_button_info_iterator_t *i) { --i->rem; ++i->data; @@ -258,7 +258,7 @@ xcb_input_button_info_next (xcb_input_button_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_button_info_end (xcb_input_button_info_iterator_t i /**< */) +xcb_input_button_info_end (xcb_input_button_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -268,7 +268,7 @@ xcb_input_button_info_end (xcb_input_button_info_iterator_t i /**< */) } void -xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i /**< */) +xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i) { --i->rem; ++i->data; @@ -276,7 +276,7 @@ xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_axis_info_end (xcb_input_axis_info_iterator_t i /**< */) +xcb_input_axis_info_end (xcb_input_axis_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -286,7 +286,7 @@ xcb_input_axis_info_end (xcb_input_axis_info_iterator_t i /**< */) } int -xcb_input_valuator_info_sizeof (const void *_buffer /**< */) +xcb_input_valuator_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_valuator_info_t *_aux = (xcb_input_valuator_info_t *)_buffer; @@ -317,19 +317,19 @@ xcb_input_valuator_info_sizeof (const void *_buffer /**< */) } xcb_input_axis_info_t * -xcb_input_valuator_info_axes (const xcb_input_valuator_info_t *R /**< */) +xcb_input_valuator_info_axes (const xcb_input_valuator_info_t *R) { return (xcb_input_axis_info_t *) (R + 1); } int -xcb_input_valuator_info_axes_length (const xcb_input_valuator_info_t *R /**< */) +xcb_input_valuator_info_axes_length (const xcb_input_valuator_info_t *R) { return R->axes_len; } xcb_input_axis_info_iterator_t -xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R /**< */) +xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R) { xcb_input_axis_info_iterator_t i; i.data = (xcb_input_axis_info_t *) (R + 1); @@ -339,7 +339,7 @@ xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R /**< } void -xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i /**< */) +xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i) { xcb_input_valuator_info_t *R = i->data; xcb_generic_iterator_t child; @@ -350,7 +350,7 @@ xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i /**< */) +xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -361,26 +361,305 @@ xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i /**< */) return ret; } -void -xcb_input_input_info_next (xcb_input_input_info_iterator_t *i /**< */) +xcb_input_axis_info_t * +xcb_input_input_info_info_valuator_axes (const xcb_input_input_info_info_t *S) { + return S->valuator.axes; +} + +int +xcb_input_input_info_info_valuator_axes_length (const xcb_input_input_info_t *R, + const xcb_input_input_info_info_t *S) +{ + return S->valuator.axes_len; +} + +xcb_input_axis_info_iterator_t +xcb_input_input_info_info_valuator_axes_iterator (const xcb_input_input_info_t *R, + const xcb_input_input_info_info_t *S) +{ + xcb_input_axis_info_iterator_t i; + i.data = S->valuator.axes; + i.rem = S->valuator.axes_len; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_input_info_info_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_input_info_info_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 2; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[11]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(class_id == XCB_INPUT_INPUT_CLASS_KEY) { + /* xcb_input_input_info_info_t.key.min_keycode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.min_keycode; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_input_info_info_t.key.max_keycode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.max_keycode; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_input_info_info_t.key.num_keys */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_input_info_info_t.key.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) { + /* xcb_input_input_info_info_t.button.num_buttons */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) { + /* xcb_input_input_info_info_t.valuator.axes_len */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.axes_len; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_info_info_t.valuator.mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_info_info_t.valuator.motion_size */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.motion_size; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* axes */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->valuator.axes; + xcb_block_len += _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_axis_info_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ikey.min_keycode = *(xcb_input_key_code_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_tmp += sizeof(xcb_input_key_code_t); + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_input_info_info_t.key.max_keycode */ + _aux->key.max_keycode = *(xcb_input_key_code_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_tmp += sizeof(xcb_input_key_code_t); + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_input_info_info_t.key.num_keys */ + _aux->key.num_keys = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_input_info_info_t.key.pad0 */ + _aux->key.pad0[0] = *(uint8_t *)xcb_tmp; + _aux->key.pad0[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) { + /* xcb_input_input_info_info_t.button.num_buttons */ + _aux->button.num_buttons = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) { + /* xcb_input_input_info_info_t.valuator.axes_len */ + _aux->valuator.axes_len = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_info_info_t.valuator.mode */ + _aux->valuator.mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_info_info_t.valuator.motion_size */ + _aux->valuator.motion_size = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_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; + /* axes */ + _aux->valuator.axes = (xcb_input_axis_info_t *)xcb_tmp; + xcb_block_len += _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_axis_info_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; +} + +int +xcb_input_input_info_info_sizeof (const void *_buffer, + uint8_t class_id) +{ + xcb_input_input_info_info_t _aux; + return xcb_input_input_info_info_unpack(_buffer, class_id, &_aux); +} + +int +xcb_input_input_info_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_input_info_t *_aux = (xcb_input_input_info_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; + + + xcb_block_len += sizeof(xcb_input_input_info_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* info */ + xcb_block_len += xcb_input_input_info_info_sizeof(xcb_tmp, _aux->class_id); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; + + return xcb_buffer_len; +} + +void * +xcb_input_input_info_info (const xcb_input_input_info_t *R) +{ + return (void *) (R + 1); +} + +void +xcb_input_input_info_next (xcb_input_input_info_iterator_t *i) +{ + xcb_input_input_info_t *R = i->data; + xcb_generic_iterator_t child; + child.data = (xcb_input_input_info_t *)(((char *)R) + xcb_input_input_info_sizeof(R)); + i->index = (char *) child.data - (char *) i->data; --i->rem; - ++i->data; - i->index += sizeof(xcb_input_input_info_t); + i->data = (xcb_input_input_info_t *) child.data; } xcb_generic_iterator_t -xcb_input_input_info_end (xcb_input_input_info_iterator_t i /**< */) +xcb_input_input_info_end (xcb_input_input_info_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_input_info_next(&i); + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; return ret; } int -xcb_input_device_name_sizeof (const void *_buffer /**< */) +xcb_input_device_name_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_device_name_t *_aux = (xcb_input_device_name_t *)_buffer; @@ -411,19 +690,19 @@ xcb_input_device_name_sizeof (const void *_buffer /**< */) } char * -xcb_input_device_name_string (const xcb_input_device_name_t *R /**< */) +xcb_input_device_name_string (const xcb_input_device_name_t *R) { return (char *) (R + 1); } int -xcb_input_device_name_string_length (const xcb_input_device_name_t *R /**< */) +xcb_input_device_name_string_length (const xcb_input_device_name_t *R) { return R->len; } xcb_generic_iterator_t -xcb_input_device_name_string_end (const xcb_input_device_name_t *R /**< */) +xcb_input_device_name_string_end (const xcb_input_device_name_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->len); @@ -433,7 +712,7 @@ xcb_input_device_name_string_end (const xcb_input_device_name_t *R /**< */) } void -xcb_input_device_name_next (xcb_input_device_name_iterator_t *i /**< */) +xcb_input_device_name_next (xcb_input_device_name_iterator_t *i) { xcb_input_device_name_t *R = i->data; xcb_generic_iterator_t child; @@ -444,7 +723,7 @@ xcb_input_device_name_next (xcb_input_device_name_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_device_name_end (xcb_input_device_name_iterator_t i /**< */) +xcb_input_device_name_end (xcb_input_device_name_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -456,7 +735,7 @@ xcb_input_device_name_end (xcb_input_device_name_iterator_t i /**< */) } int -xcb_input_list_input_devices_sizeof (const void *_buffer /**< */) +xcb_input_list_input_devices_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_list_input_devices_reply_t *_aux = (xcb_input_list_input_devices_reply_t *)_buffer; @@ -465,6 +744,12 @@ xcb_input_list_input_devices_sizeof (const void *_buffer /**< */) unsigned int xcb_pad = 0; unsigned int xcb_align_to = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const xcb_input_device_info_t* xcb_pre_tmp_4; /* sumof list ptr */ + unsigned int i; + unsigned int xcb_tmp_len; xcb_block_len += sizeof(xcb_input_list_input_devices_reply_t); xcb_tmp += xcb_block_len; @@ -482,18 +767,66 @@ xcb_input_list_input_devices_sizeof (const void *_buffer /**< */) xcb_pad = 0; } xcb_block_len = 0; + /* infos */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->devices_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_list_input_devices_devices(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += xcb_pre_tmp_4->num_class_info; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + for(i=0; idevices_len; i++) { + xcb_tmp_len = xcb_str_sizeof(xcb_tmp); + xcb_block_len += xcb_tmp_len; + xcb_tmp += xcb_tmp_len; + } + xcb_align_to = ALIGNOF(xcb_str_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; return xcb_buffer_len; } xcb_input_list_input_devices_cookie_t -xcb_input_list_input_devices (xcb_connection_t *c /**< */) +xcb_input_list_input_devices (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_LIST_INPUT_DEVICES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_LIST_INPUT_DEVICES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -511,13 +844,13 @@ xcb_input_list_input_devices (xcb_connection_t *c /**< */) } xcb_input_list_input_devices_cookie_t -xcb_input_list_input_devices_unchecked (xcb_connection_t *c /**< */) +xcb_input_list_input_devices_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_LIST_INPUT_DEVICES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_LIST_INPUT_DEVICES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -535,19 +868,19 @@ xcb_input_list_input_devices_unchecked (xcb_connection_t *c /**< */) } xcb_input_device_info_t * -xcb_input_list_input_devices_devices (const xcb_input_list_input_devices_reply_t *R /**< */) +xcb_input_list_input_devices_devices (const xcb_input_list_input_devices_reply_t *R) { return (xcb_input_device_info_t *) (R + 1); } int -xcb_input_list_input_devices_devices_length (const xcb_input_list_input_devices_reply_t *R /**< */) +xcb_input_list_input_devices_devices_length (const xcb_input_list_input_devices_reply_t *R) { return R->devices_len; } xcb_input_device_info_iterator_t -xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_devices_reply_t *R /**< */) +xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_devices_reply_t *R) { xcb_input_device_info_iterator_t i; i.data = (xcb_input_device_info_t *) (R + 1); @@ -556,16 +889,76 @@ xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_device return i; } +int +xcb_input_list_input_devices_infos_length (const xcb_input_list_input_devices_reply_t *R) +{ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const xcb_input_device_info_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = R->devices_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_list_input_devices_devices(R); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + xcb_pre_tmp_7 += xcb_pre_tmp_8->num_class_info; + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + return xcb_pre_tmp_7; +} + +xcb_input_input_info_iterator_t +xcb_input_list_input_devices_infos_iterator (const xcb_input_list_input_devices_reply_t *R) +{ + xcb_input_input_info_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_device_info_end(xcb_input_list_input_devices_devices_iterator(R)); + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const xcb_input_device_info_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->devices_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_list_input_devices_devices(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + xcb_pre_tmp_11 += xcb_pre_tmp_12->num_class_info; + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + i.data = (xcb_input_input_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_input_info_t, prev.index)); + i.rem = xcb_pre_tmp_11; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_list_input_devices_names_length (const xcb_input_list_input_devices_reply_t *R) +{ + return R->devices_len; +} + +xcb_str_iterator_t +xcb_input_list_input_devices_names_iterator (const xcb_input_list_input_devices_reply_t *R) +{ + xcb_str_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_input_info_end(xcb_input_list_input_devices_infos_iterator(R)); + i.data = (xcb_str_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_str_t, prev.index)); + i.rem = R->devices_len; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_input_list_input_devices_reply_t * -xcb_input_list_input_devices_reply (xcb_connection_t *c /**< */, +xcb_input_list_input_devices_reply (xcb_connection_t *c, xcb_input_list_input_devices_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_list_input_devices_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } void -xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i /**< */) +xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i) { --i->rem; ++i->data; @@ -573,7 +966,7 @@ xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i /**< } xcb_generic_iterator_t -xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i /**< */) +xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -583,7 +976,7 @@ xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i /**< */ } int -xcb_input_open_device_sizeof (const void *_buffer /**< */) +xcb_input_open_device_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_open_device_reply_t *_aux = (xcb_input_open_device_reply_t *)_buffer; @@ -601,6 +994,15 @@ xcb_input_open_device_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->num_classes * sizeof(xcb_input_input_class_info_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_input_input_class_info_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -614,14 +1016,14 @@ xcb_input_open_device_sizeof (const void *_buffer /**< */) } xcb_input_open_device_cookie_t -xcb_input_open_device (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_open_device (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_OPEN_DEVICE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_OPEN_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -641,14 +1043,14 @@ xcb_input_open_device (xcb_connection_t *c /**< */, } xcb_input_open_device_cookie_t -xcb_input_open_device_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_open_device_unchecked (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_OPEN_DEVICE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_OPEN_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -668,19 +1070,19 @@ xcb_input_open_device_unchecked (xcb_connection_t *c /**< */, } xcb_input_input_class_info_t * -xcb_input_open_device_class_info (const xcb_input_open_device_reply_t *R /**< */) +xcb_input_open_device_class_info (const xcb_input_open_device_reply_t *R) { return (xcb_input_input_class_info_t *) (R + 1); } int -xcb_input_open_device_class_info_length (const xcb_input_open_device_reply_t *R /**< */) +xcb_input_open_device_class_info_length (const xcb_input_open_device_reply_t *R) { return R->num_classes; } xcb_input_input_class_info_iterator_t -xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t *R /**< */) +xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t *R) { xcb_input_input_class_info_iterator_t i; i.data = (xcb_input_input_class_info_t *) (R + 1); @@ -690,22 +1092,22 @@ xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t * } xcb_input_open_device_reply_t * -xcb_input_open_device_reply (xcb_connection_t *c /**< */, +xcb_input_open_device_reply (xcb_connection_t *c, xcb_input_open_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_open_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_input_close_device_checked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_close_device_checked (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CLOSE_DEVICE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CLOSE_DEVICE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -725,14 +1127,14 @@ xcb_input_close_device_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_close_device (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_close_device (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CLOSE_DEVICE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CLOSE_DEVICE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -752,15 +1154,15 @@ xcb_input_close_device (xcb_connection_t *c /**< */, } xcb_input_set_device_mode_cookie_t -xcb_input_set_device_mode (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t mode /**< */) +xcb_input_set_device_mode (xcb_connection_t *c, + uint8_t device_id, + uint8_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SET_DEVICE_MODE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_MODE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -781,15 +1183,15 @@ xcb_input_set_device_mode (xcb_connection_t *c /**< */, } xcb_input_set_device_mode_cookie_t -xcb_input_set_device_mode_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t mode /**< */) +xcb_input_set_device_mode_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SET_DEVICE_MODE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_MODE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -810,15 +1212,15 @@ xcb_input_set_device_mode_unchecked (xcb_connection_t *c /**< */, } xcb_input_set_device_mode_reply_t * -xcb_input_set_device_mode_reply (xcb_connection_t *c /**< */, +xcb_input_set_device_mode_reply (xcb_connection_t *c, xcb_input_set_device_mode_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_set_device_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_select_extension_event_sizeof (const void *_buffer /**< */) +xcb_input_select_extension_event_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_select_extension_event_request_t *_aux = (xcb_input_select_extension_event_request_t *)_buffer; @@ -849,16 +1251,16 @@ xcb_input_select_extension_event_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_input_select_extension_event_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_classes /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_select_extension_event_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SELECT_EXTENSION_EVENT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SELECT_EXTENSION_EVENT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -884,16 +1286,16 @@ xcb_input_select_extension_event_checked (xcb_connection_t *c /**< } xcb_void_cookie_t -xcb_input_select_extension_event (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_classes /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_select_extension_event (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SELECT_EXTENSION_EVENT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SELECT_EXTENSION_EVENT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -918,8 +1320,30 @@ xcb_input_select_extension_event (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_input_event_class_t * +xcb_input_select_extension_event_classes (const xcb_input_select_extension_event_request_t *R) +{ + return (xcb_input_event_class_t *) (R + 1); +} + int -xcb_input_get_selected_extension_events_sizeof (const void *_buffer /**< */) +xcb_input_select_extension_event_classes_length (const xcb_input_select_extension_event_request_t *R) +{ + return R->num_classes; +} + +xcb_generic_iterator_t +xcb_input_select_extension_event_classes_end (const xcb_input_select_extension_event_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_get_selected_extension_events_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_get_selected_extension_events_reply_t *_aux = (xcb_input_get_selected_extension_events_reply_t *)_buffer; @@ -962,14 +1386,14 @@ xcb_input_get_selected_extension_events_sizeof (const void *_buffer /**< */) } xcb_input_get_selected_extension_events_cookie_t -xcb_input_get_selected_extension_events (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_input_get_selected_extension_events (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -988,14 +1412,14 @@ xcb_input_get_selected_extension_events (xcb_connection_t *c /**< */, } xcb_input_get_selected_extension_events_cookie_t -xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1014,19 +1438,19 @@ xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c /**< */, } xcb_input_event_class_t * -xcb_input_get_selected_extension_events_this_classes (const xcb_input_get_selected_extension_events_reply_t *R /**< */) +xcb_input_get_selected_extension_events_this_classes (const xcb_input_get_selected_extension_events_reply_t *R) { return (xcb_input_event_class_t *) (R + 1); } int -xcb_input_get_selected_extension_events_this_classes_length (const xcb_input_get_selected_extension_events_reply_t *R /**< */) +xcb_input_get_selected_extension_events_this_classes_length (const xcb_input_get_selected_extension_events_reply_t *R) { return R->num_this_classes; } xcb_generic_iterator_t -xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_selected_extension_events_reply_t *R /**< */) +xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_selected_extension_events_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_this_classes); @@ -1036,39 +1460,39 @@ xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_se } xcb_input_event_class_t * -xcb_input_get_selected_extension_events_all_classes (const xcb_input_get_selected_extension_events_reply_t *R /**< */) +xcb_input_get_selected_extension_events_all_classes (const xcb_input_get_selected_extension_events_reply_t *R) { xcb_generic_iterator_t prev = xcb_input_get_selected_extension_events_this_classes_end(R); return (xcb_input_event_class_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index) + 0); } int -xcb_input_get_selected_extension_events_all_classes_length (const xcb_input_get_selected_extension_events_reply_t *R /**< */) +xcb_input_get_selected_extension_events_all_classes_length (const xcb_input_get_selected_extension_events_reply_t *R) { return R->num_all_classes; } xcb_generic_iterator_t -xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_selected_extension_events_reply_t *R /**< */) +xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_selected_extension_events_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_input_get_selected_extension_events_this_classes_end(R); - i.data = ((xcb_input_event_class_t *) child.data) + (R->num_all_classes); + xcb_generic_iterator_t prev = xcb_input_get_selected_extension_events_this_classes_end(R); + i.data = ((xcb_input_event_class_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index))) + (R->num_all_classes); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_input_get_selected_extension_events_reply_t * -xcb_input_get_selected_extension_events_reply (xcb_connection_t *c /**< */, +xcb_input_get_selected_extension_events_reply (xcb_connection_t *c, xcb_input_get_selected_extension_events_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_selected_extension_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_change_device_dont_propagate_list_sizeof (const void *_buffer /**< */) +xcb_input_change_device_dont_propagate_list_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_change_device_dont_propagate_list_request_t *_aux = (xcb_input_change_device_dont_propagate_list_request_t *)_buffer; @@ -1099,17 +1523,17 @@ xcb_input_change_device_dont_propagate_list_sizeof (const void *_buffer /**< * } xcb_void_cookie_t -xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_classes /**< */, - uint8_t mode /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + uint8_t mode, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1136,17 +1560,17 @@ xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t } xcb_void_cookie_t -xcb_input_change_device_dont_propagate_list (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_classes /**< */, - uint8_t mode /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_change_device_dont_propagate_list (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + uint8_t mode, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1172,8 +1596,30 @@ xcb_input_change_device_dont_propagate_list (xcb_connection_t *c / return xcb_ret; } +xcb_input_event_class_t * +xcb_input_change_device_dont_propagate_list_classes (const xcb_input_change_device_dont_propagate_list_request_t *R) +{ + return (xcb_input_event_class_t *) (R + 1); +} + int -xcb_input_get_device_dont_propagate_list_sizeof (const void *_buffer /**< */) +xcb_input_change_device_dont_propagate_list_classes_length (const xcb_input_change_device_dont_propagate_list_request_t *R) +{ + return R->num_classes; +} + +xcb_generic_iterator_t +xcb_input_change_device_dont_propagate_list_classes_end (const xcb_input_change_device_dont_propagate_list_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_get_device_dont_propagate_list_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_get_device_dont_propagate_list_reply_t *_aux = (xcb_input_get_device_dont_propagate_list_reply_t *)_buffer; @@ -1204,14 +1650,14 @@ xcb_input_get_device_dont_propagate_list_sizeof (const void *_buffer /**< */) } xcb_input_get_device_dont_propagate_list_cookie_t -xcb_input_get_device_dont_propagate_list (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_input_get_device_dont_propagate_list (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1230,14 +1676,14 @@ xcb_input_get_device_dont_propagate_list (xcb_connection_t *c /**< */, } xcb_input_get_device_dont_propagate_list_cookie_t -xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1256,19 +1702,19 @@ xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c /**< */ } xcb_input_event_class_t * -xcb_input_get_device_dont_propagate_list_classes (const xcb_input_get_device_dont_propagate_list_reply_t *R /**< */) +xcb_input_get_device_dont_propagate_list_classes (const xcb_input_get_device_dont_propagate_list_reply_t *R) { return (xcb_input_event_class_t *) (R + 1); } int -xcb_input_get_device_dont_propagate_list_classes_length (const xcb_input_get_device_dont_propagate_list_reply_t *R /**< */) +xcb_input_get_device_dont_propagate_list_classes_length (const xcb_input_get_device_dont_propagate_list_reply_t *R) { return R->num_classes; } xcb_generic_iterator_t -xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device_dont_propagate_list_reply_t *R /**< */) +xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device_dont_propagate_list_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); @@ -1278,42 +1724,138 @@ xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device } 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_reply (xcb_connection_t *c, xcb_input_get_device_dont_propagate_list_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_device_dont_propagate_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } -void -xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i /**< */) +int +xcb_input_device_time_coord_sizeof (const void *_buffer, + uint8_t num_axes) { - --i->rem; - ++i->data; - i->index += sizeof(xcb_input_device_time_coord_t); + char *xcb_tmp = (char *)_buffer; + 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; + /* 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_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; + + 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_end (xcb_input_device_time_coord_iterator_t i /**< */) +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 = (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; + 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; + /* 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_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; + + 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 /**< */) +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 = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_MOTION_EVENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_MOTION_EVENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1323,6 +1865,7 @@ xcb_input_get_device_motion_events (xcb_connection_t *c /**< */, xcb_out.start = start; xcb_out.stop = stop; xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -1334,16 +1877,16 @@ xcb_input_get_device_motion_events (xcb_connection_t *c /**< */, } 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 /**< */) +xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c, + xcb_timestamp_t start, + xcb_timestamp_t stop, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_MOTION_EVENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_MOTION_EVENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1353,6 +1896,7 @@ xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c /**< */, xcb_out.start = start; xcb_out.stop = stop; xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -1363,23 +1907,40 @@ xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c /**< */, 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_reply (xcb_connection_t *c, xcb_input_get_device_motion_events_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_device_motion_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_input_change_keyboard_device_cookie_t -xcb_input_change_keyboard_device (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_change_keyboard_device (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_KEYBOARD_DEVICE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_KEYBOARD_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1399,14 +1960,14 @@ xcb_input_change_keyboard_device (xcb_connection_t *c /**< */, } xcb_input_change_keyboard_device_cookie_t -xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_KEYBOARD_DEVICE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_KEYBOARD_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1426,24 +1987,24 @@ xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c /**< */, } xcb_input_change_keyboard_device_reply_t * -xcb_input_change_keyboard_device_reply (xcb_connection_t *c /**< */, +xcb_input_change_keyboard_device_reply (xcb_connection_t *c, xcb_input_change_keyboard_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_change_keyboard_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_input_change_pointer_device_cookie_t -xcb_input_change_pointer_device (xcb_connection_t *c /**< */, - uint8_t x_axis /**< */, - uint8_t y_axis /**< */, - uint8_t device_id /**< */) +xcb_input_change_pointer_device (xcb_connection_t *c, + uint8_t x_axis, + uint8_t y_axis, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_POINTER_DEVICE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_POINTER_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1465,16 +2026,16 @@ xcb_input_change_pointer_device (xcb_connection_t *c /**< */, } xcb_input_change_pointer_device_cookie_t -xcb_input_change_pointer_device_unchecked (xcb_connection_t *c /**< */, - uint8_t x_axis /**< */, - uint8_t y_axis /**< */, - uint8_t device_id /**< */) +xcb_input_change_pointer_device_unchecked (xcb_connection_t *c, + uint8_t x_axis, + uint8_t y_axis, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_POINTER_DEVICE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_POINTER_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1496,15 +2057,15 @@ xcb_input_change_pointer_device_unchecked (xcb_connection_t *c /**< */, } xcb_input_change_pointer_device_reply_t * -xcb_input_change_pointer_device_reply (xcb_connection_t *c /**< */, +xcb_input_change_pointer_device_reply (xcb_connection_t *c, xcb_input_change_pointer_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_change_pointer_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_grab_device_sizeof (const void *_buffer /**< */) +xcb_input_grab_device_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_grab_device_request_t *_aux = (xcb_input_grab_device_request_t *)_buffer; @@ -1535,21 +2096,21 @@ xcb_input_grab_device_sizeof (const void *_buffer /**< */) } xcb_input_grab_device_cookie_t -xcb_input_grab_device (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - xcb_timestamp_t time /**< */, - uint16_t num_classes /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t owner_events /**< */, - uint8_t device_id /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_grab_device (xcb_connection_t *c, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint16_t num_classes, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + uint8_t device_id, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GRAB_DEVICE, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -1580,21 +2141,21 @@ xcb_input_grab_device (xcb_connection_t *c /**< */, } xcb_input_grab_device_cookie_t -xcb_input_grab_device_unchecked (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - xcb_timestamp_t time /**< */, - uint16_t num_classes /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t owner_events /**< */, - uint8_t device_id /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_grab_device_unchecked (xcb_connection_t *c, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint16_t num_classes, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + uint8_t device_id, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GRAB_DEVICE, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -1625,23 +2186,23 @@ xcb_input_grab_device_unchecked (xcb_connection_t *c /**< */, } xcb_input_grab_device_reply_t * -xcb_input_grab_device_reply (xcb_connection_t *c /**< */, +xcb_input_grab_device_reply (xcb_connection_t *c, xcb_input_grab_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_input_ungrab_device_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - uint8_t device_id /**< */) +xcb_input_ungrab_device_checked (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_UNGRAB_DEVICE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1650,6 +2211,7 @@ xcb_input_ungrab_device_checked (xcb_connection_t *c /**< */, xcb_out.time = time; xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -1661,15 +2223,15 @@ xcb_input_ungrab_device_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_ungrab_device (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - uint8_t device_id /**< */) +xcb_input_ungrab_device (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_UNGRAB_DEVICE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1678,6 +2240,7 @@ xcb_input_ungrab_device (xcb_connection_t *c /**< */, xcb_out.time = time; xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 3); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -1689,7 +2252,7 @@ xcb_input_ungrab_device (xcb_connection_t *c /**< */, } int -xcb_input_grab_device_key_sizeof (const void *_buffer /**< */) +xcb_input_grab_device_key_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_grab_device_key_request_t *_aux = (xcb_input_grab_device_key_request_t *)_buffer; @@ -1720,23 +2283,23 @@ xcb_input_grab_device_key_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_input_grab_device_key_checked (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint16_t num_classes /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t grabbed_device /**< */, - uint8_t key /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t owner_events /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_grab_device_key_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t num_classes, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t grabbed_device, + uint8_t key, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GRAB_DEVICE_KEY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE_KEY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1769,23 +2332,23 @@ xcb_input_grab_device_key_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_grab_device_key (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint16_t num_classes /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t grabbed_device /**< */, - uint8_t key /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t owner_events /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_grab_device_key (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t num_classes, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t grabbed_device, + uint8_t key, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GRAB_DEVICE_KEY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE_KEY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1817,19 +2380,41 @@ xcb_input_grab_device_key (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_input_event_class_t * +xcb_input_grab_device_key_classes (const xcb_input_grab_device_key_request_t *R) +{ + return (xcb_input_event_class_t *) (R + 1); +} + +int +xcb_input_grab_device_key_classes_length (const xcb_input_grab_device_key_request_t *R) +{ + return R->num_classes; +} + +xcb_generic_iterator_t +xcb_input_grab_device_key_classes_end (const xcb_input_grab_device_key_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_input_ungrab_device_key_checked (xcb_connection_t *c /**< */, - xcb_window_t grabWindow /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t key /**< */, - uint8_t grabbed_device /**< */) +xcb_input_ungrab_device_key_checked (xcb_connection_t *c, + xcb_window_t grabWindow, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t key, + uint8_t grabbed_device) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_UNGRAB_DEVICE_KEY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE_KEY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1852,18 +2437,18 @@ xcb_input_ungrab_device_key_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_ungrab_device_key (xcb_connection_t *c /**< */, - xcb_window_t grabWindow /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t key /**< */, - uint8_t grabbed_device /**< */) +xcb_input_ungrab_device_key (xcb_connection_t *c, + xcb_window_t grabWindow, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t key, + uint8_t grabbed_device) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_UNGRAB_DEVICE_KEY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE_KEY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1886,7 +2471,7 @@ xcb_input_ungrab_device_key (xcb_connection_t *c /**< */, } int -xcb_input_grab_device_button_sizeof (const void *_buffer /**< */) +xcb_input_grab_device_button_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_grab_device_button_request_t *_aux = (xcb_input_grab_device_button_request_t *)_buffer; @@ -1917,23 +2502,23 @@ xcb_input_grab_device_button_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_input_grab_device_button_checked (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint8_t grabbed_device /**< */, - uint8_t modifier_device /**< */, - uint16_t num_classes /**< */, - uint16_t modifiers /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t button /**< */, - uint8_t owner_events /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_grab_device_button_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint8_t grabbed_device, + uint8_t modifier_device, + uint16_t num_classes, + uint16_t modifiers, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t button, + uint8_t owner_events, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GRAB_DEVICE_BUTTON, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE_BUTTON, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1966,23 +2551,23 @@ xcb_input_grab_device_button_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_grab_device_button (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint8_t grabbed_device /**< */, - uint8_t modifier_device /**< */, - uint16_t num_classes /**< */, - uint16_t modifiers /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t button /**< */, - uint8_t owner_events /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_grab_device_button (xcb_connection_t *c, + xcb_window_t grab_window, + uint8_t grabbed_device, + uint8_t modifier_device, + uint16_t num_classes, + uint16_t modifiers, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t button, + uint8_t owner_events, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GRAB_DEVICE_BUTTON, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GRAB_DEVICE_BUTTON, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2014,19 +2599,41 @@ xcb_input_grab_device_button (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_input_event_class_t * +xcb_input_grab_device_button_classes (const xcb_input_grab_device_button_request_t *R) +{ + return (xcb_input_event_class_t *) (R + 1); +} + +int +xcb_input_grab_device_button_classes_length (const xcb_input_grab_device_button_request_t *R) +{ + return R->num_classes; +} + +xcb_generic_iterator_t +xcb_input_grab_device_button_classes_end (const xcb_input_grab_device_button_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_input_ungrab_device_button_checked (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t button /**< */, - uint8_t grabbed_device /**< */) +xcb_input_ungrab_device_button_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t button, + uint8_t grabbed_device) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_UNGRAB_DEVICE_BUTTON, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE_BUTTON, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2038,6 +2645,7 @@ xcb_input_ungrab_device_button_checked (xcb_connection_t *c /**< */, xcb_out.modifier_device = modifier_device; xcb_out.button = button; xcb_out.grabbed_device = grabbed_device; + memset(xcb_out.pad0, 0, 3); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -2049,18 +2657,18 @@ xcb_input_ungrab_device_button_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_ungrab_device_button (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t button /**< */, - uint8_t grabbed_device /**< */) +xcb_input_ungrab_device_button (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t button, + uint8_t grabbed_device) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_UNGRAB_DEVICE_BUTTON, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_UNGRAB_DEVICE_BUTTON, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2072,6 +2680,7 @@ xcb_input_ungrab_device_button (xcb_connection_t *c /**< */, xcb_out.modifier_device = modifier_device; xcb_out.button = button; xcb_out.grabbed_device = grabbed_device; + memset(xcb_out.pad0, 0, 3); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -2083,16 +2692,16 @@ xcb_input_ungrab_device_button (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_allow_device_events_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - uint8_t mode /**< */, - uint8_t device_id /**< */) +xcb_input_allow_device_events_checked (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t mode, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_ALLOW_DEVICE_EVENTS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_ALLOW_DEVICE_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2102,6 +2711,7 @@ xcb_input_allow_device_events_checked (xcb_connection_t *c /**< */, xcb_out.time = time; xcb_out.mode = mode; xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 2); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -2113,16 +2723,16 @@ xcb_input_allow_device_events_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_allow_device_events (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - uint8_t mode /**< */, - uint8_t device_id /**< */) +xcb_input_allow_device_events (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t mode, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_ALLOW_DEVICE_EVENTS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_ALLOW_DEVICE_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2132,6 +2742,7 @@ xcb_input_allow_device_events (xcb_connection_t *c /**< */, xcb_out.time = time; xcb_out.mode = mode; xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 2); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -2143,14 +2754,14 @@ xcb_input_allow_device_events (xcb_connection_t *c /**< */, } xcb_input_get_device_focus_cookie_t -xcb_input_get_device_focus (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_get_device_focus (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_FOCUS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_FOCUS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2170,14 +2781,14 @@ xcb_input_get_device_focus (xcb_connection_t *c /**< */, } xcb_input_get_device_focus_cookie_t -xcb_input_get_device_focus_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_get_device_focus_unchecked (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_FOCUS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_FOCUS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2197,25 +2808,25 @@ xcb_input_get_device_focus_unchecked (xcb_connection_t *c /**< */, } xcb_input_get_device_focus_reply_t * -xcb_input_get_device_focus_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_focus_reply (xcb_connection_t *c, xcb_input_get_device_focus_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_device_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_input_set_device_focus_checked (xcb_connection_t *c /**< */, - xcb_window_t focus /**< */, - xcb_timestamp_t time /**< */, - uint8_t revert_to /**< */, - uint8_t device_id /**< */) +xcb_input_set_device_focus_checked (xcb_connection_t *c, + xcb_window_t focus, + xcb_timestamp_t time, + uint8_t revert_to, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SET_DEVICE_FOCUS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_FOCUS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2226,6 +2837,7 @@ xcb_input_set_device_focus_checked (xcb_connection_t *c /**< */, xcb_out.time = time; xcb_out.revert_to = revert_to; xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 2); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -2237,17 +2849,17 @@ xcb_input_set_device_focus_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_set_device_focus (xcb_connection_t *c /**< */, - xcb_window_t focus /**< */, - xcb_timestamp_t time /**< */, - uint8_t revert_to /**< */, - uint8_t device_id /**< */) +xcb_input_set_device_focus (xcb_connection_t *c, + xcb_window_t focus, + xcb_timestamp_t time, + uint8_t revert_to, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SET_DEVICE_FOCUS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_FOCUS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2258,6 +2870,7 @@ xcb_input_set_device_focus (xcb_connection_t *c /**< */, xcb_out.time = time; xcb_out.revert_to = revert_to; xcb_out.device_id = device_id; + memset(xcb_out.pad0, 0, 2); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -2269,7 +2882,7 @@ xcb_input_set_device_focus (xcb_connection_t *c /**< */, } void -xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i /**< */) +xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i) { --i->rem; ++i->data; @@ -2277,7 +2890,7 @@ xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i / } xcb_generic_iterator_t -xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i /**< */) +xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2287,7 +2900,7 @@ xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i /** } void -xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i /**< */) +xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i) { --i->rem; ++i->data; @@ -2295,7 +2908,7 @@ xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i / } xcb_generic_iterator_t -xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i /**< */) +xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2305,7 +2918,7 @@ xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i /** } void -xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator_t *i /**< */) +xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator_t *i) { --i->rem; ++i->data; @@ -2313,7 +2926,7 @@ xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator } xcb_generic_iterator_t -xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_t i /**< */) +xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2323,7 +2936,7 @@ xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_ } int -xcb_input_string_feedback_state_sizeof (const void *_buffer /**< */) +xcb_input_string_feedback_state_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_string_feedback_state_t *_aux = (xcb_input_string_feedback_state_t *)_buffer; @@ -2354,19 +2967,19 @@ xcb_input_string_feedback_state_sizeof (const void *_buffer /**< */) } xcb_keysym_t * -xcb_input_string_feedback_state_keysyms (const xcb_input_string_feedback_state_t *R /**< */) +xcb_input_string_feedback_state_keysyms (const xcb_input_string_feedback_state_t *R) { return (xcb_keysym_t *) (R + 1); } int -xcb_input_string_feedback_state_keysyms_length (const xcb_input_string_feedback_state_t *R /**< */) +xcb_input_string_feedback_state_keysyms_length (const xcb_input_string_feedback_state_t *R) { return R->num_keysyms; } xcb_generic_iterator_t -xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_state_t *R /**< */) +xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_state_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_keysym_t *) (R + 1)) + (R->num_keysyms); @@ -2376,7 +2989,7 @@ xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_sta } void -xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t *i /**< */) +xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t *i) { xcb_input_string_feedback_state_t *R = i->data; xcb_generic_iterator_t child; @@ -2387,7 +3000,7 @@ xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t } xcb_generic_iterator_t -xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t i /**< */) +xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -2399,7 +3012,7 @@ xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t } void -xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i /**< */) +xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i) { --i->rem; ++i->data; @@ -2407,7 +3020,7 @@ xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i } xcb_generic_iterator_t -xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i /**< */) +xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2417,7 +3030,7 @@ xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i / } void -xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i /**< */) +xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i) { --i->rem; ++i->data; @@ -2425,7 +3038,7 @@ xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i / } xcb_generic_iterator_t -xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i /**< */) +xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2434,8 +3047,435 @@ xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i /** return ret; } +xcb_keysym_t * +xcb_input_feedback_state_data_string_keysyms (const xcb_input_feedback_state_data_t *S) +{ + return S->string.keysyms; +} + int -xcb_input_feedback_state_sizeof (const void *_buffer /**< */) +xcb_input_feedback_state_data_string_keysyms_length (const xcb_input_feedback_state_t *R, + const xcb_input_feedback_state_data_t *S) +{ + return S->string.num_keysyms; +} + +xcb_generic_iterator_t +xcb_input_feedback_state_data_string_keysyms_end (const xcb_input_feedback_state_t *R, + const xcb_input_feedback_state_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->string.keysyms + S->string.num_keysyms; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_feedback_state_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_feedback_state_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[27]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) { + /* xcb_input_feedback_state_data_t.keyboard.pitch */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.pitch; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.keyboard.duration */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.duration; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.keyboard.led_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.keyboard.led_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_values; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.keyboard.global_auto_repeat */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.global_auto_repeat; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.click */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.click; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.percent; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.auto_repeats */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyboard.auto_repeats; + xcb_block_len += 32; + xcb_parts[xcb_parts_idx].iov_len = 32; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) { + /* xcb_input_feedback_state_data_t.pointer.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.pointer.accel_num */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.accel_num; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.pointer.accel_denom */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.accel_denom; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.pointer.threshold */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.threshold; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) { + /* xcb_input_feedback_state_data_t.string.max_symbols */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.max_symbols; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.string.num_keysyms */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.num_keysyms; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* keysyms */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->string.keysyms; + xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->string.num_keysyms * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_keysym_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) { + /* xcb_input_feedback_state_data_t.integer.resolution */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.resolution; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.integer.min_value */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.min_value; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_feedback_state_data_t.integer.max_value */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.max_value; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) { + /* xcb_input_feedback_state_data_t.led.led_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.led.led_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_values; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) { + /* xcb_input_feedback_state_data_t.bell.percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.percent; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.bell.pad2 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.bell.pitch */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.pitch; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.bell.duration */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.duration; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ikeyboard.pitch = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.keyboard.duration */ + _aux->keyboard.duration = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.keyboard.led_mask */ + _aux->keyboard.led_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.keyboard.led_values */ + _aux->keyboard.led_values = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.keyboard.global_auto_repeat */ + _aux->keyboard.global_auto_repeat = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.click */ + _aux->keyboard.click = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.percent */ + _aux->keyboard.percent = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.pad0 */ + _aux->keyboard.pad0 = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.keyboard.auto_repeats */ + memcpy(_aux->keyboard.auto_repeats, xcb_tmp, sizeof(uint8_t) * 32); + xcb_block_len += sizeof(uint8_t) * 32; + xcb_tmp += sizeof(uint8_t) * 32; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) { + /* xcb_input_feedback_state_data_t.pointer.pad1 */ + _aux->pointer.pad1[0] = *(uint8_t *)xcb_tmp; + _aux->pointer.pad1[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.pointer.accel_num */ + _aux->pointer.accel_num = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.pointer.accel_denom */ + _aux->pointer.accel_denom = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.pointer.threshold */ + _aux->pointer.threshold = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) { + /* xcb_input_feedback_state_data_t.string.max_symbols */ + _aux->string.max_symbols = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.string.num_keysyms */ + _aux->string.num_keysyms = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_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; + /* keysyms */ + _aux->string.keysyms = (xcb_keysym_t *)xcb_tmp; + xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_keysym_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) { + /* xcb_input_feedback_state_data_t.integer.resolution */ + _aux->integer.resolution = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.integer.min_value */ + _aux->integer.min_value = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_feedback_state_data_t.integer.max_value */ + _aux->integer.max_value = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) { + /* xcb_input_feedback_state_data_t.led.led_mask */ + _aux->led.led_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_state_data_t.led.led_values */ + _aux->led.led_values = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) { + /* xcb_input_feedback_state_data_t.bell.percent */ + _aux->bell.percent = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.bell.pad2 */ + _aux->bell.pad2[0] = *(uint8_t *)xcb_tmp; + _aux->bell.pad2[1] = *(uint8_t *)xcb_tmp; + _aux->bell.pad2[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_state_data_t.bell.pitch */ + _aux->bell.pitch = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_feedback_state_data_t.bell.duration */ + _aux->bell.duration = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_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; +} + +int +xcb_input_feedback_state_data_sizeof (const void *_buffer, + uint8_t class_id) +{ + xcb_input_feedback_state_data_t _aux; + return xcb_input_feedback_state_data_unpack(_buffer, class_id, &_aux); +} + +int +xcb_input_feedback_state_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_feedback_state_t *_aux = (xcb_input_feedback_state_t *)_buffer; @@ -2449,10 +3489,10 @@ xcb_input_feedback_state_sizeof (const void *_buffer /**< */) xcb_tmp += xcb_block_len; xcb_buffer_len += xcb_block_len; xcb_block_len = 0; - /* uninterpreted_data */ - xcb_block_len += (_aux->len - 4) * sizeof(uint8_t); + /* data */ + xcb_block_len += xcb_input_feedback_state_data_sizeof(xcb_tmp, _aux->class_id); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -2465,30 +3505,14 @@ xcb_input_feedback_state_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } -uint8_t * -xcb_input_feedback_state_uninterpreted_data (const xcb_input_feedback_state_t *R /**< */) +void * +xcb_input_feedback_state_data (const xcb_input_feedback_state_t *R) { - return (uint8_t *) (R + 1); -} - -int -xcb_input_feedback_state_uninterpreted_data_length (const xcb_input_feedback_state_t *R /**< */) -{ - return (R->len - 4); -} - -xcb_generic_iterator_t -xcb_input_feedback_state_uninterpreted_data_end (const xcb_input_feedback_state_t *R /**< */) -{ - xcb_generic_iterator_t i; - i.data = ((uint8_t *) (R + 1)) + ((R->len - 4)); - i.rem = 0; - i.index = (char *) i.data - (char *) R; - return i; + return (void *) (R + 1); } void -xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i /**< */) +xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i) { xcb_input_feedback_state_t *R = i->data; xcb_generic_iterator_t child; @@ -2499,7 +3523,7 @@ xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i /**< */) +xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -2511,7 +3535,7 @@ xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i /**< */) } int -xcb_input_get_feedback_control_sizeof (const void *_buffer /**< */) +xcb_input_get_feedback_control_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_get_feedback_control_reply_t *_aux = (xcb_input_get_feedback_control_reply_t *)_buffer; @@ -2547,14 +3571,14 @@ xcb_input_get_feedback_control_sizeof (const void *_buffer /**< */) } xcb_input_get_feedback_control_cookie_t -xcb_input_get_feedback_control (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_get_feedback_control (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_FEEDBACK_CONTROL, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_FEEDBACK_CONTROL, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2574,14 +3598,14 @@ xcb_input_get_feedback_control (xcb_connection_t *c /**< */, } xcb_input_get_feedback_control_cookie_t -xcb_input_get_feedback_control_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_get_feedback_control_unchecked (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_FEEDBACK_CONTROL, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_FEEDBACK_CONTROL, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2601,13 +3625,13 @@ xcb_input_get_feedback_control_unchecked (xcb_connection_t *c /**< */, } int -xcb_input_get_feedback_control_feedbacks_length (const xcb_input_get_feedback_control_reply_t *R /**< */) +xcb_input_get_feedback_control_feedbacks_length (const xcb_input_get_feedback_control_reply_t *R) { return R->num_feedbacks; } xcb_input_feedback_state_iterator_t -xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_control_reply_t *R /**< */) +xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_control_reply_t *R) { xcb_input_feedback_state_iterator_t i; i.data = (xcb_input_feedback_state_t *) (R + 1); @@ -2617,15 +3641,15 @@ xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_ } xcb_input_get_feedback_control_reply_t * -xcb_input_get_feedback_control_reply (xcb_connection_t *c /**< */, +xcb_input_get_feedback_control_reply (xcb_connection_t *c, xcb_input_get_feedback_control_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_feedback_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } void -xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i /**< */) +xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i) { --i->rem; ++i->data; @@ -2633,7 +3657,7 @@ xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i /**< } xcb_generic_iterator_t -xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i /**< */) +xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2643,7 +3667,7 @@ xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i /**< */ } void -xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i /**< */) +xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i) { --i->rem; ++i->data; @@ -2651,7 +3675,7 @@ xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i /**< } xcb_generic_iterator_t -xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i /**< */) +xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2661,7 +3685,7 @@ xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i /**< */ } void -xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t *i /**< */) +xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t *i) { --i->rem; ++i->data; @@ -2669,7 +3693,7 @@ xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t * } xcb_generic_iterator_t -xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i /**< */) +xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2679,7 +3703,7 @@ xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i } int -xcb_input_string_feedback_ctl_sizeof (const void *_buffer /**< */) +xcb_input_string_feedback_ctl_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_string_feedback_ctl_t *_aux = (xcb_input_string_feedback_ctl_t *)_buffer; @@ -2710,19 +3734,19 @@ xcb_input_string_feedback_ctl_sizeof (const void *_buffer /**< */) } xcb_keysym_t * -xcb_input_string_feedback_ctl_keysyms (const xcb_input_string_feedback_ctl_t *R /**< */) +xcb_input_string_feedback_ctl_keysyms (const xcb_input_string_feedback_ctl_t *R) { return (xcb_keysym_t *) (R + 1); } int -xcb_input_string_feedback_ctl_keysyms_length (const xcb_input_string_feedback_ctl_t *R /**< */) +xcb_input_string_feedback_ctl_keysyms_length (const xcb_input_string_feedback_ctl_t *R) { return R->num_keysyms; } xcb_generic_iterator_t -xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t *R /**< */) +xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_keysym_t *) (R + 1)) + (R->num_keysyms); @@ -2732,7 +3756,7 @@ xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t } void -xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i /**< */) +xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i) { xcb_input_string_feedback_ctl_t *R = i->data; xcb_generic_iterator_t child; @@ -2743,7 +3767,7 @@ xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i } xcb_generic_iterator_t -xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i /**< */) +xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -2755,7 +3779,7 @@ xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i / } void -xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i /**< */) +xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i) { --i->rem; ++i->data; @@ -2763,7 +3787,7 @@ xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i /** } xcb_generic_iterator_t -xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i /**< */) +xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2773,7 +3797,7 @@ xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i /**< } void -xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i /**< */) +xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i) { --i->rem; ++i->data; @@ -2781,7 +3805,7 @@ xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i /**< } xcb_generic_iterator_t -xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i /**< */) +xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -2790,8 +3814,403 @@ xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i /**< */ return ret; } +xcb_keysym_t * +xcb_input_feedback_ctl_data_string_keysyms (const xcb_input_feedback_ctl_data_t *S) +{ + return S->string.keysyms; +} + int -xcb_input_feedback_ctl_sizeof (const void *_buffer /**< */) +xcb_input_feedback_ctl_data_string_keysyms_length (const xcb_input_feedback_ctl_t *R, + const xcb_input_feedback_ctl_data_t *S) +{ + return S->string.num_keysyms; +} + +xcb_generic_iterator_t +xcb_input_feedback_ctl_data_string_keysyms_end (const xcb_input_feedback_ctl_t *R, + const xcb_input_feedback_ctl_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->string.keysyms + S->string.num_keysyms; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_feedback_ctl_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_feedback_ctl_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[24]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) { + /* xcb_input_feedback_ctl_data_t.keyboard.key */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.key; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_feedback_ctl_data_t.keyboard.auto_repeat_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.auto_repeat_mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.key_click_percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.key_click_percent; + xcb_block_len += sizeof(int8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_percent; + xcb_block_len += sizeof(int8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_pitch */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_pitch; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_duration */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_duration; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.keyboard.led_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_ctl_data_t.keyboard.led_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_values; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) { + /* xcb_input_feedback_ctl_data_t.pointer.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.pointer.num */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.num; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.pointer.denom */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.denom; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.pointer.threshold */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.threshold; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) { + /* xcb_input_feedback_ctl_data_t.string.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.string.num_keysyms */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.num_keysyms; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* keysyms */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->string.keysyms; + xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->string.num_keysyms * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_keysym_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) { + /* xcb_input_feedback_ctl_data_t.integer.int_to_display */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.int_to_display; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) { + /* xcb_input_feedback_ctl_data_t.led.led_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_ctl_data_t.led.led_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_values; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) { + /* xcb_input_feedback_ctl_data_t.bell.percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.percent; + xcb_block_len += sizeof(int8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.bell.pad2 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.bell.pitch */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.pitch; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.bell.duration */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.duration; + xcb_block_len += sizeof(int16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int16_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ikeyboard.key = *(xcb_input_key_code_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_key_code_t); + xcb_tmp += sizeof(xcb_input_key_code_t); + xcb_align_to = ALIGNOF(xcb_input_key_code_t); + /* xcb_input_feedback_ctl_data_t.keyboard.auto_repeat_mode */ + _aux->keyboard.auto_repeat_mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.key_click_percent */ + _aux->keyboard.key_click_percent = *(int8_t *)xcb_tmp; + xcb_block_len += sizeof(int8_t); + xcb_tmp += sizeof(int8_t); + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_percent */ + _aux->keyboard.bell_percent = *(int8_t *)xcb_tmp; + xcb_block_len += sizeof(int8_t); + xcb_tmp += sizeof(int8_t); + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_pitch */ + _aux->keyboard.bell_pitch = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.keyboard.bell_duration */ + _aux->keyboard.bell_duration = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.keyboard.led_mask */ + _aux->keyboard.led_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_ctl_data_t.keyboard.led_values */ + _aux->keyboard.led_values = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) { + /* xcb_input_feedback_ctl_data_t.pointer.pad0 */ + _aux->pointer.pad0[0] = *(uint8_t *)xcb_tmp; + _aux->pointer.pad0[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.pointer.num */ + _aux->pointer.num = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.pointer.denom */ + _aux->pointer.denom = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.pointer.threshold */ + _aux->pointer.threshold = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) { + /* xcb_input_feedback_ctl_data_t.string.pad1 */ + _aux->string.pad1[0] = *(uint8_t *)xcb_tmp; + _aux->string.pad1[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.string.num_keysyms */ + _aux->string.num_keysyms = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_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; + /* keysyms */ + _aux->string.keysyms = (xcb_keysym_t *)xcb_tmp; + xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_keysym_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) { + /* xcb_input_feedback_ctl_data_t.integer.int_to_display */ + _aux->integer.int_to_display = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) { + /* xcb_input_feedback_ctl_data_t.led.led_mask */ + _aux->led.led_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_feedback_ctl_data_t.led.led_values */ + _aux->led.led_values = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) { + /* xcb_input_feedback_ctl_data_t.bell.percent */ + _aux->bell.percent = *(int8_t *)xcb_tmp; + xcb_block_len += sizeof(int8_t); + xcb_tmp += sizeof(int8_t); + xcb_align_to = ALIGNOF(int8_t); + /* xcb_input_feedback_ctl_data_t.bell.pad2 */ + _aux->bell.pad2[0] = *(uint8_t *)xcb_tmp; + _aux->bell.pad2[1] = *(uint8_t *)xcb_tmp; + _aux->bell.pad2[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_feedback_ctl_data_t.bell.pitch */ + _aux->bell.pitch = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_t); + /* xcb_input_feedback_ctl_data_t.bell.duration */ + _aux->bell.duration = *(int16_t *)xcb_tmp; + xcb_block_len += sizeof(int16_t); + xcb_tmp += sizeof(int16_t); + xcb_align_to = ALIGNOF(int16_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; +} + +int +xcb_input_feedback_ctl_data_sizeof (const void *_buffer, + uint8_t class_id) +{ + xcb_input_feedback_ctl_data_t _aux; + return xcb_input_feedback_ctl_data_unpack(_buffer, class_id, &_aux); +} + +int +xcb_input_feedback_ctl_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_feedback_ctl_t *_aux = (xcb_input_feedback_ctl_t *)_buffer; @@ -2805,10 +4224,10 @@ xcb_input_feedback_ctl_sizeof (const void *_buffer /**< */) xcb_tmp += xcb_block_len; xcb_buffer_len += xcb_block_len; xcb_block_len = 0; - /* uninterpreted_data */ - xcb_block_len += (_aux->len - 4) * sizeof(uint8_t); + /* data */ + xcb_block_len += xcb_input_feedback_ctl_data_sizeof(xcb_tmp, _aux->class_id); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -2821,30 +4240,14 @@ xcb_input_feedback_ctl_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } -uint8_t * -xcb_input_feedback_ctl_uninterpreted_data (const xcb_input_feedback_ctl_t *R /**< */) +void * +xcb_input_feedback_ctl_data (const xcb_input_feedback_ctl_t *R) { - return (uint8_t *) (R + 1); -} - -int -xcb_input_feedback_ctl_uninterpreted_data_length (const xcb_input_feedback_ctl_t *R /**< */) -{ - return (R->len - 4); -} - -xcb_generic_iterator_t -xcb_input_feedback_ctl_uninterpreted_data_end (const xcb_input_feedback_ctl_t *R /**< */) -{ - xcb_generic_iterator_t i; - i.data = ((uint8_t *) (R + 1)) + ((R->len - 4)); - i.rem = 0; - i.index = (char *) i.data - (char *) R; - return i; + return (void *) (R + 1); } void -xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i /**< */) +xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i) { xcb_input_feedback_ctl_t *R = i->data; xcb_generic_iterator_t child; @@ -2855,7 +4258,7 @@ xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i /**< */) +xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -2867,7 +4270,7 @@ xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i /**< */) } int -xcb_input_change_feedback_control_sizeof (const void *_buffer /**< */) +xcb_input_change_feedback_control_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -2897,17 +4300,17 @@ xcb_input_change_feedback_control_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_input_change_feedback_control_checked (xcb_connection_t *c /**< */, - uint32_t mask /**< */, - uint8_t device_id /**< */, - uint8_t feedback_id /**< */, - xcb_input_feedback_ctl_t *feedback /**< */) +xcb_input_change_feedback_control_checked (xcb_connection_t *c, + uint32_t mask, + uint8_t device_id, + uint8_t feedback_id, + xcb_input_feedback_ctl_t *feedback) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_FEEDBACK_CONTROL, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_FEEDBACK_CONTROL, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2917,6 +4320,7 @@ xcb_input_change_feedback_control_checked (xcb_connection_t *c /**< */, xcb_out.mask = mask; xcb_out.device_id = device_id; xcb_out.feedback_id = feedback_id; + memset(xcb_out.pad0, 0, 2); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -2932,17 +4336,17 @@ xcb_input_change_feedback_control_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_change_feedback_control (xcb_connection_t *c /**< */, - uint32_t mask /**< */, - uint8_t device_id /**< */, - uint8_t feedback_id /**< */, - xcb_input_feedback_ctl_t *feedback /**< */) +xcb_input_change_feedback_control (xcb_connection_t *c, + uint32_t mask, + uint8_t device_id, + uint8_t feedback_id, + xcb_input_feedback_ctl_t *feedback) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_FEEDBACK_CONTROL, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_FEEDBACK_CONTROL, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2952,6 +4356,7 @@ xcb_input_change_feedback_control (xcb_connection_t *c /**< */, xcb_out.mask = mask; xcb_out.device_id = device_id; xcb_out.feedback_id = feedback_id; + memset(xcb_out.pad0, 0, 2); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -2966,8 +4371,14 @@ xcb_input_change_feedback_control (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_input_feedback_ctl_t * +xcb_input_change_feedback_control_feedback (const xcb_input_change_feedback_control_request_t *R) +{ + return (xcb_input_feedback_ctl_t *) (R + 1); +} + int -xcb_input_get_device_key_mapping_sizeof (const void *_buffer /**< */) +xcb_input_get_device_key_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_get_device_key_mapping_reply_t *_aux = (xcb_input_get_device_key_mapping_reply_t *)_buffer; @@ -2998,16 +4409,16 @@ xcb_input_get_device_key_mapping_sizeof (const void *_buffer /**< */) } xcb_input_get_device_key_mapping_cookie_t -xcb_input_get_device_key_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - xcb_input_key_code_t first_keycode /**< */, - uint8_t count /**< */) +xcb_input_get_device_key_mapping (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t count) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_KEY_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_KEY_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3017,6 +4428,7 @@ xcb_input_get_device_key_mapping (xcb_connection_t *c /**< */, xcb_out.device_id = device_id; xcb_out.first_keycode = first_keycode; xcb_out.count = count; + xcb_out.pad0 = 0; xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -3028,16 +4440,16 @@ xcb_input_get_device_key_mapping (xcb_connection_t *c /**< */, } xcb_input_get_device_key_mapping_cookie_t -xcb_input_get_device_key_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - xcb_input_key_code_t first_keycode /**< */, - uint8_t count /**< */) +xcb_input_get_device_key_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t count) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_KEY_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_KEY_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3047,6 +4459,7 @@ xcb_input_get_device_key_mapping_unchecked (xcb_connection_t *c /**< */, xcb_out.device_id = device_id; xcb_out.first_keycode = first_keycode; xcb_out.count = count; + xcb_out.pad0 = 0; xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -3058,19 +4471,19 @@ xcb_input_get_device_key_mapping_unchecked (xcb_connection_t *c /**< */, } xcb_keysym_t * -xcb_input_get_device_key_mapping_keysyms (const xcb_input_get_device_key_mapping_reply_t *R /**< */) +xcb_input_get_device_key_mapping_keysyms (const xcb_input_get_device_key_mapping_reply_t *R) { return (xcb_keysym_t *) (R + 1); } int -xcb_input_get_device_key_mapping_keysyms_length (const xcb_input_get_device_key_mapping_reply_t *R /**< */) +xcb_input_get_device_key_mapping_keysyms_length (const xcb_input_get_device_key_mapping_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_mapping_reply_t *R /**< */) +xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_mapping_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_keysym_t *) (R + 1)) + (R->length); @@ -3080,15 +4493,15 @@ xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_map } xcb_input_get_device_key_mapping_reply_t * -xcb_input_get_device_key_mapping_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_key_mapping_reply (xcb_connection_t *c, xcb_input_get_device_key_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_device_key_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_change_device_key_mapping_sizeof (const void *_buffer /**< */) +xcb_input_change_device_key_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_change_device_key_mapping_request_t *_aux = (xcb_input_change_device_key_mapping_request_t *)_buffer; @@ -3119,18 +4532,18 @@ xcb_input_change_device_key_mapping_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_input_change_device_key_mapping_checked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - xcb_input_key_code_t first_keycode /**< */, - uint8_t keysyms_per_keycode /**< */, - uint8_t keycode_count /**< */, - const xcb_keysym_t *keysyms /**< */) +xcb_input_change_device_key_mapping_checked (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t keysyms_per_keycode, + uint8_t keycode_count, + const xcb_keysym_t *keysyms) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -3157,18 +4570,18 @@ xcb_input_change_device_key_mapping_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_change_device_key_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - xcb_input_key_code_t first_keycode /**< */, - uint8_t keysyms_per_keycode /**< */, - uint8_t keycode_count /**< */, - const xcb_keysym_t *keysyms /**< */) +xcb_input_change_device_key_mapping (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t keysyms_per_keycode, + uint8_t keycode_count, + const xcb_keysym_t *keysyms) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -3194,8 +4607,30 @@ xcb_input_change_device_key_mapping (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_keysym_t * +xcb_input_change_device_key_mapping_keysyms (const xcb_input_change_device_key_mapping_request_t *R) +{ + return (xcb_keysym_t *) (R + 1); +} + int -xcb_input_get_device_modifier_mapping_sizeof (const void *_buffer /**< */) +xcb_input_change_device_key_mapping_keysyms_length (const xcb_input_change_device_key_mapping_request_t *R) +{ + return (R->keycode_count * R->keysyms_per_keycode); +} + +xcb_generic_iterator_t +xcb_input_change_device_key_mapping_keysyms_end (const xcb_input_change_device_key_mapping_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_keysym_t *) (R + 1)) + ((R->keycode_count * R->keysyms_per_keycode)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_get_device_modifier_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_get_device_modifier_mapping_reply_t *_aux = (xcb_input_get_device_modifier_mapping_reply_t *)_buffer; @@ -3226,14 +4661,14 @@ xcb_input_get_device_modifier_mapping_sizeof (const void *_buffer /**< */) } xcb_input_get_device_modifier_mapping_cookie_t -xcb_input_get_device_modifier_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_get_device_modifier_mapping (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3253,14 +4688,14 @@ xcb_input_get_device_modifier_mapping (xcb_connection_t *c /**< */, } xcb_input_get_device_modifier_mapping_cookie_t -xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3280,19 +4715,19 @@ xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_input_get_device_modifier_mapping_keymaps (const xcb_input_get_device_modifier_mapping_reply_t *R /**< */) +xcb_input_get_device_modifier_mapping_keymaps (const xcb_input_get_device_modifier_mapping_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_input_get_device_modifier_mapping_keymaps_length (const xcb_input_get_device_modifier_mapping_reply_t *R /**< */) +xcb_input_get_device_modifier_mapping_keymaps_length (const xcb_input_get_device_modifier_mapping_reply_t *R) { return (R->keycodes_per_modifier * 8); } xcb_generic_iterator_t -xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_modifier_mapping_reply_t *R /**< */) +xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_modifier_mapping_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->keycodes_per_modifier * 8)); @@ -3302,15 +4737,15 @@ xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_mo } xcb_input_get_device_modifier_mapping_reply_t * -xcb_input_get_device_modifier_mapping_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_modifier_mapping_reply (xcb_connection_t *c, xcb_input_get_device_modifier_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_device_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_set_device_modifier_mapping_sizeof (const void *_buffer /**< */) +xcb_input_set_device_modifier_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_set_device_modifier_mapping_request_t *_aux = (xcb_input_set_device_modifier_mapping_request_t *)_buffer; @@ -3341,16 +4776,16 @@ xcb_input_set_device_modifier_mapping_sizeof (const void *_buffer /**< */) } xcb_input_set_device_modifier_mapping_cookie_t -xcb_input_set_device_modifier_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t keycodes_per_modifier /**< */, - const uint8_t *keymaps /**< */) +xcb_input_set_device_modifier_mapping (xcb_connection_t *c, + uint8_t device_id, + uint8_t keycodes_per_modifier, + const uint8_t *keymaps) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -3359,7 +4794,7 @@ xcb_input_set_device_modifier_mapping (xcb_connection_t *c /**< */, xcb_out.device_id = device_id; xcb_out.keycodes_per_modifier = keycodes_per_modifier; - xcb_out.pad0 = 0; + memset(xcb_out.pad0, 0, 2); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -3376,16 +4811,16 @@ xcb_input_set_device_modifier_mapping (xcb_connection_t *c /**< */, } xcb_input_set_device_modifier_mapping_cookie_t -xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t keycodes_per_modifier /**< */, - const uint8_t *keymaps /**< */) +xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t keycodes_per_modifier, + const uint8_t *keymaps) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -3394,7 +4829,7 @@ xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c /**< */, xcb_out.device_id = device_id; xcb_out.keycodes_per_modifier = keycodes_per_modifier; - xcb_out.pad0 = 0; + memset(xcb_out.pad0, 0, 2); xcb_parts[2].iov_base = (char *) &xcb_out; xcb_parts[2].iov_len = sizeof(xcb_out); @@ -3411,15 +4846,15 @@ xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c /**< */, } xcb_input_set_device_modifier_mapping_reply_t * -xcb_input_set_device_modifier_mapping_reply (xcb_connection_t *c /**< */, +xcb_input_set_device_modifier_mapping_reply (xcb_connection_t *c, xcb_input_set_device_modifier_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_set_device_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_get_device_button_mapping_sizeof (const void *_buffer /**< */) +xcb_input_get_device_button_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_get_device_button_mapping_reply_t *_aux = (xcb_input_get_device_button_mapping_reply_t *)_buffer; @@ -3437,6 +4872,15 @@ xcb_input_get_device_button_mapping_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->map_size * sizeof(uint8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -3450,14 +4894,14 @@ xcb_input_get_device_button_mapping_sizeof (const void *_buffer /**< */) } xcb_input_get_device_button_mapping_cookie_t -xcb_input_get_device_button_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_get_device_button_mapping (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_BUTTON_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_BUTTON_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3477,14 +4921,14 @@ xcb_input_get_device_button_mapping (xcb_connection_t *c /**< */, } xcb_input_get_device_button_mapping_cookie_t -xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_BUTTON_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_BUTTON_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3504,19 +4948,19 @@ xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_input_get_device_button_mapping_map (const xcb_input_get_device_button_mapping_reply_t *R /**< */) +xcb_input_get_device_button_mapping_map (const xcb_input_get_device_button_mapping_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_input_get_device_button_mapping_map_length (const xcb_input_get_device_button_mapping_reply_t *R /**< */) +xcb_input_get_device_button_mapping_map_length (const xcb_input_get_device_button_mapping_reply_t *R) { return R->map_size; } xcb_generic_iterator_t -xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_mapping_reply_t *R /**< */) +xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_mapping_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + (R->map_size); @@ -3526,15 +4970,15 @@ xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_m } xcb_input_get_device_button_mapping_reply_t * -xcb_input_get_device_button_mapping_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_button_mapping_reply (xcb_connection_t *c, xcb_input_get_device_button_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_device_button_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_set_device_button_mapping_sizeof (const void *_buffer /**< */) +xcb_input_set_device_button_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_set_device_button_mapping_request_t *_aux = (xcb_input_set_device_button_mapping_request_t *)_buffer; @@ -3565,16 +5009,16 @@ xcb_input_set_device_button_mapping_sizeof (const void *_buffer /**< */) } xcb_input_set_device_button_mapping_cookie_t -xcb_input_set_device_button_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t map_size /**< */, - const uint8_t *map /**< */) +xcb_input_set_device_button_mapping (xcb_connection_t *c, + uint8_t device_id, + uint8_t map_size, + const uint8_t *map) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SET_DEVICE_BUTTON_MAPPING, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_BUTTON_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -3600,16 +5044,16 @@ xcb_input_set_device_button_mapping (xcb_connection_t *c /**< */, } xcb_input_set_device_button_mapping_cookie_t -xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t map_size /**< */, - const uint8_t *map /**< */) +xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t map_size, + const uint8_t *map) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SET_DEVICE_BUTTON_MAPPING, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_BUTTON_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -3635,15 +5079,15 @@ xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c /**< */, } xcb_input_set_device_button_mapping_reply_t * -xcb_input_set_device_button_mapping_reply (xcb_connection_t *c /**< */, +xcb_input_set_device_button_mapping_reply (xcb_connection_t *c, xcb_input_set_device_button_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_set_device_button_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } void -xcb_input_key_state_next (xcb_input_key_state_iterator_t *i /**< */) +xcb_input_key_state_next (xcb_input_key_state_iterator_t *i) { --i->rem; ++i->data; @@ -3651,7 +5095,7 @@ xcb_input_key_state_next (xcb_input_key_state_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_key_state_end (xcb_input_key_state_iterator_t i /**< */) +xcb_input_key_state_end (xcb_input_key_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -3661,7 +5105,7 @@ xcb_input_key_state_end (xcb_input_key_state_iterator_t i /**< */) } void -xcb_input_button_state_next (xcb_input_button_state_iterator_t *i /**< */) +xcb_input_button_state_next (xcb_input_button_state_iterator_t *i) { --i->rem; ++i->data; @@ -3669,7 +5113,7 @@ xcb_input_button_state_next (xcb_input_button_state_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_button_state_end (xcb_input_button_state_iterator_t i /**< */) +xcb_input_button_state_end (xcb_input_button_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -3679,7 +5123,7 @@ xcb_input_button_state_end (xcb_input_button_state_iterator_t i /**< */) } int -xcb_input_valuator_state_sizeof (const void *_buffer /**< */) +xcb_input_valuator_state_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_valuator_state_t *_aux = (xcb_input_valuator_state_t *)_buffer; @@ -3694,9 +5138,9 @@ xcb_input_valuator_state_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* valuators */ - xcb_block_len += _aux->num_valuators * sizeof(uint32_t); + xcb_block_len += _aux->num_valuators * sizeof(int32_t); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(int32_t); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -3709,30 +5153,30 @@ xcb_input_valuator_state_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } -uint32_t * -xcb_input_valuator_state_valuators (const xcb_input_valuator_state_t *R /**< */) +int32_t * +xcb_input_valuator_state_valuators (const xcb_input_valuator_state_t *R) { - return (uint32_t *) (R + 1); + return (int32_t *) (R + 1); } int -xcb_input_valuator_state_valuators_length (const xcb_input_valuator_state_t *R /**< */) +xcb_input_valuator_state_valuators_length (const xcb_input_valuator_state_t *R) { return R->num_valuators; } xcb_generic_iterator_t -xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R /**< */) +xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R) { xcb_generic_iterator_t i; - i.data = ((uint32_t *) (R + 1)) + (R->num_valuators); + i.data = ((int32_t *) (R + 1)) + (R->num_valuators); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } void -xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i /**< */) +xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i) { xcb_input_valuator_state_t *R = i->data; xcb_generic_iterator_t child; @@ -3743,7 +5187,7 @@ xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i /**< */) +xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -3754,8 +5198,244 @@ xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i /**< */) return ret; } +int32_t * +xcb_input_input_state_data_valuator_valuators (const xcb_input_input_state_data_t *S) +{ + return S->valuator.valuators; +} + int -xcb_input_input_state_sizeof (const void *_buffer /**< */) +xcb_input_input_state_data_valuator_valuators_length (const xcb_input_input_state_t *R, + const xcb_input_input_state_data_t *S) +{ + return S->valuator.num_valuators; +} + +xcb_generic_iterator_t +xcb_input_input_state_data_valuator_valuators_end (const xcb_input_input_state_t *R, + const xcb_input_input_state_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->valuator.valuators + S->valuator.num_valuators; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_input_state_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_input_state_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 2; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[11]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(class_id == XCB_INPUT_INPUT_CLASS_KEY) { + /* xcb_input_input_state_data_t.key.num_keys */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.key.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.key.keys */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->key.keys; + xcb_block_len += 32; + xcb_parts[xcb_parts_idx].iov_len = 32; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) { + /* xcb_input_input_state_data_t.button.num_buttons */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.button.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.button.buttons */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.buttons; + xcb_block_len += 32; + xcb_parts[xcb_parts_idx].iov_len = 32; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) { + /* xcb_input_input_state_data_t.valuator.num_valuators */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.num_valuators; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.valuator.mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* valuators */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->valuator.valuators; + xcb_block_len += _aux->valuator.num_valuators * sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->valuator.num_valuators * sizeof(int32_t); + xcb_parts_idx++; + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ikey.num_keys = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.key.pad0 */ + _aux->key.pad0 = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.key.keys */ + memcpy(_aux->key.keys, xcb_tmp, sizeof(uint8_t) * 32); + xcb_block_len += sizeof(uint8_t) * 32; + xcb_tmp += sizeof(uint8_t) * 32; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) { + /* xcb_input_input_state_data_t.button.num_buttons */ + _aux->button.num_buttons = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.button.pad1 */ + _aux->button.pad1 = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.button.buttons */ + memcpy(_aux->button.buttons, xcb_tmp, sizeof(uint8_t) * 32); + xcb_block_len += sizeof(uint8_t) * 32; + xcb_tmp += sizeof(uint8_t) * 32; + xcb_align_to = ALIGNOF(uint8_t); + } + if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) { + /* xcb_input_input_state_data_t.valuator.num_valuators */ + _aux->valuator.num_valuators = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_input_state_data_t.valuator.mode */ + _aux->valuator.mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_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; + /* valuators */ + _aux->valuator.valuators = (int32_t *)xcb_tmp; + xcb_block_len += _aux->valuator.num_valuators * 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; +} + +int +xcb_input_input_state_data_sizeof (const void *_buffer, + uint8_t class_id) +{ + xcb_input_input_state_data_t _aux; + return xcb_input_input_state_data_unpack(_buffer, class_id, &_aux); +} + +int +xcb_input_input_state_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_input_state_t *_aux = (xcb_input_input_state_t *)_buffer; @@ -3769,10 +5449,10 @@ xcb_input_input_state_sizeof (const void *_buffer /**< */) xcb_tmp += xcb_block_len; xcb_buffer_len += xcb_block_len; xcb_block_len = 0; - /* uninterpreted_data */ - xcb_block_len += (_aux->len - 4) * sizeof(uint8_t); + /* data */ + xcb_block_len += xcb_input_input_state_data_sizeof(xcb_tmp, _aux->class_id); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -3785,30 +5465,14 @@ xcb_input_input_state_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } -uint8_t * -xcb_input_input_state_uninterpreted_data (const xcb_input_input_state_t *R /**< */) +void * +xcb_input_input_state_data (const xcb_input_input_state_t *R) { - return (uint8_t *) (R + 1); -} - -int -xcb_input_input_state_uninterpreted_data_length (const xcb_input_input_state_t *R /**< */) -{ - return (R->len - 4); -} - -xcb_generic_iterator_t -xcb_input_input_state_uninterpreted_data_end (const xcb_input_input_state_t *R /**< */) -{ - xcb_generic_iterator_t i; - i.data = ((uint8_t *) (R + 1)) + ((R->len - 4)); - i.rem = 0; - i.index = (char *) i.data - (char *) R; - return i; + return (void *) (R + 1); } void -xcb_input_input_state_next (xcb_input_input_state_iterator_t *i /**< */) +xcb_input_input_state_next (xcb_input_input_state_iterator_t *i) { xcb_input_input_state_t *R = i->data; xcb_generic_iterator_t child; @@ -3819,7 +5483,7 @@ xcb_input_input_state_next (xcb_input_input_state_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_input_state_end (xcb_input_input_state_iterator_t i /**< */) +xcb_input_input_state_end (xcb_input_input_state_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -3831,7 +5495,7 @@ xcb_input_input_state_end (xcb_input_input_state_iterator_t i /**< */) } int -xcb_input_query_device_state_sizeof (const void *_buffer /**< */) +xcb_input_query_device_state_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_query_device_state_reply_t *_aux = (xcb_input_query_device_state_reply_t *)_buffer; @@ -3867,14 +5531,14 @@ xcb_input_query_device_state_sizeof (const void *_buffer /**< */) } xcb_input_query_device_state_cookie_t -xcb_input_query_device_state (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_query_device_state (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_QUERY_DEVICE_STATE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_QUERY_DEVICE_STATE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3894,14 +5558,14 @@ xcb_input_query_device_state (xcb_connection_t *c /**< */, } xcb_input_query_device_state_cookie_t -xcb_input_query_device_state_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_query_device_state_unchecked (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_QUERY_DEVICE_STATE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_QUERY_DEVICE_STATE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3921,13 +5585,13 @@ xcb_input_query_device_state_unchecked (xcb_connection_t *c /**< */, } int -xcb_input_query_device_state_classes_length (const xcb_input_query_device_state_reply_t *R /**< */) +xcb_input_query_device_state_classes_length (const xcb_input_query_device_state_reply_t *R) { return R->num_classes; } xcb_input_input_state_iterator_t -xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_state_reply_t *R /**< */) +xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_state_reply_t *R) { xcb_input_input_state_iterator_t i; i.data = (xcb_input_input_state_t *) (R + 1); @@ -3937,15 +5601,15 @@ xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_stat } xcb_input_query_device_state_reply_t * -xcb_input_query_device_state_reply (xcb_connection_t *c /**< */, +xcb_input_query_device_state_reply (xcb_connection_t *c, xcb_input_query_device_state_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_query_device_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_send_extension_event_sizeof (const void *_buffer /**< */) +xcb_input_send_extension_event_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_send_extension_event_request_t *_aux = (xcb_input_send_extension_event_request_t *)_buffer; @@ -3988,20 +5652,20 @@ xcb_input_send_extension_event_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_input_send_extension_event_checked (xcb_connection_t *c /**< */, - xcb_window_t destination /**< */, - uint8_t device_id /**< */, - uint8_t propagate /**< */, - uint16_t num_classes /**< */, - uint8_t num_events /**< */, - const uint8_t *events /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_send_extension_event_checked (xcb_connection_t *c, + xcb_window_t destination, + uint8_t device_id, + uint8_t propagate, + uint16_t num_classes, + uint8_t num_events, + const uint8_t *events, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SEND_EXTENSION_EVENT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SEND_EXTENSION_EVENT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -4035,20 +5699,20 @@ xcb_input_send_extension_event_checked (xcb_connection_t *c /**< * } xcb_void_cookie_t -xcb_input_send_extension_event (xcb_connection_t *c /**< */, - xcb_window_t destination /**< */, - uint8_t device_id /**< */, - uint8_t propagate /**< */, - uint16_t num_classes /**< */, - uint8_t num_events /**< */, - const uint8_t *events /**< */, - const xcb_input_event_class_t *classes /**< */) +xcb_input_send_extension_event (xcb_connection_t *c, + xcb_window_t destination, + uint8_t device_id, + uint8_t propagate, + uint16_t num_classes, + uint8_t num_events, + const uint8_t *events, + const xcb_input_event_class_t *classes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SEND_EXTENSION_EVENT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SEND_EXTENSION_EVENT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -4081,18 +5745,64 @@ xcb_input_send_extension_event (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_input_send_extension_event_events (const xcb_input_send_extension_event_request_t *R) +{ + return (uint8_t *) (R + 1); +} + +int +xcb_input_send_extension_event_events_length (const xcb_input_send_extension_event_request_t *R) +{ + return (R->num_events * 32); +} + +xcb_generic_iterator_t +xcb_input_send_extension_event_events_end (const xcb_input_send_extension_event_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((R->num_events * 32)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_event_class_t * +xcb_input_send_extension_event_classes (const xcb_input_send_extension_event_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_send_extension_event_events_end(R); + return (xcb_input_event_class_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index) + 0); +} + +int +xcb_input_send_extension_event_classes_length (const xcb_input_send_extension_event_request_t *R) +{ + return R->num_classes; +} + +xcb_generic_iterator_t +xcb_input_send_extension_event_classes_end (const xcb_input_send_extension_event_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_send_extension_event_events_end(R); + i.data = ((xcb_input_event_class_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index))) + (R->num_classes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_input_device_bell_checked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t feedback_id /**< */, - uint8_t feedback_class /**< */, - int8_t percent /**< */) +xcb_input_device_bell_checked (xcb_connection_t *c, + uint8_t device_id, + uint8_t feedback_id, + uint8_t feedback_class, + int8_t percent) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_DEVICE_BELL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_DEVICE_BELL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4114,17 +5824,17 @@ xcb_input_device_bell_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_device_bell (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t feedback_id /**< */, - uint8_t feedback_class /**< */, - int8_t percent /**< */) +xcb_input_device_bell (xcb_connection_t *c, + uint8_t device_id, + uint8_t feedback_id, + uint8_t feedback_class, + int8_t percent) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_DEVICE_BELL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_DEVICE_BELL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4146,7 +5856,7 @@ xcb_input_device_bell (xcb_connection_t *c /**< */, } int -xcb_input_set_device_valuators_sizeof (const void *_buffer /**< */) +xcb_input_set_device_valuators_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_set_device_valuators_request_t *_aux = (xcb_input_set_device_valuators_request_t *)_buffer; @@ -4177,17 +5887,17 @@ xcb_input_set_device_valuators_sizeof (const void *_buffer /**< */) } xcb_input_set_device_valuators_cookie_t -xcb_input_set_device_valuators (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t first_valuator /**< */, - uint8_t num_valuators /**< */, - const int32_t *valuators /**< */) +xcb_input_set_device_valuators (xcb_connection_t *c, + uint8_t device_id, + uint8_t first_valuator, + uint8_t num_valuators, + const int32_t *valuators) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SET_DEVICE_VALUATORS, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_VALUATORS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -4214,17 +5924,17 @@ xcb_input_set_device_valuators (xcb_connection_t *c /**< */, } xcb_input_set_device_valuators_cookie_t -xcb_input_set_device_valuators_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t first_valuator /**< */, - uint8_t num_valuators /**< */, - const int32_t *valuators /**< */) +xcb_input_set_device_valuators_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t first_valuator, + uint8_t num_valuators, + const int32_t *valuators) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_SET_DEVICE_VALUATORS, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_SET_DEVICE_VALUATORS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -4251,15 +5961,15 @@ xcb_input_set_device_valuators_unchecked (xcb_connection_t *c /**< */, } xcb_input_set_device_valuators_reply_t * -xcb_input_set_device_valuators_reply (xcb_connection_t *c /**< */, +xcb_input_set_device_valuators_reply (xcb_connection_t *c, xcb_input_set_device_valuators_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_set_device_valuators_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_device_resolution_state_sizeof (const void *_buffer /**< */) +xcb_input_device_resolution_state_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_device_resolution_state_t *_aux = (xcb_input_device_resolution_state_t *)_buffer; @@ -4314,19 +6024,19 @@ xcb_input_device_resolution_state_sizeof (const void *_buffer /**< */) } uint32_t * -xcb_input_device_resolution_state_resolution_values (const xcb_input_device_resolution_state_t *R /**< */) +xcb_input_device_resolution_state_resolution_values (const xcb_input_device_resolution_state_t *R) { return (uint32_t *) (R + 1); } int -xcb_input_device_resolution_state_resolution_values_length (const xcb_input_device_resolution_state_t *R /**< */) +xcb_input_device_resolution_state_resolution_values_length (const xcb_input_device_resolution_state_t *R) { return R->num_valuators; } xcb_generic_iterator_t -xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_resolution_state_t *R /**< */) +xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_resolution_state_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->num_valuators); @@ -4336,55 +6046,55 @@ xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_ } uint32_t * -xcb_input_device_resolution_state_resolution_min (const xcb_input_device_resolution_state_t *R /**< */) +xcb_input_device_resolution_state_resolution_min (const xcb_input_device_resolution_state_t *R) { xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_values_end(R); return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); } int -xcb_input_device_resolution_state_resolution_min_length (const xcb_input_device_resolution_state_t *R /**< */) +xcb_input_device_resolution_state_resolution_min_length (const xcb_input_device_resolution_state_t *R) { return R->num_valuators; } xcb_generic_iterator_t -xcb_input_device_resolution_state_resolution_min_end (const xcb_input_device_resolution_state_t *R /**< */) +xcb_input_device_resolution_state_resolution_min_end (const xcb_input_device_resolution_state_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_input_device_resolution_state_resolution_values_end(R); - i.data = ((uint32_t *) child.data) + (R->num_valuators); + xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_values_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_valuators); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } uint32_t * -xcb_input_device_resolution_state_resolution_max (const xcb_input_device_resolution_state_t *R /**< */) +xcb_input_device_resolution_state_resolution_max (const xcb_input_device_resolution_state_t *R) { xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_min_end(R); return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); } int -xcb_input_device_resolution_state_resolution_max_length (const xcb_input_device_resolution_state_t *R /**< */) +xcb_input_device_resolution_state_resolution_max_length (const xcb_input_device_resolution_state_t *R) { return R->num_valuators; } xcb_generic_iterator_t -xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_resolution_state_t *R /**< */) +xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_resolution_state_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_input_device_resolution_state_resolution_min_end(R); - i.data = ((uint32_t *) child.data) + (R->num_valuators); + xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_min_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_valuators); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } void -xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterator_t *i /**< */) +xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterator_t *i) { xcb_input_device_resolution_state_t *R = i->data; xcb_generic_iterator_t child; @@ -4395,7 +6105,7 @@ xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterat } xcb_generic_iterator_t -xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterator_t i /**< */) +xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -4407,7 +6117,7 @@ xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterato } void -xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator_t *i /**< */) +xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator_t *i) { --i->rem; ++i->data; @@ -4415,7 +6125,7 @@ xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator } xcb_generic_iterator_t -xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_t i /**< */) +xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4425,7 +6135,7 @@ xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_ } void -xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t *i /**< */) +xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t *i) { --i->rem; ++i->data; @@ -4433,7 +6143,7 @@ xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t } xcb_generic_iterator_t -xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t i /**< */) +xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4443,7 +6153,7 @@ xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t } void -xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i /**< */) +xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i) { --i->rem; ++i->data; @@ -4451,7 +6161,7 @@ xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i /** } xcb_generic_iterator_t -xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i /**< */) +xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4461,7 +6171,7 @@ xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i /**< } void -xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i /**< */) +xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i) { --i->rem; ++i->data; @@ -4469,7 +6179,7 @@ xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i } xcb_generic_iterator_t -xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i /**< */) +xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4478,8 +6188,497 @@ xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i / return ret; } +uint32_t * +xcb_input_device_state_data_resolution_resolution_values (const xcb_input_device_state_data_t *S) +{ + return S->resolution.resolution_values; +} + int -xcb_input_device_state_sizeof (const void *_buffer /**< */) +xcb_input_device_state_data_resolution_resolution_values_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + return S->resolution.num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_values_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->resolution.resolution_values + S->resolution.num_valuators; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint32_t * +xcb_input_device_state_data_resolution_resolution_min (const xcb_input_device_state_data_t *S) +{ + return S->resolution.resolution_min; +} + +int +xcb_input_device_state_data_resolution_resolution_min_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + return S->resolution.num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_min_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->resolution.resolution_min + S->resolution.num_valuators; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint32_t * +xcb_input_device_state_data_resolution_resolution_max (const xcb_input_device_state_data_t *S) +{ + return S->resolution.resolution_max; +} + +int +xcb_input_device_state_data_resolution_resolution_max_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + return S->resolution.num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_max_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->resolution.resolution_max + S->resolution.num_valuators; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_device_state_data_serialize (void **_buffer, + uint16_t control_id, + const xcb_input_device_state_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[27]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) { + /* xcb_input_device_state_data_t.resolution.num_valuators */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.num_valuators; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_values; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_min */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_min; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_max */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_max; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) { + /* xcb_input_device_state_data_t.abs_calib.min_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_x; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.max_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_x; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.min_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_y; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.max_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_y; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.flip_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_x; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.flip_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_y; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.rotation */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.rotation; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.button_threshold */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.button_threshold; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) { + /* xcb_input_device_state_data_t.core.status */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.status; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.core.iscore */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.iscore; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.core.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) { + /* xcb_input_device_state_data_t.enable.enable */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->enable.enable; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.enable.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) { + /* xcb_input_device_state_data_t.abs_area.offset_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_x; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.offset_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_y; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.width */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.width; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.height */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.height; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.screen */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.screen; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.following */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.following; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; iresolution.num_valuators = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_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; + /* resolution_values */ + _aux->resolution.resolution_values = (uint32_t *)xcb_tmp; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_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; + /* resolution_min */ + _aux->resolution.resolution_min = (uint32_t *)xcb_tmp; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_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; + /* resolution_max */ + _aux->resolution.resolution_max = (uint32_t *)xcb_tmp; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) { + /* xcb_input_device_state_data_t.abs_calib.min_x */ + _aux->abs_calib.min_x = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.max_x */ + _aux->abs_calib.max_x = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.min_y */ + _aux->abs_calib.min_y = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.max_y */ + _aux->abs_calib.max_y = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_state_data_t.abs_calib.flip_x */ + _aux->abs_calib.flip_x = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.flip_y */ + _aux->abs_calib.flip_y = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.rotation */ + _aux->abs_calib.rotation = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_calib.button_threshold */ + _aux->abs_calib.button_threshold = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) { + /* xcb_input_device_state_data_t.core.status */ + _aux->core.status = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.core.iscore */ + _aux->core.iscore = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.core.pad0 */ + _aux->core.pad0[0] = *(uint8_t *)xcb_tmp; + _aux->core.pad0[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) { + /* xcb_input_device_state_data_t.enable.enable */ + _aux->enable.enable = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_state_data_t.enable.pad1 */ + _aux->enable.pad1[0] = *(uint8_t *)xcb_tmp; + _aux->enable.pad1[1] = *(uint8_t *)xcb_tmp; + _aux->enable.pad1[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) { + /* xcb_input_device_state_data_t.abs_area.offset_x */ + _aux->abs_area.offset_x = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.offset_y */ + _aux->abs_area.offset_y = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.width */ + _aux->abs_area.width = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.height */ + _aux->abs_area.height = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.screen */ + _aux->abs_area.screen = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_state_data_t.abs_area.following */ + _aux->abs_area.following = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_input_device_state_data_sizeof (const void *_buffer, + uint16_t control_id) +{ + xcb_input_device_state_data_t _aux; + return xcb_input_device_state_data_unpack(_buffer, control_id, &_aux); +} + +int +xcb_input_device_state_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_device_state_t *_aux = (xcb_input_device_state_t *)_buffer; @@ -4493,10 +6692,10 @@ xcb_input_device_state_sizeof (const void *_buffer /**< */) xcb_tmp += xcb_block_len; xcb_buffer_len += xcb_block_len; xcb_block_len = 0; - /* uninterpreted_data */ - xcb_block_len += (_aux->len - 4) * sizeof(uint8_t); + /* data */ + xcb_block_len += xcb_input_device_state_data_sizeof(xcb_tmp, _aux->control_id); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -4509,30 +6708,14 @@ xcb_input_device_state_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } -uint8_t * -xcb_input_device_state_uninterpreted_data (const xcb_input_device_state_t *R /**< */) +void * +xcb_input_device_state_data (const xcb_input_device_state_t *R) { - return (uint8_t *) (R + 1); -} - -int -xcb_input_device_state_uninterpreted_data_length (const xcb_input_device_state_t *R /**< */) -{ - return (R->len - 4); -} - -xcb_generic_iterator_t -xcb_input_device_state_uninterpreted_data_end (const xcb_input_device_state_t *R /**< */) -{ - xcb_generic_iterator_t i; - i.data = ((uint8_t *) (R + 1)) + ((R->len - 4)); - i.rem = 0; - i.index = (char *) i.data - (char *) R; - return i; + return (void *) (R + 1); } void -xcb_input_device_state_next (xcb_input_device_state_iterator_t *i /**< */) +xcb_input_device_state_next (xcb_input_device_state_iterator_t *i) { xcb_input_device_state_t *R = i->data; xcb_generic_iterator_t child; @@ -4543,7 +6726,7 @@ xcb_input_device_state_next (xcb_input_device_state_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_device_state_end (xcb_input_device_state_iterator_t i /**< */) +xcb_input_device_state_end (xcb_input_device_state_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -4555,7 +6738,7 @@ xcb_input_device_state_end (xcb_input_device_state_iterator_t i /**< */) } int -xcb_input_get_device_control_sizeof (const void *_buffer /**< */) +xcb_input_get_device_control_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -4585,15 +6768,15 @@ xcb_input_get_device_control_sizeof (const void *_buffer /**< */) } xcb_input_get_device_control_cookie_t -xcb_input_get_device_control (xcb_connection_t *c /**< */, - uint16_t control_id /**< */, - uint8_t device_id /**< */) +xcb_input_get_device_control (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_CONTROL, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_CONTROL, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4614,15 +6797,15 @@ xcb_input_get_device_control (xcb_connection_t *c /**< */, } xcb_input_get_device_control_cookie_t -xcb_input_get_device_control_unchecked (xcb_connection_t *c /**< */, - uint16_t control_id /**< */, - uint8_t device_id /**< */) +xcb_input_get_device_control_unchecked (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_CONTROL, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_CONTROL, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4643,21 +6826,21 @@ xcb_input_get_device_control_unchecked (xcb_connection_t *c /**< */, } xcb_input_device_state_t * -xcb_input_get_device_control_control (const xcb_input_get_device_control_reply_t *R /**< */) +xcb_input_get_device_control_control (const xcb_input_get_device_control_reply_t *R) { return (xcb_input_device_state_t *) (R + 1); } xcb_input_get_device_control_reply_t * -xcb_input_get_device_control_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_control_reply (xcb_connection_t *c, xcb_input_get_device_control_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_device_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_device_resolution_ctl_sizeof (const void *_buffer /**< */) +xcb_input_device_resolution_ctl_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_device_resolution_ctl_t *_aux = (xcb_input_device_resolution_ctl_t *)_buffer; @@ -4688,19 +6871,19 @@ xcb_input_device_resolution_ctl_sizeof (const void *_buffer /**< */) } uint32_t * -xcb_input_device_resolution_ctl_resolution_values (const xcb_input_device_resolution_ctl_t *R /**< */) +xcb_input_device_resolution_ctl_resolution_values (const xcb_input_device_resolution_ctl_t *R) { return (uint32_t *) (R + 1); } int -xcb_input_device_resolution_ctl_resolution_values_length (const xcb_input_device_resolution_ctl_t *R /**< */) +xcb_input_device_resolution_ctl_resolution_values_length (const xcb_input_device_resolution_ctl_t *R) { return R->num_valuators; } xcb_generic_iterator_t -xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_resolution_ctl_t *R /**< */) +xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_resolution_ctl_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->num_valuators); @@ -4710,7 +6893,7 @@ xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_re } void -xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t *i /**< */) +xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t *i) { xcb_input_device_resolution_ctl_t *R = i->data; xcb_generic_iterator_t child; @@ -4721,7 +6904,7 @@ xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t } xcb_generic_iterator_t -xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t i /**< */) +xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -4733,7 +6916,7 @@ xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t } void -xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t *i /**< */) +xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t *i) { --i->rem; ++i->data; @@ -4741,7 +6924,7 @@ xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t * } xcb_generic_iterator_t -xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i /**< */) +xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4751,7 +6934,7 @@ xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i } void -xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t *i /**< */) +xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t *i) { --i->rem; ++i->data; @@ -4759,7 +6942,7 @@ xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t * } xcb_generic_iterator_t -xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i /**< */) +xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4769,7 +6952,7 @@ xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i } void -xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i /**< */) +xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i) { --i->rem; ++i->data; @@ -4777,7 +6960,7 @@ xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i /**< } xcb_generic_iterator_t -xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i /**< */) +xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4787,7 +6970,7 @@ xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i /**< */ } void -xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i /**< */) +xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i) { --i->rem; ++i->data; @@ -4795,7 +6978,7 @@ xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i / } xcb_generic_iterator_t -xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i /**< */) +xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4804,8 +6987,400 @@ xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i /** return ret; } +uint32_t * +xcb_input_device_ctl_data_resolution_resolution_values (const xcb_input_device_ctl_data_t *S) +{ + return S->resolution.resolution_values; +} + int -xcb_input_device_ctl_sizeof (const void *_buffer /**< */) +xcb_input_device_ctl_data_resolution_resolution_values_length (const xcb_input_device_ctl_t *R, + const xcb_input_device_ctl_data_t *S) +{ + return S->resolution.num_valuators; +} + +xcb_generic_iterator_t +xcb_input_device_ctl_data_resolution_resolution_values_end (const xcb_input_device_ctl_t *R, + const xcb_input_device_ctl_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->resolution.resolution_values + S->resolution.num_valuators; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_device_ctl_data_serialize (void **_buffer, + uint16_t control_id, + const xcb_input_device_ctl_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[24]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) { + /* xcb_input_device_ctl_data_t.resolution.first_valuator */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.first_valuator; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.resolution.num_valuators */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.num_valuators; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.resolution.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* resolution_values */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_values; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) { + /* xcb_input_device_ctl_data_t.abs_calib.min_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_x; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.max_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_x; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.min_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_y; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.max_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_y; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.flip_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_x; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.flip_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_y; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.rotation */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.rotation; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.button_threshold */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.button_threshold; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) { + /* xcb_input_device_ctl_data_t.core.status */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.status; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.core.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) { + /* xcb_input_device_ctl_data_t.enable.enable */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->enable.enable; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.enable.pad2 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) { + /* xcb_input_device_ctl_data_t.abs_area.offset_x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_x; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_area.offset_y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_y; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_area.width */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.width; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.height */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.height; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.screen */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.screen; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.following */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.following; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; iresolution.first_valuator = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.resolution.num_valuators */ + _aux->resolution.num_valuators = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.resolution.pad0 */ + _aux->resolution.pad0[0] = *(uint8_t *)xcb_tmp; + _aux->resolution.pad0[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_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; + /* resolution_values */ + _aux->resolution.resolution_values = (uint32_t *)xcb_tmp; + xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) { + /* xcb_input_device_ctl_data_t.abs_calib.min_x */ + _aux->abs_calib.min_x = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.max_x */ + _aux->abs_calib.max_x = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.min_y */ + _aux->abs_calib.min_y = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.max_y */ + _aux->abs_calib.max_y = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_calib.flip_x */ + _aux->abs_calib.flip_x = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.flip_y */ + _aux->abs_calib.flip_y = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.rotation */ + _aux->abs_calib.rotation = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_calib.button_threshold */ + _aux->abs_calib.button_threshold = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) { + /* xcb_input_device_ctl_data_t.core.status */ + _aux->core.status = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.core.pad1 */ + _aux->core.pad1[0] = *(uint8_t *)xcb_tmp; + _aux->core.pad1[1] = *(uint8_t *)xcb_tmp; + _aux->core.pad1[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) { + /* xcb_input_device_ctl_data_t.enable.enable */ + _aux->enable.enable = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_ctl_data_t.enable.pad2 */ + _aux->enable.pad2[0] = *(uint8_t *)xcb_tmp; + _aux->enable.pad2[1] = *(uint8_t *)xcb_tmp; + _aux->enable.pad2[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + } + if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) { + /* xcb_input_device_ctl_data_t.abs_area.offset_x */ + _aux->abs_area.offset_x = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_area.offset_y */ + _aux->abs_area.offset_y = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_ctl_data_t.abs_area.width */ + _aux->abs_area.width = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.height */ + _aux->abs_area.height = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.screen */ + _aux->abs_area.screen = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + /* xcb_input_device_ctl_data_t.abs_area.following */ + _aux->abs_area.following = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_input_device_ctl_data_sizeof (const void *_buffer, + uint16_t control_id) +{ + xcb_input_device_ctl_data_t _aux; + return xcb_input_device_ctl_data_unpack(_buffer, control_id, &_aux); +} + +int +xcb_input_device_ctl_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_device_ctl_t *_aux = (xcb_input_device_ctl_t *)_buffer; @@ -4819,10 +7394,10 @@ xcb_input_device_ctl_sizeof (const void *_buffer /**< */) xcb_tmp += xcb_block_len; xcb_buffer_len += xcb_block_len; xcb_block_len = 0; - /* uninterpreted_data */ - xcb_block_len += (_aux->len - 4) * sizeof(uint8_t); + /* data */ + xcb_block_len += xcb_input_device_ctl_data_sizeof(xcb_tmp, _aux->control_id); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -4835,30 +7410,14 @@ xcb_input_device_ctl_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } -uint8_t * -xcb_input_device_ctl_uninterpreted_data (const xcb_input_device_ctl_t *R /**< */) +void * +xcb_input_device_ctl_data (const xcb_input_device_ctl_t *R) { - return (uint8_t *) (R + 1); -} - -int -xcb_input_device_ctl_uninterpreted_data_length (const xcb_input_device_ctl_t *R /**< */) -{ - return (R->len - 4); -} - -xcb_generic_iterator_t -xcb_input_device_ctl_uninterpreted_data_end (const xcb_input_device_ctl_t *R /**< */) -{ - xcb_generic_iterator_t i; - i.data = ((uint8_t *) (R + 1)) + ((R->len - 4)); - i.rem = 0; - i.index = (char *) i.data - (char *) R; - return i; + return (void *) (R + 1); } void -xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i /**< */) +xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i) { xcb_input_device_ctl_t *R = i->data; xcb_generic_iterator_t child; @@ -4869,7 +7428,7 @@ xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i /**< */) +xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -4881,7 +7440,7 @@ xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i /**< */) } int -xcb_input_change_device_control_sizeof (const void *_buffer /**< */) +xcb_input_change_device_control_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -4911,16 +7470,16 @@ xcb_input_change_device_control_sizeof (const void *_buffer /**< */) } xcb_input_change_device_control_cookie_t -xcb_input_change_device_control (xcb_connection_t *c /**< */, - uint16_t control_id /**< */, - uint8_t device_id /**< */, - xcb_input_device_ctl_t *control /**< */) +xcb_input_change_device_control (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id, + xcb_input_device_ctl_t *control) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_DEVICE_CONTROL, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_CONTROL, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -4945,16 +7504,16 @@ xcb_input_change_device_control (xcb_connection_t *c /**< */, } xcb_input_change_device_control_cookie_t -xcb_input_change_device_control_unchecked (xcb_connection_t *c /**< */, - uint16_t control_id /**< */, - uint8_t device_id /**< */, - xcb_input_device_ctl_t *control /**< */) +xcb_input_change_device_control_unchecked (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id, + xcb_input_device_ctl_t *control) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_DEVICE_CONTROL, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_CONTROL, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -4979,15 +7538,15 @@ xcb_input_change_device_control_unchecked (xcb_connection_t *c /**< */, } xcb_input_change_device_control_reply_t * -xcb_input_change_device_control_reply (xcb_connection_t *c /**< */, +xcb_input_change_device_control_reply (xcb_connection_t *c, xcb_input_change_device_control_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_change_device_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_list_device_properties_sizeof (const void *_buffer /**< */) +xcb_input_list_device_properties_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_list_device_properties_reply_t *_aux = (xcb_input_list_device_properties_reply_t *)_buffer; @@ -5018,14 +7577,14 @@ xcb_input_list_device_properties_sizeof (const void *_buffer /**< */) } xcb_input_list_device_properties_cookie_t -xcb_input_list_device_properties (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_list_device_properties (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_LIST_DEVICE_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_LIST_DEVICE_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5045,14 +7604,14 @@ xcb_input_list_device_properties (xcb_connection_t *c /**< */, } xcb_input_list_device_properties_cookie_t -xcb_input_list_device_properties_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */) +xcb_input_list_device_properties_unchecked (xcb_connection_t *c, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_LIST_DEVICE_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_LIST_DEVICE_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5072,19 +7631,19 @@ xcb_input_list_device_properties_unchecked (xcb_connection_t *c /**< */, } xcb_atom_t * -xcb_input_list_device_properties_atoms (const xcb_input_list_device_properties_reply_t *R /**< */) +xcb_input_list_device_properties_atoms (const xcb_input_list_device_properties_reply_t *R) { return (xcb_atom_t *) (R + 1); } int -xcb_input_list_device_properties_atoms_length (const xcb_input_list_device_properties_reply_t *R /**< */) +xcb_input_list_device_properties_atoms_length (const xcb_input_list_device_properties_reply_t *R) { return R->num_atoms; } xcb_generic_iterator_t -xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properties_reply_t *R /**< */) +xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properties_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_atom_t *) (R + 1)) + (R->num_atoms); @@ -5094,106 +7653,107 @@ xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properti } xcb_input_list_device_properties_reply_t * -xcb_input_list_device_properties_reply (xcb_connection_t *c /**< */, +xcb_input_list_device_properties_reply (xcb_connection_t *c, xcb_input_list_device_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_list_device_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } uint8_t * -xcb_input_change_device_property_items_data_8 (const xcb_input_change_device_property_items_t *S /**< */) +xcb_input_change_device_property_items_data_8 (const xcb_input_change_device_property_items_t *S) { - return /* items */ S->data8; + return S->data8; } int -xcb_input_change_device_property_items_data_8_length (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */) +xcb_input_change_device_property_items_data_8_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_change_device_property_items_data_8_end (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */) +xcb_input_change_device_property_items_data_8_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data8 + R->num_items; + i.data = S->data8 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint16_t * -xcb_input_change_device_property_items_data_16 (const xcb_input_change_device_property_items_t *S /**< */) +xcb_input_change_device_property_items_data_16 (const xcb_input_change_device_property_items_t *S) { - return /* items */ S->data16; + return S->data16; } int -xcb_input_change_device_property_items_data_16_length (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */) +xcb_input_change_device_property_items_data_16_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_change_device_property_items_data_16_end (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */) +xcb_input_change_device_property_items_data_16_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data16 + R->num_items; + i.data = S->data16 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint32_t * -xcb_input_change_device_property_items_data_32 (const xcb_input_change_device_property_items_t *S /**< */) +xcb_input_change_device_property_items_data_32 (const xcb_input_change_device_property_items_t *S) { - return /* items */ S->data32; + return S->data32; } int -xcb_input_change_device_property_items_data_32_length (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */) +xcb_input_change_device_property_items_data_32_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_change_device_property_items_data_32_end (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */) +xcb_input_change_device_property_items_data_32_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data32 + R->num_items; + i.data = S->data32 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } int -xcb_input_change_device_property_items_serialize (void **_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - const xcb_input_change_device_property_items_t *_aux /**< */) +xcb_input_change_device_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_change_device_property_items_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[7]; + struct iovec xcb_parts[9]; unsigned int xcb_parts_idx = 0; unsigned int xcb_block_len = 0; unsigned int i; char *xcb_tmp; - if(format & XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5202,16 +7762,16 @@ xcb_input_change_device_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* data8 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8; xcb_block_len += num_items * sizeof(uint8_t); xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5220,16 +7780,29 @@ xcb_input_change_device_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* data16 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16; xcb_block_len += num_items * sizeof(uint16_t); xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint16_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5238,6 +7811,20 @@ xcb_input_change_device_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* data32 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32; xcb_block_len += num_items * sizeof(uint32_t); @@ -5246,7 +7833,7 @@ xcb_input_change_device_property_items_serialize (void xcb_align_to = ALIGNOF(uint32_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5255,6 +7842,7 @@ xcb_input_change_device_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -5274,57 +7862,81 @@ xcb_input_change_device_property_items_serialize (void } int -xcb_input_change_device_property_items_unpack (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - xcb_input_change_device_property_items_t *_aux /**< */) +xcb_input_change_device_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_change_device_property_items_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; - if(format & XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* data8 */ _aux->data8 = (uint8_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* 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; /* data16 */ _aux->data16 = (uint16_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint16_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint16_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* 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; /* data32 */ _aux->data32 = (uint32_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint32_t); @@ -5332,6 +7944,47 @@ xcb_input_change_device_property_items_unpack (const void xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_input_change_device_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format) +{ + xcb_input_change_device_property_items_t _aux; + return xcb_input_change_device_property_items_unpack(_buffer, num_items, format, &_aux); +} + +int +xcb_input_change_device_property_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_change_device_property_request_t *_aux = (xcb_input_change_device_property_request_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; + + + xcb_block_len += sizeof(xcb_input_change_device_property_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* items */ + xcb_block_len += xcb_input_change_device_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -5343,30 +7996,21 @@ xcb_input_change_device_property_items_unpack (const void return xcb_buffer_len; } -int -xcb_input_change_device_property_items_sizeof (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */) -{ - xcb_input_change_device_property_items_t _aux; - return xcb_input_change_device_property_items_unpack(_buffer, num_items, format, &_aux); -} - xcb_void_cookie_t -xcb_input_change_device_property_checked (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t device_id /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const void *items /**< */) +xcb_input_change_device_property_checked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_DEVICE_PROPERTY, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -5395,20 +8039,20 @@ xcb_input_change_device_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_change_device_property (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t device_id /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const void *items /**< */) +xcb_input_change_device_property (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_DEVICE_PROPERTY, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -5437,20 +8081,20 @@ xcb_input_change_device_property (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_change_device_property_aux_checked (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t device_id /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const xcb_input_change_device_property_items_t *items /**< */) +xcb_input_change_device_property_aux_checked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const xcb_input_change_device_property_items_t *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_DEVICE_PROPERTY, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -5481,20 +8125,20 @@ xcb_input_change_device_property_aux_checked (xcb_connection_t } xcb_void_cookie_t -xcb_input_change_device_property_aux (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t device_id /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const xcb_input_change_device_property_items_t *items /**< */) +xcb_input_change_device_property_aux (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const xcb_input_change_device_property_items_t *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_CHANGE_DEVICE_PROPERTY, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -5524,16 +8168,22 @@ xcb_input_change_device_property_aux (xcb_connection_t return xcb_ret; } +void * +xcb_input_change_device_property_items (const xcb_input_change_device_property_request_t *R) +{ + return (void *) (R + 1); +} + xcb_void_cookie_t -xcb_input_delete_device_property_checked (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - uint8_t device_id /**< */) +xcb_input_delete_device_property_checked (xcb_connection_t *c, + xcb_atom_t property, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_DELETE_DEVICE_PROPERTY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_DELETE_DEVICE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5554,15 +8204,15 @@ xcb_input_delete_device_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_delete_device_property (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - uint8_t device_id /**< */) +xcb_input_delete_device_property (xcb_connection_t *c, + xcb_atom_t property, + uint8_t device_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_DELETE_DEVICE_PROPERTY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_DELETE_DEVICE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5583,98 +8233,99 @@ xcb_input_delete_device_property (xcb_connection_t *c /**< */, } uint8_t * -xcb_input_get_device_property_items_data_8 (const xcb_input_get_device_property_items_t *S /**< */) +xcb_input_get_device_property_items_data_8 (const xcb_input_get_device_property_items_t *S) { - return /* items */ S->data8; + return S->data8; } int -xcb_input_get_device_property_items_data_8_length (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */) +xcb_input_get_device_property_items_data_8_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_get_device_property_items_data_8_end (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */) +xcb_input_get_device_property_items_data_8_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data8 + R->num_items; + i.data = S->data8 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint16_t * -xcb_input_get_device_property_items_data_16 (const xcb_input_get_device_property_items_t *S /**< */) +xcb_input_get_device_property_items_data_16 (const xcb_input_get_device_property_items_t *S) { - return /* items */ S->data16; + return S->data16; } int -xcb_input_get_device_property_items_data_16_length (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */) +xcb_input_get_device_property_items_data_16_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_get_device_property_items_data_16_end (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */) +xcb_input_get_device_property_items_data_16_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data16 + R->num_items; + i.data = S->data16 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint32_t * -xcb_input_get_device_property_items_data_32 (const xcb_input_get_device_property_items_t *S /**< */) +xcb_input_get_device_property_items_data_32 (const xcb_input_get_device_property_items_t *S) { - return /* items */ S->data32; + return S->data32; } int -xcb_input_get_device_property_items_data_32_length (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */) +xcb_input_get_device_property_items_data_32_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_get_device_property_items_data_32_end (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */) +xcb_input_get_device_property_items_data_32_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data32 + R->num_items; + i.data = S->data32 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } int -xcb_input_get_device_property_items_serialize (void **_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - const xcb_input_get_device_property_items_t *_aux /**< */) +xcb_input_get_device_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_get_device_property_items_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[7]; + struct iovec xcb_parts[9]; unsigned int xcb_parts_idx = 0; unsigned int xcb_block_len = 0; unsigned int i; char *xcb_tmp; - if(format & XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5683,16 +8334,16 @@ xcb_input_get_device_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* data8 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8; xcb_block_len += num_items * sizeof(uint8_t); xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5701,16 +8352,29 @@ xcb_input_get_device_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* data16 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16; xcb_block_len += num_items * sizeof(uint16_t); xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint16_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5719,6 +8383,20 @@ xcb_input_get_device_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* data32 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32; xcb_block_len += num_items * sizeof(uint32_t); @@ -5727,7 +8405,7 @@ xcb_input_get_device_property_items_serialize (void xcb_align_to = ALIGNOF(uint32_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5736,6 +8414,7 @@ xcb_input_get_device_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -5755,57 +8434,81 @@ xcb_input_get_device_property_items_serialize (void } int -xcb_input_get_device_property_items_unpack (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - xcb_input_get_device_property_items_t *_aux /**< */) +xcb_input_get_device_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_get_device_property_items_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; - if(format & XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* data8 */ _aux->data8 = (uint8_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* 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; /* data16 */ _aux->data16 = (uint16_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint16_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint16_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* 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; /* data32 */ _aux->data32 = (uint32_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint32_t); @@ -5813,6 +8516,47 @@ xcb_input_get_device_property_items_unpack (const void xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_input_get_device_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format) +{ + xcb_input_get_device_property_items_t _aux; + return xcb_input_get_device_property_items_unpack(_buffer, num_items, format, &_aux); +} + +int +xcb_input_get_device_property_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_get_device_property_reply_t *_aux = (xcb_input_get_device_property_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; + + + xcb_block_len += sizeof(xcb_input_get_device_property_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* items */ + xcb_block_len += xcb_input_get_device_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -5824,29 +8568,20 @@ xcb_input_get_device_property_items_unpack (const void return xcb_buffer_len; } -int -xcb_input_get_device_property_items_sizeof (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */) -{ - xcb_input_get_device_property_items_t _aux; - return xcb_input_get_device_property_items_unpack(_buffer, num_items, format, &_aux); -} - xcb_input_get_device_property_cookie_t -xcb_input_get_device_property (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t offset /**< */, - uint32_t len /**< */, - uint8_t device_id /**< */, - uint8_t _delete /**< */) +xcb_input_get_device_property (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len, + uint8_t device_id, + uint8_t _delete) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5871,19 +8606,19 @@ xcb_input_get_device_property (xcb_connection_t *c /**< */, } xcb_input_get_device_property_cookie_t -xcb_input_get_device_property_unchecked (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t offset /**< */, - uint32_t len /**< */, - uint8_t device_id /**< */, - uint8_t _delete /**< */) +xcb_input_get_device_property_unchecked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len, + uint8_t device_id, + uint8_t _delete) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_GET_DEVICE_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_GET_DEVICE_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5908,21 +8643,21 @@ xcb_input_get_device_property_unchecked (xcb_connection_t *c /**< */, } void * -xcb_input_get_device_property_items (const xcb_input_get_device_property_reply_t *R /**< */) +xcb_input_get_device_property_items (const xcb_input_get_device_property_reply_t *R) { return (void *) (R + 1); } xcb_input_get_device_property_reply_t * -xcb_input_get_device_property_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_property_reply (xcb_connection_t *c, xcb_input_get_device_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_get_device_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } void -xcb_input_group_info_next (xcb_input_group_info_iterator_t *i /**< */) +xcb_input_group_info_next (xcb_input_group_info_iterator_t *i) { --i->rem; ++i->data; @@ -5930,7 +8665,7 @@ xcb_input_group_info_next (xcb_input_group_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_group_info_end (xcb_input_group_info_iterator_t i /**< */) +xcb_input_group_info_end (xcb_input_group_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -5940,7 +8675,7 @@ xcb_input_group_info_end (xcb_input_group_info_iterator_t i /**< */) } void -xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i /**< */) +xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i) { --i->rem; ++i->data; @@ -5948,7 +8683,7 @@ xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_modifier_info_end (xcb_input_modifier_info_iterator_t i /**< */) +xcb_input_modifier_info_end (xcb_input_modifier_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -5958,7 +8693,7 @@ xcb_input_modifier_info_end (xcb_input_modifier_info_iterator_t i /**< */) } int -xcb_input_xi_query_pointer_sizeof (const void *_buffer /**< */) +xcb_input_xi_query_pointer_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_query_pointer_reply_t *_aux = (xcb_input_xi_query_pointer_reply_t *)_buffer; @@ -5989,15 +8724,15 @@ xcb_input_xi_query_pointer_sizeof (const void *_buffer /**< */) } xcb_input_xi_query_pointer_cookie_t -xcb_input_xi_query_pointer (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_query_pointer (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_QUERY_POINTER, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_POINTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6018,15 +8753,15 @@ xcb_input_xi_query_pointer (xcb_connection_t *c /**< */, } xcb_input_xi_query_pointer_cookie_t -xcb_input_xi_query_pointer_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_query_pointer_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_QUERY_POINTER, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_POINTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6047,19 +8782,19 @@ xcb_input_xi_query_pointer_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_input_xi_query_pointer_buttons (const xcb_input_xi_query_pointer_reply_t *R /**< */) +xcb_input_xi_query_pointer_buttons (const xcb_input_xi_query_pointer_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_input_xi_query_pointer_buttons_length (const xcb_input_xi_query_pointer_reply_t *R /**< */) +xcb_input_xi_query_pointer_buttons_length (const xcb_input_xi_query_pointer_reply_t *R) { return R->buttons_len; } xcb_generic_iterator_t -xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t *R /**< */) +xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->buttons_len); @@ -6069,30 +8804,30 @@ xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t } xcb_input_xi_query_pointer_reply_t * -xcb_input_xi_query_pointer_reply (xcb_connection_t *c /**< */, +xcb_input_xi_query_pointer_reply (xcb_connection_t *c, xcb_input_xi_query_pointer_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_xi_query_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_input_xi_warp_pointer_checked (xcb_connection_t *c /**< */, - xcb_window_t src_win /**< */, - xcb_window_t dst_win /**< */, - xcb_input_fp1616_t src_x /**< */, - xcb_input_fp1616_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - xcb_input_fp1616_t dst_x /**< */, - xcb_input_fp1616_t dst_y /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_warp_pointer_checked (xcb_connection_t *c, + xcb_window_t src_win, + xcb_window_t dst_win, + xcb_input_fp1616_t src_x, + xcb_input_fp1616_t src_y, + uint16_t src_width, + uint16_t src_height, + xcb_input_fp1616_t dst_x, + xcb_input_fp1616_t dst_y, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_WARP_POINTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_WARP_POINTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6120,22 +8855,22 @@ xcb_input_xi_warp_pointer_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_warp_pointer (xcb_connection_t *c /**< */, - xcb_window_t src_win /**< */, - xcb_window_t dst_win /**< */, - xcb_input_fp1616_t src_x /**< */, - xcb_input_fp1616_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - xcb_input_fp1616_t dst_x /**< */, - xcb_input_fp1616_t dst_y /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_warp_pointer (xcb_connection_t *c, + xcb_window_t src_win, + xcb_window_t dst_win, + xcb_input_fp1616_t src_x, + xcb_input_fp1616_t src_y, + uint16_t src_width, + uint16_t src_height, + xcb_input_fp1616_t dst_x, + xcb_input_fp1616_t dst_y, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_WARP_POINTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_WARP_POINTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6163,16 +8898,16 @@ xcb_input_xi_warp_pointer (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_change_cursor_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_cursor_t cursor /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_change_cursor_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_CHANGE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6194,16 +8929,16 @@ xcb_input_xi_change_cursor_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_change_cursor (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_cursor_t cursor /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_change_cursor (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_CHANGE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6225,7 +8960,7 @@ xcb_input_xi_change_cursor (xcb_connection_t *c /**< */, } int -xcb_input_add_master_sizeof (const void *_buffer /**< */) +xcb_input_add_master_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_add_master_t *_aux = (xcb_input_add_master_t *)_buffer; @@ -6243,6 +8978,15 @@ xcb_input_add_master_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->name_len * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -6256,19 +9000,19 @@ xcb_input_add_master_sizeof (const void *_buffer /**< */) } char * -xcb_input_add_master_name (const xcb_input_add_master_t *R /**< */) +xcb_input_add_master_name (const xcb_input_add_master_t *R) { return (char *) (R + 1); } int -xcb_input_add_master_name_length (const xcb_input_add_master_t *R /**< */) +xcb_input_add_master_name_length (const xcb_input_add_master_t *R) { return R->name_len; } xcb_generic_iterator_t -xcb_input_add_master_name_end (const xcb_input_add_master_t *R /**< */) +xcb_input_add_master_name_end (const xcb_input_add_master_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->name_len); @@ -6278,7 +9022,7 @@ xcb_input_add_master_name_end (const xcb_input_add_master_t *R /**< */) } void -xcb_input_add_master_next (xcb_input_add_master_iterator_t *i /**< */) +xcb_input_add_master_next (xcb_input_add_master_iterator_t *i) { xcb_input_add_master_t *R = i->data; xcb_generic_iterator_t child; @@ -6289,7 +9033,7 @@ xcb_input_add_master_next (xcb_input_add_master_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_add_master_end (xcb_input_add_master_iterator_t i /**< */) +xcb_input_add_master_end (xcb_input_add_master_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -6301,7 +9045,7 @@ xcb_input_add_master_end (xcb_input_add_master_iterator_t i /**< */) } void -xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i /**< */) +xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i) { --i->rem; ++i->data; @@ -6309,7 +9053,7 @@ xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i /**< */) +xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -6319,7 +9063,7 @@ xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i /**< */) } void -xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i /**< */) +xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i) { --i->rem; ++i->data; @@ -6327,7 +9071,7 @@ xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i /**< */) +xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -6337,7 +9081,7 @@ xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i /**< */) } void -xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i /**< */) +xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i) { --i->rem; ++i->data; @@ -6345,7 +9089,7 @@ xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_detach_slave_end (xcb_input_detach_slave_iterator_t i /**< */) +xcb_input_detach_slave_end (xcb_input_detach_slave_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -6354,8 +9098,315 @@ xcb_input_detach_slave_end (xcb_input_detach_slave_iterator_t i /**< */) return ret; } +char * +xcb_input_hierarchy_change_data_add_master_name (const xcb_input_hierarchy_change_data_t *S) +{ + return S->add_master.name; +} + int -xcb_input_hierarchy_change_sizeof (const void *_buffer /**< */) +xcb_input_hierarchy_change_data_add_master_name_length (const xcb_input_hierarchy_change_t *R, + const xcb_input_hierarchy_change_data_t *S) +{ + return S->add_master.name_len; +} + +xcb_generic_iterator_t +xcb_input_hierarchy_change_data_add_master_name_end (const xcb_input_hierarchy_change_t *R, + const xcb_input_hierarchy_change_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->add_master.name + S->add_master.name_len; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_hierarchy_change_data_serialize (void **_buffer, + uint16_t type, + const xcb_input_hierarchy_change_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[16]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ADD_MASTER) { + /* xcb_input_hierarchy_change_data_t.add_master.name_len */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.name_len; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_hierarchy_change_data_t.add_master.send_core */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.send_core; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.add_master.enable */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.enable; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* name */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->add_master.name; + xcb_block_len += _aux->add_master.name_len * sizeof(char); + xcb_parts[xcb_parts_idx].iov_len = _aux->add_master.name_len * sizeof(char); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_REMOVE_MASTER) { + /* xcb_input_hierarchy_change_data_t.remove_master.deviceid */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.deviceid; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.remove_master.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_pointer */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_pointer; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_keyboard */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_keyboard; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ATTACH_SLAVE) { + /* xcb_input_hierarchy_change_data_t.attach_slave.deviceid */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->attach_slave.deviceid; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.attach_slave.master */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->attach_slave.master; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_DETACH_SLAVE) { + /* xcb_input_hierarchy_change_data_t.detach_slave.deviceid */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->detach_slave.deviceid; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.detach_slave.pad2 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; iadd_master.name_len = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_hierarchy_change_data_t.add_master.send_core */ + _aux->add_master.send_core = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.add_master.enable */ + _aux->add_master.enable = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_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; + /* name */ + _aux->add_master.name = (char *)xcb_tmp; + xcb_block_len += _aux->add_master.name_len * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* 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; + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_REMOVE_MASTER) { + /* xcb_input_hierarchy_change_data_t.remove_master.deviceid */ + _aux->remove_master.deviceid = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_mode */ + _aux->remove_master.return_mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.remove_master.pad1 */ + _aux->remove_master.pad1 = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_pointer */ + _aux->remove_master.return_pointer = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.remove_master.return_keyboard */ + _aux->remove_master.return_keyboard = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ATTACH_SLAVE) { + /* xcb_input_hierarchy_change_data_t.attach_slave.deviceid */ + _aux->attach_slave.deviceid = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.attach_slave.master */ + _aux->attach_slave.master = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + } + if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_DETACH_SLAVE) { + /* xcb_input_hierarchy_change_data_t.detach_slave.deviceid */ + _aux->detach_slave.deviceid = *(xcb_input_device_id_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_device_id_t); + xcb_tmp += sizeof(xcb_input_device_id_t); + xcb_align_to = ALIGNOF(xcb_input_device_id_t); + /* xcb_input_hierarchy_change_data_t.detach_slave.pad2 */ + _aux->detach_slave.pad2[0] = *(uint8_t *)xcb_tmp; + _aux->detach_slave.pad2[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_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; +} + +int +xcb_input_hierarchy_change_data_sizeof (const void *_buffer, + uint16_t type) +{ + xcb_input_hierarchy_change_data_t _aux; + return xcb_input_hierarchy_change_data_unpack(_buffer, type, &_aux); +} + +int +xcb_input_hierarchy_change_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_hierarchy_change_t *_aux = (xcb_input_hierarchy_change_t *)_buffer; @@ -6369,10 +9420,10 @@ xcb_input_hierarchy_change_sizeof (const void *_buffer /**< */) xcb_tmp += xcb_block_len; xcb_buffer_len += xcb_block_len; xcb_block_len = 0; - /* uninterpreted_data */ - xcb_block_len += ((_aux->len * 4) - 4) * sizeof(uint8_t); + /* data */ + xcb_block_len += xcb_input_hierarchy_change_data_sizeof(xcb_tmp, _aux->type); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -6385,30 +9436,14 @@ xcb_input_hierarchy_change_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } -uint8_t * -xcb_input_hierarchy_change_uninterpreted_data (const xcb_input_hierarchy_change_t *R /**< */) +void * +xcb_input_hierarchy_change_data (const xcb_input_hierarchy_change_t *R) { - return (uint8_t *) (R + 1); -} - -int -xcb_input_hierarchy_change_uninterpreted_data_length (const xcb_input_hierarchy_change_t *R /**< */) -{ - return ((R->len * 4) - 4); -} - -xcb_generic_iterator_t -xcb_input_hierarchy_change_uninterpreted_data_end (const xcb_input_hierarchy_change_t *R /**< */) -{ - xcb_generic_iterator_t i; - i.data = ((uint8_t *) (R + 1)) + (((R->len * 4) - 4)); - i.rem = 0; - i.index = (char *) i.data - (char *) R; - return i; + return (void *) (R + 1); } void -xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i /**< */) +xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i) { xcb_input_hierarchy_change_t *R = i->data; xcb_generic_iterator_t child; @@ -6419,7 +9454,7 @@ xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i /**< } xcb_generic_iterator_t -xcb_input_hierarchy_change_end (xcb_input_hierarchy_change_iterator_t i /**< */) +xcb_input_hierarchy_change_end (xcb_input_hierarchy_change_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -6431,7 +9466,7 @@ xcb_input_hierarchy_change_end (xcb_input_hierarchy_change_iterator_t i /**< */ } int -xcb_input_xi_change_hierarchy_sizeof (const void *_buffer /**< */) +xcb_input_xi_change_hierarchy_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_change_hierarchy_request_t *_aux = (xcb_input_xi_change_hierarchy_request_t *)_buffer; @@ -6467,15 +9502,15 @@ xcb_input_xi_change_hierarchy_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_input_xi_change_hierarchy_checked (xcb_connection_t *c /**< */, - uint8_t num_changes /**< */, - const xcb_input_hierarchy_change_t *changes /**< */) +xcb_input_xi_change_hierarchy_checked (xcb_connection_t *c, + uint8_t num_changes, + const xcb_input_hierarchy_change_t *changes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_CHANGE_HIERARCHY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_HIERARCHY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6509,15 +9544,15 @@ xcb_input_xi_change_hierarchy_checked (xcb_connection_t *c /* } xcb_void_cookie_t -xcb_input_xi_change_hierarchy (xcb_connection_t *c /**< */, - uint8_t num_changes /**< */, - const xcb_input_hierarchy_change_t *changes /**< */) +xcb_input_xi_change_hierarchy (xcb_connection_t *c, + uint8_t num_changes, + const xcb_input_hierarchy_change_t *changes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_CHANGE_HIERARCHY, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_HIERARCHY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6550,16 +9585,32 @@ xcb_input_xi_change_hierarchy (xcb_connection_t *c /**< */, return xcb_ret; } +int +xcb_input_xi_change_hierarchy_changes_length (const xcb_input_xi_change_hierarchy_request_t *R) +{ + return R->num_changes; +} + +xcb_input_hierarchy_change_iterator_t +xcb_input_xi_change_hierarchy_changes_iterator (const xcb_input_xi_change_hierarchy_request_t *R) +{ + xcb_input_hierarchy_change_iterator_t i; + i.data = (xcb_input_hierarchy_change_t *) (R + 1); + i.rem = R->num_changes; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_input_xi_set_client_pointer_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_set_client_pointer_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_SET_CLIENT_POINTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SET_CLIENT_POINTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6580,15 +9631,15 @@ xcb_input_xi_set_client_pointer_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_set_client_pointer (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_set_client_pointer (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_SET_CLIENT_POINTER, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SET_CLIENT_POINTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6609,14 +9660,14 @@ xcb_input_xi_set_client_pointer (xcb_connection_t *c /**< */, } xcb_input_xi_get_client_pointer_cookie_t -xcb_input_xi_get_client_pointer (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_input_xi_get_client_pointer (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_GET_CLIENT_POINTER, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_CLIENT_POINTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6635,14 +9686,14 @@ xcb_input_xi_get_client_pointer (xcb_connection_t *c /**< */, } xcb_input_xi_get_client_pointer_cookie_t -xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_GET_CLIENT_POINTER, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_CLIENT_POINTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6661,15 +9712,15 @@ xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c /**< */, } xcb_input_xi_get_client_pointer_reply_t * -xcb_input_xi_get_client_pointer_reply (xcb_connection_t *c /**< */, +xcb_input_xi_get_client_pointer_reply (xcb_connection_t *c, xcb_input_xi_get_client_pointer_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_xi_get_client_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_event_mask_sizeof (const void *_buffer /**< */) +xcb_input_event_mask_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_event_mask_t *_aux = (xcb_input_event_mask_t *)_buffer; @@ -6700,19 +9751,19 @@ xcb_input_event_mask_sizeof (const void *_buffer /**< */) } uint32_t * -xcb_input_event_mask_mask (const xcb_input_event_mask_t *R /**< */) +xcb_input_event_mask_mask (const xcb_input_event_mask_t *R) { return (uint32_t *) (R + 1); } int -xcb_input_event_mask_mask_length (const xcb_input_event_mask_t *R /**< */) +xcb_input_event_mask_mask_length (const xcb_input_event_mask_t *R) { return R->mask_len; } xcb_generic_iterator_t -xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R /**< */) +xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->mask_len); @@ -6722,7 +9773,7 @@ xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R /**< */) } void -xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i /**< */) +xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i) { xcb_input_event_mask_t *R = i->data; xcb_generic_iterator_t child; @@ -6733,7 +9784,7 @@ xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_event_mask_end (xcb_input_event_mask_iterator_t i /**< */) +xcb_input_event_mask_end (xcb_input_event_mask_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -6745,7 +9796,7 @@ xcb_input_event_mask_end (xcb_input_event_mask_iterator_t i /**< */) } int -xcb_input_xi_select_events_sizeof (const void *_buffer /**< */) +xcb_input_xi_select_events_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_select_events_request_t *_aux = (xcb_input_xi_select_events_request_t *)_buffer; @@ -6781,16 +9832,16 @@ xcb_input_xi_select_events_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_input_xi_select_events_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_mask /**< */, - const xcb_input_event_mask_t *masks /**< */) +xcb_input_xi_select_events_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_mask, + const xcb_input_event_mask_t *masks) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_SELECT_EVENTS, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SELECT_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6825,16 +9876,16 @@ xcb_input_xi_select_events_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_select_events (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_mask /**< */, - const xcb_input_event_mask_t *masks /**< */) +xcb_input_xi_select_events (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_mask, + const xcb_input_event_mask_t *masks) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_SELECT_EVENTS, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SELECT_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6868,16 +9919,32 @@ xcb_input_xi_select_events (xcb_connection_t *c /**< */, return xcb_ret; } +int +xcb_input_xi_select_events_masks_length (const xcb_input_xi_select_events_request_t *R) +{ + return R->num_mask; +} + +xcb_input_event_mask_iterator_t +xcb_input_xi_select_events_masks_iterator (const xcb_input_xi_select_events_request_t *R) +{ + xcb_input_event_mask_iterator_t i; + i.data = (xcb_input_event_mask_t *) (R + 1); + i.rem = R->num_mask; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_input_xi_query_version_cookie_t -xcb_input_xi_query_version (xcb_connection_t *c /**< */, - uint16_t major_version /**< */, - uint16_t minor_version /**< */) +xcb_input_xi_query_version (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6897,15 +9964,15 @@ xcb_input_xi_query_version (xcb_connection_t *c /**< */, } xcb_input_xi_query_version_cookie_t -xcb_input_xi_query_version_unchecked (xcb_connection_t *c /**< */, - uint16_t major_version /**< */, - uint16_t minor_version /**< */) +xcb_input_xi_query_version_unchecked (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6925,15 +9992,15 @@ xcb_input_xi_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_input_xi_query_version_reply_t * -xcb_input_xi_query_version_reply (xcb_connection_t *c /**< */, +xcb_input_xi_query_version_reply (xcb_connection_t *c, xcb_input_xi_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_xi_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_button_class_sizeof (const void *_buffer /**< */) +xcb_input_button_class_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_button_class_t *_aux = (xcb_input_button_class_t *)_buffer; @@ -6976,19 +10043,19 @@ xcb_input_button_class_sizeof (const void *_buffer /**< */) } uint32_t * -xcb_input_button_class_state (const xcb_input_button_class_t *R /**< */) +xcb_input_button_class_state (const xcb_input_button_class_t *R) { return (uint32_t *) (R + 1); } int -xcb_input_button_class_state_length (const xcb_input_button_class_t *R /**< */) +xcb_input_button_class_state_length (const xcb_input_button_class_t *R) { return ((R->num_buttons + 31) / 32); } xcb_generic_iterator_t -xcb_input_button_class_state_end (const xcb_input_button_class_t *R /**< */) +xcb_input_button_class_state_end (const xcb_input_button_class_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (((R->num_buttons + 31) / 32)); @@ -6998,31 +10065,31 @@ xcb_input_button_class_state_end (const xcb_input_button_class_t *R /**< */) } xcb_atom_t * -xcb_input_button_class_labels (const xcb_input_button_class_t *R /**< */) +xcb_input_button_class_labels (const xcb_input_button_class_t *R) { xcb_generic_iterator_t prev = xcb_input_button_class_state_end(R); return (xcb_atom_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_atom_t, prev.index) + 0); } int -xcb_input_button_class_labels_length (const xcb_input_button_class_t *R /**< */) +xcb_input_button_class_labels_length (const xcb_input_button_class_t *R) { return R->num_buttons; } xcb_generic_iterator_t -xcb_input_button_class_labels_end (const xcb_input_button_class_t *R /**< */) +xcb_input_button_class_labels_end (const xcb_input_button_class_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_input_button_class_state_end(R); - i.data = ((xcb_atom_t *) child.data) + (R->num_buttons); + xcb_generic_iterator_t prev = xcb_input_button_class_state_end(R); + i.data = ((xcb_atom_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_atom_t, prev.index))) + (R->num_buttons); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } void -xcb_input_button_class_next (xcb_input_button_class_iterator_t *i /**< */) +xcb_input_button_class_next (xcb_input_button_class_iterator_t *i) { xcb_input_button_class_t *R = i->data; xcb_generic_iterator_t child; @@ -7033,7 +10100,7 @@ xcb_input_button_class_next (xcb_input_button_class_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_button_class_end (xcb_input_button_class_iterator_t i /**< */) +xcb_input_button_class_end (xcb_input_button_class_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -7045,7 +10112,7 @@ xcb_input_button_class_end (xcb_input_button_class_iterator_t i /**< */) } int -xcb_input_key_class_sizeof (const void *_buffer /**< */) +xcb_input_key_class_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_key_class_t *_aux = (xcb_input_key_class_t *)_buffer; @@ -7076,19 +10143,19 @@ xcb_input_key_class_sizeof (const void *_buffer /**< */) } uint32_t * -xcb_input_key_class_keys (const xcb_input_key_class_t *R /**< */) +xcb_input_key_class_keys (const xcb_input_key_class_t *R) { return (uint32_t *) (R + 1); } int -xcb_input_key_class_keys_length (const xcb_input_key_class_t *R /**< */) +xcb_input_key_class_keys_length (const xcb_input_key_class_t *R) { return R->num_keys; } xcb_generic_iterator_t -xcb_input_key_class_keys_end (const xcb_input_key_class_t *R /**< */) +xcb_input_key_class_keys_end (const xcb_input_key_class_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->num_keys); @@ -7098,7 +10165,7 @@ xcb_input_key_class_keys_end (const xcb_input_key_class_t *R /**< */) } void -xcb_input_key_class_next (xcb_input_key_class_iterator_t *i /**< */) +xcb_input_key_class_next (xcb_input_key_class_iterator_t *i) { xcb_input_key_class_t *R = i->data; xcb_generic_iterator_t child; @@ -7109,7 +10176,7 @@ xcb_input_key_class_next (xcb_input_key_class_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_key_class_end (xcb_input_key_class_iterator_t i /**< */) +xcb_input_key_class_end (xcb_input_key_class_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -7121,7 +10188,7 @@ xcb_input_key_class_end (xcb_input_key_class_iterator_t i /**< */) } void -xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i /**< */) +xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i) { --i->rem; ++i->data; @@ -7129,7 +10196,7 @@ xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i /**< */) +xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -7139,7 +10206,7 @@ xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i /**< */) } void -xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i /**< */) +xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i) { --i->rem; ++i->data; @@ -7147,7 +10214,7 @@ xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i /**< */) +xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -7157,7 +10224,7 @@ xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i /**< */) } void -xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i /**< */) +xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i) { --i->rem; ++i->data; @@ -7165,7 +10232,7 @@ xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_valuator_class_end (xcb_input_valuator_class_iterator_t i /**< */) +xcb_input_valuator_class_end (xcb_input_valuator_class_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -7174,8 +10241,464 @@ xcb_input_valuator_class_end (xcb_input_valuator_class_iterator_t i /**< */) return ret; } +uint32_t * +xcb_input_device_class_data_key_keys (const xcb_input_device_class_data_t *S) +{ + return S->key.keys; +} + int -xcb_input_device_class_sizeof (const void *_buffer /**< */) +xcb_input_device_class_data_key_keys_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + return S->key.num_keys; +} + +xcb_generic_iterator_t +xcb_input_device_class_data_key_keys_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->key.keys + S->key.num_keys; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +uint32_t * +xcb_input_device_class_data_button_state (const xcb_input_device_class_data_t *S) +{ + return S->button.state; +} + +int +xcb_input_device_class_data_button_state_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + return ((S->button.num_buttons + 31) / 32); +} + +xcb_generic_iterator_t +xcb_input_device_class_data_button_state_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->button.state + ((S->button.num_buttons + 31) / 32); + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +xcb_atom_t * +xcb_input_device_class_data_button_labels (const xcb_input_device_class_data_t *S) +{ + return S->button.labels; +} + +int +xcb_input_device_class_data_button_labels_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + return S->button.num_buttons; +} + +xcb_generic_iterator_t +xcb_input_device_class_data_button_labels_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S) +{ + xcb_generic_iterator_t i; + i.data = S->button.labels + S->button.num_buttons; + i.rem = 0; + i.index = (char *) i.data - (char *) S; + return i; +} + +int +xcb_input_device_class_data_serialize (void **_buffer, + uint16_t type, + const xcb_input_device_class_data_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 2; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[24]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_KEY) { + /* xcb_input_device_class_data_t.key.num_keys */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* keys */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->key.keys; + xcb_block_len += _aux->key.num_keys * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->key.num_keys * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON) { + /* xcb_input_device_class_data_t.button.num_buttons */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* state */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.state; + xcb_block_len += ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + /* labels */ + xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.labels; + xcb_block_len += _aux->button.num_buttons * sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = _aux->button.num_buttons * sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_atom_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR) { + /* xcb_input_device_class_data_t.valuator.number */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.number; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.valuator.label */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.label; + xcb_block_len += sizeof(xcb_atom_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_atom_t); + /* xcb_input_device_class_data_t.valuator.min */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.min; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.max */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.max; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.value */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.value; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.resolution */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.resolution; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_class_data_t.valuator.mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.valuator.pad0 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*3; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL) { + /* xcb_input_device_class_data_t.scroll.number */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.number; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.scroll.scroll_type */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.scroll_type; + xcb_block_len += sizeof(uint16_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.scroll.pad1 */ + xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_block_len += sizeof(uint8_t)*2; + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2; + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.scroll.flags */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.flags; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_class_data_t.scroll.increment */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.increment; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH) { + /* xcb_input_device_class_data_t.touch.mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->touch.mode; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.touch.num_touches */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->touch.num_touches; + xcb_block_len += sizeof(uint8_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint8_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ikey.num_keys = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_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; + /* keys */ + _aux->key.keys = (uint32_t *)xcb_tmp; + xcb_block_len += _aux->key.num_keys * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON) { + /* xcb_input_device_class_data_t.button.num_buttons */ + _aux->button.num_buttons = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_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; + /* state */ + _aux->button.state = (uint32_t *)xcb_tmp; + xcb_block_len += ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_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; + /* labels */ + _aux->button.labels = (xcb_atom_t *)xcb_tmp; + xcb_block_len += _aux->button.num_buttons * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_atom_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR) { + /* xcb_input_device_class_data_t.valuator.number */ + _aux->valuator.number = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.valuator.label */ + _aux->valuator.label = *(xcb_atom_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_atom_t); + xcb_tmp += sizeof(xcb_atom_t); + xcb_align_to = ALIGNOF(xcb_atom_t); + /* xcb_input_device_class_data_t.valuator.min */ + _aux->valuator.min = *(xcb_input_fp3232_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_tmp += sizeof(xcb_input_fp3232_t); + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.max */ + _aux->valuator.max = *(xcb_input_fp3232_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_tmp += sizeof(xcb_input_fp3232_t); + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.value */ + _aux->valuator.value = *(xcb_input_fp3232_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_tmp += sizeof(xcb_input_fp3232_t); + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* xcb_input_device_class_data_t.valuator.resolution */ + _aux->valuator.resolution = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_class_data_t.valuator.mode */ + _aux->valuator.mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.valuator.pad0 */ + _aux->valuator.pad0[0] = *(uint8_t *)xcb_tmp; + _aux->valuator.pad0[1] = *(uint8_t *)xcb_tmp; + _aux->valuator.pad0[2] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 3; + xcb_tmp += sizeof(uint8_t) * 3; + xcb_align_to = ALIGNOF(uint8_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL) { + /* xcb_input_device_class_data_t.scroll.number */ + _aux->scroll.number = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.scroll.scroll_type */ + _aux->scroll.scroll_type = *(uint16_t *)xcb_tmp; + xcb_block_len += sizeof(uint16_t); + xcb_tmp += sizeof(uint16_t); + xcb_align_to = ALIGNOF(uint16_t); + /* xcb_input_device_class_data_t.scroll.pad1 */ + _aux->scroll.pad1[0] = *(uint8_t *)xcb_tmp; + _aux->scroll.pad1[1] = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t) * 2; + xcb_tmp += sizeof(uint8_t) * 2; + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.scroll.flags */ + _aux->scroll.flags = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + /* xcb_input_device_class_data_t.scroll.increment */ + _aux->scroll.increment = *(xcb_input_fp3232_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_input_fp3232_t); + xcb_tmp += sizeof(xcb_input_fp3232_t); + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + } + if(type == XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH) { + /* xcb_input_device_class_data_t.touch.mode */ + _aux->touch.mode = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_t); + /* xcb_input_device_class_data_t.touch.num_touches */ + _aux->touch.num_touches = *(uint8_t *)xcb_tmp; + xcb_block_len += sizeof(uint8_t); + xcb_tmp += sizeof(uint8_t); + xcb_align_to = ALIGNOF(uint8_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; +} + +int +xcb_input_device_class_data_sizeof (const void *_buffer, + uint16_t type) +{ + xcb_input_device_class_data_t _aux; + return xcb_input_device_class_data_unpack(_buffer, type, &_aux); +} + +int +xcb_input_device_class_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_device_class_t *_aux = (xcb_input_device_class_t *)_buffer; @@ -7189,10 +10712,10 @@ xcb_input_device_class_sizeof (const void *_buffer /**< */) xcb_tmp += xcb_block_len; xcb_buffer_len += xcb_block_len; xcb_block_len = 0; - /* uninterpreted_data */ - xcb_block_len += ((_aux->len * 4) - 8) * sizeof(uint8_t); + /* data */ + xcb_block_len += xcb_input_device_class_data_sizeof(xcb_tmp, _aux->type); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -7205,30 +10728,14 @@ xcb_input_device_class_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } -uint8_t * -xcb_input_device_class_uninterpreted_data (const xcb_input_device_class_t *R /**< */) +void * +xcb_input_device_class_data (const xcb_input_device_class_t *R) { - return (uint8_t *) (R + 1); -} - -int -xcb_input_device_class_uninterpreted_data_length (const xcb_input_device_class_t *R /**< */) -{ - return ((R->len * 4) - 8); -} - -xcb_generic_iterator_t -xcb_input_device_class_uninterpreted_data_end (const xcb_input_device_class_t *R /**< */) -{ - xcb_generic_iterator_t i; - i.data = ((uint8_t *) (R + 1)) + (((R->len * 4) - 8)); - i.rem = 0; - i.index = (char *) i.data - (char *) R; - return i; + return (void *) (R + 1); } void -xcb_input_device_class_next (xcb_input_device_class_iterator_t *i /**< */) +xcb_input_device_class_next (xcb_input_device_class_iterator_t *i) { xcb_input_device_class_t *R = i->data; xcb_generic_iterator_t child; @@ -7239,7 +10746,7 @@ xcb_input_device_class_next (xcb_input_device_class_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_device_class_end (xcb_input_device_class_iterator_t i /**< */) +xcb_input_device_class_end (xcb_input_device_class_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -7251,7 +10758,7 @@ xcb_input_device_class_end (xcb_input_device_class_iterator_t i /**< */) } int -xcb_input_xi_device_info_sizeof (const void *_buffer /**< */) +xcb_input_xi_device_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_device_info_t *_aux = (xcb_input_xi_device_info_t *)_buffer; @@ -7268,9 +10775,18 @@ xcb_input_xi_device_info_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* name */ - xcb_block_len += (((_aux->name_len + 3) / 4) * 4) * sizeof(char); + xcb_block_len += _aux->name_len * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -7299,46 +10815,46 @@ xcb_input_xi_device_info_sizeof (const void *_buffer /**< */) } char * -xcb_input_xi_device_info_name (const xcb_input_xi_device_info_t *R /**< */) +xcb_input_xi_device_info_name (const xcb_input_xi_device_info_t *R) { return (char *) (R + 1); } int -xcb_input_xi_device_info_name_length (const xcb_input_xi_device_info_t *R /**< */) +xcb_input_xi_device_info_name_length (const xcb_input_xi_device_info_t *R) { - return (((R->name_len + 3) / 4) * 4); + return R->name_len; } xcb_generic_iterator_t -xcb_input_xi_device_info_name_end (const xcb_input_xi_device_info_t *R /**< */) +xcb_input_xi_device_info_name_end (const xcb_input_xi_device_info_t *R) { xcb_generic_iterator_t i; - i.data = ((char *) (R + 1)) + ((((R->name_len + 3) / 4) * 4)); + i.data = ((char *) (R + 1)) + (R->name_len); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } int -xcb_input_xi_device_info_classes_length (const xcb_input_xi_device_info_t *R /**< */) +xcb_input_xi_device_info_classes_length (const xcb_input_xi_device_info_t *R) { return R->num_classes; } xcb_input_device_class_iterator_t -xcb_input_xi_device_info_classes_iterator (const xcb_input_xi_device_info_t *R /**< */) +xcb_input_xi_device_info_classes_iterator (const xcb_input_xi_device_info_t *R) { xcb_input_device_class_iterator_t i; xcb_generic_iterator_t prev = xcb_input_xi_device_info_name_end(R); - i.data = (xcb_input_device_class_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_device_class_t, prev.index)); + i.data = (xcb_input_device_class_t *) ((char *) prev.data + ((-prev.index) & (4 - 1))); i.rem = R->num_classes; i.index = (char *) i.data - (char *) R; return i; } void -xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i /**< */) +xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i) { xcb_input_xi_device_info_t *R = i->data; xcb_generic_iterator_t child; @@ -7349,7 +10865,7 @@ xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_xi_device_info_end (xcb_input_xi_device_info_iterator_t i /**< */) +xcb_input_xi_device_info_end (xcb_input_xi_device_info_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -7361,7 +10877,7 @@ xcb_input_xi_device_info_end (xcb_input_xi_device_info_iterator_t i /**< */) } int -xcb_input_xi_query_device_sizeof (const void *_buffer /**< */) +xcb_input_xi_query_device_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_query_device_reply_t *_aux = (xcb_input_xi_query_device_reply_t *)_buffer; @@ -7397,14 +10913,14 @@ xcb_input_xi_query_device_sizeof (const void *_buffer /**< */) } xcb_input_xi_query_device_cookie_t -xcb_input_xi_query_device (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_query_device (xcb_connection_t *c, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_QUERY_DEVICE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7424,14 +10940,14 @@ xcb_input_xi_query_device (xcb_connection_t *c /**< */, } xcb_input_xi_query_device_cookie_t -xcb_input_xi_query_device_unchecked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_query_device_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_QUERY_DEVICE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_QUERY_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7451,13 +10967,13 @@ xcb_input_xi_query_device_unchecked (xcb_connection_t *c /**< */, } int -xcb_input_xi_query_device_infos_length (const xcb_input_xi_query_device_reply_t *R /**< */) +xcb_input_xi_query_device_infos_length (const xcb_input_xi_query_device_reply_t *R) { return R->num_infos; } xcb_input_xi_device_info_iterator_t -xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_t *R /**< */) +xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_t *R) { xcb_input_xi_device_info_iterator_t i; i.data = (xcb_input_xi_device_info_t *) (R + 1); @@ -7467,24 +10983,24 @@ xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_ } xcb_input_xi_query_device_reply_t * -xcb_input_xi_query_device_reply (xcb_connection_t *c /**< */, +xcb_input_xi_query_device_reply (xcb_connection_t *c, xcb_input_xi_query_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_xi_query_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_input_xi_set_focus_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_set_focus_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_SET_FOCUS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SET_FOCUS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7506,16 +11022,16 @@ xcb_input_xi_set_focus_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_set_focus (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_set_focus (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_SET_FOCUS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_SET_FOCUS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7537,14 +11053,14 @@ xcb_input_xi_set_focus (xcb_connection_t *c /**< */, } xcb_input_xi_get_focus_cookie_t -xcb_input_xi_get_focus (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_get_focus (xcb_connection_t *c, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_GET_FOCUS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_FOCUS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7564,14 +11080,14 @@ xcb_input_xi_get_focus (xcb_connection_t *c /**< */, } xcb_input_xi_get_focus_cookie_t -xcb_input_xi_get_focus_unchecked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_get_focus_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_GET_FOCUS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_FOCUS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7591,15 +11107,15 @@ xcb_input_xi_get_focus_unchecked (xcb_connection_t *c /**< */, } xcb_input_xi_get_focus_reply_t * -xcb_input_xi_get_focus_reply (xcb_connection_t *c /**< */, +xcb_input_xi_get_focus_reply (xcb_connection_t *c, xcb_input_xi_get_focus_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_xi_get_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_xi_grab_device_sizeof (const void *_buffer /**< */) +xcb_input_xi_grab_device_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_grab_device_request_t *_aux = (xcb_input_xi_grab_device_request_t *)_buffer; @@ -7630,22 +11146,22 @@ xcb_input_xi_grab_device_sizeof (const void *_buffer /**< */) } xcb_input_xi_grab_device_cookie_t -xcb_input_xi_grab_device (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t time /**< */, - xcb_cursor_t cursor /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t paired_device_mode /**< */, - uint8_t owner_events /**< */, - uint16_t mask_len /**< */, - const uint32_t *mask /**< */) +xcb_input_xi_grab_device (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t paired_device_mode, + uint8_t owner_events, + uint16_t mask_len, + const uint32_t *mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_GRAB_DEVICE, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GRAB_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -7677,22 +11193,22 @@ xcb_input_xi_grab_device (xcb_connection_t *c /**< */, } xcb_input_xi_grab_device_cookie_t -xcb_input_xi_grab_device_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t time /**< */, - xcb_cursor_t cursor /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t paired_device_mode /**< */, - uint8_t owner_events /**< */, - uint16_t mask_len /**< */, - const uint32_t *mask /**< */) +xcb_input_xi_grab_device_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t paired_device_mode, + uint8_t owner_events, + uint16_t mask_len, + const uint32_t *mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_GRAB_DEVICE, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GRAB_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -7724,23 +11240,23 @@ xcb_input_xi_grab_device_unchecked (xcb_connection_t *c /**< */, } xcb_input_xi_grab_device_reply_t * -xcb_input_xi_grab_device_reply (xcb_connection_t *c /**< */, +xcb_input_xi_grab_device_reply (xcb_connection_t *c, xcb_input_xi_grab_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_xi_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_input_xi_ungrab_device_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_ungrab_device_checked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_UNGRAB_DEVICE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_UNGRAB_DEVICE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7761,15 +11277,15 @@ xcb_input_xi_ungrab_device_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_ungrab_device (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_ungrab_device (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_UNGRAB_DEVICE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_UNGRAB_DEVICE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7790,18 +11306,18 @@ xcb_input_xi_ungrab_device (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_allow_events_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t event_mode /**< */, - uint32_t touchid /**< */, - xcb_window_t grab_window /**< */) +xcb_input_xi_allow_events_checked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid, + uint8_t event_mode, + uint32_t touchid, + xcb_window_t grab_window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_ALLOW_EVENTS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_ALLOW_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7825,18 +11341,18 @@ xcb_input_xi_allow_events_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_allow_events (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t event_mode /**< */, - uint32_t touchid /**< */, - xcb_window_t grab_window /**< */) +xcb_input_xi_allow_events (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid, + uint8_t event_mode, + uint32_t touchid, + xcb_window_t grab_window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_ALLOW_EVENTS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_ALLOW_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7860,7 +11376,7 @@ xcb_input_xi_allow_events (xcb_connection_t *c /**< */, } void -xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i /**< */) +xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i) { --i->rem; ++i->data; @@ -7868,7 +11384,7 @@ xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i / } xcb_generic_iterator_t -xcb_input_grab_modifier_info_end (xcb_input_grab_modifier_info_iterator_t i /**< */) +xcb_input_grab_modifier_info_end (xcb_input_grab_modifier_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -7878,7 +11394,7 @@ xcb_input_grab_modifier_info_end (xcb_input_grab_modifier_info_iterator_t i /** } int -xcb_input_xi_passive_grab_device_sizeof (const void *_buffer /**< */) +xcb_input_xi_passive_grab_device_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_passive_grab_device_request_t *_aux = (xcb_input_xi_passive_grab_device_request_t *)_buffer; @@ -7921,26 +11437,26 @@ xcb_input_xi_passive_grab_device_sizeof (const void *_buffer /**< */) } xcb_input_xi_passive_grab_device_cookie_t -xcb_input_xi_passive_grab_device (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_window_t grab_window /**< */, - xcb_cursor_t cursor /**< */, - uint32_t detail /**< */, - xcb_input_device_id_t deviceid /**< */, - uint16_t num_modifiers /**< */, - uint16_t mask_len /**< */, - uint8_t grab_type /**< */, - uint8_t grab_mode /**< */, - uint8_t paired_device_mode /**< */, - uint8_t owner_events /**< */, - const uint32_t *mask /**< */, - const uint32_t *modifiers /**< */) +xcb_input_xi_passive_grab_device (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_window_t grab_window, + xcb_cursor_t cursor, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint16_t mask_len, + uint8_t grab_type, + uint8_t grab_mode, + uint8_t paired_device_mode, + uint8_t owner_events, + const uint32_t *mask, + const uint32_t *modifiers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_PASSIVE_GRAB_DEVICE, - /* isvoid */ 0 + .count = 6, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_PASSIVE_GRAB_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[8]; @@ -7980,26 +11496,26 @@ xcb_input_xi_passive_grab_device (xcb_connection_t *c /**< */, } xcb_input_xi_passive_grab_device_cookie_t -xcb_input_xi_passive_grab_device_unchecked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_window_t grab_window /**< */, - xcb_cursor_t cursor /**< */, - uint32_t detail /**< */, - xcb_input_device_id_t deviceid /**< */, - uint16_t num_modifiers /**< */, - uint16_t mask_len /**< */, - uint8_t grab_type /**< */, - uint8_t grab_mode /**< */, - uint8_t paired_device_mode /**< */, - uint8_t owner_events /**< */, - const uint32_t *mask /**< */, - const uint32_t *modifiers /**< */) +xcb_input_xi_passive_grab_device_unchecked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_window_t grab_window, + xcb_cursor_t cursor, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint16_t mask_len, + uint8_t grab_type, + uint8_t grab_mode, + uint8_t paired_device_mode, + uint8_t owner_events, + const uint32_t *mask, + const uint32_t *modifiers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_PASSIVE_GRAB_DEVICE, - /* isvoid */ 0 + .count = 6, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_PASSIVE_GRAB_DEVICE, + .isvoid = 0 }; struct iovec xcb_parts[8]; @@ -8039,19 +11555,19 @@ xcb_input_xi_passive_grab_device_unchecked (xcb_connection_t *c /**< */, } xcb_input_grab_modifier_info_t * -xcb_input_xi_passive_grab_device_modifiers (const xcb_input_xi_passive_grab_device_reply_t *R /**< */) +xcb_input_xi_passive_grab_device_modifiers (const xcb_input_xi_passive_grab_device_reply_t *R) { return (xcb_input_grab_modifier_info_t *) (R + 1); } int -xcb_input_xi_passive_grab_device_modifiers_length (const xcb_input_xi_passive_grab_device_reply_t *R /**< */) +xcb_input_xi_passive_grab_device_modifiers_length (const xcb_input_xi_passive_grab_device_reply_t *R) { return R->num_modifiers; } xcb_input_grab_modifier_info_iterator_t -xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_grab_device_reply_t *R /**< */) +xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_grab_device_reply_t *R) { xcb_input_grab_modifier_info_iterator_t i; i.data = (xcb_input_grab_modifier_info_t *) (R + 1); @@ -8061,15 +11577,15 @@ xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_ } xcb_input_xi_passive_grab_device_reply_t * -xcb_input_xi_passive_grab_device_reply (xcb_connection_t *c /**< */, +xcb_input_xi_passive_grab_device_reply (xcb_connection_t *c, xcb_input_xi_passive_grab_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_xi_passive_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_xi_passive_ungrab_device_sizeof (const void *_buffer /**< */) +xcb_input_xi_passive_ungrab_device_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_passive_ungrab_device_request_t *_aux = (xcb_input_xi_passive_ungrab_device_request_t *)_buffer; @@ -8100,19 +11616,19 @@ xcb_input_xi_passive_ungrab_device_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint32_t detail /**< */, - xcb_input_device_id_t deviceid /**< */, - uint16_t num_modifiers /**< */, - uint8_t grab_type /**< */, - const uint32_t *modifiers /**< */) +xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint8_t grab_type, + const uint32_t *modifiers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -8141,19 +11657,19 @@ xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_passive_ungrab_device (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint32_t detail /**< */, - xcb_input_device_id_t deviceid /**< */, - uint16_t num_modifiers /**< */, - uint8_t grab_type /**< */, - const uint32_t *modifiers /**< */) +xcb_input_xi_passive_ungrab_device (xcb_connection_t *c, + xcb_window_t grab_window, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint8_t grab_type, + const uint32_t *modifiers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -8181,8 +11697,30 @@ xcb_input_xi_passive_ungrab_device (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_input_xi_passive_ungrab_device_modifiers (const xcb_input_xi_passive_ungrab_device_request_t *R) +{ + return (uint32_t *) (R + 1); +} + int -xcb_input_xi_list_properties_sizeof (const void *_buffer /**< */) +xcb_input_xi_passive_ungrab_device_modifiers_length (const xcb_input_xi_passive_ungrab_device_request_t *R) +{ + return R->num_modifiers; +} + +xcb_generic_iterator_t +xcb_input_xi_passive_ungrab_device_modifiers_end (const xcb_input_xi_passive_ungrab_device_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->num_modifiers); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_xi_list_properties_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_list_properties_reply_t *_aux = (xcb_input_xi_list_properties_reply_t *)_buffer; @@ -8213,14 +11751,14 @@ xcb_input_xi_list_properties_sizeof (const void *_buffer /**< */) } xcb_input_xi_list_properties_cookie_t -xcb_input_xi_list_properties (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_list_properties (xcb_connection_t *c, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_LIST_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_LIST_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8240,14 +11778,14 @@ xcb_input_xi_list_properties (xcb_connection_t *c /**< */, } xcb_input_xi_list_properties_cookie_t -xcb_input_xi_list_properties_unchecked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */) +xcb_input_xi_list_properties_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_LIST_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_LIST_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8267,19 +11805,19 @@ xcb_input_xi_list_properties_unchecked (xcb_connection_t *c /**< */, } xcb_atom_t * -xcb_input_xi_list_properties_properties (const xcb_input_xi_list_properties_reply_t *R /**< */) +xcb_input_xi_list_properties_properties (const xcb_input_xi_list_properties_reply_t *R) { return (xcb_atom_t *) (R + 1); } int -xcb_input_xi_list_properties_properties_length (const xcb_input_xi_list_properties_reply_t *R /**< */) +xcb_input_xi_list_properties_properties_length (const xcb_input_xi_list_properties_reply_t *R) { return R->num_properties; } xcb_generic_iterator_t -xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_reply_t *R /**< */) +xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_atom_t *) (R + 1)) + (R->num_properties); @@ -8289,106 +11827,107 @@ xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_ } xcb_input_xi_list_properties_reply_t * -xcb_input_xi_list_properties_reply (xcb_connection_t *c /**< */, +xcb_input_xi_list_properties_reply (xcb_connection_t *c, xcb_input_xi_list_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_xi_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } uint8_t * -xcb_input_xi_change_property_items_data_8 (const xcb_input_xi_change_property_items_t *S /**< */) +xcb_input_xi_change_property_items_data_8 (const xcb_input_xi_change_property_items_t *S) { - return /* items */ S->data8; + return S->data8; } int -xcb_input_xi_change_property_items_data_8_length (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */) +xcb_input_xi_change_property_items_data_8_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_xi_change_property_items_data_8_end (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */) +xcb_input_xi_change_property_items_data_8_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data8 + R->num_items; + i.data = S->data8 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint16_t * -xcb_input_xi_change_property_items_data_16 (const xcb_input_xi_change_property_items_t *S /**< */) +xcb_input_xi_change_property_items_data_16 (const xcb_input_xi_change_property_items_t *S) { - return /* items */ S->data16; + return S->data16; } int -xcb_input_xi_change_property_items_data_16_length (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */) +xcb_input_xi_change_property_items_data_16_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_xi_change_property_items_data_16_end (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */) +xcb_input_xi_change_property_items_data_16_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data16 + R->num_items; + i.data = S->data16 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint32_t * -xcb_input_xi_change_property_items_data_32 (const xcb_input_xi_change_property_items_t *S /**< */) +xcb_input_xi_change_property_items_data_32 (const xcb_input_xi_change_property_items_t *S) { - return /* items */ S->data32; + return S->data32; } int -xcb_input_xi_change_property_items_data_32_length (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */) +xcb_input_xi_change_property_items_data_32_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_xi_change_property_items_data_32_end (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */) +xcb_input_xi_change_property_items_data_32_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data32 + R->num_items; + i.data = S->data32 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } int -xcb_input_xi_change_property_items_serialize (void **_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - const xcb_input_xi_change_property_items_t *_aux /**< */) +xcb_input_xi_change_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_xi_change_property_items_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[7]; + struct iovec xcb_parts[9]; unsigned int xcb_parts_idx = 0; unsigned int xcb_block_len = 0; unsigned int i; char *xcb_tmp; - if(format & XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8397,16 +11936,16 @@ xcb_input_xi_change_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* data8 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8; xcb_block_len += num_items * sizeof(uint8_t); xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8415,16 +11954,29 @@ xcb_input_xi_change_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* data16 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16; xcb_block_len += num_items * sizeof(uint16_t); xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint16_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8433,6 +11985,20 @@ xcb_input_xi_change_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* data32 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32; xcb_block_len += num_items * sizeof(uint32_t); @@ -8441,7 +12007,7 @@ xcb_input_xi_change_property_items_serialize (void xcb_align_to = ALIGNOF(uint32_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8450,6 +12016,7 @@ xcb_input_xi_change_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -8469,57 +12036,81 @@ xcb_input_xi_change_property_items_serialize (void } int -xcb_input_xi_change_property_items_unpack (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - xcb_input_xi_change_property_items_t *_aux /**< */) +xcb_input_xi_change_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_xi_change_property_items_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; - if(format & XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* data8 */ _aux->data8 = (uint8_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* 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; /* data16 */ _aux->data16 = (uint16_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint16_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint16_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* 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; /* data32 */ _aux->data32 = (uint32_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint32_t); @@ -8527,6 +12118,47 @@ xcb_input_xi_change_property_items_unpack (const void xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_input_xi_change_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format) +{ + xcb_input_xi_change_property_items_t _aux; + return xcb_input_xi_change_property_items_unpack(_buffer, num_items, format, &_aux); +} + +int +xcb_input_xi_change_property_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_change_property_request_t *_aux = (xcb_input_xi_change_property_request_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; + + + xcb_block_len += sizeof(xcb_input_xi_change_property_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* items */ + xcb_block_len += xcb_input_xi_change_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -8538,30 +12170,21 @@ xcb_input_xi_change_property_items_unpack (const void return xcb_buffer_len; } -int -xcb_input_xi_change_property_items_sizeof (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */) -{ - xcb_input_xi_change_property_items_t _aux; - return xcb_input_xi_change_property_items_unpack(_buffer, num_items, format, &_aux); -} - xcb_void_cookie_t -xcb_input_xi_change_property_checked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t format /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t num_items /**< */, - const void *items /**< */) +xcb_input_xi_change_property_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const void *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_CHANGE_PROPERTY, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -8589,20 +12212,20 @@ xcb_input_xi_change_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_change_property (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t format /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t num_items /**< */, - const void *items /**< */) +xcb_input_xi_change_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const void *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_CHANGE_PROPERTY, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -8630,20 +12253,20 @@ xcb_input_xi_change_property (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_change_property_aux_checked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t format /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t num_items /**< */, - const xcb_input_xi_change_property_items_t *items /**< */) +xcb_input_xi_change_property_aux_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const xcb_input_xi_change_property_items_t *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_CHANGE_PROPERTY, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -8673,20 +12296,20 @@ xcb_input_xi_change_property_aux_checked (xcb_connection_t } xcb_void_cookie_t -xcb_input_xi_change_property_aux (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t format /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t num_items /**< */, - const xcb_input_xi_change_property_items_t *items /**< */) +xcb_input_xi_change_property_aux (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const xcb_input_xi_change_property_items_t *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_CHANGE_PROPERTY, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_CHANGE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -8715,16 +12338,22 @@ xcb_input_xi_change_property_aux (xcb_connection_t *c return xcb_ret; } +void * +xcb_input_xi_change_property_items (const xcb_input_xi_change_property_request_t *R) +{ + return (void *) (R + 1); +} + xcb_void_cookie_t -xcb_input_xi_delete_property_checked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - xcb_atom_t property /**< */) +xcb_input_xi_delete_property_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_DELETE_PROPERTY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_DELETE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -8745,15 +12374,15 @@ xcb_input_xi_delete_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_input_xi_delete_property (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - xcb_atom_t property /**< */) +xcb_input_xi_delete_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_DELETE_PROPERTY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_DELETE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -8774,98 +12403,99 @@ xcb_input_xi_delete_property (xcb_connection_t *c /**< */, } uint8_t * -xcb_input_xi_get_property_items_data_8 (const xcb_input_xi_get_property_items_t *S /**< */) +xcb_input_xi_get_property_items_data_8 (const xcb_input_xi_get_property_items_t *S) { - return /* items */ S->data8; + return S->data8; } int -xcb_input_xi_get_property_items_data_8_length (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */) +xcb_input_xi_get_property_items_data_8_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_xi_get_property_items_data_8_end (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */) +xcb_input_xi_get_property_items_data_8_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data8 + R->num_items; + i.data = S->data8 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint16_t * -xcb_input_xi_get_property_items_data_16 (const xcb_input_xi_get_property_items_t *S /**< */) +xcb_input_xi_get_property_items_data_16 (const xcb_input_xi_get_property_items_t *S) { - return /* items */ S->data16; + return S->data16; } int -xcb_input_xi_get_property_items_data_16_length (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */) +xcb_input_xi_get_property_items_data_16_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_xi_get_property_items_data_16_end (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */) +xcb_input_xi_get_property_items_data_16_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data16 + R->num_items; + i.data = S->data16 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint32_t * -xcb_input_xi_get_property_items_data_32 (const xcb_input_xi_get_property_items_t *S /**< */) +xcb_input_xi_get_property_items_data_32 (const xcb_input_xi_get_property_items_t *S) { - return /* items */ S->data32; + return S->data32; } int -xcb_input_xi_get_property_items_data_32_length (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */) +xcb_input_xi_get_property_items_data_32_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) { return R->num_items; } xcb_generic_iterator_t -xcb_input_xi_get_property_items_data_32_end (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */) +xcb_input_xi_get_property_items_data_32_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S) { xcb_generic_iterator_t i; - i.data = /* items */ S->data32 + R->num_items; + i.data = S->data32 + R->num_items; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } int -xcb_input_xi_get_property_items_serialize (void **_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - const xcb_input_xi_get_property_items_t *_aux /**< */) +xcb_input_xi_get_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_xi_get_property_items_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[7]; + struct iovec xcb_parts[9]; unsigned int xcb_parts_idx = 0; unsigned int xcb_block_len = 0; unsigned int i; char *xcb_tmp; - if(format & XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8874,16 +12504,16 @@ xcb_input_xi_get_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* data8 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8; xcb_block_len += num_items * sizeof(uint8_t); xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8892,16 +12522,29 @@ xcb_input_xi_get_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* data16 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16; xcb_block_len += num_items * sizeof(uint16_t); xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint16_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8910,6 +12553,20 @@ xcb_input_xi_get_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* data32 */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32; xcb_block_len += num_items * sizeof(uint32_t); @@ -8918,7 +12575,7 @@ xcb_input_xi_get_property_items_serialize (void xcb_align_to = ALIGNOF(uint32_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8927,6 +12584,7 @@ xcb_input_xi_get_property_items_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -8946,57 +12604,81 @@ xcb_input_xi_get_property_items_serialize (void } int -xcb_input_xi_get_property_items_unpack (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - xcb_input_xi_get_property_items_t *_aux /**< */) +xcb_input_xi_get_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_xi_get_property_items_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; - if(format & XCB_INPUT_PROPERTY_FORMAT_8_BITS) { + if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* data8 */ _aux->data8 = (uint8_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) { + /* 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; /* data16 */ _aux->data16 = (uint16_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint16_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint16_t); - } - if(format & XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) { + /* 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; /* data32 */ _aux->data32 = (uint32_t *)xcb_tmp; xcb_block_len += num_items * sizeof(uint32_t); @@ -9004,6 +12686,47 @@ xcb_input_xi_get_property_items_unpack (const void *_buf xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_input_xi_get_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format) +{ + xcb_input_xi_get_property_items_t _aux; + return xcb_input_xi_get_property_items_unpack(_buffer, num_items, format, &_aux); +} + +int +xcb_input_xi_get_property_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_input_xi_get_property_reply_t *_aux = (xcb_input_xi_get_property_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; + + + xcb_block_len += sizeof(xcb_input_xi_get_property_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* items */ + xcb_block_len += xcb_input_xi_get_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -9015,29 +12738,20 @@ xcb_input_xi_get_property_items_unpack (const void *_buf return xcb_buffer_len; } -int -xcb_input_xi_get_property_items_sizeof (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */) -{ - xcb_input_xi_get_property_items_t _aux; - return xcb_input_xi_get_property_items_unpack(_buffer, num_items, format, &_aux); -} - xcb_input_xi_get_property_cookie_t -xcb_input_xi_get_property (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t _delete /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t offset /**< */, - uint32_t len /**< */) +xcb_input_xi_get_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t _delete, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_GET_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9062,19 +12776,19 @@ xcb_input_xi_get_property (xcb_connection_t *c /**< */, } xcb_input_xi_get_property_cookie_t -xcb_input_xi_get_property_unchecked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t _delete /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t offset /**< */, - uint32_t len /**< */) +xcb_input_xi_get_property_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t _delete, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_GET_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9099,21 +12813,21 @@ xcb_input_xi_get_property_unchecked (xcb_connection_t *c /**< */, } void * -xcb_input_xi_get_property_items (const xcb_input_xi_get_property_reply_t *R /**< */) +xcb_input_xi_get_property_items (const xcb_input_xi_get_property_reply_t *R) { return (void *) (R + 1); } xcb_input_xi_get_property_reply_t * -xcb_input_xi_get_property_reply (xcb_connection_t *c /**< */, +xcb_input_xi_get_property_reply (xcb_connection_t *c, xcb_input_xi_get_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_xi_get_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_input_xi_get_selected_events_sizeof (const void *_buffer /**< */) +xcb_input_xi_get_selected_events_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_get_selected_events_reply_t *_aux = (xcb_input_xi_get_selected_events_reply_t *)_buffer; @@ -9149,14 +12863,14 @@ xcb_input_xi_get_selected_events_sizeof (const void *_buffer /**< */) } xcb_input_xi_get_selected_events_cookie_t -xcb_input_xi_get_selected_events (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_input_xi_get_selected_events (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_GET_SELECTED_EVENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_SELECTED_EVENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9175,14 +12889,14 @@ xcb_input_xi_get_selected_events (xcb_connection_t *c /**< */, } xcb_input_xi_get_selected_events_cookie_t -xcb_input_xi_get_selected_events_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_input_xi_get_selected_events_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_GET_SELECTED_EVENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_GET_SELECTED_EVENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9201,13 +12915,13 @@ xcb_input_xi_get_selected_events_unchecked (xcb_connection_t *c /**< */, } int -xcb_input_xi_get_selected_events_masks_length (const xcb_input_xi_get_selected_events_reply_t *R /**< */) +xcb_input_xi_get_selected_events_masks_length (const xcb_input_xi_get_selected_events_reply_t *R) { return R->num_masks; } xcb_input_event_mask_iterator_t -xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected_events_reply_t *R /**< */) +xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected_events_reply_t *R) { xcb_input_event_mask_iterator_t i; i.data = (xcb_input_event_mask_t *) (R + 1); @@ -9217,15 +12931,15 @@ xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected } xcb_input_xi_get_selected_events_reply_t * -xcb_input_xi_get_selected_events_reply (xcb_connection_t *c /**< */, +xcb_input_xi_get_selected_events_reply (xcb_connection_t *c, xcb_input_xi_get_selected_events_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_input_xi_get_selected_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } void -xcb_input_barrier_release_pointer_info_next (xcb_input_barrier_release_pointer_info_iterator_t *i /**< */) +xcb_input_barrier_release_pointer_info_next (xcb_input_barrier_release_pointer_info_iterator_t *i) { --i->rem; ++i->data; @@ -9233,7 +12947,7 @@ xcb_input_barrier_release_pointer_info_next (xcb_input_barrier_release_pointer_i } xcb_generic_iterator_t -xcb_input_barrier_release_pointer_info_end (xcb_input_barrier_release_pointer_info_iterator_t i /**< */) +xcb_input_barrier_release_pointer_info_end (xcb_input_barrier_release_pointer_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -9243,7 +12957,7 @@ xcb_input_barrier_release_pointer_info_end (xcb_input_barrier_release_pointer_in } int -xcb_input_xi_barrier_release_pointer_sizeof (const void *_buffer /**< */) +xcb_input_xi_barrier_release_pointer_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_xi_barrier_release_pointer_request_t *_aux = (xcb_input_xi_barrier_release_pointer_request_t *)_buffer; @@ -9274,15 +12988,15 @@ xcb_input_xi_barrier_release_pointer_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_input_xi_barrier_release_pointer_checked (xcb_connection_t *c /**< */, - uint32_t num_barriers /**< */, - const xcb_input_barrier_release_pointer_info_t *barriers /**< */) +xcb_input_xi_barrier_release_pointer_checked (xcb_connection_t *c, + uint32_t num_barriers, + const xcb_input_barrier_release_pointer_info_t *barriers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_BARRIER_RELEASE_POINTER, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_BARRIER_RELEASE_POINTER, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -9306,15 +13020,15 @@ xcb_input_xi_barrier_release_pointer_checked (xcb_connection_t } xcb_void_cookie_t -xcb_input_xi_barrier_release_pointer (xcb_connection_t *c /**< */, - uint32_t num_barriers /**< */, - const xcb_input_barrier_release_pointer_info_t *barriers /**< */) +xcb_input_xi_barrier_release_pointer (xcb_connection_t *c, + uint32_t num_barriers, + const xcb_input_barrier_release_pointer_info_t *barriers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_input_id, - /* opcode */ XCB_INPUT_XI_BARRIER_RELEASE_POINTER, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_input_id, + .opcode = XCB_INPUT_XI_BARRIER_RELEASE_POINTER, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -9337,8 +13051,30 @@ xcb_input_xi_barrier_release_pointer (xcb_connection_t return xcb_ret; } +xcb_input_barrier_release_pointer_info_t * +xcb_input_xi_barrier_release_pointer_barriers (const xcb_input_xi_barrier_release_pointer_request_t *R) +{ + return (xcb_input_barrier_release_pointer_info_t *) (R + 1); +} + int -xcb_input_device_changed_sizeof (const void *_buffer /**< */) +xcb_input_xi_barrier_release_pointer_barriers_length (const xcb_input_xi_barrier_release_pointer_request_t *R) +{ + return R->num_barriers; +} + +xcb_input_barrier_release_pointer_info_iterator_t +xcb_input_xi_barrier_release_pointer_barriers_iterator (const xcb_input_xi_barrier_release_pointer_request_t *R) +{ + xcb_input_barrier_release_pointer_info_iterator_t i; + i.data = (xcb_input_barrier_release_pointer_info_t *) (R + 1); + i.rem = R->num_barriers; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_device_changed_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_device_changed_event_t *_aux = (xcb_input_device_changed_event_t *)_buffer; @@ -9374,7 +13110,23 @@ xcb_input_device_changed_sizeof (const void *_buffer /**< */) } int -xcb_input_key_press_sizeof (const void *_buffer /**< */) +xcb_input_device_changed_classes_length (const xcb_input_device_changed_event_t *R) +{ + return R->num_classes; +} + +xcb_input_device_class_iterator_t +xcb_input_device_changed_classes_iterator (const xcb_input_device_changed_event_t *R) +{ + xcb_input_device_class_iterator_t i; + i.data = (xcb_input_device_class_t *) (R + 1); + i.rem = R->num_classes; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_key_press_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_key_press_event_t *_aux = (xcb_input_key_press_event_t *)_buffer; @@ -9383,6 +13135,10 @@ xcb_input_key_press_sizeof (const void *_buffer /**< */) unsigned int xcb_pad = 0; unsigned int xcb_align_to = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ xcb_block_len += sizeof(xcb_input_key_press_event_t); xcb_tmp += xcb_block_len; @@ -9412,55 +13168,138 @@ xcb_input_key_press_sizeof (const void *_buffer /**< */) xcb_pad = 0; } xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_key_press_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; return xcb_buffer_len; } +uint32_t * +xcb_input_key_press_button_mask (const xcb_input_key_press_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_key_press_button_mask_length (const xcb_input_key_press_event_t *R) +{ + return R->buttons_len; +} + +xcb_generic_iterator_t +xcb_input_key_press_button_mask_end (const xcb_input_key_press_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->buttons_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint32_t * +xcb_input_key_press_valuator_mask (const xcb_input_key_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_key_press_button_mask_end(R); + return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); +} + +int +xcb_input_key_press_valuator_mask_length (const xcb_input_key_press_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_key_press_valuator_mask_end (const xcb_input_key_press_event_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_key_press_button_mask_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_key_press_axisvalues (const xcb_input_key_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_key_press_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_key_press_axisvalues_length (const xcb_input_key_press_event_t *R) +{ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = R->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_key_press_valuator_mask(R); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + return xcb_pre_tmp_7; +} + +xcb_input_fp3232_iterator_t +xcb_input_key_press_axisvalues_iterator (const xcb_input_key_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_key_press_valuator_mask_end(R); + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_key_press_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_11; + i.index = (char *) i.data - (char *) R; + return i; +} + int xcb_input_key_release_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_key_release_event_t *_aux = (xcb_input_key_release_event_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; - - - xcb_block_len += sizeof(xcb_input_key_release_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* button_mask */ - xcb_block_len += _aux->buttons_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - /* valuator_mask */ - xcb_block_len += _aux->valuators_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_key_press_sizeof(_buffer); } int -xcb_input_button_press_sizeof (const void *_buffer /**< */) +xcb_input_button_press_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_button_press_event_t *_aux = (xcb_input_button_press_event_t *)_buffer; @@ -9469,6 +13308,10 @@ xcb_input_button_press_sizeof (const void *_buffer /**< */) unsigned int xcb_pad = 0; unsigned int xcb_align_to = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ xcb_block_len += sizeof(xcb_input_button_press_event_t); xcb_tmp += xcb_block_len; @@ -9498,98 +13341,144 @@ xcb_input_button_press_sizeof (const void *_buffer /**< */) xcb_pad = 0; } xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_button_press_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; return xcb_buffer_len; } +uint32_t * +xcb_input_button_press_button_mask (const xcb_input_button_press_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_button_press_button_mask_length (const xcb_input_button_press_event_t *R) +{ + return R->buttons_len; +} + +xcb_generic_iterator_t +xcb_input_button_press_button_mask_end (const xcb_input_button_press_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->buttons_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint32_t * +xcb_input_button_press_valuator_mask (const xcb_input_button_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_button_press_button_mask_end(R); + return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); +} + +int +xcb_input_button_press_valuator_mask_length (const xcb_input_button_press_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_button_press_valuator_mask_end (const xcb_input_button_press_event_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_button_press_button_mask_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_button_press_axisvalues (const xcb_input_button_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_button_press_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_button_press_axisvalues_length (const xcb_input_button_press_event_t *R) +{ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = R->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_button_press_valuator_mask(R); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + return xcb_pre_tmp_7; +} + +xcb_input_fp3232_iterator_t +xcb_input_button_press_axisvalues_iterator (const xcb_input_button_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_button_press_valuator_mask_end(R); + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_button_press_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_11; + i.index = (char *) i.data - (char *) R; + return i; +} + int xcb_input_button_release_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_button_release_event_t *_aux = (xcb_input_button_release_event_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; - - - xcb_block_len += sizeof(xcb_input_button_release_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* button_mask */ - xcb_block_len += _aux->buttons_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - /* valuator_mask */ - xcb_block_len += _aux->valuators_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_button_press_sizeof(_buffer); } int xcb_input_motion_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_motion_event_t *_aux = (xcb_input_motion_event_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; - - - xcb_block_len += sizeof(xcb_input_motion_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* button_mask */ - xcb_block_len += _aux->buttons_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - /* valuator_mask */ - xcb_block_len += _aux->valuators_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_button_press_sizeof(_buffer); } int -xcb_input_enter_sizeof (const void *_buffer /**< */) +xcb_input_enter_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_enter_event_t *_aux = (xcb_input_enter_event_t *)_buffer; @@ -9619,101 +13508,48 @@ xcb_input_enter_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } +uint32_t * +xcb_input_enter_buttons (const xcb_input_enter_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_enter_buttons_length (const xcb_input_enter_event_t *R) +{ + return R->buttons_len; +} + +xcb_generic_iterator_t +xcb_input_enter_buttons_end (const xcb_input_enter_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->buttons_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + int xcb_input_leave_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_leave_event_t *_aux = (xcb_input_leave_event_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; - - - xcb_block_len += sizeof(xcb_input_leave_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* buttons */ - xcb_block_len += _aux->buttons_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_enter_sizeof(_buffer); } int xcb_input_focus_in_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_focus_in_event_t *_aux = (xcb_input_focus_in_event_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; - - - xcb_block_len += sizeof(xcb_input_focus_in_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* buttons */ - xcb_block_len += _aux->buttons_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_enter_sizeof(_buffer); } int xcb_input_focus_out_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_focus_out_event_t *_aux = (xcb_input_focus_out_event_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; - - - xcb_block_len += sizeof(xcb_input_focus_out_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* buttons */ - xcb_block_len += _aux->buttons_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_enter_sizeof(_buffer); } void -xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i /**< */) +xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i) { --i->rem; ++i->data; @@ -9721,7 +13557,7 @@ xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_input_hierarchy_info_end (xcb_input_hierarchy_info_iterator_t i /**< */) +xcb_input_hierarchy_info_end (xcb_input_hierarchy_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -9731,7 +13567,7 @@ xcb_input_hierarchy_info_end (xcb_input_hierarchy_info_iterator_t i /**< */) } int -xcb_input_hierarchy_sizeof (const void *_buffer /**< */) +xcb_input_hierarchy_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_hierarchy_event_t *_aux = (xcb_input_hierarchy_event_t *)_buffer; @@ -9761,8 +13597,30 @@ xcb_input_hierarchy_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } +xcb_input_hierarchy_info_t * +xcb_input_hierarchy_infos (const xcb_input_hierarchy_event_t *R) +{ + return (xcb_input_hierarchy_info_t *) (R + 1); +} + int -xcb_input_raw_key_press_sizeof (const void *_buffer /**< */) +xcb_input_hierarchy_infos_length (const xcb_input_hierarchy_event_t *R) +{ + return R->num_infos; +} + +xcb_input_hierarchy_info_iterator_t +xcb_input_hierarchy_infos_iterator (const xcb_input_hierarchy_event_t *R) +{ + xcb_input_hierarchy_info_iterator_t i; + i.data = (xcb_input_hierarchy_info_t *) (R + 1); + i.rem = R->num_infos; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_raw_key_press_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_raw_key_press_event_t *_aux = (xcb_input_raw_key_press_event_t *)_buffer; @@ -9771,6 +13629,14 @@ xcb_input_raw_key_press_sizeof (const void *_buffer /**< */) unsigned int xcb_pad = 0; unsigned int xcb_align_to = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ xcb_block_len += sizeof(xcb_input_raw_key_press_event_t); xcb_tmp += xcb_block_len; @@ -9788,29 +13654,42 @@ xcb_input_raw_key_press_sizeof (const void *_buffer /**< */) xcb_pad = 0; } xcb_block_len = 0; - - return xcb_buffer_len; -} - -int -xcb_input_raw_key_release_sizeof (const void *_buffer /**< */) -{ - char *xcb_tmp = (char *)_buffer; - const xcb_input_raw_key_release_event_t *_aux = (xcb_input_raw_key_release_event_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; - - - xcb_block_len += sizeof(xcb_input_raw_key_release_event_t); + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_raw_key_press_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; - /* valuator_mask */ - xcb_block_len += _aux->valuators_len * sizeof(uint32_t); + /* axisvalues_raw */ + /* sumof start */ + xcb_pre_tmp_5 = _aux->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_raw_key_press_valuator_mask(_aux); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -9823,8 +13702,140 @@ xcb_input_raw_key_release_sizeof (const void *_buffer /**< */) return xcb_buffer_len; } +uint32_t * +xcb_input_raw_key_press_valuator_mask (const xcb_input_raw_key_press_event_t *R) +{ + return (uint32_t *) (R + 1); +} + int -xcb_input_raw_button_press_sizeof (const void *_buffer /**< */) +xcb_input_raw_key_press_valuator_mask_length (const xcb_input_raw_key_press_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_raw_key_press_valuator_mask_end (const xcb_input_raw_key_press_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_key_press_axisvalues (const xcb_input_raw_key_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_raw_key_press_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_key_press_axisvalues_length (const xcb_input_raw_key_press_event_t *R) +{ + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_raw_key_press_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + return xcb_pre_tmp_11; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_key_press_axisvalues_iterator (const xcb_input_raw_key_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_raw_key_press_valuator_mask_end(R); + int xcb_pre_tmp_13; /* sumof length */ + int xcb_pre_tmp_14; /* sumof loop counter */ + int64_t xcb_pre_tmp_15; /* sumof sum */ + const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_13 = R->valuators_len; + xcb_pre_tmp_15 = 0; + xcb_pre_tmp_16 = xcb_input_raw_key_press_valuator_mask(R); + for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_16; + xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_16++; + } + /* sumof end. Result is in xcb_pre_tmp_15 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_15; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_key_press_axisvalues_raw (const xcb_input_raw_key_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_key_press_axisvalues_iterator(R)); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_key_press_axisvalues_raw_length (const xcb_input_raw_key_press_event_t *R) +{ + int xcb_pre_tmp_17; /* sumof length */ + int xcb_pre_tmp_18; /* sumof loop counter */ + int64_t xcb_pre_tmp_19; /* sumof sum */ + const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_17 = R->valuators_len; + xcb_pre_tmp_19 = 0; + xcb_pre_tmp_20 = xcb_input_raw_key_press_valuator_mask(R); + for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_20; + xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_20++; + } + /* sumof end. Result is in xcb_pre_tmp_19 */ + return xcb_pre_tmp_19; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_key_press_axisvalues_raw_iterator (const xcb_input_raw_key_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_key_press_axisvalues_iterator(R)); + int xcb_pre_tmp_21; /* sumof length */ + int xcb_pre_tmp_22; /* sumof loop counter */ + int64_t xcb_pre_tmp_23; /* sumof sum */ + const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_21 = R->valuators_len; + xcb_pre_tmp_23 = 0; + xcb_pre_tmp_24 = xcb_input_raw_key_press_valuator_mask(R); + for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_24; + xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_24++; + } + /* sumof end. Result is in xcb_pre_tmp_23 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_23; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_input_raw_key_release_sizeof (const void *_buffer /**< */) +{ + return xcb_input_raw_key_press_sizeof(_buffer); +} + +int +xcb_input_raw_button_press_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_raw_button_press_event_t *_aux = (xcb_input_raw_button_press_event_t *)_buffer; @@ -9833,6 +13844,14 @@ xcb_input_raw_button_press_sizeof (const void *_buffer /**< */) unsigned int xcb_pad = 0; unsigned int xcb_align_to = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ xcb_block_len += sizeof(xcb_input_raw_button_press_event_t); xcb_tmp += xcb_block_len; @@ -9850,74 +13869,194 @@ xcb_input_raw_button_press_sizeof (const void *_buffer /**< */) xcb_pad = 0; } xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_raw_button_press_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; + /* axisvalues_raw */ + /* sumof start */ + xcb_pre_tmp_5 = _aux->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_raw_button_press_valuator_mask(_aux); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; return xcb_buffer_len; } +uint32_t * +xcb_input_raw_button_press_valuator_mask (const xcb_input_raw_button_press_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_raw_button_press_valuator_mask_length (const xcb_input_raw_button_press_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_raw_button_press_valuator_mask_end (const xcb_input_raw_button_press_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_button_press_axisvalues (const xcb_input_raw_button_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_raw_button_press_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_button_press_axisvalues_length (const xcb_input_raw_button_press_event_t *R) +{ + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_raw_button_press_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + return xcb_pre_tmp_11; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_button_press_axisvalues_iterator (const xcb_input_raw_button_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_raw_button_press_valuator_mask_end(R); + int xcb_pre_tmp_13; /* sumof length */ + int xcb_pre_tmp_14; /* sumof loop counter */ + int64_t xcb_pre_tmp_15; /* sumof sum */ + const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_13 = R->valuators_len; + xcb_pre_tmp_15 = 0; + xcb_pre_tmp_16 = xcb_input_raw_button_press_valuator_mask(R); + for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_16; + xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_16++; + } + /* sumof end. Result is in xcb_pre_tmp_15 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_15; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_button_press_axisvalues_raw (const xcb_input_raw_button_press_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_button_press_axisvalues_iterator(R)); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_button_press_axisvalues_raw_length (const xcb_input_raw_button_press_event_t *R) +{ + int xcb_pre_tmp_17; /* sumof length */ + int xcb_pre_tmp_18; /* sumof loop counter */ + int64_t xcb_pre_tmp_19; /* sumof sum */ + const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_17 = R->valuators_len; + xcb_pre_tmp_19 = 0; + xcb_pre_tmp_20 = xcb_input_raw_button_press_valuator_mask(R); + for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_20; + xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_20++; + } + /* sumof end. Result is in xcb_pre_tmp_19 */ + return xcb_pre_tmp_19; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_button_press_axisvalues_raw_iterator (const xcb_input_raw_button_press_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_button_press_axisvalues_iterator(R)); + int xcb_pre_tmp_21; /* sumof length */ + int xcb_pre_tmp_22; /* sumof loop counter */ + int64_t xcb_pre_tmp_23; /* sumof sum */ + const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_21 = R->valuators_len; + xcb_pre_tmp_23 = 0; + xcb_pre_tmp_24 = xcb_input_raw_button_press_valuator_mask(R); + for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_24; + xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_24++; + } + /* sumof end. Result is in xcb_pre_tmp_23 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_23; + i.index = (char *) i.data - (char *) R; + return i; +} + int xcb_input_raw_button_release_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_raw_button_release_event_t *_aux = (xcb_input_raw_button_release_event_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; - - - xcb_block_len += sizeof(xcb_input_raw_button_release_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* valuator_mask */ - xcb_block_len += _aux->valuators_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_raw_button_press_sizeof(_buffer); } int xcb_input_raw_motion_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_raw_motion_event_t *_aux = (xcb_input_raw_motion_event_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; - - - xcb_block_len += sizeof(xcb_input_raw_motion_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* valuator_mask */ - xcb_block_len += _aux->valuators_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_raw_button_press_sizeof(_buffer); } int -xcb_input_touch_begin_sizeof (const void *_buffer /**< */) +xcb_input_touch_begin_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_touch_begin_event_t *_aux = (xcb_input_touch_begin_event_t *)_buffer; @@ -9926,6 +14065,10 @@ xcb_input_touch_begin_sizeof (const void *_buffer /**< */) unsigned int xcb_pad = 0; unsigned int xcb_align_to = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ xcb_block_len += sizeof(xcb_input_touch_begin_event_t); xcb_tmp += xcb_block_len; @@ -9955,98 +14098,144 @@ xcb_input_touch_begin_sizeof (const void *_buffer /**< */) xcb_pad = 0; } xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_touch_begin_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; return xcb_buffer_len; } +uint32_t * +xcb_input_touch_begin_button_mask (const xcb_input_touch_begin_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_touch_begin_button_mask_length (const xcb_input_touch_begin_event_t *R) +{ + return R->buttons_len; +} + +xcb_generic_iterator_t +xcb_input_touch_begin_button_mask_end (const xcb_input_touch_begin_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->buttons_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +uint32_t * +xcb_input_touch_begin_valuator_mask (const xcb_input_touch_begin_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_touch_begin_button_mask_end(R); + return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); +} + +int +xcb_input_touch_begin_valuator_mask_length (const xcb_input_touch_begin_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_touch_begin_valuator_mask_end (const xcb_input_touch_begin_event_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_touch_begin_button_mask_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_touch_begin_axisvalues (const xcb_input_touch_begin_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_touch_begin_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_touch_begin_axisvalues_length (const xcb_input_touch_begin_event_t *R) +{ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = R->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + return xcb_pre_tmp_7; +} + +xcb_input_fp3232_iterator_t +xcb_input_touch_begin_axisvalues_iterator (const xcb_input_touch_begin_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_touch_begin_valuator_mask_end(R); + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_11; + i.index = (char *) i.data - (char *) R; + return i; +} + int xcb_input_touch_update_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_touch_update_event_t *_aux = (xcb_input_touch_update_event_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; - - - xcb_block_len += sizeof(xcb_input_touch_update_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* button_mask */ - xcb_block_len += _aux->buttons_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - /* valuator_mask */ - xcb_block_len += _aux->valuators_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_touch_begin_sizeof(_buffer); } int xcb_input_touch_end_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_touch_end_event_t *_aux = (xcb_input_touch_end_event_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; - - - xcb_block_len += sizeof(xcb_input_touch_end_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* button_mask */ - xcb_block_len += _aux->buttons_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - /* valuator_mask */ - xcb_block_len += _aux->valuators_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_touch_begin_sizeof(_buffer); } int -xcb_input_raw_touch_begin_sizeof (const void *_buffer /**< */) +xcb_input_raw_touch_begin_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_input_raw_touch_begin_event_t *_aux = (xcb_input_raw_touch_begin_event_t *)_buffer; @@ -10055,6 +14244,14 @@ xcb_input_raw_touch_begin_sizeof (const void *_buffer /**< */) unsigned int xcb_pad = 0; unsigned int xcb_align_to = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */ + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */ xcb_block_len += sizeof(xcb_input_raw_touch_begin_event_t); xcb_tmp += xcb_block_len; @@ -10072,69 +14269,189 @@ xcb_input_raw_touch_begin_sizeof (const void *_buffer /**< */) xcb_pad = 0; } xcb_block_len = 0; + /* axisvalues */ + /* sumof start */ + xcb_pre_tmp_1 = _aux->valuators_len; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = xcb_input_raw_touch_begin_valuator_mask(_aux); + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_4; + xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; + /* axisvalues_raw */ + /* sumof start */ + xcb_pre_tmp_5 = _aux->valuators_len; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = xcb_input_raw_touch_begin_valuator_mask(_aux); + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_8; + xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_input_fp3232_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (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; return xcb_buffer_len; } +uint32_t * +xcb_input_raw_touch_begin_valuator_mask (const xcb_input_raw_touch_begin_event_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_input_raw_touch_begin_valuator_mask_length (const xcb_input_raw_touch_begin_event_t *R) +{ + return R->valuators_len; +} + +xcb_generic_iterator_t +xcb_input_raw_touch_begin_valuator_mask_end (const xcb_input_raw_touch_begin_event_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + (R->valuators_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_touch_begin_axisvalues (const xcb_input_raw_touch_begin_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_raw_touch_begin_valuator_mask_end(R); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_touch_begin_axisvalues_length (const xcb_input_raw_touch_begin_event_t *R) +{ + int xcb_pre_tmp_9; /* sumof length */ + int xcb_pre_tmp_10; /* sumof loop counter */ + int64_t xcb_pre_tmp_11; /* sumof sum */ + const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_9 = R->valuators_len; + xcb_pre_tmp_11 = 0; + xcb_pre_tmp_12 = xcb_input_raw_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_12; + xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_12++; + } + /* sumof end. Result is in xcb_pre_tmp_11 */ + return xcb_pre_tmp_11; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_touch_begin_axisvalues_iterator (const xcb_input_raw_touch_begin_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_raw_touch_begin_valuator_mask_end(R); + int xcb_pre_tmp_13; /* sumof length */ + int xcb_pre_tmp_14; /* sumof loop counter */ + int64_t xcb_pre_tmp_15; /* sumof sum */ + const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_13 = R->valuators_len; + xcb_pre_tmp_15 = 0; + xcb_pre_tmp_16 = xcb_input_raw_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_16; + xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_16++; + } + /* sumof end. Result is in xcb_pre_tmp_15 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_15; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_input_fp3232_t * +xcb_input_raw_touch_begin_axisvalues_raw (const xcb_input_raw_touch_begin_event_t *R) +{ + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_touch_begin_axisvalues_iterator(R)); + return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0); +} + +int +xcb_input_raw_touch_begin_axisvalues_raw_length (const xcb_input_raw_touch_begin_event_t *R) +{ + int xcb_pre_tmp_17; /* sumof length */ + int xcb_pre_tmp_18; /* sumof loop counter */ + int64_t xcb_pre_tmp_19; /* sumof sum */ + const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_17 = R->valuators_len; + xcb_pre_tmp_19 = 0; + xcb_pre_tmp_20 = xcb_input_raw_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_20; + xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_20++; + } + /* sumof end. Result is in xcb_pre_tmp_19 */ + return xcb_pre_tmp_19; +} + +xcb_input_fp3232_iterator_t +xcb_input_raw_touch_begin_axisvalues_raw_iterator (const xcb_input_raw_touch_begin_event_t *R) +{ + xcb_input_fp3232_iterator_t i; + xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_touch_begin_axisvalues_iterator(R)); + int xcb_pre_tmp_21; /* sumof length */ + int xcb_pre_tmp_22; /* sumof loop counter */ + int64_t xcb_pre_tmp_23; /* sumof sum */ + const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_21 = R->valuators_len; + xcb_pre_tmp_23 = 0; + xcb_pre_tmp_24 = xcb_input_raw_touch_begin_valuator_mask(R); + for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) { + const uint32_t *xcb_listelement = xcb_pre_tmp_24; + xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement)); + xcb_pre_tmp_24++; + } + /* sumof end. Result is in xcb_pre_tmp_23 */ + i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index)); + i.rem = xcb_pre_tmp_23; + i.index = (char *) i.data - (char *) R; + return i; +} + int xcb_input_raw_touch_update_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_raw_touch_update_event_t *_aux = (xcb_input_raw_touch_update_event_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; - - - xcb_block_len += sizeof(xcb_input_raw_touch_update_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* valuator_mask */ - xcb_block_len += _aux->valuators_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_raw_touch_begin_sizeof(_buffer); } int xcb_input_raw_touch_end_sizeof (const void *_buffer /**< */) { - char *xcb_tmp = (char *)_buffer; - const xcb_input_raw_touch_end_event_t *_aux = (xcb_input_raw_touch_end_event_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; - - - xcb_block_len += sizeof(xcb_input_raw_touch_end_event_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* valuator_mask */ - xcb_block_len += _aux->valuators_len * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; + return xcb_input_raw_touch_begin_sizeof(_buffer); } diff --git a/lib/libxcb/src/xinput.h b/lib/libxcb/src/xinput.h index e972573dd..d5ca67638 100644 --- a/lib/libxcb/src/xinput.h +++ b/lib/libxcb/src/xinput.h @@ -30,9 +30,9 @@ typedef uint32_t xcb_input_event_class_t; * @brief xcb_input_event_class_iterator_t **/ typedef struct xcb_input_event_class_iterator_t { - xcb_input_event_class_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_event_class_t *data; + int rem; + int index; } xcb_input_event_class_iterator_t; typedef uint8_t xcb_input_key_code_t; @@ -41,9 +41,9 @@ typedef uint8_t xcb_input_key_code_t; * @brief xcb_input_key_code_iterator_t **/ typedef struct xcb_input_key_code_iterator_t { - xcb_input_key_code_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_key_code_t *data; + int rem; + int index; } xcb_input_key_code_iterator_t; typedef uint16_t xcb_input_device_id_t; @@ -52,9 +52,9 @@ typedef uint16_t xcb_input_device_id_t; * @brief xcb_input_device_id_iterator_t **/ typedef struct xcb_input_device_id_iterator_t { - xcb_input_device_id_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_id_t *data; + int rem; + int index; } xcb_input_device_id_iterator_t; typedef int32_t xcb_input_fp1616_t; @@ -63,33 +63,33 @@ typedef int32_t xcb_input_fp1616_t; * @brief xcb_input_fp1616_iterator_t **/ typedef struct xcb_input_fp1616_iterator_t { - xcb_input_fp1616_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_fp1616_t *data; + int rem; + int index; } xcb_input_fp1616_iterator_t; /** * @brief xcb_input_fp3232_t **/ typedef struct xcb_input_fp3232_t { - int32_t integral; /**< */ - uint32_t frac; /**< */ + int32_t integral; + uint32_t frac; } xcb_input_fp3232_t; /** * @brief xcb_input_fp3232_iterator_t **/ typedef struct xcb_input_fp3232_iterator_t { - xcb_input_fp3232_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_fp3232_t *data; + int rem; + int index; } xcb_input_fp3232_iterator_t; /** * @brief xcb_input_get_extension_version_cookie_t **/ typedef struct xcb_input_get_extension_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_get_extension_version_cookie_t; /** Opcode for xcb_input_get_extension_version. */ @@ -99,25 +99,25 @@ typedef struct xcb_input_get_extension_version_cookie_t { * @brief xcb_input_get_extension_version_request_t **/ typedef struct xcb_input_get_extension_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t name_len; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t name_len; + uint8_t pad0[2]; } xcb_input_get_extension_version_request_t; /** * @brief xcb_input_get_extension_version_reply_t **/ typedef struct xcb_input_get_extension_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t server_major; /**< */ - uint16_t server_minor; /**< */ - uint8_t present; /**< */ - uint8_t pad1[19]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint16_t server_major; + uint16_t server_minor; + uint8_t present; + uint8_t pad0[19]; } xcb_input_get_extension_version_reply_t; typedef enum xcb_input_device_use_t { @@ -147,137 +147,161 @@ typedef enum xcb_input_valuator_mode_t { * @brief xcb_input_device_info_t **/ typedef struct xcb_input_device_info_t { - xcb_atom_t device_type; /**< */ - uint8_t device_id; /**< */ - uint8_t num_class_info; /**< */ - uint8_t device_use; /**< */ - uint8_t pad0; /**< */ + xcb_atom_t device_type; + uint8_t device_id; + uint8_t num_class_info; + uint8_t device_use; + uint8_t pad0; } xcb_input_device_info_t; /** * @brief xcb_input_device_info_iterator_t **/ typedef struct xcb_input_device_info_iterator_t { - xcb_input_device_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_info_t *data; + int rem; + int index; } xcb_input_device_info_iterator_t; /** * @brief xcb_input_key_info_t **/ typedef struct xcb_input_key_info_t { - uint8_t class_id; /**< */ - uint8_t len; /**< */ - xcb_input_key_code_t min_keycode; /**< */ - xcb_input_key_code_t max_keycode; /**< */ - uint16_t num_keys; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t class_id; + uint8_t len; + xcb_input_key_code_t min_keycode; + xcb_input_key_code_t max_keycode; + uint16_t num_keys; + uint8_t pad0[2]; } xcb_input_key_info_t; /** * @brief xcb_input_key_info_iterator_t **/ typedef struct xcb_input_key_info_iterator_t { - xcb_input_key_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_key_info_t *data; + int rem; + int index; } xcb_input_key_info_iterator_t; /** * @brief xcb_input_button_info_t **/ typedef struct xcb_input_button_info_t { - uint8_t class_id; /**< */ - uint8_t len; /**< */ - uint16_t num_buttons; /**< */ + uint8_t class_id; + uint8_t len; + uint16_t num_buttons; } xcb_input_button_info_t; /** * @brief xcb_input_button_info_iterator_t **/ typedef struct xcb_input_button_info_iterator_t { - xcb_input_button_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_button_info_t *data; + int rem; + int index; } xcb_input_button_info_iterator_t; /** * @brief xcb_input_axis_info_t **/ typedef struct xcb_input_axis_info_t { - uint32_t resolution; /**< */ - int32_t minimum; /**< */ - int32_t maximum; /**< */ + uint32_t resolution; + int32_t minimum; + int32_t maximum; } xcb_input_axis_info_t; /** * @brief xcb_input_axis_info_iterator_t **/ typedef struct xcb_input_axis_info_iterator_t { - xcb_input_axis_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_axis_info_t *data; + int rem; + int index; } xcb_input_axis_info_iterator_t; /** * @brief xcb_input_valuator_info_t **/ typedef struct xcb_input_valuator_info_t { - uint8_t class_id; /**< */ - uint8_t len; /**< */ - uint8_t axes_len; /**< */ - uint8_t mode; /**< */ - uint32_t motion_size; /**< */ + uint8_t class_id; + uint8_t len; + uint8_t axes_len; + uint8_t mode; + uint32_t motion_size; } xcb_input_valuator_info_t; /** * @brief xcb_input_valuator_info_iterator_t **/ typedef struct xcb_input_valuator_info_iterator_t { - xcb_input_valuator_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_valuator_info_t *data; + int rem; + int index; } xcb_input_valuator_info_iterator_t; +/** + * @brief xcb_input_input_info_info_t + **/ +typedef struct xcb_input_input_info_info_t { + struct { + xcb_input_key_code_t min_keycode; + xcb_input_key_code_t max_keycode; + uint16_t num_keys; + uint8_t pad0[2]; + } key; + struct { + uint16_t num_buttons; + } button; + struct { + uint8_t axes_len; + uint8_t mode; + uint32_t motion_size; + xcb_input_axis_info_t *axes; + } valuator; +} xcb_input_input_info_info_t; + /** * @brief xcb_input_input_info_t **/ typedef struct xcb_input_input_info_t { - uint8_t class_id; /**< */ - uint8_t len; /**< */ + uint8_t class_id; + uint8_t len; } xcb_input_input_info_t; +void * +xcb_input_input_info_info (const xcb_input_input_info_t *R); + /** * @brief xcb_input_input_info_iterator_t **/ typedef struct xcb_input_input_info_iterator_t { - xcb_input_input_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_input_info_t *data; + int rem; + int index; } xcb_input_input_info_iterator_t; /** * @brief xcb_input_device_name_t **/ typedef struct xcb_input_device_name_t { - uint8_t len; /**< */ + uint8_t len; } xcb_input_device_name_t; /** * @brief xcb_input_device_name_iterator_t **/ typedef struct xcb_input_device_name_iterator_t { - xcb_input_device_name_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_name_t *data; + int rem; + int index; } xcb_input_device_name_iterator_t; /** * @brief xcb_input_list_input_devices_cookie_t **/ typedef struct xcb_input_list_input_devices_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_list_input_devices_cookie_t; /** Opcode for xcb_input_list_input_devices. */ @@ -287,45 +311,45 @@ typedef struct xcb_input_list_input_devices_cookie_t { * @brief xcb_input_list_input_devices_request_t **/ typedef struct xcb_input_list_input_devices_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_input_list_input_devices_request_t; /** * @brief xcb_input_list_input_devices_reply_t **/ typedef struct xcb_input_list_input_devices_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t devices_len; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t devices_len; + uint8_t pad0[23]; } xcb_input_list_input_devices_reply_t; /** * @brief xcb_input_input_class_info_t **/ typedef struct xcb_input_input_class_info_t { - uint8_t class_id; /**< */ - uint8_t event_type_base; /**< */ + uint8_t class_id; + uint8_t event_type_base; } xcb_input_input_class_info_t; /** * @brief xcb_input_input_class_info_iterator_t **/ typedef struct xcb_input_input_class_info_iterator_t { - xcb_input_input_class_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_input_class_info_t *data; + int rem; + int index; } xcb_input_input_class_info_iterator_t; /** * @brief xcb_input_open_device_cookie_t **/ typedef struct xcb_input_open_device_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_open_device_cookie_t; /** Opcode for xcb_input_open_device. */ @@ -335,23 +359,23 @@ typedef struct xcb_input_open_device_cookie_t { * @brief xcb_input_open_device_request_t **/ typedef struct xcb_input_open_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_open_device_request_t; /** * @brief xcb_input_open_device_reply_t **/ typedef struct xcb_input_open_device_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t num_classes; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t num_classes; + uint8_t pad0[23]; } xcb_input_open_device_reply_t; /** Opcode for xcb_input_close_device. */ @@ -361,18 +385,18 @@ typedef struct xcb_input_open_device_reply_t { * @brief xcb_input_close_device_request_t **/ typedef struct xcb_input_close_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_close_device_request_t; /** * @brief xcb_input_set_device_mode_cookie_t **/ typedef struct xcb_input_set_device_mode_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_set_device_mode_cookie_t; /** Opcode for xcb_input_set_device_mode. */ @@ -382,24 +406,24 @@ typedef struct xcb_input_set_device_mode_cookie_t { * @brief xcb_input_set_device_mode_request_t **/ typedef struct xcb_input_set_device_mode_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t mode; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t mode; + uint8_t pad0[2]; } xcb_input_set_device_mode_request_t; /** * @brief xcb_input_set_device_mode_reply_t **/ typedef struct xcb_input_set_device_mode_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t status; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; } xcb_input_set_device_mode_reply_t; /** Opcode for xcb_input_select_extension_event. */ @@ -409,19 +433,19 @@ typedef struct xcb_input_set_device_mode_reply_t { * @brief xcb_input_select_extension_event_request_t **/ typedef struct xcb_input_select_extension_event_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint16_t num_classes; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint16_t num_classes; + uint8_t pad0[2]; } xcb_input_select_extension_event_request_t; /** * @brief xcb_input_get_selected_extension_events_cookie_t **/ typedef struct xcb_input_get_selected_extension_events_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_get_selected_extension_events_cookie_t; /** Opcode for xcb_input_get_selected_extension_events. */ @@ -431,23 +455,23 @@ typedef struct xcb_input_get_selected_extension_events_cookie_t { * @brief xcb_input_get_selected_extension_events_request_t **/ typedef struct xcb_input_get_selected_extension_events_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_input_get_selected_extension_events_request_t; /** * @brief xcb_input_get_selected_extension_events_reply_t **/ typedef struct xcb_input_get_selected_extension_events_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_this_classes; /**< */ - uint16_t num_all_classes; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint16_t num_this_classes; + uint16_t num_all_classes; + uint8_t pad0[20]; } xcb_input_get_selected_extension_events_reply_t; typedef enum xcb_input_propagate_mode_t { @@ -462,20 +486,20 @@ typedef enum xcb_input_propagate_mode_t { * @brief xcb_input_change_device_dont_propagate_list_request_t **/ typedef struct xcb_input_change_device_dont_propagate_list_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint16_t num_classes; /**< */ - uint8_t mode; /**< */ - uint8_t pad0; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint16_t num_classes; + uint8_t mode; + uint8_t pad0; } xcb_input_change_device_dont_propagate_list_request_t; /** * @brief xcb_input_get_device_dont_propagate_list_cookie_t **/ typedef struct xcb_input_get_device_dont_propagate_list_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_get_device_dont_propagate_list_cookie_t; /** Opcode for xcb_input_get_device_dont_propagate_list. */ @@ -485,45 +509,46 @@ typedef struct xcb_input_get_device_dont_propagate_list_cookie_t { * @brief xcb_input_get_device_dont_propagate_list_request_t **/ typedef struct xcb_input_get_device_dont_propagate_list_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_input_get_device_dont_propagate_list_request_t; /** * @brief xcb_input_get_device_dont_propagate_list_reply_t **/ typedef struct xcb_input_get_device_dont_propagate_list_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_classes; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint16_t num_classes; + uint8_t pad0[22]; } xcb_input_get_device_dont_propagate_list_reply_t; /** * @brief xcb_input_device_time_coord_t **/ typedef struct xcb_input_device_time_coord_t { - xcb_timestamp_t time; /**< */ + xcb_timestamp_t time; } xcb_input_device_time_coord_t; /** * @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; /**< */ + 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; /**< */ + unsigned int sequence; } xcb_input_get_device_motion_events_cookie_t; /** Opcode for xcb_input_get_device_motion_events. */ @@ -533,33 +558,34 @@ typedef struct xcb_input_get_device_motion_events_cookie_t { * @brief xcb_input_get_device_motion_events_request_t **/ typedef struct xcb_input_get_device_motion_events_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_timestamp_t start; /**< */ - xcb_timestamp_t stop; /**< */ - uint8_t device_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t start; + xcb_timestamp_t stop; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_get_device_motion_events_request_t; /** * @brief xcb_input_get_device_motion_events_reply_t **/ typedef struct xcb_input_get_device_motion_events_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_events; /**< */ - uint8_t num_axes; /**< */ - uint8_t device_mode; /**< */ - uint8_t pad1[18]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint32_t num_events; + uint8_t num_axes; + uint8_t device_mode; + uint8_t pad0[18]; } xcb_input_get_device_motion_events_reply_t; /** * @brief xcb_input_change_keyboard_device_cookie_t **/ typedef struct xcb_input_change_keyboard_device_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_change_keyboard_device_cookie_t; /** Opcode for xcb_input_change_keyboard_device. */ @@ -569,30 +595,30 @@ typedef struct xcb_input_change_keyboard_device_cookie_t { * @brief xcb_input_change_keyboard_device_request_t **/ typedef struct xcb_input_change_keyboard_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_change_keyboard_device_request_t; /** * @brief xcb_input_change_keyboard_device_reply_t **/ typedef struct xcb_input_change_keyboard_device_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t status; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; } xcb_input_change_keyboard_device_reply_t; /** * @brief xcb_input_change_pointer_device_cookie_t **/ typedef struct xcb_input_change_pointer_device_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_change_pointer_device_cookie_t; /** Opcode for xcb_input_change_pointer_device. */ @@ -602,32 +628,32 @@ typedef struct xcb_input_change_pointer_device_cookie_t { * @brief xcb_input_change_pointer_device_request_t **/ typedef struct xcb_input_change_pointer_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t x_axis; /**< */ - uint8_t y_axis; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t x_axis; + uint8_t y_axis; + uint8_t device_id; + uint8_t pad0; } xcb_input_change_pointer_device_request_t; /** * @brief xcb_input_change_pointer_device_reply_t **/ typedef struct xcb_input_change_pointer_device_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t status; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; } xcb_input_change_pointer_device_reply_t; /** * @brief xcb_input_grab_device_cookie_t **/ typedef struct xcb_input_grab_device_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_grab_device_cookie_t; /** Opcode for xcb_input_grab_device. */ @@ -637,29 +663,29 @@ typedef struct xcb_input_grab_device_cookie_t { * @brief xcb_input_grab_device_request_t **/ typedef struct xcb_input_grab_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - xcb_timestamp_t time; /**< */ - uint16_t num_classes; /**< */ - uint8_t this_device_mode; /**< */ - uint8_t other_device_mode; /**< */ - uint8_t owner_events; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grab_window; + xcb_timestamp_t time; + uint16_t num_classes; + uint8_t this_device_mode; + uint8_t other_device_mode; + uint8_t owner_events; + uint8_t device_id; + uint8_t pad0[2]; } xcb_input_grab_device_request_t; /** * @brief xcb_input_grab_device_reply_t **/ typedef struct xcb_input_grab_device_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t status; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; } xcb_input_grab_device_reply_t; /** Opcode for xcb_input_ungrab_device. */ @@ -669,13 +695,18 @@ typedef struct xcb_input_grab_device_reply_t { * @brief xcb_input_ungrab_device_request_t **/ typedef struct xcb_input_ungrab_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t device_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t time; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_ungrab_device_request_t; +typedef enum xcb_input_modifier_device_t { + XCB_INPUT_MODIFIER_DEVICE_USE_X_KEYBOARD = 255 +} xcb_input_modifier_device_t; + /** Opcode for xcb_input_grab_device_key. */ #define XCB_INPUT_GRAB_DEVICE_KEY 15 @@ -683,19 +714,19 @@ typedef struct xcb_input_ungrab_device_request_t { * @brief xcb_input_grab_device_key_request_t **/ typedef struct xcb_input_grab_device_key_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - uint16_t num_classes; /**< */ - uint16_t modifiers; /**< */ - uint8_t modifier_device; /**< */ - uint8_t grabbed_device; /**< */ - uint8_t key; /**< */ - uint8_t this_device_mode; /**< */ - uint8_t other_device_mode; /**< */ - uint8_t owner_events; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grab_window; + uint16_t num_classes; + uint16_t modifiers; + uint8_t modifier_device; + uint8_t grabbed_device; + uint8_t key; + uint8_t this_device_mode; + uint8_t other_device_mode; + uint8_t owner_events; + uint8_t pad0[2]; } xcb_input_grab_device_key_request_t; /** Opcode for xcb_input_ungrab_device_key. */ @@ -705,14 +736,14 @@ typedef struct xcb_input_grab_device_key_request_t { * @brief xcb_input_ungrab_device_key_request_t **/ typedef struct xcb_input_ungrab_device_key_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t grabWindow; /**< */ - uint16_t modifiers; /**< */ - uint8_t modifier_device; /**< */ - uint8_t key; /**< */ - uint8_t grabbed_device; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grabWindow; + uint16_t modifiers; + uint8_t modifier_device; + uint8_t key; + uint8_t grabbed_device; } xcb_input_ungrab_device_key_request_t; /** Opcode for xcb_input_grab_device_button. */ @@ -722,19 +753,19 @@ typedef struct xcb_input_ungrab_device_key_request_t { * @brief xcb_input_grab_device_button_request_t **/ typedef struct xcb_input_grab_device_button_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - uint8_t grabbed_device; /**< */ - uint8_t modifier_device; /**< */ - uint16_t num_classes; /**< */ - uint16_t modifiers; /**< */ - uint8_t this_device_mode; /**< */ - uint8_t other_device_mode; /**< */ - uint8_t button; /**< */ - uint8_t owner_events; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grab_window; + uint8_t grabbed_device; + uint8_t modifier_device; + uint16_t num_classes; + uint16_t modifiers; + uint8_t this_device_mode; + uint8_t other_device_mode; + uint8_t button; + uint8_t owner_events; + uint8_t pad0[2]; } xcb_input_grab_device_button_request_t; /** Opcode for xcb_input_ungrab_device_button. */ @@ -744,14 +775,15 @@ typedef struct xcb_input_grab_device_button_request_t { * @brief xcb_input_ungrab_device_button_request_t **/ typedef struct xcb_input_ungrab_device_button_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - uint16_t modifiers; /**< */ - uint8_t modifier_device; /**< */ - uint8_t button; /**< */ - uint8_t grabbed_device; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grab_window; + uint16_t modifiers; + uint8_t modifier_device; + uint8_t button; + uint8_t grabbed_device; + uint8_t pad0[3]; } xcb_input_ungrab_device_button_request_t; typedef enum xcb_input_device_input_mode_t { @@ -770,19 +802,20 @@ typedef enum xcb_input_device_input_mode_t { * @brief xcb_input_allow_device_events_request_t **/ typedef struct xcb_input_allow_device_events_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t mode; /**< */ - uint8_t device_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t time; + uint8_t mode; + uint8_t device_id; + uint8_t pad0[2]; } xcb_input_allow_device_events_request_t; /** * @brief xcb_input_get_device_focus_cookie_t **/ typedef struct xcb_input_get_device_focus_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_get_device_focus_cookie_t; /** Opcode for xcb_input_get_device_focus. */ @@ -792,25 +825,25 @@ typedef struct xcb_input_get_device_focus_cookie_t { * @brief xcb_input_get_device_focus_request_t **/ typedef struct xcb_input_get_device_focus_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_get_device_focus_request_t; /** * @brief xcb_input_get_device_focus_reply_t **/ typedef struct xcb_input_get_device_focus_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t focus; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t revert_to; /**< */ - uint8_t pad1[15]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + xcb_window_t focus; + xcb_timestamp_t time; + uint8_t revert_to; + uint8_t pad0[15]; } xcb_input_get_device_focus_reply_t; /** Opcode for xcb_input_set_device_focus. */ @@ -820,13 +853,14 @@ typedef struct xcb_input_get_device_focus_reply_t { * @brief xcb_input_set_device_focus_request_t **/ typedef struct xcb_input_set_device_focus_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t focus; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t revert_to; /**< */ - uint8_t device_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t focus; + xcb_timestamp_t time; + uint8_t revert_to; + uint8_t device_id; + uint8_t pad0[2]; } xcb_input_set_device_focus_request_t; typedef enum xcb_input_feedback_class_t { @@ -842,157 +876,203 @@ typedef enum xcb_input_feedback_class_t { * @brief xcb_input_kbd_feedback_state_t **/ typedef struct xcb_input_kbd_feedback_state_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - uint16_t pitch; /**< */ - uint16_t duration; /**< */ - uint32_t led_mask; /**< */ - uint32_t led_values; /**< */ - uint8_t global_auto_repeat; /**< */ - uint8_t click; /**< */ - uint8_t percent; /**< */ - uint8_t pad0; /**< */ - uint8_t auto_repeats[32]; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint16_t pitch; + uint16_t duration; + uint32_t led_mask; + uint32_t led_values; + uint8_t global_auto_repeat; + uint8_t click; + uint8_t percent; + uint8_t pad0; + uint8_t auto_repeats[32]; } xcb_input_kbd_feedback_state_t; /** * @brief xcb_input_kbd_feedback_state_iterator_t **/ typedef struct xcb_input_kbd_feedback_state_iterator_t { - xcb_input_kbd_feedback_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_kbd_feedback_state_t *data; + int rem; + int index; } xcb_input_kbd_feedback_state_iterator_t; /** * @brief xcb_input_ptr_feedback_state_t **/ typedef struct xcb_input_ptr_feedback_state_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - uint8_t pad0[2]; /**< */ - uint16_t accel_num; /**< */ - uint16_t accel_denom; /**< */ - uint16_t threshold; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint8_t pad0[2]; + uint16_t accel_num; + uint16_t accel_denom; + uint16_t threshold; } xcb_input_ptr_feedback_state_t; /** * @brief xcb_input_ptr_feedback_state_iterator_t **/ typedef struct xcb_input_ptr_feedback_state_iterator_t { - xcb_input_ptr_feedback_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_ptr_feedback_state_t *data; + int rem; + int index; } xcb_input_ptr_feedback_state_iterator_t; /** * @brief xcb_input_integer_feedback_state_t **/ typedef struct xcb_input_integer_feedback_state_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - uint32_t resolution; /**< */ - int32_t min_value; /**< */ - int32_t max_value; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint32_t resolution; + int32_t min_value; + int32_t max_value; } xcb_input_integer_feedback_state_t; /** * @brief xcb_input_integer_feedback_state_iterator_t **/ typedef struct xcb_input_integer_feedback_state_iterator_t { - xcb_input_integer_feedback_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_integer_feedback_state_t *data; + int rem; + int index; } xcb_input_integer_feedback_state_iterator_t; /** * @brief xcb_input_string_feedback_state_t **/ typedef struct xcb_input_string_feedback_state_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - uint16_t max_symbols; /**< */ - uint16_t num_keysyms; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint16_t max_symbols; + uint16_t num_keysyms; } xcb_input_string_feedback_state_t; /** * @brief xcb_input_string_feedback_state_iterator_t **/ typedef struct xcb_input_string_feedback_state_iterator_t { - xcb_input_string_feedback_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_string_feedback_state_t *data; + int rem; + int index; } xcb_input_string_feedback_state_iterator_t; /** * @brief xcb_input_bell_feedback_state_t **/ typedef struct xcb_input_bell_feedback_state_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - uint8_t percent; /**< */ - uint8_t pad0[3]; /**< */ - uint16_t pitch; /**< */ - uint16_t duration; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint8_t percent; + uint8_t pad0[3]; + uint16_t pitch; + uint16_t duration; } xcb_input_bell_feedback_state_t; /** * @brief xcb_input_bell_feedback_state_iterator_t **/ typedef struct xcb_input_bell_feedback_state_iterator_t { - xcb_input_bell_feedback_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_bell_feedback_state_t *data; + int rem; + int index; } xcb_input_bell_feedback_state_iterator_t; /** * @brief xcb_input_led_feedback_state_t **/ typedef struct xcb_input_led_feedback_state_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - uint32_t led_mask; /**< */ - uint32_t led_values; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint32_t led_mask; + uint32_t led_values; } xcb_input_led_feedback_state_t; /** * @brief xcb_input_led_feedback_state_iterator_t **/ typedef struct xcb_input_led_feedback_state_iterator_t { - xcb_input_led_feedback_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_led_feedback_state_t *data; + int rem; + int index; } xcb_input_led_feedback_state_iterator_t; +/** + * @brief xcb_input_feedback_state_data_t + **/ +typedef struct xcb_input_feedback_state_data_t { + struct { + uint16_t pitch; + uint16_t duration; + uint32_t led_mask; + uint32_t led_values; + uint8_t global_auto_repeat; + uint8_t click; + uint8_t percent; + uint8_t pad0; + uint8_t auto_repeats[32]; + } keyboard; + struct { + uint8_t pad1[2]; + uint16_t accel_num; + uint16_t accel_denom; + uint16_t threshold; + } pointer; + struct { + uint16_t max_symbols; + uint16_t num_keysyms; + xcb_keysym_t *keysyms; + } string; + struct { + uint32_t resolution; + int32_t min_value; + int32_t max_value; + } integer; + struct { + uint32_t led_mask; + uint32_t led_values; + } led; + struct { + uint8_t percent; + uint8_t pad2[3]; + uint16_t pitch; + uint16_t duration; + } bell; +} xcb_input_feedback_state_data_t; + /** * @brief xcb_input_feedback_state_t **/ typedef struct xcb_input_feedback_state_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; } xcb_input_feedback_state_t; +void * +xcb_input_feedback_state_data (const xcb_input_feedback_state_t *R); + /** * @brief xcb_input_feedback_state_iterator_t **/ typedef struct xcb_input_feedback_state_iterator_t { - xcb_input_feedback_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_feedback_state_t *data; + int rem; + int index; } xcb_input_feedback_state_iterator_t; /** * @brief xcb_input_get_feedback_control_cookie_t **/ typedef struct xcb_input_get_feedback_control_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_get_feedback_control_cookie_t; /** Opcode for xcb_input_get_feedback_control. */ @@ -1002,172 +1082,231 @@ typedef struct xcb_input_get_feedback_control_cookie_t { * @brief xcb_input_get_feedback_control_request_t **/ typedef struct xcb_input_get_feedback_control_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_get_feedback_control_request_t; /** * @brief xcb_input_get_feedback_control_reply_t **/ typedef struct xcb_input_get_feedback_control_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_feedbacks; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint16_t num_feedbacks; + uint8_t pad0[22]; } xcb_input_get_feedback_control_reply_t; /** * @brief xcb_input_kbd_feedback_ctl_t **/ typedef struct xcb_input_kbd_feedback_ctl_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - xcb_input_key_code_t key; /**< */ - uint8_t auto_repeat_mode; /**< */ - int8_t key_click_percent; /**< */ - int8_t bell_percent; /**< */ - int16_t bell_pitch; /**< */ - int16_t bell_duration; /**< */ - uint32_t led_mask; /**< */ - uint32_t led_values; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + xcb_input_key_code_t key; + uint8_t auto_repeat_mode; + int8_t key_click_percent; + int8_t bell_percent; + int16_t bell_pitch; + int16_t bell_duration; + uint32_t led_mask; + uint32_t led_values; } xcb_input_kbd_feedback_ctl_t; /** * @brief xcb_input_kbd_feedback_ctl_iterator_t **/ typedef struct xcb_input_kbd_feedback_ctl_iterator_t { - xcb_input_kbd_feedback_ctl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_kbd_feedback_ctl_t *data; + int rem; + int index; } xcb_input_kbd_feedback_ctl_iterator_t; /** * @brief xcb_input_ptr_feedback_ctl_t **/ typedef struct xcb_input_ptr_feedback_ctl_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - uint8_t pad0[2]; /**< */ - int16_t num; /**< */ - int16_t denom; /**< */ - int16_t threshold; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint8_t pad0[2]; + int16_t num; + int16_t denom; + int16_t threshold; } xcb_input_ptr_feedback_ctl_t; /** * @brief xcb_input_ptr_feedback_ctl_iterator_t **/ typedef struct xcb_input_ptr_feedback_ctl_iterator_t { - xcb_input_ptr_feedback_ctl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_ptr_feedback_ctl_t *data; + int rem; + int index; } xcb_input_ptr_feedback_ctl_iterator_t; /** * @brief xcb_input_integer_feedback_ctl_t **/ typedef struct xcb_input_integer_feedback_ctl_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - int32_t int_to_display; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + int32_t int_to_display; } xcb_input_integer_feedback_ctl_t; /** * @brief xcb_input_integer_feedback_ctl_iterator_t **/ typedef struct xcb_input_integer_feedback_ctl_iterator_t { - xcb_input_integer_feedback_ctl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_integer_feedback_ctl_t *data; + int rem; + int index; } xcb_input_integer_feedback_ctl_iterator_t; /** * @brief xcb_input_string_feedback_ctl_t **/ typedef struct xcb_input_string_feedback_ctl_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - uint8_t pad0[2]; /**< */ - uint16_t num_keysyms; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint8_t pad0[2]; + uint16_t num_keysyms; } xcb_input_string_feedback_ctl_t; /** * @brief xcb_input_string_feedback_ctl_iterator_t **/ typedef struct xcb_input_string_feedback_ctl_iterator_t { - xcb_input_string_feedback_ctl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_string_feedback_ctl_t *data; + int rem; + int index; } xcb_input_string_feedback_ctl_iterator_t; /** * @brief xcb_input_bell_feedback_ctl_t **/ typedef struct xcb_input_bell_feedback_ctl_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - int8_t percent; /**< */ - uint8_t pad0[3]; /**< */ - int16_t pitch; /**< */ - int16_t duration; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + int8_t percent; + uint8_t pad0[3]; + int16_t pitch; + int16_t duration; } xcb_input_bell_feedback_ctl_t; /** * @brief xcb_input_bell_feedback_ctl_iterator_t **/ typedef struct xcb_input_bell_feedback_ctl_iterator_t { - xcb_input_bell_feedback_ctl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_bell_feedback_ctl_t *data; + int rem; + int index; } xcb_input_bell_feedback_ctl_iterator_t; /** * @brief xcb_input_led_feedback_ctl_t **/ typedef struct xcb_input_led_feedback_ctl_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ - uint32_t led_mask; /**< */ - uint32_t led_values; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; + uint32_t led_mask; + uint32_t led_values; } xcb_input_led_feedback_ctl_t; /** * @brief xcb_input_led_feedback_ctl_iterator_t **/ typedef struct xcb_input_led_feedback_ctl_iterator_t { - xcb_input_led_feedback_ctl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_led_feedback_ctl_t *data; + int rem; + int index; } xcb_input_led_feedback_ctl_iterator_t; +/** + * @brief xcb_input_feedback_ctl_data_t + **/ +typedef struct xcb_input_feedback_ctl_data_t { + struct { + xcb_input_key_code_t key; + uint8_t auto_repeat_mode; + int8_t key_click_percent; + int8_t bell_percent; + int16_t bell_pitch; + int16_t bell_duration; + uint32_t led_mask; + uint32_t led_values; + } keyboard; + struct { + uint8_t pad0[2]; + int16_t num; + int16_t denom; + int16_t threshold; + } pointer; + struct { + uint8_t pad1[2]; + uint16_t num_keysyms; + xcb_keysym_t *keysyms; + } string; + struct { + int32_t int_to_display; + } integer; + struct { + uint32_t led_mask; + uint32_t led_values; + } led; + struct { + int8_t percent; + uint8_t pad2[3]; + int16_t pitch; + int16_t duration; + } bell; +} xcb_input_feedback_ctl_data_t; + /** * @brief xcb_input_feedback_ctl_t **/ typedef struct xcb_input_feedback_ctl_t { - uint8_t class_id; /**< */ - uint8_t feedback_id; /**< */ - uint16_t len; /**< */ + uint8_t class_id; + uint8_t feedback_id; + uint16_t len; } xcb_input_feedback_ctl_t; +void * +xcb_input_feedback_ctl_data (const xcb_input_feedback_ctl_t *R); + /** * @brief xcb_input_feedback_ctl_iterator_t **/ typedef struct xcb_input_feedback_ctl_iterator_t { - xcb_input_feedback_ctl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_feedback_ctl_t *data; + int rem; + int index; } xcb_input_feedback_ctl_iterator_t; +typedef enum xcb_input_change_feedback_control_mask_t { + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_KEY_CLICK_PERCENT = 1, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_PERCENT = 2, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_PITCH = 4, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_DURATION = 8, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_LED = 16, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_LED_MODE = 32, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_KEY = 64, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_AUTO_REPEAT_MODE = 128, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_STRING = 1, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_INTEGER = 1, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_ACCEL_NUM = 1, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_ACCEL_DENOM = 2, + XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_THRESHOLD = 4 +} xcb_input_change_feedback_control_mask_t; + /** Opcode for xcb_input_change_feedback_control. */ #define XCB_INPUT_CHANGE_FEEDBACK_CONTROL 23 @@ -1175,19 +1314,20 @@ typedef struct xcb_input_feedback_ctl_iterator_t { * @brief xcb_input_change_feedback_control_request_t **/ typedef struct xcb_input_change_feedback_control_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t mask; /**< */ - uint8_t device_id; /**< */ - uint8_t feedback_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t mask; + uint8_t device_id; + uint8_t feedback_id; + uint8_t pad0[2]; } xcb_input_change_feedback_control_request_t; /** * @brief xcb_input_get_device_key_mapping_cookie_t **/ typedef struct xcb_input_get_device_key_mapping_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_get_device_key_mapping_cookie_t; /** Opcode for xcb_input_get_device_key_mapping. */ @@ -1197,24 +1337,25 @@ typedef struct xcb_input_get_device_key_mapping_cookie_t { * @brief xcb_input_get_device_key_mapping_request_t **/ typedef struct xcb_input_get_device_key_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - xcb_input_key_code_t first_keycode; /**< */ - uint8_t count; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + xcb_input_key_code_t first_keycode; + uint8_t count; + uint8_t pad0; } xcb_input_get_device_key_mapping_request_t; /** * @brief xcb_input_get_device_key_mapping_reply_t **/ typedef struct xcb_input_get_device_key_mapping_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t keysyms_per_keycode; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t keysyms_per_keycode; + uint8_t pad0[23]; } xcb_input_get_device_key_mapping_reply_t; /** Opcode for xcb_input_change_device_key_mapping. */ @@ -1224,20 +1365,20 @@ typedef struct xcb_input_get_device_key_mapping_reply_t { * @brief xcb_input_change_device_key_mapping_request_t **/ typedef struct xcb_input_change_device_key_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - xcb_input_key_code_t first_keycode; /**< */ - uint8_t keysyms_per_keycode; /**< */ - uint8_t keycode_count; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + xcb_input_key_code_t first_keycode; + uint8_t keysyms_per_keycode; + uint8_t keycode_count; } xcb_input_change_device_key_mapping_request_t; /** * @brief xcb_input_get_device_modifier_mapping_cookie_t **/ typedef struct xcb_input_get_device_modifier_mapping_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_get_device_modifier_mapping_cookie_t; /** Opcode for xcb_input_get_device_modifier_mapping. */ @@ -1247,30 +1388,30 @@ typedef struct xcb_input_get_device_modifier_mapping_cookie_t { * @brief xcb_input_get_device_modifier_mapping_request_t **/ typedef struct xcb_input_get_device_modifier_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_get_device_modifier_mapping_request_t; /** * @brief xcb_input_get_device_modifier_mapping_reply_t **/ typedef struct xcb_input_get_device_modifier_mapping_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t keycodes_per_modifier; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t keycodes_per_modifier; + uint8_t pad0[23]; } xcb_input_get_device_modifier_mapping_reply_t; /** * @brief xcb_input_set_device_modifier_mapping_cookie_t **/ typedef struct xcb_input_set_device_modifier_mapping_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_set_device_modifier_mapping_cookie_t; /** Opcode for xcb_input_set_device_modifier_mapping. */ @@ -1280,31 +1421,31 @@ typedef struct xcb_input_set_device_modifier_mapping_cookie_t { * @brief xcb_input_set_device_modifier_mapping_request_t **/ typedef struct xcb_input_set_device_modifier_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t keycodes_per_modifier; /**< */ - uint8_t pad0; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t keycodes_per_modifier; + uint8_t pad0[2]; } xcb_input_set_device_modifier_mapping_request_t; /** * @brief xcb_input_set_device_modifier_mapping_reply_t **/ typedef struct xcb_input_set_device_modifier_mapping_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t status; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; } xcb_input_set_device_modifier_mapping_reply_t; /** * @brief xcb_input_get_device_button_mapping_cookie_t **/ typedef struct xcb_input_get_device_button_mapping_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_get_device_button_mapping_cookie_t; /** Opcode for xcb_input_get_device_button_mapping. */ @@ -1314,30 +1455,30 @@ typedef struct xcb_input_get_device_button_mapping_cookie_t { * @brief xcb_input_get_device_button_mapping_request_t **/ typedef struct xcb_input_get_device_button_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_get_device_button_mapping_request_t; /** * @brief xcb_input_get_device_button_mapping_reply_t **/ typedef struct xcb_input_get_device_button_mapping_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t map_size; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t map_size; + uint8_t pad0[23]; } xcb_input_get_device_button_mapping_reply_t; /** * @brief xcb_input_set_device_button_mapping_cookie_t **/ typedef struct xcb_input_set_device_button_mapping_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_set_device_button_mapping_cookie_t; /** Opcode for xcb_input_set_device_button_mapping. */ @@ -1347,109 +1488,136 @@ typedef struct xcb_input_set_device_button_mapping_cookie_t { * @brief xcb_input_set_device_button_mapping_request_t **/ typedef struct xcb_input_set_device_button_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t map_size; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t map_size; + uint8_t pad0[2]; } xcb_input_set_device_button_mapping_request_t; /** * @brief xcb_input_set_device_button_mapping_reply_t **/ typedef struct xcb_input_set_device_button_mapping_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t status; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; } xcb_input_set_device_button_mapping_reply_t; /** * @brief xcb_input_key_state_t **/ typedef struct xcb_input_key_state_t { - uint8_t class_id; /**< */ - uint8_t len; /**< */ - uint8_t num_keys; /**< */ - uint8_t pad0; /**< */ - uint8_t keys[32]; /**< */ + uint8_t class_id; + uint8_t len; + uint8_t num_keys; + uint8_t pad0; + uint8_t keys[32]; } xcb_input_key_state_t; /** * @brief xcb_input_key_state_iterator_t **/ typedef struct xcb_input_key_state_iterator_t { - xcb_input_key_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_key_state_t *data; + int rem; + int index; } xcb_input_key_state_iterator_t; /** * @brief xcb_input_button_state_t **/ typedef struct xcb_input_button_state_t { - uint8_t class_id; /**< */ - uint8_t len; /**< */ - uint8_t num_buttons; /**< */ - uint8_t pad0; /**< */ - uint8_t buttons[32]; /**< */ + uint8_t class_id; + uint8_t len; + uint8_t num_buttons; + uint8_t pad0; + uint8_t buttons[32]; } xcb_input_button_state_t; /** * @brief xcb_input_button_state_iterator_t **/ typedef struct xcb_input_button_state_iterator_t { - xcb_input_button_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_button_state_t *data; + int rem; + int index; } xcb_input_button_state_iterator_t; +typedef enum xcb_input_valuator_state_mode_mask_t { + XCB_INPUT_VALUATOR_STATE_MODE_MASK_DEVICE_MODE_ABSOLUTE = 1, + XCB_INPUT_VALUATOR_STATE_MODE_MASK_OUT_OF_PROXIMITY = 2 +} xcb_input_valuator_state_mode_mask_t; + /** * @brief xcb_input_valuator_state_t **/ typedef struct xcb_input_valuator_state_t { - uint8_t class_id; /**< */ - uint8_t len; /**< */ - uint8_t num_valuators; /**< */ - uint8_t mode; /**< */ + uint8_t class_id; + uint8_t len; + uint8_t num_valuators; + uint8_t mode; } xcb_input_valuator_state_t; /** * @brief xcb_input_valuator_state_iterator_t **/ typedef struct xcb_input_valuator_state_iterator_t { - xcb_input_valuator_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_valuator_state_t *data; + int rem; + int index; } xcb_input_valuator_state_iterator_t; +/** + * @brief xcb_input_input_state_data_t + **/ +typedef struct xcb_input_input_state_data_t { + struct { + uint8_t num_keys; + uint8_t pad0; + uint8_t keys[32]; + } key; + struct { + uint8_t num_buttons; + uint8_t pad1; + uint8_t buttons[32]; + } button; + struct { + uint8_t num_valuators; + uint8_t mode; + int32_t *valuators; + } valuator; +} xcb_input_input_state_data_t; + /** * @brief xcb_input_input_state_t **/ typedef struct xcb_input_input_state_t { - uint8_t class_id; /**< */ - uint8_t len; /**< */ - uint8_t num_items; /**< */ - uint8_t pad0; /**< */ + uint8_t class_id; + uint8_t len; } xcb_input_input_state_t; +void * +xcb_input_input_state_data (const xcb_input_input_state_t *R); + /** * @brief xcb_input_input_state_iterator_t **/ typedef struct xcb_input_input_state_iterator_t { - xcb_input_input_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_input_state_t *data; + int rem; + int index; } xcb_input_input_state_iterator_t; /** * @brief xcb_input_query_device_state_cookie_t **/ typedef struct xcb_input_query_device_state_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_query_device_state_cookie_t; /** Opcode for xcb_input_query_device_state. */ @@ -1459,23 +1627,23 @@ typedef struct xcb_input_query_device_state_cookie_t { * @brief xcb_input_query_device_state_request_t **/ typedef struct xcb_input_query_device_state_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_query_device_state_request_t; /** * @brief xcb_input_query_device_state_reply_t **/ typedef struct xcb_input_query_device_state_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t num_classes; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t num_classes; + uint8_t pad0[23]; } xcb_input_query_device_state_reply_t; /** Opcode for xcb_input_send_extension_event. */ @@ -1485,15 +1653,15 @@ typedef struct xcb_input_query_device_state_reply_t { * @brief xcb_input_send_extension_event_request_t **/ typedef struct xcb_input_send_extension_event_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t destination; /**< */ - uint8_t device_id; /**< */ - uint8_t propagate; /**< */ - uint16_t num_classes; /**< */ - uint8_t num_events; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t destination; + uint8_t device_id; + uint8_t propagate; + uint16_t num_classes; + uint8_t num_events; + uint8_t pad0[3]; } xcb_input_send_extension_event_request_t; /** Opcode for xcb_input_device_bell. */ @@ -1503,20 +1671,20 @@ typedef struct xcb_input_send_extension_event_request_t { * @brief xcb_input_device_bell_request_t **/ typedef struct xcb_input_device_bell_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t feedback_id; /**< */ - uint8_t feedback_class; /**< */ - int8_t percent; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t feedback_id; + uint8_t feedback_class; + int8_t percent; } xcb_input_device_bell_request_t; /** * @brief xcb_input_set_device_valuators_cookie_t **/ typedef struct xcb_input_set_device_valuators_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_set_device_valuators_cookie_t; /** Opcode for xcb_input_set_device_valuators. */ @@ -1526,25 +1694,25 @@ typedef struct xcb_input_set_device_valuators_cookie_t { * @brief xcb_input_set_device_valuators_request_t **/ typedef struct xcb_input_set_device_valuators_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t first_valuator; /**< */ - uint8_t num_valuators; /**< */ - uint8_t pad0; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t first_valuator; + uint8_t num_valuators; + uint8_t pad0; } xcb_input_set_device_valuators_request_t; /** * @brief xcb_input_set_device_valuators_reply_t **/ typedef struct xcb_input_set_device_valuators_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t status; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; } xcb_input_set_device_valuators_reply_t; typedef enum xcb_input_device_control_t { @@ -1559,129 +1727,171 @@ typedef enum xcb_input_device_control_t { * @brief xcb_input_device_resolution_state_t **/ typedef struct xcb_input_device_resolution_state_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ - uint32_t num_valuators; /**< */ + uint16_t control_id; + uint16_t len; + uint32_t num_valuators; } xcb_input_device_resolution_state_t; /** * @brief xcb_input_device_resolution_state_iterator_t **/ typedef struct xcb_input_device_resolution_state_iterator_t { - xcb_input_device_resolution_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_resolution_state_t *data; + int rem; + int index; } xcb_input_device_resolution_state_iterator_t; /** * @brief xcb_input_device_abs_calib_state_t **/ typedef struct xcb_input_device_abs_calib_state_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ - int32_t min_x; /**< */ - int32_t max_x; /**< */ - int32_t min_y; /**< */ - int32_t max_y; /**< */ - uint32_t flip_x; /**< */ - uint32_t flip_y; /**< */ - uint32_t rotation; /**< */ - uint32_t button_threshold; /**< */ + uint16_t control_id; + uint16_t len; + int32_t min_x; + int32_t max_x; + int32_t min_y; + int32_t max_y; + uint32_t flip_x; + uint32_t flip_y; + uint32_t rotation; + uint32_t button_threshold; } xcb_input_device_abs_calib_state_t; /** * @brief xcb_input_device_abs_calib_state_iterator_t **/ typedef struct xcb_input_device_abs_calib_state_iterator_t { - xcb_input_device_abs_calib_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_abs_calib_state_t *data; + int rem; + int index; } xcb_input_device_abs_calib_state_iterator_t; /** * @brief xcb_input_device_abs_area_state_t **/ typedef struct xcb_input_device_abs_area_state_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ - uint32_t offset_x; /**< */ - uint32_t offset_y; /**< */ - uint32_t width; /**< */ - uint32_t height; /**< */ - uint32_t screen; /**< */ - uint32_t following; /**< */ + uint16_t control_id; + uint16_t len; + uint32_t offset_x; + uint32_t offset_y; + uint32_t width; + uint32_t height; + uint32_t screen; + uint32_t following; } xcb_input_device_abs_area_state_t; /** * @brief xcb_input_device_abs_area_state_iterator_t **/ typedef struct xcb_input_device_abs_area_state_iterator_t { - xcb_input_device_abs_area_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_abs_area_state_t *data; + int rem; + int index; } xcb_input_device_abs_area_state_iterator_t; /** * @brief xcb_input_device_core_state_t **/ typedef struct xcb_input_device_core_state_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ - uint8_t status; /**< */ - uint8_t iscore; /**< */ - uint8_t pad0[2]; /**< */ + uint16_t control_id; + uint16_t len; + uint8_t status; + uint8_t iscore; + uint8_t pad0[2]; } xcb_input_device_core_state_t; /** * @brief xcb_input_device_core_state_iterator_t **/ typedef struct xcb_input_device_core_state_iterator_t { - xcb_input_device_core_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_core_state_t *data; + int rem; + int index; } xcb_input_device_core_state_iterator_t; /** * @brief xcb_input_device_enable_state_t **/ typedef struct xcb_input_device_enable_state_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ - uint8_t enable; /**< */ - uint8_t pad0[3]; /**< */ + uint16_t control_id; + uint16_t len; + uint8_t enable; + uint8_t pad0[3]; } xcb_input_device_enable_state_t; /** * @brief xcb_input_device_enable_state_iterator_t **/ typedef struct xcb_input_device_enable_state_iterator_t { - xcb_input_device_enable_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_enable_state_t *data; + int rem; + int index; } xcb_input_device_enable_state_iterator_t; +/** + * @brief xcb_input_device_state_data_t + **/ +typedef struct xcb_input_device_state_data_t { + struct { + uint32_t num_valuators; + uint32_t *resolution_values; + uint32_t *resolution_min; + uint32_t *resolution_max; + } resolution; + struct { + int32_t min_x; + int32_t max_x; + int32_t min_y; + int32_t max_y; + uint32_t flip_x; + uint32_t flip_y; + uint32_t rotation; + uint32_t button_threshold; + } abs_calib; + struct { + uint8_t status; + uint8_t iscore; + uint8_t pad0[2]; + } core; + struct { + uint8_t enable; + uint8_t pad1[3]; + } enable; + struct { + uint32_t offset_x; + uint32_t offset_y; + uint32_t width; + uint32_t height; + uint32_t screen; + uint32_t following; + } abs_area; +} xcb_input_device_state_data_t; + /** * @brief xcb_input_device_state_t **/ typedef struct xcb_input_device_state_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ + uint16_t control_id; + uint16_t len; } xcb_input_device_state_t; +void * +xcb_input_device_state_data (const xcb_input_device_state_t *R); + /** * @brief xcb_input_device_state_iterator_t **/ typedef struct xcb_input_device_state_iterator_t { - xcb_input_device_state_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_state_t *data; + int rem; + int index; } xcb_input_device_state_iterator_t; /** * @brief xcb_input_get_device_control_cookie_t **/ typedef struct xcb_input_get_device_control_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_get_device_control_cookie_t; /** Opcode for xcb_input_get_device_control. */ @@ -1691,154 +1901,195 @@ typedef struct xcb_input_get_device_control_cookie_t { * @brief xcb_input_get_device_control_request_t **/ typedef struct xcb_input_get_device_control_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t control_id; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t control_id; + uint8_t device_id; + uint8_t pad0; } xcb_input_get_device_control_request_t; /** * @brief xcb_input_get_device_control_reply_t **/ typedef struct xcb_input_get_device_control_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t status; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; } xcb_input_get_device_control_reply_t; /** * @brief xcb_input_device_resolution_ctl_t **/ typedef struct xcb_input_device_resolution_ctl_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ - uint8_t first_valuator; /**< */ - uint8_t num_valuators; /**< */ - uint8_t pad0[2]; /**< */ + uint16_t control_id; + uint16_t len; + uint8_t first_valuator; + uint8_t num_valuators; + uint8_t pad0[2]; } xcb_input_device_resolution_ctl_t; /** * @brief xcb_input_device_resolution_ctl_iterator_t **/ typedef struct xcb_input_device_resolution_ctl_iterator_t { - xcb_input_device_resolution_ctl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_resolution_ctl_t *data; + int rem; + int index; } xcb_input_device_resolution_ctl_iterator_t; /** * @brief xcb_input_device_abs_calib_ctl_t **/ typedef struct xcb_input_device_abs_calib_ctl_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ - int32_t min_x; /**< */ - int32_t max_x; /**< */ - int32_t min_y; /**< */ - int32_t max_y; /**< */ - uint32_t flip_x; /**< */ - uint32_t flip_y; /**< */ - uint32_t rotation; /**< */ - uint32_t button_threshold; /**< */ + uint16_t control_id; + uint16_t len; + int32_t min_x; + int32_t max_x; + int32_t min_y; + int32_t max_y; + uint32_t flip_x; + uint32_t flip_y; + uint32_t rotation; + uint32_t button_threshold; } xcb_input_device_abs_calib_ctl_t; /** * @brief xcb_input_device_abs_calib_ctl_iterator_t **/ typedef struct xcb_input_device_abs_calib_ctl_iterator_t { - xcb_input_device_abs_calib_ctl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_abs_calib_ctl_t *data; + int rem; + int index; } xcb_input_device_abs_calib_ctl_iterator_t; /** * @brief xcb_input_device_abs_area_ctrl_t **/ typedef struct xcb_input_device_abs_area_ctrl_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ - uint32_t offset_x; /**< */ - uint32_t offset_y; /**< */ - int32_t width; /**< */ - int32_t height; /**< */ - int32_t screen; /**< */ - uint32_t following; /**< */ + uint16_t control_id; + uint16_t len; + uint32_t offset_x; + uint32_t offset_y; + int32_t width; + int32_t height; + int32_t screen; + uint32_t following; } xcb_input_device_abs_area_ctrl_t; /** * @brief xcb_input_device_abs_area_ctrl_iterator_t **/ typedef struct xcb_input_device_abs_area_ctrl_iterator_t { - xcb_input_device_abs_area_ctrl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_abs_area_ctrl_t *data; + int rem; + int index; } xcb_input_device_abs_area_ctrl_iterator_t; /** * @brief xcb_input_device_core_ctrl_t **/ typedef struct xcb_input_device_core_ctrl_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ - uint8_t status; /**< */ - uint8_t pad0[3]; /**< */ + uint16_t control_id; + uint16_t len; + uint8_t status; + uint8_t pad0[3]; } xcb_input_device_core_ctrl_t; /** * @brief xcb_input_device_core_ctrl_iterator_t **/ typedef struct xcb_input_device_core_ctrl_iterator_t { - xcb_input_device_core_ctrl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_core_ctrl_t *data; + int rem; + int index; } xcb_input_device_core_ctrl_iterator_t; /** * @brief xcb_input_device_enable_ctrl_t **/ typedef struct xcb_input_device_enable_ctrl_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ - uint8_t enable; /**< */ - uint8_t pad0[3]; /**< */ + uint16_t control_id; + uint16_t len; + uint8_t enable; + uint8_t pad0[3]; } xcb_input_device_enable_ctrl_t; /** * @brief xcb_input_device_enable_ctrl_iterator_t **/ typedef struct xcb_input_device_enable_ctrl_iterator_t { - xcb_input_device_enable_ctrl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_enable_ctrl_t *data; + int rem; + int index; } xcb_input_device_enable_ctrl_iterator_t; +/** + * @brief xcb_input_device_ctl_data_t + **/ +typedef struct xcb_input_device_ctl_data_t { + struct { + uint8_t first_valuator; + uint8_t num_valuators; + uint8_t pad0[2]; + uint32_t *resolution_values; + } resolution; + struct { + int32_t min_x; + int32_t max_x; + int32_t min_y; + int32_t max_y; + uint32_t flip_x; + uint32_t flip_y; + uint32_t rotation; + uint32_t button_threshold; + } abs_calib; + struct { + uint8_t status; + uint8_t pad1[3]; + } core; + struct { + uint8_t enable; + uint8_t pad2[3]; + } enable; + struct { + uint32_t offset_x; + uint32_t offset_y; + int32_t width; + int32_t height; + int32_t screen; + uint32_t following; + } abs_area; +} xcb_input_device_ctl_data_t; + /** * @brief xcb_input_device_ctl_t **/ typedef struct xcb_input_device_ctl_t { - uint16_t control_id; /**< */ - uint16_t len; /**< */ + uint16_t control_id; + uint16_t len; } xcb_input_device_ctl_t; +void * +xcb_input_device_ctl_data (const xcb_input_device_ctl_t *R); + /** * @brief xcb_input_device_ctl_iterator_t **/ typedef struct xcb_input_device_ctl_iterator_t { - xcb_input_device_ctl_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_ctl_t *data; + int rem; + int index; } xcb_input_device_ctl_iterator_t; /** * @brief xcb_input_change_device_control_cookie_t **/ typedef struct xcb_input_change_device_control_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_change_device_control_cookie_t; /** Opcode for xcb_input_change_device_control. */ @@ -1848,31 +2099,31 @@ typedef struct xcb_input_change_device_control_cookie_t { * @brief xcb_input_change_device_control_request_t **/ typedef struct xcb_input_change_device_control_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t control_id; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t control_id; + uint8_t device_id; + uint8_t pad0; } xcb_input_change_device_control_request_t; /** * @brief xcb_input_change_device_control_reply_t **/ typedef struct xcb_input_change_device_control_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t status; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad0[23]; } xcb_input_change_device_control_reply_t; /** * @brief xcb_input_list_device_properties_cookie_t **/ typedef struct xcb_input_list_device_properties_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_list_device_properties_cookie_t; /** Opcode for xcb_input_list_device_properties. */ @@ -1882,23 +2133,23 @@ typedef struct xcb_input_list_device_properties_cookie_t { * @brief xcb_input_list_device_properties_request_t **/ typedef struct xcb_input_list_device_properties_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_list_device_properties_request_t; /** * @brief xcb_input_list_device_properties_reply_t **/ typedef struct xcb_input_list_device_properties_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_atoms; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + uint16_t num_atoms; + uint8_t pad0[22]; } xcb_input_list_device_properties_reply_t; typedef enum xcb_input_property_format_t { @@ -1911,9 +2162,9 @@ typedef enum xcb_input_property_format_t { * @brief xcb_input_change_device_property_items_t **/ typedef struct xcb_input_change_device_property_items_t { - uint8_t *data8; /**< */ - uint16_t *data16; /**< */ - uint32_t *data32; /**< */ + uint8_t *data8; + uint16_t *data16; + uint32_t *data32; } xcb_input_change_device_property_items_t; /** Opcode for xcb_input_change_device_property. */ @@ -1923,16 +2174,16 @@ typedef struct xcb_input_change_device_property_items_t { * @brief xcb_input_change_device_property_request_t **/ typedef struct xcb_input_change_device_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_atom_t property; /**< */ - xcb_atom_t type; /**< */ - uint8_t device_id; /**< */ - uint8_t format; /**< */ - uint8_t mode; /**< */ - uint8_t pad0; /**< */ - uint32_t num_items; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_atom_t property; + xcb_atom_t type; + uint8_t device_id; + uint8_t format; + uint8_t mode; + uint8_t pad0; + uint32_t num_items; } xcb_input_change_device_property_request_t; /** Opcode for xcb_input_delete_device_property. */ @@ -1942,19 +2193,19 @@ typedef struct xcb_input_change_device_property_request_t { * @brief xcb_input_delete_device_property_request_t **/ typedef struct xcb_input_delete_device_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_atom_t property; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_atom_t property; + uint8_t device_id; + uint8_t pad0[3]; } xcb_input_delete_device_property_request_t; /** * @brief xcb_input_get_device_property_cookie_t **/ typedef struct xcb_input_get_device_property_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_get_device_property_cookie_t; /** Opcode for xcb_input_get_device_property. */ @@ -1964,41 +2215,41 @@ typedef struct xcb_input_get_device_property_cookie_t { * @brief xcb_input_get_device_property_request_t **/ typedef struct xcb_input_get_device_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_atom_t property; /**< */ - xcb_atom_t type; /**< */ - uint32_t offset; /**< */ - uint32_t len; /**< */ - uint8_t device_id; /**< */ - uint8_t _delete; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_atom_t property; + xcb_atom_t type; + uint32_t offset; + uint32_t len; + uint8_t device_id; + uint8_t _delete; + uint8_t pad0[2]; } xcb_input_get_device_property_request_t; /** * @brief xcb_input_get_device_property_items_t **/ typedef struct xcb_input_get_device_property_items_t { - uint8_t *data8; /**< */ - uint16_t *data16; /**< */ - uint32_t *data32; /**< */ + uint8_t *data8; + uint16_t *data16; + uint32_t *data32; } xcb_input_get_device_property_items_t; /** * @brief xcb_input_get_device_property_reply_t **/ typedef struct xcb_input_get_device_property_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_atom_t type; /**< */ - uint32_t bytes_after; /**< */ - uint32_t num_items; /**< */ - uint8_t format; /**< */ - uint8_t device_id; /**< */ - uint8_t pad1[10]; /**< */ + uint8_t response_type; + uint8_t xi_reply_type; + uint16_t sequence; + uint32_t length; + xcb_atom_t type; + uint32_t bytes_after; + uint32_t num_items; + uint8_t format; + uint8_t device_id; + uint8_t pad0[10]; } xcb_input_get_device_property_reply_t; typedef enum xcb_input_device_t { @@ -2010,45 +2261,45 @@ typedef enum xcb_input_device_t { * @brief xcb_input_group_info_t **/ typedef struct xcb_input_group_info_t { - uint8_t base; /**< */ - uint8_t latched; /**< */ - uint8_t locked; /**< */ - uint8_t effective; /**< */ + uint8_t base; + uint8_t latched; + uint8_t locked; + uint8_t effective; } xcb_input_group_info_t; /** * @brief xcb_input_group_info_iterator_t **/ typedef struct xcb_input_group_info_iterator_t { - xcb_input_group_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_group_info_t *data; + int rem; + int index; } xcb_input_group_info_iterator_t; /** * @brief xcb_input_modifier_info_t **/ typedef struct xcb_input_modifier_info_t { - uint32_t base; /**< */ - uint32_t latched; /**< */ - uint32_t locked; /**< */ - uint32_t effective; /**< */ + uint32_t base; + uint32_t latched; + uint32_t locked; + uint32_t effective; } xcb_input_modifier_info_t; /** * @brief xcb_input_modifier_info_iterator_t **/ typedef struct xcb_input_modifier_info_iterator_t { - xcb_input_modifier_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_modifier_info_t *data; + int rem; + int index; } xcb_input_modifier_info_iterator_t; /** * @brief xcb_input_xi_query_pointer_cookie_t **/ typedef struct xcb_input_xi_query_pointer_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_xi_query_pointer_cookie_t; /** Opcode for xcb_input_xi_query_pointer. */ @@ -2058,33 +2309,33 @@ typedef struct xcb_input_xi_query_pointer_cookie_t { * @brief xcb_input_xi_query_pointer_request_t **/ typedef struct xcb_input_xi_query_pointer_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; } xcb_input_xi_query_pointer_request_t; /** * @brief xcb_input_xi_query_pointer_reply_t **/ typedef struct xcb_input_xi_query_pointer_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t root; /**< */ - xcb_window_t child; /**< */ - xcb_input_fp1616_t root_x; /**< */ - xcb_input_fp1616_t root_y; /**< */ - xcb_input_fp1616_t win_x; /**< */ - xcb_input_fp1616_t win_y; /**< */ - uint8_t same_screen; /**< */ - uint8_t pad1; /**< */ - uint16_t buttons_len; /**< */ - xcb_input_modifier_info_t mods; /**< */ - xcb_input_group_info_t group; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_window_t root; + xcb_window_t child; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp1616_t win_x; + xcb_input_fp1616_t win_y; + uint8_t same_screen; + uint8_t pad1; + uint16_t buttons_len; + xcb_input_modifier_info_t mods; + xcb_input_group_info_t group; } xcb_input_xi_query_pointer_reply_t; /** Opcode for xcb_input_xi_warp_pointer. */ @@ -2094,19 +2345,19 @@ typedef struct xcb_input_xi_query_pointer_reply_t { * @brief xcb_input_xi_warp_pointer_request_t **/ typedef struct xcb_input_xi_warp_pointer_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t src_win; /**< */ - xcb_window_t dst_win; /**< */ - xcb_input_fp1616_t src_x; /**< */ - xcb_input_fp1616_t src_y; /**< */ - uint16_t src_width; /**< */ - uint16_t src_height; /**< */ - xcb_input_fp1616_t dst_x; /**< */ - xcb_input_fp1616_t dst_y; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t src_win; + xcb_window_t dst_win; + xcb_input_fp1616_t src_x; + xcb_input_fp1616_t src_y; + uint16_t src_width; + uint16_t src_height; + xcb_input_fp1616_t dst_x; + xcb_input_fp1616_t dst_y; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; } xcb_input_xi_warp_pointer_request_t; /** Opcode for xcb_input_xi_change_cursor. */ @@ -2116,13 +2367,13 @@ typedef struct xcb_input_xi_warp_pointer_request_t { * @brief xcb_input_xi_change_cursor_request_t **/ typedef struct xcb_input_xi_change_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_cursor_t cursor; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_cursor_t cursor; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; } xcb_input_xi_change_cursor_request_t; typedef enum xcb_input_hierarchy_change_type_t { @@ -2141,97 +2392,127 @@ typedef enum xcb_input_change_mode_t { * @brief xcb_input_add_master_t **/ typedef struct xcb_input_add_master_t { - uint16_t type; /**< */ - uint16_t len; /**< */ - uint16_t name_len; /**< */ - uint8_t send_core; /**< */ - uint8_t enable; /**< */ + uint16_t type; + uint16_t len; + uint16_t name_len; + uint8_t send_core; + uint8_t enable; } xcb_input_add_master_t; /** * @brief xcb_input_add_master_iterator_t **/ typedef struct xcb_input_add_master_iterator_t { - xcb_input_add_master_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_add_master_t *data; + int rem; + int index; } xcb_input_add_master_iterator_t; /** * @brief xcb_input_remove_master_t **/ typedef struct xcb_input_remove_master_t { - uint16_t type; /**< */ - uint16_t len; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t return_mode; /**< */ - uint8_t pad0; /**< */ - xcb_input_device_id_t return_pointer; /**< */ - xcb_input_device_id_t return_keyboard; /**< */ + uint16_t type; + uint16_t len; + xcb_input_device_id_t deviceid; + uint8_t return_mode; + uint8_t pad0; + xcb_input_device_id_t return_pointer; + xcb_input_device_id_t return_keyboard; } xcb_input_remove_master_t; /** * @brief xcb_input_remove_master_iterator_t **/ typedef struct xcb_input_remove_master_iterator_t { - xcb_input_remove_master_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_remove_master_t *data; + int rem; + int index; } xcb_input_remove_master_iterator_t; /** * @brief xcb_input_attach_slave_t **/ typedef struct xcb_input_attach_slave_t { - uint16_t type; /**< */ - uint16_t len; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_input_device_id_t master; /**< */ + uint16_t type; + uint16_t len; + xcb_input_device_id_t deviceid; + xcb_input_device_id_t master; } xcb_input_attach_slave_t; /** * @brief xcb_input_attach_slave_iterator_t **/ typedef struct xcb_input_attach_slave_iterator_t { - xcb_input_attach_slave_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_attach_slave_t *data; + int rem; + int index; } xcb_input_attach_slave_iterator_t; /** * @brief xcb_input_detach_slave_t **/ typedef struct xcb_input_detach_slave_t { - uint16_t type; /**< */ - uint16_t len; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ + uint16_t type; + uint16_t len; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; } xcb_input_detach_slave_t; /** * @brief xcb_input_detach_slave_iterator_t **/ typedef struct xcb_input_detach_slave_iterator_t { - xcb_input_detach_slave_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_detach_slave_t *data; + int rem; + int index; } xcb_input_detach_slave_iterator_t; +/** + * @brief xcb_input_hierarchy_change_data_t + **/ +typedef struct xcb_input_hierarchy_change_data_t { + struct { + uint16_t name_len; + uint8_t send_core; + uint8_t enable; + char *name; + } add_master; + struct { + xcb_input_device_id_t deviceid; + uint8_t return_mode; + uint8_t pad1; + xcb_input_device_id_t return_pointer; + xcb_input_device_id_t return_keyboard; + } remove_master; + struct { + xcb_input_device_id_t deviceid; + xcb_input_device_id_t master; + } attach_slave; + struct { + xcb_input_device_id_t deviceid; + uint8_t pad2[2]; + } detach_slave; +} xcb_input_hierarchy_change_data_t; + /** * @brief xcb_input_hierarchy_change_t **/ typedef struct xcb_input_hierarchy_change_t { - uint16_t type; /**< */ - uint16_t len; /**< */ + uint16_t type; + uint16_t len; } xcb_input_hierarchy_change_t; +void * +xcb_input_hierarchy_change_data (const xcb_input_hierarchy_change_t *R); + /** * @brief xcb_input_hierarchy_change_iterator_t **/ typedef struct xcb_input_hierarchy_change_iterator_t { - xcb_input_hierarchy_change_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_hierarchy_change_t *data; + int rem; + int index; } xcb_input_hierarchy_change_iterator_t; /** Opcode for xcb_input_xi_change_hierarchy. */ @@ -2241,11 +2522,11 @@ typedef struct xcb_input_hierarchy_change_iterator_t { * @brief xcb_input_xi_change_hierarchy_request_t **/ typedef struct xcb_input_xi_change_hierarchy_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t num_changes; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t num_changes; + uint8_t pad0[3]; } xcb_input_xi_change_hierarchy_request_t; /** Opcode for xcb_input_xi_set_client_pointer. */ @@ -2255,19 +2536,19 @@ typedef struct xcb_input_xi_change_hierarchy_request_t { * @brief xcb_input_xi_set_client_pointer_request_t **/ typedef struct xcb_input_xi_set_client_pointer_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; } xcb_input_xi_set_client_pointer_request_t; /** * @brief xcb_input_xi_get_client_pointer_cookie_t **/ typedef struct xcb_input_xi_get_client_pointer_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_xi_get_client_pointer_cookie_t; /** Opcode for xcb_input_xi_get_client_pointer. */ @@ -2277,24 +2558,24 @@ typedef struct xcb_input_xi_get_client_pointer_cookie_t { * @brief xcb_input_xi_get_client_pointer_request_t **/ typedef struct xcb_input_xi_get_client_pointer_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_input_xi_get_client_pointer_request_t; /** * @brief xcb_input_xi_get_client_pointer_reply_t **/ typedef struct xcb_input_xi_get_client_pointer_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t set; /**< */ - uint8_t pad1; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad2[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t set; + uint8_t pad1; + xcb_input_device_id_t deviceid; + uint8_t pad2[20]; } xcb_input_xi_get_client_pointer_reply_t; typedef enum xcb_input_xi_event_mask_t { @@ -2330,17 +2611,17 @@ typedef enum xcb_input_xi_event_mask_t { * @brief xcb_input_event_mask_t **/ typedef struct xcb_input_event_mask_t { - xcb_input_device_id_t deviceid; /**< */ - uint16_t mask_len; /**< */ + xcb_input_device_id_t deviceid; + uint16_t mask_len; } xcb_input_event_mask_t; /** * @brief xcb_input_event_mask_iterator_t **/ typedef struct xcb_input_event_mask_iterator_t { - xcb_input_event_mask_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_event_mask_t *data; + int rem; + int index; } xcb_input_event_mask_iterator_t; /** Opcode for xcb_input_xi_select_events. */ @@ -2350,19 +2631,19 @@ typedef struct xcb_input_event_mask_iterator_t { * @brief xcb_input_xi_select_events_request_t **/ typedef struct xcb_input_xi_select_events_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint16_t num_mask; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + uint16_t num_mask; + uint8_t pad0[2]; } xcb_input_xi_select_events_request_t; /** * @brief xcb_input_xi_query_version_cookie_t **/ typedef struct xcb_input_xi_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_xi_query_version_cookie_t; /** Opcode for xcb_input_xi_query_version. */ @@ -2372,24 +2653,24 @@ typedef struct xcb_input_xi_query_version_cookie_t { * @brief xcb_input_xi_query_version_request_t **/ typedef struct xcb_input_xi_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t major_version; /**< */ - uint16_t minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t major_version; + uint16_t minor_version; } xcb_input_xi_query_version_request_t; /** * @brief xcb_input_xi_query_version_reply_t **/ typedef struct xcb_input_xi_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t major_version; /**< */ - uint16_t minor_version; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t major_version; + uint16_t minor_version; + uint8_t pad1[20]; } xcb_input_xi_query_version_reply_t; typedef enum xcb_input_device_class_type_t { @@ -2427,155 +2708,193 @@ typedef enum xcb_input_touch_mode_t { * @brief xcb_input_button_class_t **/ typedef struct xcb_input_button_class_t { - uint16_t type; /**< */ - uint16_t len; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint16_t num_buttons; /**< */ + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; + uint16_t num_buttons; } xcb_input_button_class_t; /** * @brief xcb_input_button_class_iterator_t **/ typedef struct xcb_input_button_class_iterator_t { - xcb_input_button_class_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_button_class_t *data; + int rem; + int index; } xcb_input_button_class_iterator_t; /** * @brief xcb_input_key_class_t **/ typedef struct xcb_input_key_class_t { - uint16_t type; /**< */ - uint16_t len; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint16_t num_keys; /**< */ + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; + uint16_t num_keys; } xcb_input_key_class_t; /** * @brief xcb_input_key_class_iterator_t **/ typedef struct xcb_input_key_class_iterator_t { - xcb_input_key_class_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_key_class_t *data; + int rem; + int index; } xcb_input_key_class_iterator_t; /** * @brief xcb_input_scroll_class_t **/ typedef struct xcb_input_scroll_class_t { - uint16_t type; /**< */ - uint16_t len; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint16_t number; /**< */ - uint16_t scroll_type; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t flags; /**< */ - xcb_input_fp3232_t increment; /**< */ + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; + uint16_t number; + uint16_t scroll_type; + uint8_t pad0[2]; + uint32_t flags; + xcb_input_fp3232_t increment; } xcb_input_scroll_class_t; /** * @brief xcb_input_scroll_class_iterator_t **/ typedef struct xcb_input_scroll_class_iterator_t { - xcb_input_scroll_class_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_scroll_class_t *data; + int rem; + int index; } xcb_input_scroll_class_iterator_t; /** * @brief xcb_input_touch_class_t **/ typedef struct xcb_input_touch_class_t { - uint16_t type; /**< */ - uint16_t len; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint8_t mode; /**< */ - uint8_t num_touches; /**< */ + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; + uint8_t mode; + uint8_t num_touches; } xcb_input_touch_class_t; /** * @brief xcb_input_touch_class_iterator_t **/ typedef struct xcb_input_touch_class_iterator_t { - xcb_input_touch_class_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_touch_class_t *data; + int rem; + int index; } xcb_input_touch_class_iterator_t; /** * @brief xcb_input_valuator_class_t **/ typedef struct xcb_input_valuator_class_t { - uint16_t type; /**< */ - uint16_t len; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint16_t number; /**< */ - xcb_atom_t label; /**< */ - xcb_input_fp3232_t min; /**< */ - xcb_input_fp3232_t max; /**< */ - xcb_input_fp3232_t value; /**< */ - uint32_t resolution; /**< */ - uint8_t mode; /**< */ - uint8_t pad0[3]; /**< */ + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; + uint16_t number; + xcb_atom_t label; + xcb_input_fp3232_t min; + xcb_input_fp3232_t max; + xcb_input_fp3232_t value; + uint32_t resolution; + uint8_t mode; + uint8_t pad0[3]; } xcb_input_valuator_class_t; /** * @brief xcb_input_valuator_class_iterator_t **/ typedef struct xcb_input_valuator_class_iterator_t { - xcb_input_valuator_class_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_valuator_class_t *data; + int rem; + int index; } xcb_input_valuator_class_iterator_t; +/** + * @brief xcb_input_device_class_data_t + **/ +typedef struct xcb_input_device_class_data_t { + struct { + uint16_t num_keys; + uint32_t *keys; + } key; + struct { + uint16_t num_buttons; + uint32_t *state; + xcb_atom_t *labels; + } button; + struct { + uint16_t number; + xcb_atom_t label; + xcb_input_fp3232_t min; + xcb_input_fp3232_t max; + xcb_input_fp3232_t value; + uint32_t resolution; + uint8_t mode; + uint8_t pad0[3]; + } valuator; + struct { + uint16_t number; + uint16_t scroll_type; + uint8_t pad1[2]; + uint32_t flags; + xcb_input_fp3232_t increment; + } scroll; + struct { + uint8_t mode; + uint8_t num_touches; + } touch; +} xcb_input_device_class_data_t; + /** * @brief xcb_input_device_class_t **/ typedef struct xcb_input_device_class_t { - uint16_t type; /**< */ - uint16_t len; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint8_t pad0[2]; /**< */ + uint16_t type; + uint16_t len; + xcb_input_device_id_t sourceid; } xcb_input_device_class_t; +void * +xcb_input_device_class_data (const xcb_input_device_class_t *R); + /** * @brief xcb_input_device_class_iterator_t **/ typedef struct xcb_input_device_class_iterator_t { - xcb_input_device_class_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_device_class_t *data; + int rem; + int index; } xcb_input_device_class_iterator_t; /** * @brief xcb_input_xi_device_info_t **/ typedef struct xcb_input_xi_device_info_t { - xcb_input_device_id_t deviceid; /**< */ - uint16_t type; /**< */ - xcb_input_device_id_t attachment; /**< */ - uint16_t num_classes; /**< */ - uint16_t name_len; /**< */ - uint8_t enabled; /**< */ - uint8_t pad0; /**< */ + xcb_input_device_id_t deviceid; + uint16_t type; + xcb_input_device_id_t attachment; + uint16_t num_classes; + uint16_t name_len; + uint8_t enabled; + uint8_t pad0; } xcb_input_xi_device_info_t; /** * @brief xcb_input_xi_device_info_iterator_t **/ typedef struct xcb_input_xi_device_info_iterator_t { - xcb_input_xi_device_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_xi_device_info_t *data; + int rem; + int index; } xcb_input_xi_device_info_iterator_t; /** * @brief xcb_input_xi_query_device_cookie_t **/ typedef struct xcb_input_xi_query_device_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_xi_query_device_cookie_t; /** Opcode for xcb_input_xi_query_device. */ @@ -2585,23 +2904,23 @@ typedef struct xcb_input_xi_query_device_cookie_t { * @brief xcb_input_xi_query_device_request_t **/ typedef struct xcb_input_xi_query_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; } xcb_input_xi_query_device_request_t; /** * @brief xcb_input_xi_query_device_reply_t **/ typedef struct xcb_input_xi_query_device_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_infos; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_infos; + uint8_t pad1[22]; } xcb_input_xi_query_device_reply_t; /** Opcode for xcb_input_xi_set_focus. */ @@ -2611,20 +2930,20 @@ typedef struct xcb_input_xi_query_device_reply_t { * @brief xcb_input_xi_set_focus_request_t **/ typedef struct xcb_input_xi_set_focus_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_timestamp_t time; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_timestamp_t time; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; } xcb_input_xi_set_focus_request_t; /** * @brief xcb_input_xi_get_focus_cookie_t **/ typedef struct xcb_input_xi_get_focus_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_xi_get_focus_cookie_t; /** Opcode for xcb_input_xi_get_focus. */ @@ -2634,23 +2953,23 @@ typedef struct xcb_input_xi_get_focus_cookie_t { * @brief xcb_input_xi_get_focus_request_t **/ typedef struct xcb_input_xi_get_focus_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; } xcb_input_xi_get_focus_request_t; /** * @brief xcb_input_xi_get_focus_reply_t **/ typedef struct xcb_input_xi_get_focus_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t focus; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_window_t focus; + uint8_t pad1[20]; } xcb_input_xi_get_focus_reply_t; typedef enum xcb_input_grab_owner_t { @@ -2662,7 +2981,7 @@ typedef enum xcb_input_grab_owner_t { * @brief xcb_input_xi_grab_device_cookie_t **/ typedef struct xcb_input_xi_grab_device_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_xi_grab_device_cookie_t; /** Opcode for xcb_input_xi_grab_device. */ @@ -2672,30 +2991,30 @@ typedef struct xcb_input_xi_grab_device_cookie_t { * @brief xcb_input_xi_grab_device_request_t **/ typedef struct xcb_input_xi_grab_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_timestamp_t time; /**< */ - xcb_cursor_t cursor; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t mode; /**< */ - uint8_t paired_device_mode; /**< */ - uint8_t owner_events; /**< */ - uint8_t pad0; /**< */ - uint16_t mask_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_timestamp_t time; + xcb_cursor_t cursor; + xcb_input_device_id_t deviceid; + uint8_t mode; + uint8_t paired_device_mode; + uint8_t owner_events; + uint8_t pad0; + uint16_t mask_len; } xcb_input_xi_grab_device_request_t; /** * @brief xcb_input_xi_grab_device_reply_t **/ typedef struct xcb_input_xi_grab_device_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t status; /**< */ - uint8_t pad1[23]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t status; + uint8_t pad1[23]; } xcb_input_xi_grab_device_reply_t; /** Opcode for xcb_input_xi_ungrab_device. */ @@ -2705,12 +3024,12 @@ typedef struct xcb_input_xi_grab_device_reply_t { * @brief xcb_input_xi_ungrab_device_request_t **/ typedef struct xcb_input_xi_ungrab_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_timestamp_t time; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t time; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; } xcb_input_xi_ungrab_device_request_t; typedef enum xcb_input_event_mode_t { @@ -2731,15 +3050,15 @@ typedef enum xcb_input_event_mode_t { * @brief xcb_input_xi_allow_events_request_t **/ typedef struct xcb_input_xi_allow_events_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_timestamp_t time; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t event_mode; /**< */ - uint8_t pad0; /**< */ - uint32_t touchid; /**< */ - xcb_window_t grab_window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t time; + xcb_input_device_id_t deviceid; + uint8_t event_mode; + uint8_t pad0; + uint32_t touchid; + xcb_window_t grab_window; } xcb_input_xi_allow_events_request_t; typedef enum xcb_input_grab_mode_22_t { @@ -2764,25 +3083,25 @@ typedef enum xcb_input_modifier_mask_t { * @brief xcb_input_grab_modifier_info_t **/ typedef struct xcb_input_grab_modifier_info_t { - uint32_t modifiers; /**< */ - uint8_t status; /**< */ - uint8_t pad0[3]; /**< */ + uint32_t modifiers; + uint8_t status; + uint8_t pad0[3]; } xcb_input_grab_modifier_info_t; /** * @brief xcb_input_grab_modifier_info_iterator_t **/ typedef struct xcb_input_grab_modifier_info_iterator_t { - xcb_input_grab_modifier_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_grab_modifier_info_t *data; + int rem; + int index; } xcb_input_grab_modifier_info_iterator_t; /** * @brief xcb_input_xi_passive_grab_device_cookie_t **/ typedef struct xcb_input_xi_passive_grab_device_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_xi_passive_grab_device_cookie_t; /** Opcode for xcb_input_xi_passive_grab_device. */ @@ -2792,33 +3111,33 @@ typedef struct xcb_input_xi_passive_grab_device_cookie_t { * @brief xcb_input_xi_passive_grab_device_request_t **/ typedef struct xcb_input_xi_passive_grab_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t grab_window; /**< */ - xcb_cursor_t cursor; /**< */ - uint32_t detail; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint16_t num_modifiers; /**< */ - uint16_t mask_len; /**< */ - uint8_t grab_type; /**< */ - uint8_t grab_mode; /**< */ - uint8_t paired_device_mode; /**< */ - uint8_t owner_events; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_timestamp_t time; + xcb_window_t grab_window; + xcb_cursor_t cursor; + uint32_t detail; + xcb_input_device_id_t deviceid; + uint16_t num_modifiers; + uint16_t mask_len; + uint8_t grab_type; + uint8_t grab_mode; + uint8_t paired_device_mode; + uint8_t owner_events; + uint8_t pad0[2]; } xcb_input_xi_passive_grab_device_request_t; /** * @brief xcb_input_xi_passive_grab_device_reply_t **/ typedef struct xcb_input_xi_passive_grab_device_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_modifiers; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_modifiers; + uint8_t pad1[22]; } xcb_input_xi_passive_grab_device_reply_t; /** Opcode for xcb_input_xi_passive_ungrab_device. */ @@ -2828,22 +3147,22 @@ typedef struct xcb_input_xi_passive_grab_device_reply_t { * @brief xcb_input_xi_passive_ungrab_device_request_t **/ typedef struct xcb_input_xi_passive_ungrab_device_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - uint32_t detail; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint16_t num_modifiers; /**< */ - uint8_t grab_type; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t grab_window; + uint32_t detail; + xcb_input_device_id_t deviceid; + uint16_t num_modifiers; + uint8_t grab_type; + uint8_t pad0[3]; } xcb_input_xi_passive_ungrab_device_request_t; /** * @brief xcb_input_xi_list_properties_cookie_t **/ typedef struct xcb_input_xi_list_properties_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_xi_list_properties_cookie_t; /** Opcode for xcb_input_xi_list_properties. */ @@ -2853,32 +3172,32 @@ typedef struct xcb_input_xi_list_properties_cookie_t { * @brief xcb_input_xi_list_properties_request_t **/ typedef struct xcb_input_xi_list_properties_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; } xcb_input_xi_list_properties_request_t; /** * @brief xcb_input_xi_list_properties_reply_t **/ typedef struct xcb_input_xi_list_properties_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_properties; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_properties; + uint8_t pad1[22]; } xcb_input_xi_list_properties_reply_t; /** * @brief xcb_input_xi_change_property_items_t **/ typedef struct xcb_input_xi_change_property_items_t { - uint8_t *data8; /**< */ - uint16_t *data16; /**< */ - uint32_t *data32; /**< */ + uint8_t *data8; + uint16_t *data16; + uint32_t *data32; } xcb_input_xi_change_property_items_t; /** Opcode for xcb_input_xi_change_property. */ @@ -2888,15 +3207,15 @@ typedef struct xcb_input_xi_change_property_items_t { * @brief xcb_input_xi_change_property_request_t **/ typedef struct xcb_input_xi_change_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t mode; /**< */ - uint8_t format; /**< */ - xcb_atom_t property; /**< */ - xcb_atom_t type; /**< */ - uint32_t num_items; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t mode; + uint8_t format; + xcb_atom_t property; + xcb_atom_t type; + uint32_t num_items; } xcb_input_xi_change_property_request_t; /** Opcode for xcb_input_xi_delete_property. */ @@ -2906,19 +3225,19 @@ typedef struct xcb_input_xi_change_property_request_t { * @brief xcb_input_xi_delete_property_request_t **/ typedef struct xcb_input_xi_delete_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ - xcb_atom_t property; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; + xcb_atom_t property; } xcb_input_xi_delete_property_request_t; /** * @brief xcb_input_xi_get_property_cookie_t **/ typedef struct xcb_input_xi_get_property_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_xi_get_property_cookie_t; /** Opcode for xcb_input_xi_get_property. */ @@ -2928,47 +3247,47 @@ typedef struct xcb_input_xi_get_property_cookie_t { * @brief xcb_input_xi_get_property_request_t **/ typedef struct xcb_input_xi_get_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_input_device_id_t deviceid; /**< */ - uint8_t _delete; /**< */ - uint8_t pad0; /**< */ - xcb_atom_t property; /**< */ - xcb_atom_t type; /**< */ - uint32_t offset; /**< */ - uint32_t len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_input_device_id_t deviceid; + uint8_t _delete; + uint8_t pad0; + xcb_atom_t property; + xcb_atom_t type; + uint32_t offset; + uint32_t len; } xcb_input_xi_get_property_request_t; /** * @brief xcb_input_xi_get_property_items_t **/ typedef struct xcb_input_xi_get_property_items_t { - uint8_t *data8; /**< */ - uint16_t *data16; /**< */ - uint32_t *data32; /**< */ + uint8_t *data8; + uint16_t *data16; + uint32_t *data32; } xcb_input_xi_get_property_items_t; /** * @brief xcb_input_xi_get_property_reply_t **/ typedef struct xcb_input_xi_get_property_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_atom_t type; /**< */ - uint32_t bytes_after; /**< */ - uint32_t num_items; /**< */ - uint8_t format; /**< */ - uint8_t pad1[11]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_atom_t type; + uint32_t bytes_after; + uint32_t num_items; + uint8_t format; + uint8_t pad1[11]; } xcb_input_xi_get_property_reply_t; /** * @brief xcb_input_xi_get_selected_events_cookie_t **/ typedef struct xcb_input_xi_get_selected_events_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_input_xi_get_selected_events_cookie_t; /** Opcode for xcb_input_xi_get_selected_events. */ @@ -2978,41 +3297,41 @@ typedef struct xcb_input_xi_get_selected_events_cookie_t { * @brief xcb_input_xi_get_selected_events_request_t **/ typedef struct xcb_input_xi_get_selected_events_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_input_xi_get_selected_events_request_t; /** * @brief xcb_input_xi_get_selected_events_reply_t **/ typedef struct xcb_input_xi_get_selected_events_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_masks; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_masks; + uint8_t pad1[22]; } xcb_input_xi_get_selected_events_reply_t; /** * @brief xcb_input_barrier_release_pointer_info_t **/ typedef struct xcb_input_barrier_release_pointer_info_t { - xcb_input_device_id_t deviceid; /**< */ - uint8_t pad0[2]; /**< */ - xcb_xfixes_barrier_t barrier; /**< */ - uint32_t eventid; /**< */ + xcb_input_device_id_t deviceid; + uint8_t pad0[2]; + xcb_xfixes_barrier_t barrier; + uint32_t eventid; } xcb_input_barrier_release_pointer_info_t; /** * @brief xcb_input_barrier_release_pointer_info_iterator_t **/ typedef struct xcb_input_barrier_release_pointer_info_iterator_t { - xcb_input_barrier_release_pointer_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_barrier_release_pointer_info_t *data; + int rem; + int index; } xcb_input_barrier_release_pointer_info_iterator_t; /** Opcode for xcb_input_xi_barrier_release_pointer. */ @@ -3022,10 +3341,10 @@ typedef struct xcb_input_barrier_release_pointer_info_iterator_t { * @brief xcb_input_xi_barrier_release_pointer_request_t **/ typedef struct xcb_input_xi_barrier_release_pointer_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t num_barriers; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t num_barriers; } xcb_input_xi_barrier_release_pointer_request_t; /** Opcode for xcb_input_device_valuator. */ @@ -3035,15 +3354,19 @@ typedef struct xcb_input_xi_barrier_release_pointer_request_t { * @brief xcb_input_device_valuator_event_t **/ typedef struct xcb_input_device_valuator_event_t { - uint8_t response_type; /**< */ - uint8_t device_id; /**< */ - uint16_t sequence; /**< */ - uint16_t device_state; /**< */ - uint8_t num_valuators; /**< */ - uint8_t first_valuator; /**< */ - int32_t valuators[6]; /**< */ + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + uint16_t device_state; + uint8_t num_valuators; + uint8_t first_valuator; + int32_t valuators[6]; } xcb_input_device_valuator_event_t; +typedef enum xcb_input_more_events_mask_t { + XCB_INPUT_MORE_EVENTS_MASK_MORE_EVENTS = 128 +} xcb_input_more_events_mask_t; + /** Opcode for xcb_input_device_key_press. */ #define XCB_INPUT_DEVICE_KEY_PRESS 1 @@ -3051,20 +3374,20 @@ typedef struct xcb_input_device_valuator_event_t { * @brief xcb_input_device_key_press_event_t **/ typedef struct xcb_input_device_key_press_event_t { - uint8_t response_type; /**< */ - uint8_t detail; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_window_t child; /**< */ - int16_t root_x; /**< */ - int16_t root_y; /**< */ - int16_t event_x; /**< */ - int16_t event_y; /**< */ - uint16_t state; /**< */ - uint8_t same_screen; /**< */ - uint8_t device_id; /**< */ + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t event_x; + int16_t event_y; + uint16_t state; + uint8_t same_screen; + uint8_t device_id; } xcb_input_device_key_press_event_t; /** Opcode for xcb_input_device_key_release. */ @@ -3094,14 +3417,14 @@ typedef xcb_input_device_key_press_event_t xcb_input_device_motion_notify_event_ * @brief xcb_input_device_focus_in_event_t **/ typedef struct xcb_input_device_focus_in_event_t { - uint8_t response_type; /**< */ - uint8_t detail; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t window; /**< */ - uint8_t mode; /**< */ - uint8_t device_id; /**< */ - uint8_t pad0[18]; /**< */ + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t window; + uint8_t mode; + uint8_t device_id; + uint8_t pad0[18]; } xcb_input_device_focus_in_event_t; /** Opcode for xcb_input_device_focus_out. */ @@ -3119,6 +3442,14 @@ typedef xcb_input_device_key_press_event_t xcb_input_proximity_in_event_t; typedef xcb_input_device_key_press_event_t xcb_input_proximity_out_event_t; +typedef enum xcb_input_classes_reported_mask_t { + XCB_INPUT_CLASSES_REPORTED_MASK_OUT_OF_PROXIMITY = 128, + XCB_INPUT_CLASSES_REPORTED_MASK_DEVICE_MODE_ABSOLUTE = 64, + XCB_INPUT_CLASSES_REPORTED_MASK_REPORTING_VALUATORS = 4, + XCB_INPUT_CLASSES_REPORTED_MASK_REPORTING_BUTTONS = 2, + XCB_INPUT_CLASSES_REPORTED_MASK_REPORTING_KEYS = 1 +} xcb_input_classes_reported_mask_t; + /** Opcode for xcb_input_device_state_notify. */ #define XCB_INPUT_DEVICE_STATE_NOTIFY 10 @@ -3126,17 +3457,17 @@ typedef xcb_input_device_key_press_event_t xcb_input_proximity_out_event_t; * @brief xcb_input_device_state_notify_event_t **/ typedef struct xcb_input_device_state_notify_event_t { - uint8_t response_type; /**< */ - uint8_t device_id; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t num_keys; /**< */ - uint8_t num_buttons; /**< */ - uint8_t num_valuators; /**< */ - uint8_t classes_reported; /**< */ - uint8_t buttons[4]; /**< */ - uint8_t keys[4]; /**< */ - uint32_t valuators[3]; /**< */ + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t num_keys; + uint8_t num_buttons; + uint8_t num_valuators; + uint8_t classes_reported; + uint8_t buttons[4]; + uint8_t keys[4]; + uint32_t valuators[3]; } xcb_input_device_state_notify_event_t; /** Opcode for xcb_input_device_mapping_notify. */ @@ -3146,17 +3477,22 @@ typedef struct xcb_input_device_state_notify_event_t { * @brief xcb_input_device_mapping_notify_event_t **/ typedef struct xcb_input_device_mapping_notify_event_t { - uint8_t response_type; /**< */ - uint8_t device_id; /**< */ - uint16_t sequence; /**< */ - uint8_t request; /**< */ - xcb_input_key_code_t first_keycode; /**< */ - uint8_t count; /**< */ - uint8_t pad0; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + uint8_t request; + xcb_input_key_code_t first_keycode; + uint8_t count; + uint8_t pad0; + xcb_timestamp_t time; + uint8_t pad1[20]; } xcb_input_device_mapping_notify_event_t; +typedef enum xcb_input_change_device_t { + XCB_INPUT_CHANGE_DEVICE_NEW_POINTER = 0, + XCB_INPUT_CHANGE_DEVICE_NEW_KEYBOARD = 1 +} xcb_input_change_device_t; + /** Opcode for xcb_input_change_device_notify. */ #define XCB_INPUT_CHANGE_DEVICE_NOTIFY 12 @@ -3164,12 +3500,12 @@ typedef struct xcb_input_device_mapping_notify_event_t { * @brief xcb_input_change_device_notify_event_t **/ typedef struct xcb_input_change_device_notify_event_t { - uint8_t response_type; /**< */ - uint8_t device_id; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t request; /**< */ - uint8_t pad0[23]; /**< */ + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t request; + uint8_t pad0[23]; } xcb_input_change_device_notify_event_t; /** Opcode for xcb_input_device_key_state_notify. */ @@ -3179,10 +3515,10 @@ typedef struct xcb_input_change_device_notify_event_t { * @brief xcb_input_device_key_state_notify_event_t **/ typedef struct xcb_input_device_key_state_notify_event_t { - uint8_t response_type; /**< */ - uint8_t device_id; /**< */ - uint16_t sequence; /**< */ - uint8_t keys[28]; /**< */ + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + uint8_t keys[28]; } xcb_input_device_key_state_notify_event_t; /** Opcode for xcb_input_device_button_state_notify. */ @@ -3192,10 +3528,10 @@ typedef struct xcb_input_device_key_state_notify_event_t { * @brief xcb_input_device_button_state_notify_event_t **/ typedef struct xcb_input_device_button_state_notify_event_t { - uint8_t response_type; /**< */ - uint8_t device_id; /**< */ - uint16_t sequence; /**< */ - uint8_t buttons[28]; /**< */ + uint8_t response_type; + uint8_t device_id; + uint16_t sequence; + uint8_t buttons[28]; } xcb_input_device_button_state_notify_event_t; typedef enum xcb_input_device_change_t { @@ -3214,14 +3550,14 @@ typedef enum xcb_input_device_change_t { * @brief xcb_input_device_presence_notify_event_t **/ typedef struct xcb_input_device_presence_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t devchange; /**< */ - uint8_t device_id; /**< */ - uint16_t control; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t devchange; + uint8_t device_id; + uint16_t control; + uint8_t pad1[20]; } xcb_input_device_presence_notify_event_t; /** Opcode for xcb_input_device_property_notify. */ @@ -3231,13 +3567,13 @@ typedef struct xcb_input_device_presence_notify_event_t { * @brief xcb_input_device_property_notify_event_t **/ typedef struct xcb_input_device_property_notify_event_t { - uint8_t response_type; /**< */ - uint8_t state; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_atom_t property; /**< */ - uint8_t pad0[19]; /**< */ - uint8_t device_id; /**< */ + uint8_t response_type; + uint8_t state; + uint16_t sequence; + xcb_timestamp_t time; + xcb_atom_t property; + uint8_t pad0[19]; + uint8_t device_id; } xcb_input_device_property_notify_event_t; typedef enum xcb_input_change_reason_t { @@ -3252,18 +3588,18 @@ typedef enum xcb_input_change_reason_t { * @brief xcb_input_device_changed_event_t **/ typedef struct xcb_input_device_changed_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - uint16_t num_classes; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint8_t reason; /**< */ - uint8_t pad0[11]; /**< */ - uint32_t full_sequence; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint16_t num_classes; + xcb_input_device_id_t sourceid; + uint8_t reason; + uint8_t pad0[11]; + uint32_t full_sequence; } xcb_input_device_changed_event_t; typedef enum xcb_input_key_event_flags_t { @@ -3277,29 +3613,29 @@ typedef enum xcb_input_key_event_flags_t { * @brief xcb_input_key_press_event_t **/ typedef struct xcb_input_key_press_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - uint32_t detail; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_window_t child; /**< */ - uint32_t full_sequence; /**< */ - xcb_input_fp1616_t root_x; /**< */ - xcb_input_fp1616_t root_y; /**< */ - xcb_input_fp1616_t event_x; /**< */ - xcb_input_fp1616_t event_y; /**< */ - uint16_t buttons_len; /**< */ - uint16_t valuators_len; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t flags; /**< */ - xcb_input_modifier_info_t mods; /**< */ - xcb_input_group_info_t group; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + uint32_t full_sequence; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp1616_t event_x; + xcb_input_fp1616_t event_y; + uint16_t buttons_len; + uint16_t valuators_len; + xcb_input_device_id_t sourceid; + uint8_t pad0[2]; + uint32_t flags; + xcb_input_modifier_info_t mods; + xcb_input_group_info_t group; } xcb_input_key_press_event_t; /** Opcode for xcb_input_key_release. */ @@ -3318,29 +3654,29 @@ typedef enum xcb_input_pointer_event_flags_t { * @brief xcb_input_button_press_event_t **/ typedef struct xcb_input_button_press_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - uint32_t detail; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_window_t child; /**< */ - uint32_t full_sequence; /**< */ - xcb_input_fp1616_t root_x; /**< */ - xcb_input_fp1616_t root_y; /**< */ - xcb_input_fp1616_t event_x; /**< */ - xcb_input_fp1616_t event_y; /**< */ - uint16_t buttons_len; /**< */ - uint16_t valuators_len; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t flags; /**< */ - xcb_input_modifier_info_t mods; /**< */ - xcb_input_group_info_t group; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + uint32_t full_sequence; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp1616_t event_x; + xcb_input_fp1616_t event_y; + uint16_t buttons_len; + uint16_t valuators_len; + xcb_input_device_id_t sourceid; + uint8_t pad0[2]; + uint32_t flags; + xcb_input_modifier_info_t mods; + xcb_input_group_info_t group; } xcb_input_button_press_event_t; /** Opcode for xcb_input_button_release. */ @@ -3380,29 +3716,29 @@ typedef enum xcb_input_notify_detail_t { * @brief xcb_input_enter_event_t **/ typedef struct xcb_input_enter_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint8_t mode; /**< */ - uint8_t detail; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_window_t child; /**< */ - uint32_t full_sequence; /**< */ - xcb_input_fp1616_t root_x; /**< */ - xcb_input_fp1616_t root_y; /**< */ - xcb_input_fp1616_t event_x; /**< */ - xcb_input_fp1616_t event_y; /**< */ - uint8_t same_screen; /**< */ - uint8_t focus; /**< */ - uint16_t buttons_len; /**< */ - xcb_input_modifier_info_t mods; /**< */ - xcb_input_group_info_t group; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + xcb_input_device_id_t sourceid; + uint8_t mode; + uint8_t detail; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + uint32_t full_sequence; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp1616_t event_x; + xcb_input_fp1616_t event_y; + uint8_t same_screen; + uint8_t focus; + uint16_t buttons_len; + xcb_input_modifier_info_t mods; + xcb_input_group_info_t group; } xcb_input_enter_event_t; /** Opcode for xcb_input_leave. */ @@ -3435,21 +3771,21 @@ typedef enum xcb_input_hierarchy_mask_t { * @brief xcb_input_hierarchy_info_t **/ typedef struct xcb_input_hierarchy_info_t { - xcb_input_device_id_t deviceid; /**< */ - xcb_input_device_id_t attachment; /**< */ - uint8_t type; /**< */ - uint8_t enabled; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t flags; /**< */ + xcb_input_device_id_t deviceid; + xcb_input_device_id_t attachment; + uint8_t type; + uint8_t enabled; + uint8_t pad0[2]; + uint32_t flags; } xcb_input_hierarchy_info_t; /** * @brief xcb_input_hierarchy_info_iterator_t **/ typedef struct xcb_input_hierarchy_info_iterator_t { - xcb_input_hierarchy_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_input_hierarchy_info_t *data; + int rem; + int index; } xcb_input_hierarchy_info_iterator_t; /** Opcode for xcb_input_hierarchy. */ @@ -3459,17 +3795,17 @@ typedef struct xcb_input_hierarchy_info_iterator_t { * @brief xcb_input_hierarchy_event_t **/ typedef struct xcb_input_hierarchy_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - uint32_t flags; /**< */ - uint16_t num_infos; /**< */ - uint8_t pad0[10]; /**< */ - uint32_t full_sequence; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t flags; + uint16_t num_infos; + uint8_t pad0[10]; + uint32_t full_sequence; } xcb_input_hierarchy_event_t; typedef enum xcb_input_property_flag_t { @@ -3485,17 +3821,17 @@ typedef enum xcb_input_property_flag_t { * @brief xcb_input_property_event_t **/ typedef struct xcb_input_property_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - xcb_atom_t property; /**< */ - uint8_t what; /**< */ - uint8_t pad0[11]; /**< */ - uint32_t full_sequence; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + xcb_atom_t property; + uint8_t what; + uint8_t pad0[11]; + uint32_t full_sequence; } xcb_input_property_event_t; /** Opcode for xcb_input_raw_key_press. */ @@ -3505,19 +3841,19 @@ typedef struct xcb_input_property_event_t { * @brief xcb_input_raw_key_press_event_t **/ typedef struct xcb_input_raw_key_press_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - uint32_t detail; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint16_t valuators_len; /**< */ - uint32_t flags; /**< */ - uint8_t pad0[4]; /**< */ - uint32_t full_sequence; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_input_device_id_t sourceid; + uint16_t valuators_len; + uint32_t flags; + uint8_t pad0[4]; + uint32_t full_sequence; } xcb_input_raw_key_press_event_t; /** Opcode for xcb_input_raw_key_release. */ @@ -3532,19 +3868,19 @@ typedef xcb_input_raw_key_press_event_t xcb_input_raw_key_release_event_t; * @brief xcb_input_raw_button_press_event_t **/ typedef struct xcb_input_raw_button_press_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - uint32_t detail; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint16_t valuators_len; /**< */ - uint32_t flags; /**< */ - uint8_t pad0[4]; /**< */ - uint32_t full_sequence; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_input_device_id_t sourceid; + uint16_t valuators_len; + uint32_t flags; + uint8_t pad0[4]; + uint32_t full_sequence; } xcb_input_raw_button_press_event_t; /** Opcode for xcb_input_raw_button_release. */ @@ -3569,29 +3905,29 @@ typedef enum xcb_input_touch_event_flags_t { * @brief xcb_input_touch_begin_event_t **/ typedef struct xcb_input_touch_begin_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - uint32_t detail; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_window_t child; /**< */ - uint32_t full_sequence; /**< */ - xcb_input_fp1616_t root_x; /**< */ - xcb_input_fp1616_t root_y; /**< */ - xcb_input_fp1616_t event_x; /**< */ - xcb_input_fp1616_t event_y; /**< */ - uint16_t buttons_len; /**< */ - uint16_t valuators_len; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t flags; /**< */ - xcb_input_modifier_info_t mods; /**< */ - xcb_input_group_info_t group; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + uint32_t full_sequence; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp1616_t event_x; + xcb_input_fp1616_t event_y; + uint16_t buttons_len; + uint16_t valuators_len; + xcb_input_device_id_t sourceid; + uint8_t pad0[2]; + uint32_t flags; + xcb_input_modifier_info_t mods; + xcb_input_group_info_t group; } xcb_input_touch_begin_event_t; /** Opcode for xcb_input_touch_update. */ @@ -3615,22 +3951,22 @@ typedef enum xcb_input_touch_ownership_flags_t { * @brief xcb_input_touch_ownership_event_t **/ typedef struct xcb_input_touch_ownership_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - uint32_t touchid; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_window_t child; /**< */ - uint32_t full_sequence; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t flags; /**< */ - uint8_t pad1[8]; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t touchid; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + uint32_t full_sequence; + xcb_input_device_id_t sourceid; + uint8_t pad0[2]; + uint32_t flags; + uint8_t pad1[8]; } xcb_input_touch_ownership_event_t; /** Opcode for xcb_input_raw_touch_begin. */ @@ -3640,19 +3976,19 @@ typedef struct xcb_input_touch_ownership_event_t { * @brief xcb_input_raw_touch_begin_event_t **/ typedef struct xcb_input_raw_touch_begin_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - uint32_t detail; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint16_t valuators_len; /**< */ - uint32_t flags; /**< */ - uint8_t pad0[4]; /**< */ - uint32_t full_sequence; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t detail; + xcb_input_device_id_t sourceid; + uint16_t valuators_len; + uint32_t flags; + uint8_t pad0[4]; + uint32_t full_sequence; } xcb_input_raw_touch_begin_event_t; /** Opcode for xcb_input_raw_touch_update. */ @@ -3665,6 +4001,11 @@ typedef xcb_input_raw_touch_begin_event_t xcb_input_raw_touch_update_event_t; typedef xcb_input_raw_touch_begin_event_t xcb_input_raw_touch_end_event_t; +typedef enum xcb_input_barrier_flags_t { + XCB_INPUT_BARRIER_FLAGS_POINTER_RELEASED = 1, + XCB_INPUT_BARRIER_FLAGS_DEVICE_IS_GRABBED = 2 +} xcb_input_barrier_flags_t; + /** Opcode for xcb_input_barrier_hit. */ #define XCB_INPUT_BARRIER_HIT 25 @@ -3672,26 +4013,26 @@ typedef xcb_input_raw_touch_begin_event_t xcb_input_raw_touch_end_event_t; * @brief xcb_input_barrier_hit_event_t **/ typedef struct xcb_input_barrier_hit_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - xcb_input_device_id_t deviceid; /**< */ - xcb_timestamp_t time; /**< */ - uint32_t eventid; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_xfixes_barrier_t barrier; /**< */ - uint32_t full_sequence; /**< */ - uint32_t dtime; /**< */ - uint32_t flags; /**< */ - xcb_input_device_id_t sourceid; /**< */ - uint8_t pad0[2]; /**< */ - xcb_input_fp1616_t root_x; /**< */ - xcb_input_fp1616_t root_y; /**< */ - xcb_input_fp3232_t dx; /**< */ - xcb_input_fp3232_t dy; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + xcb_input_device_id_t deviceid; + xcb_timestamp_t time; + uint32_t eventid; + xcb_window_t root; + xcb_window_t event; + xcb_xfixes_barrier_t barrier; + uint32_t full_sequence; + uint32_t dtime; + uint32_t flags; + xcb_input_device_id_t sourceid; + uint8_t pad0[2]; + xcb_input_fp1616_t root_x; + xcb_input_fp1616_t root_y; + xcb_input_fp3232_t dx; + xcb_input_fp3232_t dy; } xcb_input_barrier_hit_event_t; /** Opcode for xcb_input_barrier_leave. */ @@ -3706,9 +4047,9 @@ typedef xcb_input_barrier_hit_event_t xcb_input_barrier_leave_event_t; * @brief xcb_input_device_error_t **/ typedef struct xcb_input_device_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_input_device_error_t; /** Opcode for xcb_input_event. */ @@ -3718,9 +4059,9 @@ typedef struct xcb_input_device_error_t { * @brief xcb_input_event_error_t **/ typedef struct xcb_input_event_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_input_event_error_t; /** Opcode for xcb_input_mode. */ @@ -3730,9 +4071,9 @@ typedef struct xcb_input_event_error_t { * @brief xcb_input_mode_error_t **/ typedef struct xcb_input_mode_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_input_mode_error_t; /** Opcode for xcb_input_device_busy. */ @@ -3742,9 +4083,9 @@ typedef struct xcb_input_mode_error_t { * @brief xcb_input_device_busy_error_t **/ typedef struct xcb_input_device_busy_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_input_device_busy_error_t; /** Opcode for xcb_input_class. */ @@ -3754,9 +4095,9 @@ typedef struct xcb_input_device_busy_error_t { * @brief xcb_input_class_error_t **/ typedef struct xcb_input_class_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_input_class_error_t; /** @@ -3768,7 +4109,7 @@ typedef struct xcb_input_class_error_t { * element. The member index is increased by sizeof(xcb_input_event_class_t) */ void -xcb_input_event_class_next (xcb_input_event_class_iterator_t *i /**< */); +xcb_input_event_class_next (xcb_input_event_class_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3780,7 +4121,7 @@ xcb_input_event_class_next (xcb_input_event_class_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_event_class_end (xcb_input_event_class_iterator_t i /**< */); +xcb_input_event_class_end (xcb_input_event_class_iterator_t i); /** * Get the next element of the iterator @@ -3791,7 +4132,7 @@ xcb_input_event_class_end (xcb_input_event_class_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_key_code_t) */ void -xcb_input_key_code_next (xcb_input_key_code_iterator_t *i /**< */); +xcb_input_key_code_next (xcb_input_key_code_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3803,7 +4144,7 @@ xcb_input_key_code_next (xcb_input_key_code_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_key_code_end (xcb_input_key_code_iterator_t i /**< */); +xcb_input_key_code_end (xcb_input_key_code_iterator_t i); /** * Get the next element of the iterator @@ -3814,7 +4155,7 @@ xcb_input_key_code_end (xcb_input_key_code_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_device_id_t) */ void -xcb_input_device_id_next (xcb_input_device_id_iterator_t *i /**< */); +xcb_input_device_id_next (xcb_input_device_id_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3826,7 +4167,7 @@ xcb_input_device_id_next (xcb_input_device_id_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_device_id_end (xcb_input_device_id_iterator_t i /**< */); +xcb_input_device_id_end (xcb_input_device_id_iterator_t i); /** * Get the next element of the iterator @@ -3837,7 +4178,7 @@ xcb_input_device_id_end (xcb_input_device_id_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_fp1616_t) */ void -xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i /**< */); +xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3849,7 +4190,7 @@ xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i /**< */); +xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i); /** * Get the next element of the iterator @@ -3860,7 +4201,7 @@ xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_fp3232_t) */ void -xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i /**< */); +xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3872,10 +4213,10 @@ xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_fp3232_end (xcb_input_fp3232_iterator_t i /**< */); +xcb_input_fp3232_end (xcb_input_fp3232_iterator_t i); int -xcb_input_get_extension_version_sizeof (const void *_buffer /**< */); +xcb_input_get_extension_version_sizeof (const void *_buffer); /** * @@ -3886,9 +4227,9 @@ xcb_input_get_extension_version_sizeof (const void *_buffer /**< */); * */ xcb_input_get_extension_version_cookie_t -xcb_input_get_extension_version (xcb_connection_t *c /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_input_get_extension_version (xcb_connection_t *c, + uint16_t name_len, + const char *name); /** * @@ -3902,9 +4243,9 @@ xcb_input_get_extension_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_get_extension_version_cookie_t -xcb_input_get_extension_version_unchecked (xcb_connection_t *c /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_input_get_extension_version_unchecked (xcb_connection_t *c, + uint16_t name_len, + const char *name); /** * Return the reply @@ -3921,9 +4262,9 @@ xcb_input_get_extension_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_get_extension_version_reply_t * -xcb_input_get_extension_version_reply (xcb_connection_t *c /**< */, +xcb_input_get_extension_version_reply (xcb_connection_t *c, xcb_input_get_extension_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Get the next element of the iterator @@ -3934,7 +4275,7 @@ xcb_input_get_extension_version_reply (xcb_connection_t * element. The member index is increased by sizeof(xcb_input_device_info_t) */ void -xcb_input_device_info_next (xcb_input_device_info_iterator_t *i /**< */); +xcb_input_device_info_next (xcb_input_device_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3946,7 +4287,7 @@ xcb_input_device_info_next (xcb_input_device_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_device_info_end (xcb_input_device_info_iterator_t i /**< */); +xcb_input_device_info_end (xcb_input_device_info_iterator_t i); /** * Get the next element of the iterator @@ -3957,7 +4298,7 @@ xcb_input_device_info_end (xcb_input_device_info_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_key_info_t) */ void -xcb_input_key_info_next (xcb_input_key_info_iterator_t *i /**< */); +xcb_input_key_info_next (xcb_input_key_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3969,7 +4310,7 @@ xcb_input_key_info_next (xcb_input_key_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_key_info_end (xcb_input_key_info_iterator_t i /**< */); +xcb_input_key_info_end (xcb_input_key_info_iterator_t i); /** * Get the next element of the iterator @@ -3980,7 +4321,7 @@ xcb_input_key_info_end (xcb_input_key_info_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_button_info_t) */ void -xcb_input_button_info_next (xcb_input_button_info_iterator_t *i /**< */); +xcb_input_button_info_next (xcb_input_button_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3992,7 +4333,7 @@ xcb_input_button_info_next (xcb_input_button_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_button_info_end (xcb_input_button_info_iterator_t i /**< */); +xcb_input_button_info_end (xcb_input_button_info_iterator_t i); /** * Get the next element of the iterator @@ -4003,7 +4344,7 @@ xcb_input_button_info_end (xcb_input_button_info_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_axis_info_t) */ void -xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i /**< */); +xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4015,19 +4356,19 @@ xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_axis_info_end (xcb_input_axis_info_iterator_t i /**< */); +xcb_input_axis_info_end (xcb_input_axis_info_iterator_t i); int -xcb_input_valuator_info_sizeof (const void *_buffer /**< */); +xcb_input_valuator_info_sizeof (const void *_buffer); xcb_input_axis_info_t * -xcb_input_valuator_info_axes (const xcb_input_valuator_info_t *R /**< */); +xcb_input_valuator_info_axes (const xcb_input_valuator_info_t *R); int -xcb_input_valuator_info_axes_length (const xcb_input_valuator_info_t *R /**< */); +xcb_input_valuator_info_axes_length (const xcb_input_valuator_info_t *R); xcb_input_axis_info_iterator_t -xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R /**< */); +xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R); /** * Get the next element of the iterator @@ -4038,7 +4379,7 @@ xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R /**< * element. The member index is increased by sizeof(xcb_input_valuator_info_t) */ void -xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i /**< */); +xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4050,7 +4391,35 @@ xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i /**< */); +xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i); + +xcb_input_axis_info_t * +xcb_input_input_info_info_valuator_axes (const xcb_input_input_info_info_t *S); + +int +xcb_input_input_info_info_valuator_axes_length (const xcb_input_input_info_t *R, + const xcb_input_input_info_info_t *S); + +xcb_input_axis_info_iterator_t +xcb_input_input_info_info_valuator_axes_iterator (const xcb_input_input_info_t *R, + const xcb_input_input_info_info_t *S); + +int +xcb_input_input_info_info_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_input_info_info_t *_aux); + +int +xcb_input_input_info_info_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_input_info_info_t *_aux); + +int +xcb_input_input_info_info_sizeof (const void *_buffer, + uint8_t class_id); + +int +xcb_input_input_info_sizeof (const void *_buffer); /** * Get the next element of the iterator @@ -4061,7 +4430,7 @@ xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_input_info_t) */ void -xcb_input_input_info_next (xcb_input_input_info_iterator_t *i /**< */); +xcb_input_input_info_next (xcb_input_input_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4073,19 +4442,19 @@ xcb_input_input_info_next (xcb_input_input_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_input_info_end (xcb_input_input_info_iterator_t i /**< */); +xcb_input_input_info_end (xcb_input_input_info_iterator_t i); int -xcb_input_device_name_sizeof (const void *_buffer /**< */); +xcb_input_device_name_sizeof (const void *_buffer); char * -xcb_input_device_name_string (const xcb_input_device_name_t *R /**< */); +xcb_input_device_name_string (const xcb_input_device_name_t *R); int -xcb_input_device_name_string_length (const xcb_input_device_name_t *R /**< */); +xcb_input_device_name_string_length (const xcb_input_device_name_t *R); xcb_generic_iterator_t -xcb_input_device_name_string_end (const xcb_input_device_name_t *R /**< */); +xcb_input_device_name_string_end (const xcb_input_device_name_t *R); /** * Get the next element of the iterator @@ -4096,7 +4465,7 @@ xcb_input_device_name_string_end (const xcb_input_device_name_t *R /**< */); * element. The member index is increased by sizeof(xcb_input_device_name_t) */ void -xcb_input_device_name_next (xcb_input_device_name_iterator_t *i /**< */); +xcb_input_device_name_next (xcb_input_device_name_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4108,10 +4477,10 @@ xcb_input_device_name_next (xcb_input_device_name_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_device_name_end (xcb_input_device_name_iterator_t i /**< */); +xcb_input_device_name_end (xcb_input_device_name_iterator_t i); int -xcb_input_list_input_devices_sizeof (const void *_buffer /**< */); +xcb_input_list_input_devices_sizeof (const void *_buffer); /** * @@ -4122,7 +4491,7 @@ xcb_input_list_input_devices_sizeof (const void *_buffer /**< */); * */ xcb_input_list_input_devices_cookie_t -xcb_input_list_input_devices (xcb_connection_t *c /**< */); +xcb_input_list_input_devices (xcb_connection_t *c); /** * @@ -4136,16 +4505,28 @@ xcb_input_list_input_devices (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_input_list_input_devices_cookie_t -xcb_input_list_input_devices_unchecked (xcb_connection_t *c /**< */); +xcb_input_list_input_devices_unchecked (xcb_connection_t *c); xcb_input_device_info_t * -xcb_input_list_input_devices_devices (const xcb_input_list_input_devices_reply_t *R /**< */); +xcb_input_list_input_devices_devices (const xcb_input_list_input_devices_reply_t *R); int -xcb_input_list_input_devices_devices_length (const xcb_input_list_input_devices_reply_t *R /**< */); +xcb_input_list_input_devices_devices_length (const xcb_input_list_input_devices_reply_t *R); xcb_input_device_info_iterator_t -xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_devices_reply_t *R /**< */); +xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_devices_reply_t *R); + +int +xcb_input_list_input_devices_infos_length (const xcb_input_list_input_devices_reply_t *R); + +xcb_input_input_info_iterator_t +xcb_input_list_input_devices_infos_iterator (const xcb_input_list_input_devices_reply_t *R); + +int +xcb_input_list_input_devices_names_length (const xcb_input_list_input_devices_reply_t *R); + +xcb_str_iterator_t +xcb_input_list_input_devices_names_iterator (const xcb_input_list_input_devices_reply_t *R); /** * Return the reply @@ -4162,9 +4543,9 @@ xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_device * The returned value must be freed by the caller using free(). */ xcb_input_list_input_devices_reply_t * -xcb_input_list_input_devices_reply (xcb_connection_t *c /**< */, +xcb_input_list_input_devices_reply (xcb_connection_t *c, xcb_input_list_input_devices_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Get the next element of the iterator @@ -4175,7 +4556,7 @@ xcb_input_list_input_devices_reply (xcb_connection_t *c / * element. The member index is increased by sizeof(xcb_input_input_class_info_t) */ void -xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i /**< */); +xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4187,10 +4568,10 @@ xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i /**< * last element. */ xcb_generic_iterator_t -xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i /**< */); +xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i); int -xcb_input_open_device_sizeof (const void *_buffer /**< */); +xcb_input_open_device_sizeof (const void *_buffer); /** * @@ -4201,8 +4582,8 @@ xcb_input_open_device_sizeof (const void *_buffer /**< */); * */ xcb_input_open_device_cookie_t -xcb_input_open_device (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_open_device (xcb_connection_t *c, + uint8_t device_id); /** * @@ -4216,17 +4597,17 @@ xcb_input_open_device (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_open_device_cookie_t -xcb_input_open_device_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_open_device_unchecked (xcb_connection_t *c, + uint8_t device_id); xcb_input_input_class_info_t * -xcb_input_open_device_class_info (const xcb_input_open_device_reply_t *R /**< */); +xcb_input_open_device_class_info (const xcb_input_open_device_reply_t *R); int -xcb_input_open_device_class_info_length (const xcb_input_open_device_reply_t *R /**< */); +xcb_input_open_device_class_info_length (const xcb_input_open_device_reply_t *R); xcb_input_input_class_info_iterator_t -xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t *R /**< */); +xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t *R); /** * Return the reply @@ -4243,9 +4624,9 @@ xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t * * The returned value must be freed by the caller using free(). */ xcb_input_open_device_reply_t * -xcb_input_open_device_reply (xcb_connection_t *c /**< */, +xcb_input_open_device_reply (xcb_connection_t *c, xcb_input_open_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -4259,8 +4640,8 @@ xcb_input_open_device_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_close_device_checked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_close_device_checked (xcb_connection_t *c, + uint8_t device_id); /** * @@ -4271,8 +4652,8 @@ xcb_input_close_device_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_close_device (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_close_device (xcb_connection_t *c, + uint8_t device_id); /** * @@ -4283,9 +4664,9 @@ xcb_input_close_device (xcb_connection_t *c /**< */, * */ xcb_input_set_device_mode_cookie_t -xcb_input_set_device_mode (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t mode /**< */); +xcb_input_set_device_mode (xcb_connection_t *c, + uint8_t device_id, + uint8_t mode); /** * @@ -4299,9 +4680,9 @@ xcb_input_set_device_mode (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_set_device_mode_cookie_t -xcb_input_set_device_mode_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t mode /**< */); +xcb_input_set_device_mode_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t mode); /** * Return the reply @@ -4318,12 +4699,12 @@ xcb_input_set_device_mode_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_set_device_mode_reply_t * -xcb_input_set_device_mode_reply (xcb_connection_t *c /**< */, +xcb_input_set_device_mode_reply (xcb_connection_t *c, xcb_input_set_device_mode_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_select_extension_event_sizeof (const void *_buffer /**< */); +xcb_input_select_extension_event_sizeof (const void *_buffer); /** * @@ -4337,10 +4718,10 @@ xcb_input_select_extension_event_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_select_extension_event_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_classes /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_select_extension_event_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + const xcb_input_event_class_t *classes); /** * @@ -4351,13 +4732,22 @@ xcb_input_select_extension_event_checked (xcb_connection_t *c /**< * */ xcb_void_cookie_t -xcb_input_select_extension_event (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_classes /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_select_extension_event (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + const xcb_input_event_class_t *classes); + +xcb_input_event_class_t * +xcb_input_select_extension_event_classes (const xcb_input_select_extension_event_request_t *R); int -xcb_input_get_selected_extension_events_sizeof (const void *_buffer /**< */); +xcb_input_select_extension_event_classes_length (const xcb_input_select_extension_event_request_t *R); + +xcb_generic_iterator_t +xcb_input_select_extension_event_classes_end (const xcb_input_select_extension_event_request_t *R); + +int +xcb_input_get_selected_extension_events_sizeof (const void *_buffer); /** * @@ -4368,8 +4758,8 @@ xcb_input_get_selected_extension_events_sizeof (const void *_buffer /**< */); * */ xcb_input_get_selected_extension_events_cookie_t -xcb_input_get_selected_extension_events (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_input_get_selected_extension_events (xcb_connection_t *c, + xcb_window_t window); /** * @@ -4383,26 +4773,26 @@ xcb_input_get_selected_extension_events (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_get_selected_extension_events_cookie_t -xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c, + xcb_window_t window); xcb_input_event_class_t * -xcb_input_get_selected_extension_events_this_classes (const xcb_input_get_selected_extension_events_reply_t *R /**< */); +xcb_input_get_selected_extension_events_this_classes (const xcb_input_get_selected_extension_events_reply_t *R); int -xcb_input_get_selected_extension_events_this_classes_length (const xcb_input_get_selected_extension_events_reply_t *R /**< */); +xcb_input_get_selected_extension_events_this_classes_length (const xcb_input_get_selected_extension_events_reply_t *R); xcb_generic_iterator_t -xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_selected_extension_events_reply_t *R /**< */); +xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_selected_extension_events_reply_t *R); xcb_input_event_class_t * -xcb_input_get_selected_extension_events_all_classes (const xcb_input_get_selected_extension_events_reply_t *R /**< */); +xcb_input_get_selected_extension_events_all_classes (const xcb_input_get_selected_extension_events_reply_t *R); int -xcb_input_get_selected_extension_events_all_classes_length (const xcb_input_get_selected_extension_events_reply_t *R /**< */); +xcb_input_get_selected_extension_events_all_classes_length (const xcb_input_get_selected_extension_events_reply_t *R); xcb_generic_iterator_t -xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_selected_extension_events_reply_t *R /**< */); +xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_selected_extension_events_reply_t *R); /** * Return the reply @@ -4419,12 +4809,12 @@ xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_sel * The returned value must be freed by the caller using free(). */ xcb_input_get_selected_extension_events_reply_t * -xcb_input_get_selected_extension_events_reply (xcb_connection_t *c /**< */, +xcb_input_get_selected_extension_events_reply (xcb_connection_t *c, xcb_input_get_selected_extension_events_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_change_device_dont_propagate_list_sizeof (const void *_buffer /**< */); +xcb_input_change_device_dont_propagate_list_sizeof (const void *_buffer); /** * @@ -4438,11 +4828,11 @@ xcb_input_change_device_dont_propagate_list_sizeof (const void *_buffer /**< * * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_classes /**< */, - uint8_t mode /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + uint8_t mode, + const xcb_input_event_class_t *classes); /** * @@ -4453,14 +4843,23 @@ xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t * */ xcb_void_cookie_t -xcb_input_change_device_dont_propagate_list (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_classes /**< */, - uint8_t mode /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_change_device_dont_propagate_list (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_classes, + uint8_t mode, + const xcb_input_event_class_t *classes); + +xcb_input_event_class_t * +xcb_input_change_device_dont_propagate_list_classes (const xcb_input_change_device_dont_propagate_list_request_t *R); int -xcb_input_get_device_dont_propagate_list_sizeof (const void *_buffer /**< */); +xcb_input_change_device_dont_propagate_list_classes_length (const xcb_input_change_device_dont_propagate_list_request_t *R); + +xcb_generic_iterator_t +xcb_input_change_device_dont_propagate_list_classes_end (const xcb_input_change_device_dont_propagate_list_request_t *R); + +int +xcb_input_get_device_dont_propagate_list_sizeof (const void *_buffer); /** * @@ -4471,8 +4870,8 @@ xcb_input_get_device_dont_propagate_list_sizeof (const void *_buffer /**< */); * */ xcb_input_get_device_dont_propagate_list_cookie_t -xcb_input_get_device_dont_propagate_list (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_input_get_device_dont_propagate_list (xcb_connection_t *c, + xcb_window_t window); /** * @@ -4486,17 +4885,17 @@ xcb_input_get_device_dont_propagate_list (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_get_device_dont_propagate_list_cookie_t -xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c, + xcb_window_t window); xcb_input_event_class_t * -xcb_input_get_device_dont_propagate_list_classes (const xcb_input_get_device_dont_propagate_list_reply_t *R /**< */); +xcb_input_get_device_dont_propagate_list_classes (const xcb_input_get_device_dont_propagate_list_reply_t *R); int -xcb_input_get_device_dont_propagate_list_classes_length (const xcb_input_get_device_dont_propagate_list_reply_t *R /**< */); +xcb_input_get_device_dont_propagate_list_classes_length (const xcb_input_get_device_dont_propagate_list_reply_t *R); xcb_generic_iterator_t -xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device_dont_propagate_list_reply_t *R /**< */); +xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device_dont_propagate_list_reply_t *R); /** * Return the reply @@ -4513,9 +4912,24 @@ xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device * 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_reply (xcb_connection_t *c, xcb_input_get_device_dont_propagate_list_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + 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 @@ -4526,7 +4940,7 @@ xcb_input_get_device_dont_propagate_list_reply (xcb_connection_t * element. The member index is increased by sizeof(xcb_input_device_time_coord_t) */ void -xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i /**< */); +xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4538,7 +4952,10 @@ xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i /** * last element. */ xcb_generic_iterator_t -xcb_input_device_time_coord_end (xcb_input_device_time_coord_iterator_t i /**< */); +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); /** * @@ -4549,10 +4966,10 @@ xcb_input_device_time_coord_end (xcb_input_device_time_coord_iterator_t i /**< * */ 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 /**< */); +xcb_input_get_device_motion_events (xcb_connection_t *c, + xcb_timestamp_t start, + xcb_timestamp_t stop, + uint8_t device_id); /** * @@ -4566,10 +4983,16 @@ xcb_input_get_device_motion_events (xcb_connection_t *c /**< */, * placed in the event queue. */ 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 /**< */); +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 @@ -4586,9 +5009,9 @@ xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ 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_reply (xcb_connection_t *c, xcb_input_get_device_motion_events_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -4599,8 +5022,8 @@ xcb_input_get_device_motion_events_reply (xcb_connection_t * */ xcb_input_change_keyboard_device_cookie_t -xcb_input_change_keyboard_device (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_change_keyboard_device (xcb_connection_t *c, + uint8_t device_id); /** * @@ -4614,8 +5037,8 @@ xcb_input_change_keyboard_device (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_change_keyboard_device_cookie_t -xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c, + uint8_t device_id); /** * Return the reply @@ -4632,9 +5055,9 @@ xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_change_keyboard_device_reply_t * -xcb_input_change_keyboard_device_reply (xcb_connection_t *c /**< */, +xcb_input_change_keyboard_device_reply (xcb_connection_t *c, xcb_input_change_keyboard_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -4645,10 +5068,10 @@ xcb_input_change_keyboard_device_reply (xcb_connection_t * */ xcb_input_change_pointer_device_cookie_t -xcb_input_change_pointer_device (xcb_connection_t *c /**< */, - uint8_t x_axis /**< */, - uint8_t y_axis /**< */, - uint8_t device_id /**< */); +xcb_input_change_pointer_device (xcb_connection_t *c, + uint8_t x_axis, + uint8_t y_axis, + uint8_t device_id); /** * @@ -4662,10 +5085,10 @@ xcb_input_change_pointer_device (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_change_pointer_device_cookie_t -xcb_input_change_pointer_device_unchecked (xcb_connection_t *c /**< */, - uint8_t x_axis /**< */, - uint8_t y_axis /**< */, - uint8_t device_id /**< */); +xcb_input_change_pointer_device_unchecked (xcb_connection_t *c, + uint8_t x_axis, + uint8_t y_axis, + uint8_t device_id); /** * Return the reply @@ -4682,12 +5105,12 @@ xcb_input_change_pointer_device_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_change_pointer_device_reply_t * -xcb_input_change_pointer_device_reply (xcb_connection_t *c /**< */, +xcb_input_change_pointer_device_reply (xcb_connection_t *c, xcb_input_change_pointer_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_grab_device_sizeof (const void *_buffer /**< */); +xcb_input_grab_device_sizeof (const void *_buffer); /** * @@ -4698,15 +5121,15 @@ xcb_input_grab_device_sizeof (const void *_buffer /**< */); * */ xcb_input_grab_device_cookie_t -xcb_input_grab_device (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - xcb_timestamp_t time /**< */, - uint16_t num_classes /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t owner_events /**< */, - uint8_t device_id /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_grab_device (xcb_connection_t *c, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint16_t num_classes, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + uint8_t device_id, + const xcb_input_event_class_t *classes); /** * @@ -4720,15 +5143,15 @@ xcb_input_grab_device (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_grab_device_cookie_t -xcb_input_grab_device_unchecked (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - xcb_timestamp_t time /**< */, - uint16_t num_classes /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t owner_events /**< */, - uint8_t device_id /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_grab_device_unchecked (xcb_connection_t *c, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint16_t num_classes, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + uint8_t device_id, + const xcb_input_event_class_t *classes); /** * Return the reply @@ -4745,9 +5168,9 @@ xcb_input_grab_device_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_grab_device_reply_t * -xcb_input_grab_device_reply (xcb_connection_t *c /**< */, +xcb_input_grab_device_reply (xcb_connection_t *c, xcb_input_grab_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -4761,9 +5184,9 @@ xcb_input_grab_device_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_ungrab_device_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - uint8_t device_id /**< */); +xcb_input_ungrab_device_checked (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t device_id); /** * @@ -4774,12 +5197,12 @@ xcb_input_ungrab_device_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_ungrab_device (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - uint8_t device_id /**< */); +xcb_input_ungrab_device (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t device_id); int -xcb_input_grab_device_key_sizeof (const void *_buffer /**< */); +xcb_input_grab_device_key_sizeof (const void *_buffer); /** * @@ -4793,17 +5216,17 @@ xcb_input_grab_device_key_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_grab_device_key_checked (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint16_t num_classes /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t grabbed_device /**< */, - uint8_t key /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t owner_events /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_grab_device_key_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t num_classes, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t grabbed_device, + uint8_t key, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + const xcb_input_event_class_t *classes); /** * @@ -4814,55 +5237,26 @@ xcb_input_grab_device_key_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_grab_device_key (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint16_t num_classes /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t grabbed_device /**< */, - uint8_t key /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t owner_events /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_grab_device_key (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t num_classes, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t grabbed_device, + uint8_t key, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t owner_events, + const xcb_input_event_class_t *classes); -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_input_ungrab_device_key_checked (xcb_connection_t *c /**< */, - xcb_window_t grabWindow /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t key /**< */, - uint8_t grabbed_device /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_input_ungrab_device_key (xcb_connection_t *c /**< */, - xcb_window_t grabWindow /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t key /**< */, - uint8_t grabbed_device /**< */); +xcb_input_event_class_t * +xcb_input_grab_device_key_classes (const xcb_input_grab_device_key_request_t *R); int -xcb_input_grab_device_button_sizeof (const void *_buffer /**< */); +xcb_input_grab_device_key_classes_length (const xcb_input_grab_device_key_request_t *R); + +xcb_generic_iterator_t +xcb_input_grab_device_key_classes_end (const xcb_input_grab_device_key_request_t *R); /** * @@ -4876,17 +5270,12 @@ xcb_input_grab_device_button_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_grab_device_button_checked (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint8_t grabbed_device /**< */, - uint8_t modifier_device /**< */, - uint16_t num_classes /**< */, - uint16_t modifiers /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t button /**< */, - uint8_t owner_events /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_ungrab_device_key_checked (xcb_connection_t *c, + xcb_window_t grabWindow, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t key, + uint8_t grabbed_device); /** * @@ -4897,17 +5286,15 @@ xcb_input_grab_device_button_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_grab_device_button (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint8_t grabbed_device /**< */, - uint8_t modifier_device /**< */, - uint16_t num_classes /**< */, - uint16_t modifiers /**< */, - uint8_t this_device_mode /**< */, - uint8_t other_device_mode /**< */, - uint8_t button /**< */, - uint8_t owner_events /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_ungrab_device_key (xcb_connection_t *c, + xcb_window_t grabWindow, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t key, + uint8_t grabbed_device); + +int +xcb_input_grab_device_button_sizeof (const void *_buffer); /** * @@ -4921,12 +5308,17 @@ xcb_input_grab_device_button (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_ungrab_device_button_checked (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t button /**< */, - uint8_t grabbed_device /**< */); +xcb_input_grab_device_button_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint8_t grabbed_device, + uint8_t modifier_device, + uint16_t num_classes, + uint16_t modifiers, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t button, + uint8_t owner_events, + const xcb_input_event_class_t *classes); /** * @@ -4937,12 +5329,26 @@ xcb_input_ungrab_device_button_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_ungrab_device_button (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */, - uint8_t modifier_device /**< */, - uint8_t button /**< */, - uint8_t grabbed_device /**< */); +xcb_input_grab_device_button (xcb_connection_t *c, + xcb_window_t grab_window, + uint8_t grabbed_device, + uint8_t modifier_device, + uint16_t num_classes, + uint16_t modifiers, + uint8_t this_device_mode, + uint8_t other_device_mode, + uint8_t button, + uint8_t owner_events, + const xcb_input_event_class_t *classes); + +xcb_input_event_class_t * +xcb_input_grab_device_button_classes (const xcb_input_grab_device_button_request_t *R); + +int +xcb_input_grab_device_button_classes_length (const xcb_input_grab_device_button_request_t *R); + +xcb_generic_iterator_t +xcb_input_grab_device_button_classes_end (const xcb_input_grab_device_button_request_t *R); /** * @@ -4956,10 +5362,12 @@ xcb_input_ungrab_device_button (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_allow_device_events_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - uint8_t mode /**< */, - uint8_t device_id /**< */); +xcb_input_ungrab_device_button_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t button, + uint8_t grabbed_device); /** * @@ -4970,10 +5378,43 @@ xcb_input_allow_device_events_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_allow_device_events (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - uint8_t mode /**< */, - uint8_t device_id /**< */); +xcb_input_ungrab_device_button (xcb_connection_t *c, + xcb_window_t grab_window, + uint16_t modifiers, + uint8_t modifier_device, + uint8_t button, + uint8_t grabbed_device); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_input_allow_device_events_checked (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t mode, + uint8_t device_id); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_input_allow_device_events (xcb_connection_t *c, + xcb_timestamp_t time, + uint8_t mode, + uint8_t device_id); /** * @@ -4984,8 +5425,8 @@ xcb_input_allow_device_events (xcb_connection_t *c /**< */, * */ xcb_input_get_device_focus_cookie_t -xcb_input_get_device_focus (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_get_device_focus (xcb_connection_t *c, + uint8_t device_id); /** * @@ -4999,8 +5440,8 @@ xcb_input_get_device_focus (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_get_device_focus_cookie_t -xcb_input_get_device_focus_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_get_device_focus_unchecked (xcb_connection_t *c, + uint8_t device_id); /** * Return the reply @@ -5017,9 +5458,9 @@ xcb_input_get_device_focus_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_get_device_focus_reply_t * -xcb_input_get_device_focus_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_focus_reply (xcb_connection_t *c, xcb_input_get_device_focus_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -5033,11 +5474,11 @@ xcb_input_get_device_focus_reply (xcb_connection_t *c /**< * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_set_device_focus_checked (xcb_connection_t *c /**< */, - xcb_window_t focus /**< */, - xcb_timestamp_t time /**< */, - uint8_t revert_to /**< */, - uint8_t device_id /**< */); +xcb_input_set_device_focus_checked (xcb_connection_t *c, + xcb_window_t focus, + xcb_timestamp_t time, + uint8_t revert_to, + uint8_t device_id); /** * @@ -5048,11 +5489,11 @@ xcb_input_set_device_focus_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_set_device_focus (xcb_connection_t *c /**< */, - xcb_window_t focus /**< */, - xcb_timestamp_t time /**< */, - uint8_t revert_to /**< */, - uint8_t device_id /**< */); +xcb_input_set_device_focus (xcb_connection_t *c, + xcb_window_t focus, + xcb_timestamp_t time, + uint8_t revert_to, + uint8_t device_id); /** * Get the next element of the iterator @@ -5063,7 +5504,7 @@ xcb_input_set_device_focus (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_input_kbd_feedback_state_t) */ void -xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i /**< */); +xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5075,7 +5516,7 @@ xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i / * last element. */ xcb_generic_iterator_t -xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i /**< */); +xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i); /** * Get the next element of the iterator @@ -5086,7 +5527,7 @@ xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i /** * element. The member index is increased by sizeof(xcb_input_ptr_feedback_state_t) */ void -xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i /**< */); +xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5098,7 +5539,7 @@ xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i / * last element. */ xcb_generic_iterator_t -xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i /**< */); +xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i); /** * Get the next element of the iterator @@ -5109,7 +5550,7 @@ xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i /** * element. The member index is increased by sizeof(xcb_input_integer_feedback_state_t) */ void -xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator_t *i /**< */); +xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5121,19 +5562,19 @@ xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator * last element. */ xcb_generic_iterator_t -xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_t i /**< */); +xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_t i); int -xcb_input_string_feedback_state_sizeof (const void *_buffer /**< */); +xcb_input_string_feedback_state_sizeof (const void *_buffer); xcb_keysym_t * -xcb_input_string_feedback_state_keysyms (const xcb_input_string_feedback_state_t *R /**< */); +xcb_input_string_feedback_state_keysyms (const xcb_input_string_feedback_state_t *R); int -xcb_input_string_feedback_state_keysyms_length (const xcb_input_string_feedback_state_t *R /**< */); +xcb_input_string_feedback_state_keysyms_length (const xcb_input_string_feedback_state_t *R); xcb_generic_iterator_t -xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_state_t *R /**< */); +xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_state_t *R); /** * Get the next element of the iterator @@ -5144,7 +5585,7 @@ xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_sta * element. The member index is increased by sizeof(xcb_input_string_feedback_state_t) */ void -xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t *i /**< */); +xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5156,7 +5597,7 @@ xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t * last element. */ xcb_generic_iterator_t -xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t i /**< */); +xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t i); /** * Get the next element of the iterator @@ -5167,7 +5608,7 @@ xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t * element. The member index is increased by sizeof(xcb_input_bell_feedback_state_t) */ void -xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i /**< */); +xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5179,7 +5620,7 @@ xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i * last element. */ xcb_generic_iterator_t -xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i /**< */); +xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i); /** * Get the next element of the iterator @@ -5190,7 +5631,7 @@ xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i / * element. The member index is increased by sizeof(xcb_input_led_feedback_state_t) */ void -xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i /**< */); +xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5202,19 +5643,35 @@ xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i / * last element. */ xcb_generic_iterator_t -xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i /**< */); +xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i); + +xcb_keysym_t * +xcb_input_feedback_state_data_string_keysyms (const xcb_input_feedback_state_data_t *S); int -xcb_input_feedback_state_sizeof (const void *_buffer /**< */); - -uint8_t * -xcb_input_feedback_state_uninterpreted_data (const xcb_input_feedback_state_t *R /**< */); - -int -xcb_input_feedback_state_uninterpreted_data_length (const xcb_input_feedback_state_t *R /**< */); +xcb_input_feedback_state_data_string_keysyms_length (const xcb_input_feedback_state_t *R, + const xcb_input_feedback_state_data_t *S); xcb_generic_iterator_t -xcb_input_feedback_state_uninterpreted_data_end (const xcb_input_feedback_state_t *R /**< */); +xcb_input_feedback_state_data_string_keysyms_end (const xcb_input_feedback_state_t *R, + const xcb_input_feedback_state_data_t *S); + +int +xcb_input_feedback_state_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_feedback_state_data_t *_aux); + +int +xcb_input_feedback_state_data_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_feedback_state_data_t *_aux); + +int +xcb_input_feedback_state_data_sizeof (const void *_buffer, + uint8_t class_id); + +int +xcb_input_feedback_state_sizeof (const void *_buffer); /** * Get the next element of the iterator @@ -5225,7 +5682,7 @@ xcb_input_feedback_state_uninterpreted_data_end (const xcb_input_feedback_state_ * element. The member index is increased by sizeof(xcb_input_feedback_state_t) */ void -xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i /**< */); +xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5237,10 +5694,10 @@ xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i /**< */); +xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i); int -xcb_input_get_feedback_control_sizeof (const void *_buffer /**< */); +xcb_input_get_feedback_control_sizeof (const void *_buffer); /** * @@ -5251,8 +5708,8 @@ xcb_input_get_feedback_control_sizeof (const void *_buffer /**< */); * */ xcb_input_get_feedback_control_cookie_t -xcb_input_get_feedback_control (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_get_feedback_control (xcb_connection_t *c, + uint8_t device_id); /** * @@ -5266,14 +5723,14 @@ xcb_input_get_feedback_control (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_get_feedback_control_cookie_t -xcb_input_get_feedback_control_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_get_feedback_control_unchecked (xcb_connection_t *c, + uint8_t device_id); int -xcb_input_get_feedback_control_feedbacks_length (const xcb_input_get_feedback_control_reply_t *R /**< */); +xcb_input_get_feedback_control_feedbacks_length (const xcb_input_get_feedback_control_reply_t *R); xcb_input_feedback_state_iterator_t -xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_control_reply_t *R /**< */); +xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_control_reply_t *R); /** * Return the reply @@ -5290,9 +5747,9 @@ xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_ * The returned value must be freed by the caller using free(). */ xcb_input_get_feedback_control_reply_t * -xcb_input_get_feedback_control_reply (xcb_connection_t *c /**< */, +xcb_input_get_feedback_control_reply (xcb_connection_t *c, xcb_input_get_feedback_control_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Get the next element of the iterator @@ -5303,7 +5760,7 @@ xcb_input_get_feedback_control_reply (xcb_connection_t * * element. The member index is increased by sizeof(xcb_input_kbd_feedback_ctl_t) */ void -xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i /**< */); +xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5315,7 +5772,7 @@ xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i /**< * last element. */ xcb_generic_iterator_t -xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i /**< */); +xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i); /** * Get the next element of the iterator @@ -5326,7 +5783,7 @@ xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i /**< */ * element. The member index is increased by sizeof(xcb_input_ptr_feedback_ctl_t) */ void -xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i /**< */); +xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5338,7 +5795,7 @@ xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i /**< * last element. */ xcb_generic_iterator_t -xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i /**< */); +xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i); /** * Get the next element of the iterator @@ -5349,7 +5806,7 @@ xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i /**< */ * element. The member index is increased by sizeof(xcb_input_integer_feedback_ctl_t) */ void -xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t *i /**< */); +xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5361,19 +5818,19 @@ xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t * * last element. */ xcb_generic_iterator_t -xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i /**< */); +xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i); int -xcb_input_string_feedback_ctl_sizeof (const void *_buffer /**< */); +xcb_input_string_feedback_ctl_sizeof (const void *_buffer); xcb_keysym_t * -xcb_input_string_feedback_ctl_keysyms (const xcb_input_string_feedback_ctl_t *R /**< */); +xcb_input_string_feedback_ctl_keysyms (const xcb_input_string_feedback_ctl_t *R); int -xcb_input_string_feedback_ctl_keysyms_length (const xcb_input_string_feedback_ctl_t *R /**< */); +xcb_input_string_feedback_ctl_keysyms_length (const xcb_input_string_feedback_ctl_t *R); xcb_generic_iterator_t -xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t *R /**< */); +xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t *R); /** * Get the next element of the iterator @@ -5384,7 +5841,7 @@ xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t * element. The member index is increased by sizeof(xcb_input_string_feedback_ctl_t) */ void -xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i /**< */); +xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5396,7 +5853,7 @@ xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i * last element. */ xcb_generic_iterator_t -xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i /**< */); +xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i); /** * Get the next element of the iterator @@ -5407,7 +5864,7 @@ xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i / * element. The member index is increased by sizeof(xcb_input_bell_feedback_ctl_t) */ void -xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i /**< */); +xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5419,7 +5876,7 @@ xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i /** * last element. */ xcb_generic_iterator_t -xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i /**< */); +xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i); /** * Get the next element of the iterator @@ -5430,7 +5887,7 @@ xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i /**< * element. The member index is increased by sizeof(xcb_input_led_feedback_ctl_t) */ void -xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i /**< */); +xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5442,19 +5899,35 @@ xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i /**< * last element. */ xcb_generic_iterator_t -xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i /**< */); +xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i); + +xcb_keysym_t * +xcb_input_feedback_ctl_data_string_keysyms (const xcb_input_feedback_ctl_data_t *S); int -xcb_input_feedback_ctl_sizeof (const void *_buffer /**< */); - -uint8_t * -xcb_input_feedback_ctl_uninterpreted_data (const xcb_input_feedback_ctl_t *R /**< */); - -int -xcb_input_feedback_ctl_uninterpreted_data_length (const xcb_input_feedback_ctl_t *R /**< */); +xcb_input_feedback_ctl_data_string_keysyms_length (const xcb_input_feedback_ctl_t *R, + const xcb_input_feedback_ctl_data_t *S); xcb_generic_iterator_t -xcb_input_feedback_ctl_uninterpreted_data_end (const xcb_input_feedback_ctl_t *R /**< */); +xcb_input_feedback_ctl_data_string_keysyms_end (const xcb_input_feedback_ctl_t *R, + const xcb_input_feedback_ctl_data_t *S); + +int +xcb_input_feedback_ctl_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_feedback_ctl_data_t *_aux); + +int +xcb_input_feedback_ctl_data_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_feedback_ctl_data_t *_aux); + +int +xcb_input_feedback_ctl_data_sizeof (const void *_buffer, + uint8_t class_id); + +int +xcb_input_feedback_ctl_sizeof (const void *_buffer); /** * Get the next element of the iterator @@ -5465,7 +5938,7 @@ xcb_input_feedback_ctl_uninterpreted_data_end (const xcb_input_feedback_ctl_t *R * element. The member index is increased by sizeof(xcb_input_feedback_ctl_t) */ void -xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i /**< */); +xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5477,10 +5950,10 @@ xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i /**< */); +xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i); int -xcb_input_change_feedback_control_sizeof (const void *_buffer /**< */); +xcb_input_change_feedback_control_sizeof (const void *_buffer); /** * @@ -5494,11 +5967,11 @@ xcb_input_change_feedback_control_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_change_feedback_control_checked (xcb_connection_t *c /**< */, - uint32_t mask /**< */, - uint8_t device_id /**< */, - uint8_t feedback_id /**< */, - xcb_input_feedback_ctl_t *feedback /**< */); +xcb_input_change_feedback_control_checked (xcb_connection_t *c, + uint32_t mask, + uint8_t device_id, + uint8_t feedback_id, + xcb_input_feedback_ctl_t *feedback); /** * @@ -5509,14 +5982,17 @@ xcb_input_change_feedback_control_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_change_feedback_control (xcb_connection_t *c /**< */, - uint32_t mask /**< */, - uint8_t device_id /**< */, - uint8_t feedback_id /**< */, - xcb_input_feedback_ctl_t *feedback /**< */); +xcb_input_change_feedback_control (xcb_connection_t *c, + uint32_t mask, + uint8_t device_id, + uint8_t feedback_id, + xcb_input_feedback_ctl_t *feedback); + +xcb_input_feedback_ctl_t * +xcb_input_change_feedback_control_feedback (const xcb_input_change_feedback_control_request_t *R); int -xcb_input_get_device_key_mapping_sizeof (const void *_buffer /**< */); +xcb_input_get_device_key_mapping_sizeof (const void *_buffer); /** * @@ -5527,10 +6003,10 @@ xcb_input_get_device_key_mapping_sizeof (const void *_buffer /**< */); * */ xcb_input_get_device_key_mapping_cookie_t -xcb_input_get_device_key_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - xcb_input_key_code_t first_keycode /**< */, - uint8_t count /**< */); +xcb_input_get_device_key_mapping (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t count); /** * @@ -5544,19 +6020,19 @@ xcb_input_get_device_key_mapping (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_get_device_key_mapping_cookie_t -xcb_input_get_device_key_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - xcb_input_key_code_t first_keycode /**< */, - uint8_t count /**< */); +xcb_input_get_device_key_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t count); xcb_keysym_t * -xcb_input_get_device_key_mapping_keysyms (const xcb_input_get_device_key_mapping_reply_t *R /**< */); +xcb_input_get_device_key_mapping_keysyms (const xcb_input_get_device_key_mapping_reply_t *R); int -xcb_input_get_device_key_mapping_keysyms_length (const xcb_input_get_device_key_mapping_reply_t *R /**< */); +xcb_input_get_device_key_mapping_keysyms_length (const xcb_input_get_device_key_mapping_reply_t *R); xcb_generic_iterator_t -xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_mapping_reply_t *R /**< */); +xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_mapping_reply_t *R); /** * Return the reply @@ -5573,12 +6049,12 @@ xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_map * The returned value must be freed by the caller using free(). */ xcb_input_get_device_key_mapping_reply_t * -xcb_input_get_device_key_mapping_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_key_mapping_reply (xcb_connection_t *c, xcb_input_get_device_key_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_change_device_key_mapping_sizeof (const void *_buffer /**< */); +xcb_input_change_device_key_mapping_sizeof (const void *_buffer); /** * @@ -5592,12 +6068,12 @@ xcb_input_change_device_key_mapping_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_change_device_key_mapping_checked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - xcb_input_key_code_t first_keycode /**< */, - uint8_t keysyms_per_keycode /**< */, - uint8_t keycode_count /**< */, - const xcb_keysym_t *keysyms /**< */); +xcb_input_change_device_key_mapping_checked (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t keysyms_per_keycode, + uint8_t keycode_count, + const xcb_keysym_t *keysyms); /** * @@ -5608,15 +6084,24 @@ xcb_input_change_device_key_mapping_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_change_device_key_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - xcb_input_key_code_t first_keycode /**< */, - uint8_t keysyms_per_keycode /**< */, - uint8_t keycode_count /**< */, - const xcb_keysym_t *keysyms /**< */); +xcb_input_change_device_key_mapping (xcb_connection_t *c, + uint8_t device_id, + xcb_input_key_code_t first_keycode, + uint8_t keysyms_per_keycode, + uint8_t keycode_count, + const xcb_keysym_t *keysyms); + +xcb_keysym_t * +xcb_input_change_device_key_mapping_keysyms (const xcb_input_change_device_key_mapping_request_t *R); int -xcb_input_get_device_modifier_mapping_sizeof (const void *_buffer /**< */); +xcb_input_change_device_key_mapping_keysyms_length (const xcb_input_change_device_key_mapping_request_t *R); + +xcb_generic_iterator_t +xcb_input_change_device_key_mapping_keysyms_end (const xcb_input_change_device_key_mapping_request_t *R); + +int +xcb_input_get_device_modifier_mapping_sizeof (const void *_buffer); /** * @@ -5627,8 +6112,8 @@ xcb_input_get_device_modifier_mapping_sizeof (const void *_buffer /**< */); * */ xcb_input_get_device_modifier_mapping_cookie_t -xcb_input_get_device_modifier_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_get_device_modifier_mapping (xcb_connection_t *c, + uint8_t device_id); /** * @@ -5642,17 +6127,17 @@ xcb_input_get_device_modifier_mapping (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_get_device_modifier_mapping_cookie_t -xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id); uint8_t * -xcb_input_get_device_modifier_mapping_keymaps (const xcb_input_get_device_modifier_mapping_reply_t *R /**< */); +xcb_input_get_device_modifier_mapping_keymaps (const xcb_input_get_device_modifier_mapping_reply_t *R); int -xcb_input_get_device_modifier_mapping_keymaps_length (const xcb_input_get_device_modifier_mapping_reply_t *R /**< */); +xcb_input_get_device_modifier_mapping_keymaps_length (const xcb_input_get_device_modifier_mapping_reply_t *R); xcb_generic_iterator_t -xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_modifier_mapping_reply_t *R /**< */); +xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_modifier_mapping_reply_t *R); /** * Return the reply @@ -5669,12 +6154,12 @@ xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_mo * The returned value must be freed by the caller using free(). */ xcb_input_get_device_modifier_mapping_reply_t * -xcb_input_get_device_modifier_mapping_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_modifier_mapping_reply (xcb_connection_t *c, xcb_input_get_device_modifier_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_set_device_modifier_mapping_sizeof (const void *_buffer /**< */); +xcb_input_set_device_modifier_mapping_sizeof (const void *_buffer); /** * @@ -5685,10 +6170,10 @@ xcb_input_set_device_modifier_mapping_sizeof (const void *_buffer /**< */); * */ xcb_input_set_device_modifier_mapping_cookie_t -xcb_input_set_device_modifier_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t keycodes_per_modifier /**< */, - const uint8_t *keymaps /**< */); +xcb_input_set_device_modifier_mapping (xcb_connection_t *c, + uint8_t device_id, + uint8_t keycodes_per_modifier, + const uint8_t *keymaps); /** * @@ -5702,10 +6187,10 @@ xcb_input_set_device_modifier_mapping (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_set_device_modifier_mapping_cookie_t -xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t keycodes_per_modifier /**< */, - const uint8_t *keymaps /**< */); +xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t keycodes_per_modifier, + const uint8_t *keymaps); /** * Return the reply @@ -5722,12 +6207,12 @@ xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_set_device_modifier_mapping_reply_t * -xcb_input_set_device_modifier_mapping_reply (xcb_connection_t *c /**< */, +xcb_input_set_device_modifier_mapping_reply (xcb_connection_t *c, xcb_input_set_device_modifier_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_get_device_button_mapping_sizeof (const void *_buffer /**< */); +xcb_input_get_device_button_mapping_sizeof (const void *_buffer); /** * @@ -5738,8 +6223,8 @@ xcb_input_get_device_button_mapping_sizeof (const void *_buffer /**< */); * */ xcb_input_get_device_button_mapping_cookie_t -xcb_input_get_device_button_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_get_device_button_mapping (xcb_connection_t *c, + uint8_t device_id); /** * @@ -5753,17 +6238,17 @@ xcb_input_get_device_button_mapping (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_get_device_button_mapping_cookie_t -xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id); uint8_t * -xcb_input_get_device_button_mapping_map (const xcb_input_get_device_button_mapping_reply_t *R /**< */); +xcb_input_get_device_button_mapping_map (const xcb_input_get_device_button_mapping_reply_t *R); int -xcb_input_get_device_button_mapping_map_length (const xcb_input_get_device_button_mapping_reply_t *R /**< */); +xcb_input_get_device_button_mapping_map_length (const xcb_input_get_device_button_mapping_reply_t *R); xcb_generic_iterator_t -xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_mapping_reply_t *R /**< */); +xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_mapping_reply_t *R); /** * Return the reply @@ -5780,12 +6265,12 @@ xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_m * The returned value must be freed by the caller using free(). */ xcb_input_get_device_button_mapping_reply_t * -xcb_input_get_device_button_mapping_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_button_mapping_reply (xcb_connection_t *c, xcb_input_get_device_button_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_set_device_button_mapping_sizeof (const void *_buffer /**< */); +xcb_input_set_device_button_mapping_sizeof (const void *_buffer); /** * @@ -5796,10 +6281,10 @@ xcb_input_set_device_button_mapping_sizeof (const void *_buffer /**< */); * */ xcb_input_set_device_button_mapping_cookie_t -xcb_input_set_device_button_mapping (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t map_size /**< */, - const uint8_t *map /**< */); +xcb_input_set_device_button_mapping (xcb_connection_t *c, + uint8_t device_id, + uint8_t map_size, + const uint8_t *map); /** * @@ -5813,10 +6298,10 @@ xcb_input_set_device_button_mapping (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_set_device_button_mapping_cookie_t -xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t map_size /**< */, - const uint8_t *map /**< */); +xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t map_size, + const uint8_t *map); /** * Return the reply @@ -5833,9 +6318,9 @@ xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_set_device_button_mapping_reply_t * -xcb_input_set_device_button_mapping_reply (xcb_connection_t *c /**< */, +xcb_input_set_device_button_mapping_reply (xcb_connection_t *c, xcb_input_set_device_button_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Get the next element of the iterator @@ -5846,7 +6331,7 @@ xcb_input_set_device_button_mapping_reply (xcb_connection_t * element. The member index is increased by sizeof(xcb_input_key_state_t) */ void -xcb_input_key_state_next (xcb_input_key_state_iterator_t *i /**< */); +xcb_input_key_state_next (xcb_input_key_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5858,7 +6343,7 @@ xcb_input_key_state_next (xcb_input_key_state_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_key_state_end (xcb_input_key_state_iterator_t i /**< */); +xcb_input_key_state_end (xcb_input_key_state_iterator_t i); /** * Get the next element of the iterator @@ -5869,7 +6354,7 @@ xcb_input_key_state_end (xcb_input_key_state_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_button_state_t) */ void -xcb_input_button_state_next (xcb_input_button_state_iterator_t *i /**< */); +xcb_input_button_state_next (xcb_input_button_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5881,19 +6366,19 @@ xcb_input_button_state_next (xcb_input_button_state_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_button_state_end (xcb_input_button_state_iterator_t i /**< */); +xcb_input_button_state_end (xcb_input_button_state_iterator_t i); int -xcb_input_valuator_state_sizeof (const void *_buffer /**< */); +xcb_input_valuator_state_sizeof (const void *_buffer); -uint32_t * -xcb_input_valuator_state_valuators (const xcb_input_valuator_state_t *R /**< */); +int32_t * +xcb_input_valuator_state_valuators (const xcb_input_valuator_state_t *R); int -xcb_input_valuator_state_valuators_length (const xcb_input_valuator_state_t *R /**< */); +xcb_input_valuator_state_valuators_length (const xcb_input_valuator_state_t *R); xcb_generic_iterator_t -xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R /**< */); +xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R); /** * Get the next element of the iterator @@ -5904,7 +6389,7 @@ xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R /** * element. The member index is increased by sizeof(xcb_input_valuator_state_t) */ void -xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i /**< */); +xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5916,19 +6401,35 @@ xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i /**< */); +xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i); + +int32_t * +xcb_input_input_state_data_valuator_valuators (const xcb_input_input_state_data_t *S); int -xcb_input_input_state_sizeof (const void *_buffer /**< */); - -uint8_t * -xcb_input_input_state_uninterpreted_data (const xcb_input_input_state_t *R /**< */); - -int -xcb_input_input_state_uninterpreted_data_length (const xcb_input_input_state_t *R /**< */); +xcb_input_input_state_data_valuator_valuators_length (const xcb_input_input_state_t *R, + const xcb_input_input_state_data_t *S); xcb_generic_iterator_t -xcb_input_input_state_uninterpreted_data_end (const xcb_input_input_state_t *R /**< */); +xcb_input_input_state_data_valuator_valuators_end (const xcb_input_input_state_t *R, + const xcb_input_input_state_data_t *S); + +int +xcb_input_input_state_data_serialize (void **_buffer, + uint8_t class_id, + const xcb_input_input_state_data_t *_aux); + +int +xcb_input_input_state_data_unpack (const void *_buffer, + uint8_t class_id, + xcb_input_input_state_data_t *_aux); + +int +xcb_input_input_state_data_sizeof (const void *_buffer, + uint8_t class_id); + +int +xcb_input_input_state_sizeof (const void *_buffer); /** * Get the next element of the iterator @@ -5939,7 +6440,7 @@ xcb_input_input_state_uninterpreted_data_end (const xcb_input_input_state_t *R * element. The member index is increased by sizeof(xcb_input_input_state_t) */ void -xcb_input_input_state_next (xcb_input_input_state_iterator_t *i /**< */); +xcb_input_input_state_next (xcb_input_input_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5951,10 +6452,10 @@ xcb_input_input_state_next (xcb_input_input_state_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_input_state_end (xcb_input_input_state_iterator_t i /**< */); +xcb_input_input_state_end (xcb_input_input_state_iterator_t i); int -xcb_input_query_device_state_sizeof (const void *_buffer /**< */); +xcb_input_query_device_state_sizeof (const void *_buffer); /** * @@ -5965,8 +6466,8 @@ xcb_input_query_device_state_sizeof (const void *_buffer /**< */); * */ xcb_input_query_device_state_cookie_t -xcb_input_query_device_state (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_query_device_state (xcb_connection_t *c, + uint8_t device_id); /** * @@ -5980,14 +6481,14 @@ xcb_input_query_device_state (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_query_device_state_cookie_t -xcb_input_query_device_state_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_query_device_state_unchecked (xcb_connection_t *c, + uint8_t device_id); int -xcb_input_query_device_state_classes_length (const xcb_input_query_device_state_reply_t *R /**< */); +xcb_input_query_device_state_classes_length (const xcb_input_query_device_state_reply_t *R); xcb_input_input_state_iterator_t -xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_state_reply_t *R /**< */); +xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_state_reply_t *R); /** * Return the reply @@ -6004,12 +6505,12 @@ xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_stat * The returned value must be freed by the caller using free(). */ xcb_input_query_device_state_reply_t * -xcb_input_query_device_state_reply (xcb_connection_t *c /**< */, +xcb_input_query_device_state_reply (xcb_connection_t *c, xcb_input_query_device_state_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_send_extension_event_sizeof (const void *_buffer /**< */); +xcb_input_send_extension_event_sizeof (const void *_buffer); /** * @@ -6023,14 +6524,14 @@ xcb_input_send_extension_event_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_send_extension_event_checked (xcb_connection_t *c /**< */, - xcb_window_t destination /**< */, - uint8_t device_id /**< */, - uint8_t propagate /**< */, - uint16_t num_classes /**< */, - uint8_t num_events /**< */, - const uint8_t *events /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_send_extension_event_checked (xcb_connection_t *c, + xcb_window_t destination, + uint8_t device_id, + uint8_t propagate, + uint16_t num_classes, + uint8_t num_events, + const uint8_t *events, + const xcb_input_event_class_t *classes); /** * @@ -6041,14 +6542,32 @@ xcb_input_send_extension_event_checked (xcb_connection_t *c /**< * * */ xcb_void_cookie_t -xcb_input_send_extension_event (xcb_connection_t *c /**< */, - xcb_window_t destination /**< */, - uint8_t device_id /**< */, - uint8_t propagate /**< */, - uint16_t num_classes /**< */, - uint8_t num_events /**< */, - const uint8_t *events /**< */, - const xcb_input_event_class_t *classes /**< */); +xcb_input_send_extension_event (xcb_connection_t *c, + xcb_window_t destination, + uint8_t device_id, + uint8_t propagate, + uint16_t num_classes, + uint8_t num_events, + const uint8_t *events, + const xcb_input_event_class_t *classes); + +uint8_t * +xcb_input_send_extension_event_events (const xcb_input_send_extension_event_request_t *R); + +int +xcb_input_send_extension_event_events_length (const xcb_input_send_extension_event_request_t *R); + +xcb_generic_iterator_t +xcb_input_send_extension_event_events_end (const xcb_input_send_extension_event_request_t *R); + +xcb_input_event_class_t * +xcb_input_send_extension_event_classes (const xcb_input_send_extension_event_request_t *R); + +int +xcb_input_send_extension_event_classes_length (const xcb_input_send_extension_event_request_t *R); + +xcb_generic_iterator_t +xcb_input_send_extension_event_classes_end (const xcb_input_send_extension_event_request_t *R); /** * @@ -6062,11 +6581,11 @@ xcb_input_send_extension_event (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_device_bell_checked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t feedback_id /**< */, - uint8_t feedback_class /**< */, - int8_t percent /**< */); +xcb_input_device_bell_checked (xcb_connection_t *c, + uint8_t device_id, + uint8_t feedback_id, + uint8_t feedback_class, + int8_t percent); /** * @@ -6077,14 +6596,14 @@ xcb_input_device_bell_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_device_bell (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t feedback_id /**< */, - uint8_t feedback_class /**< */, - int8_t percent /**< */); +xcb_input_device_bell (xcb_connection_t *c, + uint8_t device_id, + uint8_t feedback_id, + uint8_t feedback_class, + int8_t percent); int -xcb_input_set_device_valuators_sizeof (const void *_buffer /**< */); +xcb_input_set_device_valuators_sizeof (const void *_buffer); /** * @@ -6095,11 +6614,11 @@ xcb_input_set_device_valuators_sizeof (const void *_buffer /**< */); * */ xcb_input_set_device_valuators_cookie_t -xcb_input_set_device_valuators (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t first_valuator /**< */, - uint8_t num_valuators /**< */, - const int32_t *valuators /**< */); +xcb_input_set_device_valuators (xcb_connection_t *c, + uint8_t device_id, + uint8_t first_valuator, + uint8_t num_valuators, + const int32_t *valuators); /** * @@ -6113,11 +6632,11 @@ xcb_input_set_device_valuators (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_set_device_valuators_cookie_t -xcb_input_set_device_valuators_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */, - uint8_t first_valuator /**< */, - uint8_t num_valuators /**< */, - const int32_t *valuators /**< */); +xcb_input_set_device_valuators_unchecked (xcb_connection_t *c, + uint8_t device_id, + uint8_t first_valuator, + uint8_t num_valuators, + const int32_t *valuators); /** * Return the reply @@ -6134,39 +6653,39 @@ xcb_input_set_device_valuators_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_set_device_valuators_reply_t * -xcb_input_set_device_valuators_reply (xcb_connection_t *c /**< */, +xcb_input_set_device_valuators_reply (xcb_connection_t *c, xcb_input_set_device_valuators_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_device_resolution_state_sizeof (const void *_buffer /**< */); +xcb_input_device_resolution_state_sizeof (const void *_buffer); uint32_t * -xcb_input_device_resolution_state_resolution_values (const xcb_input_device_resolution_state_t *R /**< */); +xcb_input_device_resolution_state_resolution_values (const xcb_input_device_resolution_state_t *R); int -xcb_input_device_resolution_state_resolution_values_length (const xcb_input_device_resolution_state_t *R /**< */); +xcb_input_device_resolution_state_resolution_values_length (const xcb_input_device_resolution_state_t *R); xcb_generic_iterator_t -xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_resolution_state_t *R /**< */); +xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_resolution_state_t *R); uint32_t * -xcb_input_device_resolution_state_resolution_min (const xcb_input_device_resolution_state_t *R /**< */); +xcb_input_device_resolution_state_resolution_min (const xcb_input_device_resolution_state_t *R); int -xcb_input_device_resolution_state_resolution_min_length (const xcb_input_device_resolution_state_t *R /**< */); +xcb_input_device_resolution_state_resolution_min_length (const xcb_input_device_resolution_state_t *R); xcb_generic_iterator_t -xcb_input_device_resolution_state_resolution_min_end (const xcb_input_device_resolution_state_t *R /**< */); +xcb_input_device_resolution_state_resolution_min_end (const xcb_input_device_resolution_state_t *R); uint32_t * -xcb_input_device_resolution_state_resolution_max (const xcb_input_device_resolution_state_t *R /**< */); +xcb_input_device_resolution_state_resolution_max (const xcb_input_device_resolution_state_t *R); int -xcb_input_device_resolution_state_resolution_max_length (const xcb_input_device_resolution_state_t *R /**< */); +xcb_input_device_resolution_state_resolution_max_length (const xcb_input_device_resolution_state_t *R); xcb_generic_iterator_t -xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_resolution_state_t *R /**< */); +xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_resolution_state_t *R); /** * Get the next element of the iterator @@ -6177,7 +6696,7 @@ xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_res * element. The member index is increased by sizeof(xcb_input_device_resolution_state_t) */ void -xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterator_t *i /**< */); +xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6189,7 +6708,7 @@ xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterat * last element. */ xcb_generic_iterator_t -xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterator_t i /**< */); +xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterator_t i); /** * Get the next element of the iterator @@ -6200,7 +6719,7 @@ xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterato * element. The member index is increased by sizeof(xcb_input_device_abs_calib_state_t) */ void -xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator_t *i /**< */); +xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6212,7 +6731,7 @@ xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator * last element. */ xcb_generic_iterator_t -xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_t i /**< */); +xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_t i); /** * Get the next element of the iterator @@ -6223,7 +6742,7 @@ xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_ * element. The member index is increased by sizeof(xcb_input_device_abs_area_state_t) */ void -xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t *i /**< */); +xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6235,7 +6754,7 @@ xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t * last element. */ xcb_generic_iterator_t -xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t i /**< */); +xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t i); /** * Get the next element of the iterator @@ -6246,7 +6765,7 @@ xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t * element. The member index is increased by sizeof(xcb_input_device_core_state_t) */ void -xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i /**< */); +xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6258,7 +6777,7 @@ xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i /** * last element. */ xcb_generic_iterator_t -xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i /**< */); +xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i); /** * Get the next element of the iterator @@ -6269,7 +6788,7 @@ xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i /**< * element. The member index is increased by sizeof(xcb_input_device_enable_state_t) */ void -xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i /**< */); +xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6281,19 +6800,57 @@ xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i * last element. */ xcb_generic_iterator_t -xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i /**< */); +xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i); + +uint32_t * +xcb_input_device_state_data_resolution_resolution_values (const xcb_input_device_state_data_t *S); int -xcb_input_device_state_sizeof (const void *_buffer /**< */); - -uint8_t * -xcb_input_device_state_uninterpreted_data (const xcb_input_device_state_t *R /**< */); - -int -xcb_input_device_state_uninterpreted_data_length (const xcb_input_device_state_t *R /**< */); +xcb_input_device_state_data_resolution_resolution_values_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); xcb_generic_iterator_t -xcb_input_device_state_uninterpreted_data_end (const xcb_input_device_state_t *R /**< */); +xcb_input_device_state_data_resolution_resolution_values_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +uint32_t * +xcb_input_device_state_data_resolution_resolution_min (const xcb_input_device_state_data_t *S); + +int +xcb_input_device_state_data_resolution_resolution_min_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_min_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +uint32_t * +xcb_input_device_state_data_resolution_resolution_max (const xcb_input_device_state_data_t *S); + +int +xcb_input_device_state_data_resolution_resolution_max_length (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_state_data_resolution_resolution_max_end (const xcb_input_device_state_t *R, + const xcb_input_device_state_data_t *S); + +int +xcb_input_device_state_data_serialize (void **_buffer, + uint16_t control_id, + const xcb_input_device_state_data_t *_aux); + +int +xcb_input_device_state_data_unpack (const void *_buffer, + uint16_t control_id, + xcb_input_device_state_data_t *_aux); + +int +xcb_input_device_state_data_sizeof (const void *_buffer, + uint16_t control_id); + +int +xcb_input_device_state_sizeof (const void *_buffer); /** * Get the next element of the iterator @@ -6304,7 +6861,7 @@ xcb_input_device_state_uninterpreted_data_end (const xcb_input_device_state_t *R * element. The member index is increased by sizeof(xcb_input_device_state_t) */ void -xcb_input_device_state_next (xcb_input_device_state_iterator_t *i /**< */); +xcb_input_device_state_next (xcb_input_device_state_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6316,10 +6873,10 @@ xcb_input_device_state_next (xcb_input_device_state_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_device_state_end (xcb_input_device_state_iterator_t i /**< */); +xcb_input_device_state_end (xcb_input_device_state_iterator_t i); int -xcb_input_get_device_control_sizeof (const void *_buffer /**< */); +xcb_input_get_device_control_sizeof (const void *_buffer); /** * @@ -6330,9 +6887,9 @@ xcb_input_get_device_control_sizeof (const void *_buffer /**< */); * */ xcb_input_get_device_control_cookie_t -xcb_input_get_device_control (xcb_connection_t *c /**< */, - uint16_t control_id /**< */, - uint8_t device_id /**< */); +xcb_input_get_device_control (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id); /** * @@ -6346,12 +6903,12 @@ xcb_input_get_device_control (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_get_device_control_cookie_t -xcb_input_get_device_control_unchecked (xcb_connection_t *c /**< */, - uint16_t control_id /**< */, - uint8_t device_id /**< */); +xcb_input_get_device_control_unchecked (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id); xcb_input_device_state_t * -xcb_input_get_device_control_control (const xcb_input_get_device_control_reply_t *R /**< */); +xcb_input_get_device_control_control (const xcb_input_get_device_control_reply_t *R); /** * Return the reply @@ -6368,21 +6925,21 @@ xcb_input_get_device_control_control (const xcb_input_get_device_control_reply_t * The returned value must be freed by the caller using free(). */ xcb_input_get_device_control_reply_t * -xcb_input_get_device_control_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_control_reply (xcb_connection_t *c, xcb_input_get_device_control_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_device_resolution_ctl_sizeof (const void *_buffer /**< */); +xcb_input_device_resolution_ctl_sizeof (const void *_buffer); uint32_t * -xcb_input_device_resolution_ctl_resolution_values (const xcb_input_device_resolution_ctl_t *R /**< */); +xcb_input_device_resolution_ctl_resolution_values (const xcb_input_device_resolution_ctl_t *R); int -xcb_input_device_resolution_ctl_resolution_values_length (const xcb_input_device_resolution_ctl_t *R /**< */); +xcb_input_device_resolution_ctl_resolution_values_length (const xcb_input_device_resolution_ctl_t *R); xcb_generic_iterator_t -xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_resolution_ctl_t *R /**< */); +xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_resolution_ctl_t *R); /** * Get the next element of the iterator @@ -6393,7 +6950,7 @@ xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_re * element. The member index is increased by sizeof(xcb_input_device_resolution_ctl_t) */ void -xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t *i /**< */); +xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6405,7 +6962,7 @@ xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t * last element. */ xcb_generic_iterator_t -xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t i /**< */); +xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t i); /** * Get the next element of the iterator @@ -6416,7 +6973,7 @@ xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t * element. The member index is increased by sizeof(xcb_input_device_abs_calib_ctl_t) */ void -xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t *i /**< */); +xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6428,7 +6985,7 @@ xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t * * last element. */ xcb_generic_iterator_t -xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i /**< */); +xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i); /** * Get the next element of the iterator @@ -6439,7 +6996,7 @@ xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i * element. The member index is increased by sizeof(xcb_input_device_abs_area_ctrl_t) */ void -xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t *i /**< */); +xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6451,7 +7008,7 @@ xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t * * last element. */ xcb_generic_iterator_t -xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i /**< */); +xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i); /** * Get the next element of the iterator @@ -6462,7 +7019,7 @@ xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i * element. The member index is increased by sizeof(xcb_input_device_core_ctrl_t) */ void -xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i /**< */); +xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6474,7 +7031,7 @@ xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i /**< * last element. */ xcb_generic_iterator_t -xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i /**< */); +xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i); /** * Get the next element of the iterator @@ -6485,7 +7042,7 @@ xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i /**< */ * element. The member index is increased by sizeof(xcb_input_device_enable_ctrl_t) */ void -xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i /**< */); +xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6497,19 +7054,35 @@ xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i / * last element. */ xcb_generic_iterator_t -xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i /**< */); +xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i); + +uint32_t * +xcb_input_device_ctl_data_resolution_resolution_values (const xcb_input_device_ctl_data_t *S); int -xcb_input_device_ctl_sizeof (const void *_buffer /**< */); - -uint8_t * -xcb_input_device_ctl_uninterpreted_data (const xcb_input_device_ctl_t *R /**< */); - -int -xcb_input_device_ctl_uninterpreted_data_length (const xcb_input_device_ctl_t *R /**< */); +xcb_input_device_ctl_data_resolution_resolution_values_length (const xcb_input_device_ctl_t *R, + const xcb_input_device_ctl_data_t *S); xcb_generic_iterator_t -xcb_input_device_ctl_uninterpreted_data_end (const xcb_input_device_ctl_t *R /**< */); +xcb_input_device_ctl_data_resolution_resolution_values_end (const xcb_input_device_ctl_t *R, + const xcb_input_device_ctl_data_t *S); + +int +xcb_input_device_ctl_data_serialize (void **_buffer, + uint16_t control_id, + const xcb_input_device_ctl_data_t *_aux); + +int +xcb_input_device_ctl_data_unpack (const void *_buffer, + uint16_t control_id, + xcb_input_device_ctl_data_t *_aux); + +int +xcb_input_device_ctl_data_sizeof (const void *_buffer, + uint16_t control_id); + +int +xcb_input_device_ctl_sizeof (const void *_buffer); /** * Get the next element of the iterator @@ -6520,7 +7093,7 @@ xcb_input_device_ctl_uninterpreted_data_end (const xcb_input_device_ctl_t *R /* * element. The member index is increased by sizeof(xcb_input_device_ctl_t) */ void -xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i /**< */); +xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6532,10 +7105,10 @@ xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i /**< */); +xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i); int -xcb_input_change_device_control_sizeof (const void *_buffer /**< */); +xcb_input_change_device_control_sizeof (const void *_buffer); /** * @@ -6546,10 +7119,10 @@ xcb_input_change_device_control_sizeof (const void *_buffer /**< */); * */ xcb_input_change_device_control_cookie_t -xcb_input_change_device_control (xcb_connection_t *c /**< */, - uint16_t control_id /**< */, - uint8_t device_id /**< */, - xcb_input_device_ctl_t *control /**< */); +xcb_input_change_device_control (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id, + xcb_input_device_ctl_t *control); /** * @@ -6563,10 +7136,10 @@ xcb_input_change_device_control (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_change_device_control_cookie_t -xcb_input_change_device_control_unchecked (xcb_connection_t *c /**< */, - uint16_t control_id /**< */, - uint8_t device_id /**< */, - xcb_input_device_ctl_t *control /**< */); +xcb_input_change_device_control_unchecked (xcb_connection_t *c, + uint16_t control_id, + uint8_t device_id, + xcb_input_device_ctl_t *control); /** * Return the reply @@ -6583,12 +7156,12 @@ xcb_input_change_device_control_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_change_device_control_reply_t * -xcb_input_change_device_control_reply (xcb_connection_t *c /**< */, +xcb_input_change_device_control_reply (xcb_connection_t *c, xcb_input_change_device_control_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_list_device_properties_sizeof (const void *_buffer /**< */); +xcb_input_list_device_properties_sizeof (const void *_buffer); /** * @@ -6599,8 +7172,8 @@ xcb_input_list_device_properties_sizeof (const void *_buffer /**< */); * */ xcb_input_list_device_properties_cookie_t -xcb_input_list_device_properties (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_list_device_properties (xcb_connection_t *c, + uint8_t device_id); /** * @@ -6614,17 +7187,17 @@ xcb_input_list_device_properties (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_list_device_properties_cookie_t -xcb_input_list_device_properties_unchecked (xcb_connection_t *c /**< */, - uint8_t device_id /**< */); +xcb_input_list_device_properties_unchecked (xcb_connection_t *c, + uint8_t device_id); xcb_atom_t * -xcb_input_list_device_properties_atoms (const xcb_input_list_device_properties_reply_t *R /**< */); +xcb_input_list_device_properties_atoms (const xcb_input_list_device_properties_reply_t *R); int -xcb_input_list_device_properties_atoms_length (const xcb_input_list_device_properties_reply_t *R /**< */); +xcb_input_list_device_properties_atoms_length (const xcb_input_list_device_properties_reply_t *R); xcb_generic_iterator_t -xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properties_reply_t *R /**< */); +xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properties_reply_t *R); /** * Return the reply @@ -6641,59 +7214,62 @@ xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properti * The returned value must be freed by the caller using free(). */ xcb_input_list_device_properties_reply_t * -xcb_input_list_device_properties_reply (xcb_connection_t *c /**< */, +xcb_input_list_device_properties_reply (xcb_connection_t *c, xcb_input_list_device_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); uint8_t * -xcb_input_change_device_property_items_data_8 (const xcb_input_change_device_property_items_t *S /**< */); +xcb_input_change_device_property_items_data_8 (const xcb_input_change_device_property_items_t *S); int -xcb_input_change_device_property_items_data_8_length (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */); +xcb_input_change_device_property_items_data_8_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); xcb_generic_iterator_t -xcb_input_change_device_property_items_data_8_end (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */); +xcb_input_change_device_property_items_data_8_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); uint16_t * -xcb_input_change_device_property_items_data_16 (const xcb_input_change_device_property_items_t *S /**< */); +xcb_input_change_device_property_items_data_16 (const xcb_input_change_device_property_items_t *S); int -xcb_input_change_device_property_items_data_16_length (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */); +xcb_input_change_device_property_items_data_16_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); xcb_generic_iterator_t -xcb_input_change_device_property_items_data_16_end (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */); +xcb_input_change_device_property_items_data_16_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); uint32_t * -xcb_input_change_device_property_items_data_32 (const xcb_input_change_device_property_items_t *S /**< */); +xcb_input_change_device_property_items_data_32 (const xcb_input_change_device_property_items_t *S); int -xcb_input_change_device_property_items_data_32_length (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */); +xcb_input_change_device_property_items_data_32_length (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); xcb_generic_iterator_t -xcb_input_change_device_property_items_data_32_end (const xcb_input_change_device_property_request_t *R /**< */, - const xcb_input_change_device_property_items_t *S /**< */); +xcb_input_change_device_property_items_data_32_end (const xcb_input_change_device_property_request_t *R, + const xcb_input_change_device_property_items_t *S); int -xcb_input_change_device_property_items_serialize (void **_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - const xcb_input_change_device_property_items_t *_aux /**< */); +xcb_input_change_device_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_change_device_property_items_t *_aux); int -xcb_input_change_device_property_items_unpack (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - xcb_input_change_device_property_items_t *_aux /**< */); +xcb_input_change_device_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_change_device_property_items_t *_aux); int -xcb_input_change_device_property_items_sizeof (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */); +xcb_input_change_device_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format); + +int +xcb_input_change_device_property_sizeof (const void *_buffer); /** * @@ -6707,14 +7283,14 @@ xcb_input_change_device_property_items_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_change_device_property_checked (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t device_id /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const void *items /**< */); +xcb_input_change_device_property_checked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *items); /** * @@ -6725,14 +7301,14 @@ xcb_input_change_device_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_change_device_property (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t device_id /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const void *items /**< */); +xcb_input_change_device_property (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const void *items); /** * @@ -6746,14 +7322,14 @@ xcb_input_change_device_property (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_change_device_property_aux_checked (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t device_id /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const xcb_input_change_device_property_items_t *items /**< */); +xcb_input_change_device_property_aux_checked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const xcb_input_change_device_property_items_t *items); /** * @@ -6764,14 +7340,17 @@ xcb_input_change_device_property_aux_checked (xcb_connection_t * */ xcb_void_cookie_t -xcb_input_change_device_property_aux (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t device_id /**< */, - uint8_t format /**< */, - uint8_t mode /**< */, - uint32_t num_items /**< */, - const xcb_input_change_device_property_items_t *items /**< */); +xcb_input_change_device_property_aux (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint8_t device_id, + uint8_t format, + uint8_t mode, + uint32_t num_items, + const xcb_input_change_device_property_items_t *items); + +void * +xcb_input_change_device_property_items (const xcb_input_change_device_property_request_t *R); /** * @@ -6785,9 +7364,9 @@ xcb_input_change_device_property_aux (xcb_connection_t * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_delete_device_property_checked (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - uint8_t device_id /**< */); +xcb_input_delete_device_property_checked (xcb_connection_t *c, + xcb_atom_t property, + uint8_t device_id); /** * @@ -6798,59 +7377,62 @@ xcb_input_delete_device_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_delete_device_property (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - uint8_t device_id /**< */); +xcb_input_delete_device_property (xcb_connection_t *c, + xcb_atom_t property, + uint8_t device_id); uint8_t * -xcb_input_get_device_property_items_data_8 (const xcb_input_get_device_property_items_t *S /**< */); +xcb_input_get_device_property_items_data_8 (const xcb_input_get_device_property_items_t *S); int -xcb_input_get_device_property_items_data_8_length (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */); +xcb_input_get_device_property_items_data_8_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); xcb_generic_iterator_t -xcb_input_get_device_property_items_data_8_end (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */); +xcb_input_get_device_property_items_data_8_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); uint16_t * -xcb_input_get_device_property_items_data_16 (const xcb_input_get_device_property_items_t *S /**< */); +xcb_input_get_device_property_items_data_16 (const xcb_input_get_device_property_items_t *S); int -xcb_input_get_device_property_items_data_16_length (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */); +xcb_input_get_device_property_items_data_16_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); xcb_generic_iterator_t -xcb_input_get_device_property_items_data_16_end (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */); +xcb_input_get_device_property_items_data_16_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); uint32_t * -xcb_input_get_device_property_items_data_32 (const xcb_input_get_device_property_items_t *S /**< */); +xcb_input_get_device_property_items_data_32 (const xcb_input_get_device_property_items_t *S); int -xcb_input_get_device_property_items_data_32_length (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */); +xcb_input_get_device_property_items_data_32_length (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); xcb_generic_iterator_t -xcb_input_get_device_property_items_data_32_end (const xcb_input_get_device_property_reply_t *R /**< */, - const xcb_input_get_device_property_items_t *S /**< */); +xcb_input_get_device_property_items_data_32_end (const xcb_input_get_device_property_reply_t *R, + const xcb_input_get_device_property_items_t *S); int -xcb_input_get_device_property_items_serialize (void **_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - const xcb_input_get_device_property_items_t *_aux /**< */); +xcb_input_get_device_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_get_device_property_items_t *_aux); int -xcb_input_get_device_property_items_unpack (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - xcb_input_get_device_property_items_t *_aux /**< */); +xcb_input_get_device_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_get_device_property_items_t *_aux); int -xcb_input_get_device_property_items_sizeof (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */); +xcb_input_get_device_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format); + +int +xcb_input_get_device_property_sizeof (const void *_buffer); /** * @@ -6861,13 +7443,13 @@ xcb_input_get_device_property_items_sizeof (const void *_buffer /**< */, * */ xcb_input_get_device_property_cookie_t -xcb_input_get_device_property (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t offset /**< */, - uint32_t len /**< */, - uint8_t device_id /**< */, - uint8_t _delete /**< */); +xcb_input_get_device_property (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len, + uint8_t device_id, + uint8_t _delete); /** * @@ -6881,16 +7463,16 @@ xcb_input_get_device_property (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_get_device_property_cookie_t -xcb_input_get_device_property_unchecked (xcb_connection_t *c /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t offset /**< */, - uint32_t len /**< */, - uint8_t device_id /**< */, - uint8_t _delete /**< */); +xcb_input_get_device_property_unchecked (xcb_connection_t *c, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len, + uint8_t device_id, + uint8_t _delete); void * -xcb_input_get_device_property_items (const xcb_input_get_device_property_reply_t *R /**< */); +xcb_input_get_device_property_items (const xcb_input_get_device_property_reply_t *R); /** * Return the reply @@ -6907,9 +7489,9 @@ xcb_input_get_device_property_items (const xcb_input_get_device_property_reply_t * The returned value must be freed by the caller using free(). */ xcb_input_get_device_property_reply_t * -xcb_input_get_device_property_reply (xcb_connection_t *c /**< */, +xcb_input_get_device_property_reply (xcb_connection_t *c, xcb_input_get_device_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Get the next element of the iterator @@ -6920,7 +7502,7 @@ xcb_input_get_device_property_reply (xcb_connection_t *c * element. The member index is increased by sizeof(xcb_input_group_info_t) */ void -xcb_input_group_info_next (xcb_input_group_info_iterator_t *i /**< */); +xcb_input_group_info_next (xcb_input_group_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6932,7 +7514,7 @@ xcb_input_group_info_next (xcb_input_group_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_group_info_end (xcb_input_group_info_iterator_t i /**< */); +xcb_input_group_info_end (xcb_input_group_info_iterator_t i); /** * Get the next element of the iterator @@ -6943,7 +7525,7 @@ xcb_input_group_info_end (xcb_input_group_info_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_modifier_info_t) */ void -xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i /**< */); +xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -6955,10 +7537,10 @@ xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_modifier_info_end (xcb_input_modifier_info_iterator_t i /**< */); +xcb_input_modifier_info_end (xcb_input_modifier_info_iterator_t i); int -xcb_input_xi_query_pointer_sizeof (const void *_buffer /**< */); +xcb_input_xi_query_pointer_sizeof (const void *_buffer); /** * @@ -6969,9 +7551,9 @@ xcb_input_xi_query_pointer_sizeof (const void *_buffer /**< */); * */ xcb_input_xi_query_pointer_cookie_t -xcb_input_xi_query_pointer (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_query_pointer (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid); /** * @@ -6985,18 +7567,18 @@ xcb_input_xi_query_pointer (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_xi_query_pointer_cookie_t -xcb_input_xi_query_pointer_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_query_pointer_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid); uint32_t * -xcb_input_xi_query_pointer_buttons (const xcb_input_xi_query_pointer_reply_t *R /**< */); +xcb_input_xi_query_pointer_buttons (const xcb_input_xi_query_pointer_reply_t *R); int -xcb_input_xi_query_pointer_buttons_length (const xcb_input_xi_query_pointer_reply_t *R /**< */); +xcb_input_xi_query_pointer_buttons_length (const xcb_input_xi_query_pointer_reply_t *R); xcb_generic_iterator_t -xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t *R /**< */); +xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t *R); /** * Return the reply @@ -7013,9 +7595,9 @@ xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t * The returned value must be freed by the caller using free(). */ xcb_input_xi_query_pointer_reply_t * -xcb_input_xi_query_pointer_reply (xcb_connection_t *c /**< */, +xcb_input_xi_query_pointer_reply (xcb_connection_t *c, xcb_input_xi_query_pointer_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -7029,16 +7611,16 @@ xcb_input_xi_query_pointer_reply (xcb_connection_t *c /**< * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_warp_pointer_checked (xcb_connection_t *c /**< */, - xcb_window_t src_win /**< */, - xcb_window_t dst_win /**< */, - xcb_input_fp1616_t src_x /**< */, - xcb_input_fp1616_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - xcb_input_fp1616_t dst_x /**< */, - xcb_input_fp1616_t dst_y /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_warp_pointer_checked (xcb_connection_t *c, + xcb_window_t src_win, + xcb_window_t dst_win, + xcb_input_fp1616_t src_x, + xcb_input_fp1616_t src_y, + uint16_t src_width, + uint16_t src_height, + xcb_input_fp1616_t dst_x, + xcb_input_fp1616_t dst_y, + xcb_input_device_id_t deviceid); /** * @@ -7049,16 +7631,16 @@ xcb_input_xi_warp_pointer_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_xi_warp_pointer (xcb_connection_t *c /**< */, - xcb_window_t src_win /**< */, - xcb_window_t dst_win /**< */, - xcb_input_fp1616_t src_x /**< */, - xcb_input_fp1616_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - xcb_input_fp1616_t dst_x /**< */, - xcb_input_fp1616_t dst_y /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_warp_pointer (xcb_connection_t *c, + xcb_window_t src_win, + xcb_window_t dst_win, + xcb_input_fp1616_t src_x, + xcb_input_fp1616_t src_y, + uint16_t src_width, + uint16_t src_height, + xcb_input_fp1616_t dst_x, + xcb_input_fp1616_t dst_y, + xcb_input_device_id_t deviceid); /** * @@ -7072,10 +7654,10 @@ xcb_input_xi_warp_pointer (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_change_cursor_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_cursor_t cursor /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_change_cursor_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid); /** * @@ -7086,22 +7668,22 @@ xcb_input_xi_change_cursor_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_xi_change_cursor (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_cursor_t cursor /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_change_cursor (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid); int -xcb_input_add_master_sizeof (const void *_buffer /**< */); +xcb_input_add_master_sizeof (const void *_buffer); char * -xcb_input_add_master_name (const xcb_input_add_master_t *R /**< */); +xcb_input_add_master_name (const xcb_input_add_master_t *R); int -xcb_input_add_master_name_length (const xcb_input_add_master_t *R /**< */); +xcb_input_add_master_name_length (const xcb_input_add_master_t *R); xcb_generic_iterator_t -xcb_input_add_master_name_end (const xcb_input_add_master_t *R /**< */); +xcb_input_add_master_name_end (const xcb_input_add_master_t *R); /** * Get the next element of the iterator @@ -7112,7 +7694,7 @@ xcb_input_add_master_name_end (const xcb_input_add_master_t *R /**< */); * element. The member index is increased by sizeof(xcb_input_add_master_t) */ void -xcb_input_add_master_next (xcb_input_add_master_iterator_t *i /**< */); +xcb_input_add_master_next (xcb_input_add_master_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7124,7 +7706,7 @@ xcb_input_add_master_next (xcb_input_add_master_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_add_master_end (xcb_input_add_master_iterator_t i /**< */); +xcb_input_add_master_end (xcb_input_add_master_iterator_t i); /** * Get the next element of the iterator @@ -7135,7 +7717,7 @@ xcb_input_add_master_end (xcb_input_add_master_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_remove_master_t) */ void -xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i /**< */); +xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7147,7 +7729,7 @@ xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i /**< */); +xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i); /** * Get the next element of the iterator @@ -7158,7 +7740,7 @@ xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_attach_slave_t) */ void -xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i /**< */); +xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7170,7 +7752,7 @@ xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i /**< */); +xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i); /** * Get the next element of the iterator @@ -7181,7 +7763,7 @@ xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_detach_slave_t) */ void -xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i /**< */); +xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7193,19 +7775,35 @@ xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_detach_slave_end (xcb_input_detach_slave_iterator_t i /**< */); +xcb_input_detach_slave_end (xcb_input_detach_slave_iterator_t i); + +char * +xcb_input_hierarchy_change_data_add_master_name (const xcb_input_hierarchy_change_data_t *S); int -xcb_input_hierarchy_change_sizeof (const void *_buffer /**< */); - -uint8_t * -xcb_input_hierarchy_change_uninterpreted_data (const xcb_input_hierarchy_change_t *R /**< */); - -int -xcb_input_hierarchy_change_uninterpreted_data_length (const xcb_input_hierarchy_change_t *R /**< */); +xcb_input_hierarchy_change_data_add_master_name_length (const xcb_input_hierarchy_change_t *R, + const xcb_input_hierarchy_change_data_t *S); xcb_generic_iterator_t -xcb_input_hierarchy_change_uninterpreted_data_end (const xcb_input_hierarchy_change_t *R /**< */); +xcb_input_hierarchy_change_data_add_master_name_end (const xcb_input_hierarchy_change_t *R, + const xcb_input_hierarchy_change_data_t *S); + +int +xcb_input_hierarchy_change_data_serialize (void **_buffer, + uint16_t type, + const xcb_input_hierarchy_change_data_t *_aux); + +int +xcb_input_hierarchy_change_data_unpack (const void *_buffer, + uint16_t type, + xcb_input_hierarchy_change_data_t *_aux); + +int +xcb_input_hierarchy_change_data_sizeof (const void *_buffer, + uint16_t type); + +int +xcb_input_hierarchy_change_sizeof (const void *_buffer); /** * Get the next element of the iterator @@ -7216,7 +7814,7 @@ xcb_input_hierarchy_change_uninterpreted_data_end (const xcb_input_hierarchy_cha * element. The member index is increased by sizeof(xcb_input_hierarchy_change_t) */ void -xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i /**< */); +xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7228,10 +7826,10 @@ xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i /**< * last element. */ xcb_generic_iterator_t -xcb_input_hierarchy_change_end (xcb_input_hierarchy_change_iterator_t i /**< */); +xcb_input_hierarchy_change_end (xcb_input_hierarchy_change_iterator_t i); int -xcb_input_xi_change_hierarchy_sizeof (const void *_buffer /**< */); +xcb_input_xi_change_hierarchy_sizeof (const void *_buffer); /** * @@ -7245,9 +7843,9 @@ xcb_input_xi_change_hierarchy_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_change_hierarchy_checked (xcb_connection_t *c /**< */, - uint8_t num_changes /**< */, - const xcb_input_hierarchy_change_t *changes /**< */); +xcb_input_xi_change_hierarchy_checked (xcb_connection_t *c, + uint8_t num_changes, + const xcb_input_hierarchy_change_t *changes); /** * @@ -7258,9 +7856,15 @@ xcb_input_xi_change_hierarchy_checked (xcb_connection_t *c /* * */ xcb_void_cookie_t -xcb_input_xi_change_hierarchy (xcb_connection_t *c /**< */, - uint8_t num_changes /**< */, - const xcb_input_hierarchy_change_t *changes /**< */); +xcb_input_xi_change_hierarchy (xcb_connection_t *c, + uint8_t num_changes, + const xcb_input_hierarchy_change_t *changes); + +int +xcb_input_xi_change_hierarchy_changes_length (const xcb_input_xi_change_hierarchy_request_t *R); + +xcb_input_hierarchy_change_iterator_t +xcb_input_xi_change_hierarchy_changes_iterator (const xcb_input_xi_change_hierarchy_request_t *R); /** * @@ -7274,9 +7878,9 @@ xcb_input_xi_change_hierarchy (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_set_client_pointer_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_set_client_pointer_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid); /** * @@ -7287,9 +7891,9 @@ xcb_input_xi_set_client_pointer_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_xi_set_client_pointer (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_set_client_pointer (xcb_connection_t *c, + xcb_window_t window, + xcb_input_device_id_t deviceid); /** * @@ -7300,8 +7904,8 @@ xcb_input_xi_set_client_pointer (xcb_connection_t *c /**< */, * */ xcb_input_xi_get_client_pointer_cookie_t -xcb_input_xi_get_client_pointer (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_input_xi_get_client_pointer (xcb_connection_t *c, + xcb_window_t window); /** * @@ -7315,8 +7919,8 @@ xcb_input_xi_get_client_pointer (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_xi_get_client_pointer_cookie_t -xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c, + xcb_window_t window); /** * Return the reply @@ -7333,21 +7937,21 @@ xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_xi_get_client_pointer_reply_t * -xcb_input_xi_get_client_pointer_reply (xcb_connection_t *c /**< */, +xcb_input_xi_get_client_pointer_reply (xcb_connection_t *c, xcb_input_xi_get_client_pointer_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_event_mask_sizeof (const void *_buffer /**< */); +xcb_input_event_mask_sizeof (const void *_buffer); uint32_t * -xcb_input_event_mask_mask (const xcb_input_event_mask_t *R /**< */); +xcb_input_event_mask_mask (const xcb_input_event_mask_t *R); int -xcb_input_event_mask_mask_length (const xcb_input_event_mask_t *R /**< */); +xcb_input_event_mask_mask_length (const xcb_input_event_mask_t *R); xcb_generic_iterator_t -xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R /**< */); +xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R); /** * Get the next element of the iterator @@ -7358,7 +7962,7 @@ xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R /**< */); * element. The member index is increased by sizeof(xcb_input_event_mask_t) */ void -xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i /**< */); +xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7370,10 +7974,10 @@ xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_event_mask_end (xcb_input_event_mask_iterator_t i /**< */); +xcb_input_event_mask_end (xcb_input_event_mask_iterator_t i); int -xcb_input_xi_select_events_sizeof (const void *_buffer /**< */); +xcb_input_xi_select_events_sizeof (const void *_buffer); /** * @@ -7387,10 +7991,10 @@ xcb_input_xi_select_events_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_select_events_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_mask /**< */, - const xcb_input_event_mask_t *masks /**< */); +xcb_input_xi_select_events_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_mask, + const xcb_input_event_mask_t *masks); /** * @@ -7401,10 +8005,16 @@ xcb_input_xi_select_events_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_xi_select_events (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t num_mask /**< */, - const xcb_input_event_mask_t *masks /**< */); +xcb_input_xi_select_events (xcb_connection_t *c, + xcb_window_t window, + uint16_t num_mask, + const xcb_input_event_mask_t *masks); + +int +xcb_input_xi_select_events_masks_length (const xcb_input_xi_select_events_request_t *R); + +xcb_input_event_mask_iterator_t +xcb_input_xi_select_events_masks_iterator (const xcb_input_xi_select_events_request_t *R); /** * @@ -7415,9 +8025,9 @@ xcb_input_xi_select_events (xcb_connection_t *c /**< */, * */ xcb_input_xi_query_version_cookie_t -xcb_input_xi_query_version (xcb_connection_t *c /**< */, - uint16_t major_version /**< */, - uint16_t minor_version /**< */); +xcb_input_xi_query_version (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version); /** * @@ -7431,9 +8041,9 @@ xcb_input_xi_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_xi_query_version_cookie_t -xcb_input_xi_query_version_unchecked (xcb_connection_t *c /**< */, - uint16_t major_version /**< */, - uint16_t minor_version /**< */); +xcb_input_xi_query_version_unchecked (xcb_connection_t *c, + uint16_t major_version, + uint16_t minor_version); /** * Return the reply @@ -7450,30 +8060,30 @@ xcb_input_xi_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_xi_query_version_reply_t * -xcb_input_xi_query_version_reply (xcb_connection_t *c /**< */, +xcb_input_xi_query_version_reply (xcb_connection_t *c, xcb_input_xi_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_button_class_sizeof (const void *_buffer /**< */); +xcb_input_button_class_sizeof (const void *_buffer); uint32_t * -xcb_input_button_class_state (const xcb_input_button_class_t *R /**< */); +xcb_input_button_class_state (const xcb_input_button_class_t *R); int -xcb_input_button_class_state_length (const xcb_input_button_class_t *R /**< */); +xcb_input_button_class_state_length (const xcb_input_button_class_t *R); xcb_generic_iterator_t -xcb_input_button_class_state_end (const xcb_input_button_class_t *R /**< */); +xcb_input_button_class_state_end (const xcb_input_button_class_t *R); xcb_atom_t * -xcb_input_button_class_labels (const xcb_input_button_class_t *R /**< */); +xcb_input_button_class_labels (const xcb_input_button_class_t *R); int -xcb_input_button_class_labels_length (const xcb_input_button_class_t *R /**< */); +xcb_input_button_class_labels_length (const xcb_input_button_class_t *R); xcb_generic_iterator_t -xcb_input_button_class_labels_end (const xcb_input_button_class_t *R /**< */); +xcb_input_button_class_labels_end (const xcb_input_button_class_t *R); /** * Get the next element of the iterator @@ -7484,7 +8094,7 @@ xcb_input_button_class_labels_end (const xcb_input_button_class_t *R /**< */); * element. The member index is increased by sizeof(xcb_input_button_class_t) */ void -xcb_input_button_class_next (xcb_input_button_class_iterator_t *i /**< */); +xcb_input_button_class_next (xcb_input_button_class_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7496,19 +8106,19 @@ xcb_input_button_class_next (xcb_input_button_class_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_button_class_end (xcb_input_button_class_iterator_t i /**< */); +xcb_input_button_class_end (xcb_input_button_class_iterator_t i); int -xcb_input_key_class_sizeof (const void *_buffer /**< */); +xcb_input_key_class_sizeof (const void *_buffer); uint32_t * -xcb_input_key_class_keys (const xcb_input_key_class_t *R /**< */); +xcb_input_key_class_keys (const xcb_input_key_class_t *R); int -xcb_input_key_class_keys_length (const xcb_input_key_class_t *R /**< */); +xcb_input_key_class_keys_length (const xcb_input_key_class_t *R); xcb_generic_iterator_t -xcb_input_key_class_keys_end (const xcb_input_key_class_t *R /**< */); +xcb_input_key_class_keys_end (const xcb_input_key_class_t *R); /** * Get the next element of the iterator @@ -7519,7 +8129,7 @@ xcb_input_key_class_keys_end (const xcb_input_key_class_t *R /**< */); * element. The member index is increased by sizeof(xcb_input_key_class_t) */ void -xcb_input_key_class_next (xcb_input_key_class_iterator_t *i /**< */); +xcb_input_key_class_next (xcb_input_key_class_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7531,7 +8141,7 @@ xcb_input_key_class_next (xcb_input_key_class_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_key_class_end (xcb_input_key_class_iterator_t i /**< */); +xcb_input_key_class_end (xcb_input_key_class_iterator_t i); /** * Get the next element of the iterator @@ -7542,7 +8152,7 @@ xcb_input_key_class_end (xcb_input_key_class_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_scroll_class_t) */ void -xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i /**< */); +xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7554,7 +8164,7 @@ xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i /**< */); +xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i); /** * Get the next element of the iterator @@ -7565,7 +8175,7 @@ xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_touch_class_t) */ void -xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i /**< */); +xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7577,7 +8187,7 @@ xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i /**< */); +xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i); /** * Get the next element of the iterator @@ -7588,7 +8198,7 @@ xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_input_valuator_class_t) */ void -xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i /**< */); +xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7600,19 +8210,57 @@ xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_valuator_class_end (xcb_input_valuator_class_iterator_t i /**< */); +xcb_input_valuator_class_end (xcb_input_valuator_class_iterator_t i); + +uint32_t * +xcb_input_device_class_data_key_keys (const xcb_input_device_class_data_t *S); int -xcb_input_device_class_sizeof (const void *_buffer /**< */); - -uint8_t * -xcb_input_device_class_uninterpreted_data (const xcb_input_device_class_t *R /**< */); - -int -xcb_input_device_class_uninterpreted_data_length (const xcb_input_device_class_t *R /**< */); +xcb_input_device_class_data_key_keys_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); xcb_generic_iterator_t -xcb_input_device_class_uninterpreted_data_end (const xcb_input_device_class_t *R /**< */); +xcb_input_device_class_data_key_keys_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +uint32_t * +xcb_input_device_class_data_button_state (const xcb_input_device_class_data_t *S); + +int +xcb_input_device_class_data_button_state_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_class_data_button_state_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +xcb_atom_t * +xcb_input_device_class_data_button_labels (const xcb_input_device_class_data_t *S); + +int +xcb_input_device_class_data_button_labels_length (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +xcb_generic_iterator_t +xcb_input_device_class_data_button_labels_end (const xcb_input_device_class_t *R, + const xcb_input_device_class_data_t *S); + +int +xcb_input_device_class_data_serialize (void **_buffer, + uint16_t type, + const xcb_input_device_class_data_t *_aux); + +int +xcb_input_device_class_data_unpack (const void *_buffer, + uint16_t type, + xcb_input_device_class_data_t *_aux); + +int +xcb_input_device_class_data_sizeof (const void *_buffer, + uint16_t type); + +int +xcb_input_device_class_sizeof (const void *_buffer); /** * Get the next element of the iterator @@ -7623,7 +8271,7 @@ xcb_input_device_class_uninterpreted_data_end (const xcb_input_device_class_t *R * element. The member index is increased by sizeof(xcb_input_device_class_t) */ void -xcb_input_device_class_next (xcb_input_device_class_iterator_t *i /**< */); +xcb_input_device_class_next (xcb_input_device_class_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7635,25 +8283,25 @@ xcb_input_device_class_next (xcb_input_device_class_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_device_class_end (xcb_input_device_class_iterator_t i /**< */); +xcb_input_device_class_end (xcb_input_device_class_iterator_t i); int -xcb_input_xi_device_info_sizeof (const void *_buffer /**< */); +xcb_input_xi_device_info_sizeof (const void *_buffer); char * -xcb_input_xi_device_info_name (const xcb_input_xi_device_info_t *R /**< */); +xcb_input_xi_device_info_name (const xcb_input_xi_device_info_t *R); int -xcb_input_xi_device_info_name_length (const xcb_input_xi_device_info_t *R /**< */); +xcb_input_xi_device_info_name_length (const xcb_input_xi_device_info_t *R); xcb_generic_iterator_t -xcb_input_xi_device_info_name_end (const xcb_input_xi_device_info_t *R /**< */); +xcb_input_xi_device_info_name_end (const xcb_input_xi_device_info_t *R); int -xcb_input_xi_device_info_classes_length (const xcb_input_xi_device_info_t *R /**< */); +xcb_input_xi_device_info_classes_length (const xcb_input_xi_device_info_t *R); xcb_input_device_class_iterator_t -xcb_input_xi_device_info_classes_iterator (const xcb_input_xi_device_info_t *R /**< */); +xcb_input_xi_device_info_classes_iterator (const xcb_input_xi_device_info_t *R); /** * Get the next element of the iterator @@ -7664,7 +8312,7 @@ xcb_input_xi_device_info_classes_iterator (const xcb_input_xi_device_info_t *R * element. The member index is increased by sizeof(xcb_input_xi_device_info_t) */ void -xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i /**< */); +xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7676,10 +8324,10 @@ xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_xi_device_info_end (xcb_input_xi_device_info_iterator_t i /**< */); +xcb_input_xi_device_info_end (xcb_input_xi_device_info_iterator_t i); int -xcb_input_xi_query_device_sizeof (const void *_buffer /**< */); +xcb_input_xi_query_device_sizeof (const void *_buffer); /** * @@ -7690,8 +8338,8 @@ xcb_input_xi_query_device_sizeof (const void *_buffer /**< */); * */ xcb_input_xi_query_device_cookie_t -xcb_input_xi_query_device (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_query_device (xcb_connection_t *c, + xcb_input_device_id_t deviceid); /** * @@ -7705,14 +8353,14 @@ xcb_input_xi_query_device (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_xi_query_device_cookie_t -xcb_input_xi_query_device_unchecked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_query_device_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid); int -xcb_input_xi_query_device_infos_length (const xcb_input_xi_query_device_reply_t *R /**< */); +xcb_input_xi_query_device_infos_length (const xcb_input_xi_query_device_reply_t *R); xcb_input_xi_device_info_iterator_t -xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_t *R /**< */); +xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_t *R); /** * Return the reply @@ -7729,9 +8377,9 @@ xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_ * The returned value must be freed by the caller using free(). */ xcb_input_xi_query_device_reply_t * -xcb_input_xi_query_device_reply (xcb_connection_t *c /**< */, +xcb_input_xi_query_device_reply (xcb_connection_t *c, xcb_input_xi_query_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -7745,10 +8393,10 @@ xcb_input_xi_query_device_reply (xcb_connection_t *c /**< */ * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_set_focus_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_set_focus_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid); /** * @@ -7759,10 +8407,10 @@ xcb_input_xi_set_focus_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_xi_set_focus (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_set_focus (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid); /** * @@ -7773,8 +8421,8 @@ xcb_input_xi_set_focus (xcb_connection_t *c /**< */, * */ xcb_input_xi_get_focus_cookie_t -xcb_input_xi_get_focus (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_get_focus (xcb_connection_t *c, + xcb_input_device_id_t deviceid); /** * @@ -7788,8 +8436,8 @@ xcb_input_xi_get_focus (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_xi_get_focus_cookie_t -xcb_input_xi_get_focus_unchecked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_get_focus_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid); /** * Return the reply @@ -7806,12 +8454,12 @@ xcb_input_xi_get_focus_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_xi_get_focus_reply_t * -xcb_input_xi_get_focus_reply (xcb_connection_t *c /**< */, +xcb_input_xi_get_focus_reply (xcb_connection_t *c, xcb_input_xi_get_focus_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_xi_grab_device_sizeof (const void *_buffer /**< */); +xcb_input_xi_grab_device_sizeof (const void *_buffer); /** * @@ -7822,16 +8470,16 @@ xcb_input_xi_grab_device_sizeof (const void *_buffer /**< */); * */ xcb_input_xi_grab_device_cookie_t -xcb_input_xi_grab_device (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t time /**< */, - xcb_cursor_t cursor /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t paired_device_mode /**< */, - uint8_t owner_events /**< */, - uint16_t mask_len /**< */, - const uint32_t *mask /**< */); +xcb_input_xi_grab_device (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t paired_device_mode, + uint8_t owner_events, + uint16_t mask_len, + const uint32_t *mask); /** * @@ -7845,16 +8493,16 @@ xcb_input_xi_grab_device (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_xi_grab_device_cookie_t -xcb_input_xi_grab_device_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t time /**< */, - xcb_cursor_t cursor /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t paired_device_mode /**< */, - uint8_t owner_events /**< */, - uint16_t mask_len /**< */, - const uint32_t *mask /**< */); +xcb_input_xi_grab_device_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t time, + xcb_cursor_t cursor, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t paired_device_mode, + uint8_t owner_events, + uint16_t mask_len, + const uint32_t *mask); /** * Return the reply @@ -7871,9 +8519,9 @@ xcb_input_xi_grab_device_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_input_xi_grab_device_reply_t * -xcb_input_xi_grab_device_reply (xcb_connection_t *c /**< */, +xcb_input_xi_grab_device_reply (xcb_connection_t *c, xcb_input_xi_grab_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -7887,9 +8535,9 @@ xcb_input_xi_grab_device_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_ungrab_device_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_ungrab_device_checked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid); /** * @@ -7900,9 +8548,9 @@ xcb_input_xi_ungrab_device_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_xi_ungrab_device (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_ungrab_device (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid); /** * @@ -7916,12 +8564,12 @@ xcb_input_xi_ungrab_device (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_allow_events_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t event_mode /**< */, - uint32_t touchid /**< */, - xcb_window_t grab_window /**< */); +xcb_input_xi_allow_events_checked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid, + uint8_t event_mode, + uint32_t touchid, + xcb_window_t grab_window); /** * @@ -7932,12 +8580,12 @@ xcb_input_xi_allow_events_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_xi_allow_events (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t event_mode /**< */, - uint32_t touchid /**< */, - xcb_window_t grab_window /**< */); +xcb_input_xi_allow_events (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_input_device_id_t deviceid, + uint8_t event_mode, + uint32_t touchid, + xcb_window_t grab_window); /** * Get the next element of the iterator @@ -7948,7 +8596,7 @@ xcb_input_xi_allow_events (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_input_grab_modifier_info_t) */ void -xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i /**< */); +xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7960,10 +8608,10 @@ xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i / * last element. */ xcb_generic_iterator_t -xcb_input_grab_modifier_info_end (xcb_input_grab_modifier_info_iterator_t i /**< */); +xcb_input_grab_modifier_info_end (xcb_input_grab_modifier_info_iterator_t i); int -xcb_input_xi_passive_grab_device_sizeof (const void *_buffer /**< */); +xcb_input_xi_passive_grab_device_sizeof (const void *_buffer); /** * @@ -7974,20 +8622,20 @@ xcb_input_xi_passive_grab_device_sizeof (const void *_buffer /**< */); * */ xcb_input_xi_passive_grab_device_cookie_t -xcb_input_xi_passive_grab_device (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_window_t grab_window /**< */, - xcb_cursor_t cursor /**< */, - uint32_t detail /**< */, - xcb_input_device_id_t deviceid /**< */, - uint16_t num_modifiers /**< */, - uint16_t mask_len /**< */, - uint8_t grab_type /**< */, - uint8_t grab_mode /**< */, - uint8_t paired_device_mode /**< */, - uint8_t owner_events /**< */, - const uint32_t *mask /**< */, - const uint32_t *modifiers /**< */); +xcb_input_xi_passive_grab_device (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_window_t grab_window, + xcb_cursor_t cursor, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint16_t mask_len, + uint8_t grab_type, + uint8_t grab_mode, + uint8_t paired_device_mode, + uint8_t owner_events, + const uint32_t *mask, + const uint32_t *modifiers); /** * @@ -8001,29 +8649,29 @@ xcb_input_xi_passive_grab_device (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_xi_passive_grab_device_cookie_t -xcb_input_xi_passive_grab_device_unchecked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */, - xcb_window_t grab_window /**< */, - xcb_cursor_t cursor /**< */, - uint32_t detail /**< */, - xcb_input_device_id_t deviceid /**< */, - uint16_t num_modifiers /**< */, - uint16_t mask_len /**< */, - uint8_t grab_type /**< */, - uint8_t grab_mode /**< */, - uint8_t paired_device_mode /**< */, - uint8_t owner_events /**< */, - const uint32_t *mask /**< */, - const uint32_t *modifiers /**< */); +xcb_input_xi_passive_grab_device_unchecked (xcb_connection_t *c, + xcb_timestamp_t time, + xcb_window_t grab_window, + xcb_cursor_t cursor, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint16_t mask_len, + uint8_t grab_type, + uint8_t grab_mode, + uint8_t paired_device_mode, + uint8_t owner_events, + const uint32_t *mask, + const uint32_t *modifiers); xcb_input_grab_modifier_info_t * -xcb_input_xi_passive_grab_device_modifiers (const xcb_input_xi_passive_grab_device_reply_t *R /**< */); +xcb_input_xi_passive_grab_device_modifiers (const xcb_input_xi_passive_grab_device_reply_t *R); int -xcb_input_xi_passive_grab_device_modifiers_length (const xcb_input_xi_passive_grab_device_reply_t *R /**< */); +xcb_input_xi_passive_grab_device_modifiers_length (const xcb_input_xi_passive_grab_device_reply_t *R); xcb_input_grab_modifier_info_iterator_t -xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_grab_device_reply_t *R /**< */); +xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_grab_device_reply_t *R); /** * Return the reply @@ -8040,12 +8688,12 @@ xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_ * The returned value must be freed by the caller using free(). */ xcb_input_xi_passive_grab_device_reply_t * -xcb_input_xi_passive_grab_device_reply (xcb_connection_t *c /**< */, +xcb_input_xi_passive_grab_device_reply (xcb_connection_t *c, xcb_input_xi_passive_grab_device_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_xi_passive_ungrab_device_sizeof (const void *_buffer /**< */); +xcb_input_xi_passive_ungrab_device_sizeof (const void *_buffer); /** * @@ -8059,13 +8707,13 @@ xcb_input_xi_passive_ungrab_device_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint32_t detail /**< */, - xcb_input_device_id_t deviceid /**< */, - uint16_t num_modifiers /**< */, - uint8_t grab_type /**< */, - const uint32_t *modifiers /**< */); +xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t *c, + xcb_window_t grab_window, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint8_t grab_type, + const uint32_t *modifiers); /** * @@ -8076,16 +8724,25 @@ xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_xi_passive_ungrab_device (xcb_connection_t *c /**< */, - xcb_window_t grab_window /**< */, - uint32_t detail /**< */, - xcb_input_device_id_t deviceid /**< */, - uint16_t num_modifiers /**< */, - uint8_t grab_type /**< */, - const uint32_t *modifiers /**< */); +xcb_input_xi_passive_ungrab_device (xcb_connection_t *c, + xcb_window_t grab_window, + uint32_t detail, + xcb_input_device_id_t deviceid, + uint16_t num_modifiers, + uint8_t grab_type, + const uint32_t *modifiers); + +uint32_t * +xcb_input_xi_passive_ungrab_device_modifiers (const xcb_input_xi_passive_ungrab_device_request_t *R); int -xcb_input_xi_list_properties_sizeof (const void *_buffer /**< */); +xcb_input_xi_passive_ungrab_device_modifiers_length (const xcb_input_xi_passive_ungrab_device_request_t *R); + +xcb_generic_iterator_t +xcb_input_xi_passive_ungrab_device_modifiers_end (const xcb_input_xi_passive_ungrab_device_request_t *R); + +int +xcb_input_xi_list_properties_sizeof (const void *_buffer); /** * @@ -8096,8 +8753,8 @@ xcb_input_xi_list_properties_sizeof (const void *_buffer /**< */); * */ xcb_input_xi_list_properties_cookie_t -xcb_input_xi_list_properties (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_list_properties (xcb_connection_t *c, + xcb_input_device_id_t deviceid); /** * @@ -8111,17 +8768,17 @@ xcb_input_xi_list_properties (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_xi_list_properties_cookie_t -xcb_input_xi_list_properties_unchecked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */); +xcb_input_xi_list_properties_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid); xcb_atom_t * -xcb_input_xi_list_properties_properties (const xcb_input_xi_list_properties_reply_t *R /**< */); +xcb_input_xi_list_properties_properties (const xcb_input_xi_list_properties_reply_t *R); int -xcb_input_xi_list_properties_properties_length (const xcb_input_xi_list_properties_reply_t *R /**< */); +xcb_input_xi_list_properties_properties_length (const xcb_input_xi_list_properties_reply_t *R); xcb_generic_iterator_t -xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_reply_t *R /**< */); +xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_reply_t *R); /** * Return the reply @@ -8138,59 +8795,62 @@ xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_ * The returned value must be freed by the caller using free(). */ xcb_input_xi_list_properties_reply_t * -xcb_input_xi_list_properties_reply (xcb_connection_t *c /**< */, +xcb_input_xi_list_properties_reply (xcb_connection_t *c, xcb_input_xi_list_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); uint8_t * -xcb_input_xi_change_property_items_data_8 (const xcb_input_xi_change_property_items_t *S /**< */); +xcb_input_xi_change_property_items_data_8 (const xcb_input_xi_change_property_items_t *S); int -xcb_input_xi_change_property_items_data_8_length (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */); +xcb_input_xi_change_property_items_data_8_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); xcb_generic_iterator_t -xcb_input_xi_change_property_items_data_8_end (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */); +xcb_input_xi_change_property_items_data_8_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); uint16_t * -xcb_input_xi_change_property_items_data_16 (const xcb_input_xi_change_property_items_t *S /**< */); +xcb_input_xi_change_property_items_data_16 (const xcb_input_xi_change_property_items_t *S); int -xcb_input_xi_change_property_items_data_16_length (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */); +xcb_input_xi_change_property_items_data_16_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); xcb_generic_iterator_t -xcb_input_xi_change_property_items_data_16_end (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */); +xcb_input_xi_change_property_items_data_16_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); uint32_t * -xcb_input_xi_change_property_items_data_32 (const xcb_input_xi_change_property_items_t *S /**< */); +xcb_input_xi_change_property_items_data_32 (const xcb_input_xi_change_property_items_t *S); int -xcb_input_xi_change_property_items_data_32_length (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */); +xcb_input_xi_change_property_items_data_32_length (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); xcb_generic_iterator_t -xcb_input_xi_change_property_items_data_32_end (const xcb_input_xi_change_property_request_t *R /**< */, - const xcb_input_xi_change_property_items_t *S /**< */); +xcb_input_xi_change_property_items_data_32_end (const xcb_input_xi_change_property_request_t *R, + const xcb_input_xi_change_property_items_t *S); int -xcb_input_xi_change_property_items_serialize (void **_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - const xcb_input_xi_change_property_items_t *_aux /**< */); +xcb_input_xi_change_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_xi_change_property_items_t *_aux); int -xcb_input_xi_change_property_items_unpack (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - xcb_input_xi_change_property_items_t *_aux /**< */); +xcb_input_xi_change_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_xi_change_property_items_t *_aux); int -xcb_input_xi_change_property_items_sizeof (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */); +xcb_input_xi_change_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format); + +int +xcb_input_xi_change_property_sizeof (const void *_buffer); /** * @@ -8204,14 +8864,14 @@ xcb_input_xi_change_property_items_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_change_property_checked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t format /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t num_items /**< */, - const void *items /**< */); +xcb_input_xi_change_property_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const void *items); /** * @@ -8222,14 +8882,14 @@ xcb_input_xi_change_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_xi_change_property (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t format /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t num_items /**< */, - const void *items /**< */); +xcb_input_xi_change_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const void *items); /** * @@ -8243,14 +8903,14 @@ xcb_input_xi_change_property (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_change_property_aux_checked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t format /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t num_items /**< */, - const xcb_input_xi_change_property_items_t *items /**< */); +xcb_input_xi_change_property_aux_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const xcb_input_xi_change_property_items_t *items); /** * @@ -8261,14 +8921,17 @@ xcb_input_xi_change_property_aux_checked (xcb_connection_t * */ xcb_void_cookie_t -xcb_input_xi_change_property_aux (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t mode /**< */, - uint8_t format /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t num_items /**< */, - const xcb_input_xi_change_property_items_t *items /**< */); +xcb_input_xi_change_property_aux (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t mode, + uint8_t format, + xcb_atom_t property, + xcb_atom_t type, + uint32_t num_items, + const xcb_input_xi_change_property_items_t *items); + +void * +xcb_input_xi_change_property_items (const xcb_input_xi_change_property_request_t *R); /** * @@ -8282,9 +8945,9 @@ xcb_input_xi_change_property_aux (xcb_connection_t *c * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_delete_property_checked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - xcb_atom_t property /**< */); +xcb_input_xi_delete_property_checked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + xcb_atom_t property); /** * @@ -8295,59 +8958,62 @@ xcb_input_xi_delete_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_input_xi_delete_property (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - xcb_atom_t property /**< */); +xcb_input_xi_delete_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + xcb_atom_t property); uint8_t * -xcb_input_xi_get_property_items_data_8 (const xcb_input_xi_get_property_items_t *S /**< */); +xcb_input_xi_get_property_items_data_8 (const xcb_input_xi_get_property_items_t *S); int -xcb_input_xi_get_property_items_data_8_length (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */); +xcb_input_xi_get_property_items_data_8_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); xcb_generic_iterator_t -xcb_input_xi_get_property_items_data_8_end (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */); +xcb_input_xi_get_property_items_data_8_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); uint16_t * -xcb_input_xi_get_property_items_data_16 (const xcb_input_xi_get_property_items_t *S /**< */); +xcb_input_xi_get_property_items_data_16 (const xcb_input_xi_get_property_items_t *S); int -xcb_input_xi_get_property_items_data_16_length (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */); +xcb_input_xi_get_property_items_data_16_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); xcb_generic_iterator_t -xcb_input_xi_get_property_items_data_16_end (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */); +xcb_input_xi_get_property_items_data_16_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); uint32_t * -xcb_input_xi_get_property_items_data_32 (const xcb_input_xi_get_property_items_t *S /**< */); +xcb_input_xi_get_property_items_data_32 (const xcb_input_xi_get_property_items_t *S); int -xcb_input_xi_get_property_items_data_32_length (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */); +xcb_input_xi_get_property_items_data_32_length (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); xcb_generic_iterator_t -xcb_input_xi_get_property_items_data_32_end (const xcb_input_xi_get_property_reply_t *R /**< */, - const xcb_input_xi_get_property_items_t *S /**< */); +xcb_input_xi_get_property_items_data_32_end (const xcb_input_xi_get_property_reply_t *R, + const xcb_input_xi_get_property_items_t *S); int -xcb_input_xi_get_property_items_serialize (void **_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - const xcb_input_xi_get_property_items_t *_aux /**< */); +xcb_input_xi_get_property_items_serialize (void **_buffer, + uint32_t num_items, + uint8_t format, + const xcb_input_xi_get_property_items_t *_aux); int -xcb_input_xi_get_property_items_unpack (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */, - xcb_input_xi_get_property_items_t *_aux /**< */); +xcb_input_xi_get_property_items_unpack (const void *_buffer, + uint32_t num_items, + uint8_t format, + xcb_input_xi_get_property_items_t *_aux); int -xcb_input_xi_get_property_items_sizeof (const void *_buffer /**< */, - uint32_t num_items /**< */, - uint8_t format /**< */); +xcb_input_xi_get_property_items_sizeof (const void *_buffer, + uint32_t num_items, + uint8_t format); + +int +xcb_input_xi_get_property_sizeof (const void *_buffer); /** * @@ -8358,13 +9024,13 @@ xcb_input_xi_get_property_items_sizeof (const void *_buffer /**< */, * */ xcb_input_xi_get_property_cookie_t -xcb_input_xi_get_property (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t _delete /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t offset /**< */, - uint32_t len /**< */); +xcb_input_xi_get_property (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t _delete, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len); /** * @@ -8378,16 +9044,16 @@ xcb_input_xi_get_property (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_xi_get_property_cookie_t -xcb_input_xi_get_property_unchecked (xcb_connection_t *c /**< */, - xcb_input_device_id_t deviceid /**< */, - uint8_t _delete /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t offset /**< */, - uint32_t len /**< */); +xcb_input_xi_get_property_unchecked (xcb_connection_t *c, + xcb_input_device_id_t deviceid, + uint8_t _delete, + xcb_atom_t property, + xcb_atom_t type, + uint32_t offset, + uint32_t len); void * -xcb_input_xi_get_property_items (const xcb_input_xi_get_property_reply_t *R /**< */); +xcb_input_xi_get_property_items (const xcb_input_xi_get_property_reply_t *R); /** * Return the reply @@ -8404,12 +9070,12 @@ xcb_input_xi_get_property_items (const xcb_input_xi_get_property_reply_t *R /** * The returned value must be freed by the caller using free(). */ xcb_input_xi_get_property_reply_t * -xcb_input_xi_get_property_reply (xcb_connection_t *c /**< */, +xcb_input_xi_get_property_reply (xcb_connection_t *c, xcb_input_xi_get_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_input_xi_get_selected_events_sizeof (const void *_buffer /**< */); +xcb_input_xi_get_selected_events_sizeof (const void *_buffer); /** * @@ -8420,8 +9086,8 @@ xcb_input_xi_get_selected_events_sizeof (const void *_buffer /**< */); * */ xcb_input_xi_get_selected_events_cookie_t -xcb_input_xi_get_selected_events (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_input_xi_get_selected_events (xcb_connection_t *c, + xcb_window_t window); /** * @@ -8435,14 +9101,14 @@ xcb_input_xi_get_selected_events (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_input_xi_get_selected_events_cookie_t -xcb_input_xi_get_selected_events_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_input_xi_get_selected_events_unchecked (xcb_connection_t *c, + xcb_window_t window); int -xcb_input_xi_get_selected_events_masks_length (const xcb_input_xi_get_selected_events_reply_t *R /**< */); +xcb_input_xi_get_selected_events_masks_length (const xcb_input_xi_get_selected_events_reply_t *R); xcb_input_event_mask_iterator_t -xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected_events_reply_t *R /**< */); +xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected_events_reply_t *R); /** * Return the reply @@ -8459,9 +9125,9 @@ xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected * The returned value must be freed by the caller using free(). */ xcb_input_xi_get_selected_events_reply_t * -xcb_input_xi_get_selected_events_reply (xcb_connection_t *c /**< */, +xcb_input_xi_get_selected_events_reply (xcb_connection_t *c, xcb_input_xi_get_selected_events_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Get the next element of the iterator @@ -8472,7 +9138,7 @@ xcb_input_xi_get_selected_events_reply (xcb_connection_t * element. The member index is increased by sizeof(xcb_input_barrier_release_pointer_info_t) */ void -xcb_input_barrier_release_pointer_info_next (xcb_input_barrier_release_pointer_info_iterator_t *i /**< */); +xcb_input_barrier_release_pointer_info_next (xcb_input_barrier_release_pointer_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -8484,10 +9150,10 @@ xcb_input_barrier_release_pointer_info_next (xcb_input_barrier_release_pointer_i * last element. */ xcb_generic_iterator_t -xcb_input_barrier_release_pointer_info_end (xcb_input_barrier_release_pointer_info_iterator_t i /**< */); +xcb_input_barrier_release_pointer_info_end (xcb_input_barrier_release_pointer_info_iterator_t i); int -xcb_input_xi_barrier_release_pointer_sizeof (const void *_buffer /**< */); +xcb_input_xi_barrier_release_pointer_sizeof (const void *_buffer); /** * @@ -8501,9 +9167,9 @@ xcb_input_xi_barrier_release_pointer_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_input_xi_barrier_release_pointer_checked (xcb_connection_t *c /**< */, - uint32_t num_barriers /**< */, - const xcb_input_barrier_release_pointer_info_t *barriers /**< */); +xcb_input_xi_barrier_release_pointer_checked (xcb_connection_t *c, + uint32_t num_barriers, + const xcb_input_barrier_release_pointer_info_t *barriers); /** * @@ -8514,21 +9180,90 @@ xcb_input_xi_barrier_release_pointer_checked (xcb_connection_t * */ xcb_void_cookie_t -xcb_input_xi_barrier_release_pointer (xcb_connection_t *c /**< */, - uint32_t num_barriers /**< */, - const xcb_input_barrier_release_pointer_info_t *barriers /**< */); +xcb_input_xi_barrier_release_pointer (xcb_connection_t *c, + uint32_t num_barriers, + const xcb_input_barrier_release_pointer_info_t *barriers); + +xcb_input_barrier_release_pointer_info_t * +xcb_input_xi_barrier_release_pointer_barriers (const xcb_input_xi_barrier_release_pointer_request_t *R); int -xcb_input_device_changed_sizeof (const void *_buffer /**< */); +xcb_input_xi_barrier_release_pointer_barriers_length (const xcb_input_xi_barrier_release_pointer_request_t *R); + +xcb_input_barrier_release_pointer_info_iterator_t +xcb_input_xi_barrier_release_pointer_barriers_iterator (const xcb_input_xi_barrier_release_pointer_request_t *R); int -xcb_input_key_press_sizeof (const void *_buffer /**< */); +xcb_input_device_changed_sizeof (const void *_buffer); + +int +xcb_input_device_changed_classes_length (const xcb_input_device_changed_event_t *R); + +xcb_input_device_class_iterator_t +xcb_input_device_changed_classes_iterator (const xcb_input_device_changed_event_t *R); + +int +xcb_input_key_press_sizeof (const void *_buffer); + +uint32_t * +xcb_input_key_press_button_mask (const xcb_input_key_press_event_t *R); + +int +xcb_input_key_press_button_mask_length (const xcb_input_key_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_key_press_button_mask_end (const xcb_input_key_press_event_t *R); + +uint32_t * +xcb_input_key_press_valuator_mask (const xcb_input_key_press_event_t *R); + +int +xcb_input_key_press_valuator_mask_length (const xcb_input_key_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_key_press_valuator_mask_end (const xcb_input_key_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_key_press_axisvalues (const xcb_input_key_press_event_t *R); + +int +xcb_input_key_press_axisvalues_length (const xcb_input_key_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_key_press_axisvalues_iterator (const xcb_input_key_press_event_t *R); int xcb_input_key_release_sizeof (const void *_buffer /**< */); int -xcb_input_button_press_sizeof (const void *_buffer /**< */); +xcb_input_button_press_sizeof (const void *_buffer); + +uint32_t * +xcb_input_button_press_button_mask (const xcb_input_button_press_event_t *R); + +int +xcb_input_button_press_button_mask_length (const xcb_input_button_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_button_press_button_mask_end (const xcb_input_button_press_event_t *R); + +uint32_t * +xcb_input_button_press_valuator_mask (const xcb_input_button_press_event_t *R); + +int +xcb_input_button_press_valuator_mask_length (const xcb_input_button_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_button_press_valuator_mask_end (const xcb_input_button_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_button_press_axisvalues (const xcb_input_button_press_event_t *R); + +int +xcb_input_button_press_axisvalues_length (const xcb_input_button_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_button_press_axisvalues_iterator (const xcb_input_button_press_event_t *R); int xcb_input_button_release_sizeof (const void *_buffer /**< */); @@ -8537,7 +9272,16 @@ int xcb_input_motion_sizeof (const void *_buffer /**< */); int -xcb_input_enter_sizeof (const void *_buffer /**< */); +xcb_input_enter_sizeof (const void *_buffer); + +uint32_t * +xcb_input_enter_buttons (const xcb_input_enter_event_t *R); + +int +xcb_input_enter_buttons_length (const xcb_input_enter_event_t *R); + +xcb_generic_iterator_t +xcb_input_enter_buttons_end (const xcb_input_enter_event_t *R); int xcb_input_leave_sizeof (const void *_buffer /**< */); @@ -8557,7 +9301,7 @@ xcb_input_focus_out_sizeof (const void *_buffer /**< */); * element. The member index is increased by sizeof(xcb_input_hierarchy_info_t) */ void -xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i /**< */); +xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -8569,19 +9313,82 @@ xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_input_hierarchy_info_end (xcb_input_hierarchy_info_iterator_t i /**< */); +xcb_input_hierarchy_info_end (xcb_input_hierarchy_info_iterator_t i); int -xcb_input_hierarchy_sizeof (const void *_buffer /**< */); +xcb_input_hierarchy_sizeof (const void *_buffer); + +xcb_input_hierarchy_info_t * +xcb_input_hierarchy_infos (const xcb_input_hierarchy_event_t *R); int -xcb_input_raw_key_press_sizeof (const void *_buffer /**< */); +xcb_input_hierarchy_infos_length (const xcb_input_hierarchy_event_t *R); + +xcb_input_hierarchy_info_iterator_t +xcb_input_hierarchy_infos_iterator (const xcb_input_hierarchy_event_t *R); + +int +xcb_input_raw_key_press_sizeof (const void *_buffer); + +uint32_t * +xcb_input_raw_key_press_valuator_mask (const xcb_input_raw_key_press_event_t *R); + +int +xcb_input_raw_key_press_valuator_mask_length (const xcb_input_raw_key_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_raw_key_press_valuator_mask_end (const xcb_input_raw_key_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_key_press_axisvalues (const xcb_input_raw_key_press_event_t *R); + +int +xcb_input_raw_key_press_axisvalues_length (const xcb_input_raw_key_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_key_press_axisvalues_iterator (const xcb_input_raw_key_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_key_press_axisvalues_raw (const xcb_input_raw_key_press_event_t *R); + +int +xcb_input_raw_key_press_axisvalues_raw_length (const xcb_input_raw_key_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_key_press_axisvalues_raw_iterator (const xcb_input_raw_key_press_event_t *R); int xcb_input_raw_key_release_sizeof (const void *_buffer /**< */); int -xcb_input_raw_button_press_sizeof (const void *_buffer /**< */); +xcb_input_raw_button_press_sizeof (const void *_buffer); + +uint32_t * +xcb_input_raw_button_press_valuator_mask (const xcb_input_raw_button_press_event_t *R); + +int +xcb_input_raw_button_press_valuator_mask_length (const xcb_input_raw_button_press_event_t *R); + +xcb_generic_iterator_t +xcb_input_raw_button_press_valuator_mask_end (const xcb_input_raw_button_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_button_press_axisvalues (const xcb_input_raw_button_press_event_t *R); + +int +xcb_input_raw_button_press_axisvalues_length (const xcb_input_raw_button_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_button_press_axisvalues_iterator (const xcb_input_raw_button_press_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_button_press_axisvalues_raw (const xcb_input_raw_button_press_event_t *R); + +int +xcb_input_raw_button_press_axisvalues_raw_length (const xcb_input_raw_button_press_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_button_press_axisvalues_raw_iterator (const xcb_input_raw_button_press_event_t *R); int xcb_input_raw_button_release_sizeof (const void *_buffer /**< */); @@ -8590,7 +9397,34 @@ int xcb_input_raw_motion_sizeof (const void *_buffer /**< */); int -xcb_input_touch_begin_sizeof (const void *_buffer /**< */); +xcb_input_touch_begin_sizeof (const void *_buffer); + +uint32_t * +xcb_input_touch_begin_button_mask (const xcb_input_touch_begin_event_t *R); + +int +xcb_input_touch_begin_button_mask_length (const xcb_input_touch_begin_event_t *R); + +xcb_generic_iterator_t +xcb_input_touch_begin_button_mask_end (const xcb_input_touch_begin_event_t *R); + +uint32_t * +xcb_input_touch_begin_valuator_mask (const xcb_input_touch_begin_event_t *R); + +int +xcb_input_touch_begin_valuator_mask_length (const xcb_input_touch_begin_event_t *R); + +xcb_generic_iterator_t +xcb_input_touch_begin_valuator_mask_end (const xcb_input_touch_begin_event_t *R); + +xcb_input_fp3232_t * +xcb_input_touch_begin_axisvalues (const xcb_input_touch_begin_event_t *R); + +int +xcb_input_touch_begin_axisvalues_length (const xcb_input_touch_begin_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_touch_begin_axisvalues_iterator (const xcb_input_touch_begin_event_t *R); int xcb_input_touch_update_sizeof (const void *_buffer /**< */); @@ -8599,7 +9433,34 @@ int xcb_input_touch_end_sizeof (const void *_buffer /**< */); int -xcb_input_raw_touch_begin_sizeof (const void *_buffer /**< */); +xcb_input_raw_touch_begin_sizeof (const void *_buffer); + +uint32_t * +xcb_input_raw_touch_begin_valuator_mask (const xcb_input_raw_touch_begin_event_t *R); + +int +xcb_input_raw_touch_begin_valuator_mask_length (const xcb_input_raw_touch_begin_event_t *R); + +xcb_generic_iterator_t +xcb_input_raw_touch_begin_valuator_mask_end (const xcb_input_raw_touch_begin_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_touch_begin_axisvalues (const xcb_input_raw_touch_begin_event_t *R); + +int +xcb_input_raw_touch_begin_axisvalues_length (const xcb_input_raw_touch_begin_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_touch_begin_axisvalues_iterator (const xcb_input_raw_touch_begin_event_t *R); + +xcb_input_fp3232_t * +xcb_input_raw_touch_begin_axisvalues_raw (const xcb_input_raw_touch_begin_event_t *R); + +int +xcb_input_raw_touch_begin_axisvalues_raw_length (const xcb_input_raw_touch_begin_event_t *R); + +xcb_input_fp3232_iterator_t +xcb_input_raw_touch_begin_axisvalues_raw_iterator (const xcb_input_raw_touch_begin_event_t *R); int xcb_input_raw_touch_update_sizeof (const void *_buffer /**< */); diff --git a/lib/libxcb/src/xkb.c b/lib/libxcb/src/xkb.c index c03ea83b3..e4621b147 100644 --- a/lib/libxcb/src/xkb.c +++ b/lib/libxcb/src/xkb.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_xkb_id = { "XKEYBOARD", 0 }; void -xcb_xkb_device_spec_next (xcb_xkb_device_spec_iterator_t *i /**< */) +xcb_xkb_device_spec_next (xcb_xkb_device_spec_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_xkb_device_spec_next (xcb_xkb_device_spec_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_device_spec_end (xcb_xkb_device_spec_iterator_t i /**< */) +xcb_xkb_device_spec_end (xcb_xkb_device_spec_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,7 +37,7 @@ xcb_xkb_device_spec_end (xcb_xkb_device_spec_iterator_t i /**< */) } void -xcb_xkb_led_class_spec_next (xcb_xkb_led_class_spec_iterator_t *i /**< */) +xcb_xkb_led_class_spec_next (xcb_xkb_led_class_spec_iterator_t *i) { --i->rem; ++i->data; @@ -45,7 +45,7 @@ xcb_xkb_led_class_spec_next (xcb_xkb_led_class_spec_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_led_class_spec_end (xcb_xkb_led_class_spec_iterator_t i /**< */) +xcb_xkb_led_class_spec_end (xcb_xkb_led_class_spec_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -55,7 +55,7 @@ xcb_xkb_led_class_spec_end (xcb_xkb_led_class_spec_iterator_t i /**< */) } void -xcb_xkb_bell_class_spec_next (xcb_xkb_bell_class_spec_iterator_t *i /**< */) +xcb_xkb_bell_class_spec_next (xcb_xkb_bell_class_spec_iterator_t *i) { --i->rem; ++i->data; @@ -63,7 +63,7 @@ xcb_xkb_bell_class_spec_next (xcb_xkb_bell_class_spec_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_bell_class_spec_end (xcb_xkb_bell_class_spec_iterator_t i /**< */) +xcb_xkb_bell_class_spec_end (xcb_xkb_bell_class_spec_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -73,7 +73,7 @@ xcb_xkb_bell_class_spec_end (xcb_xkb_bell_class_spec_iterator_t i /**< */) } void -xcb_xkb_id_spec_next (xcb_xkb_id_spec_iterator_t *i /**< */) +xcb_xkb_id_spec_next (xcb_xkb_id_spec_iterator_t *i) { --i->rem; ++i->data; @@ -81,7 +81,7 @@ xcb_xkb_id_spec_next (xcb_xkb_id_spec_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_id_spec_end (xcb_xkb_id_spec_iterator_t i /**< */) +xcb_xkb_id_spec_end (xcb_xkb_id_spec_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -91,7 +91,7 @@ xcb_xkb_id_spec_end (xcb_xkb_id_spec_iterator_t i /**< */) } void -xcb_xkb_indicator_map_next (xcb_xkb_indicator_map_iterator_t *i /**< */) +xcb_xkb_indicator_map_next (xcb_xkb_indicator_map_iterator_t *i) { --i->rem; ++i->data; @@ -99,7 +99,7 @@ xcb_xkb_indicator_map_next (xcb_xkb_indicator_map_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_indicator_map_end (xcb_xkb_indicator_map_iterator_t i /**< */) +xcb_xkb_indicator_map_end (xcb_xkb_indicator_map_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -109,7 +109,7 @@ xcb_xkb_indicator_map_end (xcb_xkb_indicator_map_iterator_t i /**< */) } void -xcb_xkb_mod_def_next (xcb_xkb_mod_def_iterator_t *i /**< */) +xcb_xkb_mod_def_next (xcb_xkb_mod_def_iterator_t *i) { --i->rem; ++i->data; @@ -117,7 +117,7 @@ xcb_xkb_mod_def_next (xcb_xkb_mod_def_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_mod_def_end (xcb_xkb_mod_def_iterator_t i /**< */) +xcb_xkb_mod_def_end (xcb_xkb_mod_def_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -127,7 +127,7 @@ xcb_xkb_mod_def_end (xcb_xkb_mod_def_iterator_t i /**< */) } void -xcb_xkb_key_name_next (xcb_xkb_key_name_iterator_t *i /**< */) +xcb_xkb_key_name_next (xcb_xkb_key_name_iterator_t *i) { --i->rem; ++i->data; @@ -135,7 +135,7 @@ xcb_xkb_key_name_next (xcb_xkb_key_name_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_key_name_end (xcb_xkb_key_name_iterator_t i /**< */) +xcb_xkb_key_name_end (xcb_xkb_key_name_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -145,7 +145,7 @@ xcb_xkb_key_name_end (xcb_xkb_key_name_iterator_t i /**< */) } void -xcb_xkb_key_alias_next (xcb_xkb_key_alias_iterator_t *i /**< */) +xcb_xkb_key_alias_next (xcb_xkb_key_alias_iterator_t *i) { --i->rem; ++i->data; @@ -153,7 +153,7 @@ xcb_xkb_key_alias_next (xcb_xkb_key_alias_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_key_alias_end (xcb_xkb_key_alias_iterator_t i /**< */) +xcb_xkb_key_alias_end (xcb_xkb_key_alias_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -163,7 +163,7 @@ xcb_xkb_key_alias_end (xcb_xkb_key_alias_iterator_t i /**< */) } int -xcb_xkb_counted_string_16_sizeof (const void *_buffer /**< */) +xcb_xkb_counted_string_16_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_counted_string_16_t *_aux = (xcb_xkb_counted_string_16_t *)_buffer; @@ -206,19 +206,19 @@ xcb_xkb_counted_string_16_sizeof (const void *_buffer /**< */) } char * -xcb_xkb_counted_string_16_string (const xcb_xkb_counted_string_16_t *R /**< */) +xcb_xkb_counted_string_16_string (const xcb_xkb_counted_string_16_t *R) { return (char *) (R + 1); } int -xcb_xkb_counted_string_16_string_length (const xcb_xkb_counted_string_16_t *R /**< */) +xcb_xkb_counted_string_16_string_length (const xcb_xkb_counted_string_16_t *R) { return R->length; } xcb_generic_iterator_t -xcb_xkb_counted_string_16_string_end (const xcb_xkb_counted_string_16_t *R /**< */) +xcb_xkb_counted_string_16_string_end (const xcb_xkb_counted_string_16_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->length); @@ -228,31 +228,31 @@ xcb_xkb_counted_string_16_string_end (const xcb_xkb_counted_string_16_t *R /**< } void * -xcb_xkb_counted_string_16_alignment_pad (const xcb_xkb_counted_string_16_t *R /**< */) +xcb_xkb_counted_string_16_alignment_pad (const xcb_xkb_counted_string_16_t *R) { xcb_generic_iterator_t prev = xcb_xkb_counted_string_16_string_end(R); return (void *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); } int -xcb_xkb_counted_string_16_alignment_pad_length (const xcb_xkb_counted_string_16_t *R /**< */) +xcb_xkb_counted_string_16_alignment_pad_length (const xcb_xkb_counted_string_16_t *R) { return (((R->length + 5) & (~3)) - (R->length + 2)); } xcb_generic_iterator_t -xcb_xkb_counted_string_16_alignment_pad_end (const xcb_xkb_counted_string_16_t *R /**< */) +xcb_xkb_counted_string_16_alignment_pad_end (const xcb_xkb_counted_string_16_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_xkb_counted_string_16_string_end(R); - i.data = ((char *) child.data) + ((((R->length + 5) & (~3)) - (R->length + 2))); + xcb_generic_iterator_t prev = xcb_xkb_counted_string_16_string_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + ((((R->length + 5) & (~3)) - (R->length + 2))); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } void -xcb_xkb_counted_string_16_next (xcb_xkb_counted_string_16_iterator_t *i /**< */) +xcb_xkb_counted_string_16_next (xcb_xkb_counted_string_16_iterator_t *i) { xcb_xkb_counted_string_16_t *R = i->data; xcb_generic_iterator_t child; @@ -263,7 +263,7 @@ xcb_xkb_counted_string_16_next (xcb_xkb_counted_string_16_iterator_t *i /**< */ } xcb_generic_iterator_t -xcb_xkb_counted_string_16_end (xcb_xkb_counted_string_16_iterator_t i /**< */) +xcb_xkb_counted_string_16_end (xcb_xkb_counted_string_16_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -275,7 +275,7 @@ xcb_xkb_counted_string_16_end (xcb_xkb_counted_string_16_iterator_t i /**< */) } void -xcb_xkb_kt_map_entry_next (xcb_xkb_kt_map_entry_iterator_t *i /**< */) +xcb_xkb_kt_map_entry_next (xcb_xkb_kt_map_entry_iterator_t *i) { --i->rem; ++i->data; @@ -283,7 +283,7 @@ xcb_xkb_kt_map_entry_next (xcb_xkb_kt_map_entry_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_kt_map_entry_end (xcb_xkb_kt_map_entry_iterator_t i /**< */) +xcb_xkb_kt_map_entry_end (xcb_xkb_kt_map_entry_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -293,7 +293,7 @@ xcb_xkb_kt_map_entry_end (xcb_xkb_kt_map_entry_iterator_t i /**< */) } int -xcb_xkb_key_type_sizeof (const void *_buffer /**< */) +xcb_xkb_key_type_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_key_type_t *_aux = (xcb_xkb_key_type_t *)_buffer; @@ -336,19 +336,19 @@ xcb_xkb_key_type_sizeof (const void *_buffer /**< */) } xcb_xkb_kt_map_entry_t * -xcb_xkb_key_type_map (const xcb_xkb_key_type_t *R /**< */) +xcb_xkb_key_type_map (const xcb_xkb_key_type_t *R) { return (xcb_xkb_kt_map_entry_t *) (R + 1); } int -xcb_xkb_key_type_map_length (const xcb_xkb_key_type_t *R /**< */) +xcb_xkb_key_type_map_length (const xcb_xkb_key_type_t *R) { return R->nMapEntries; } xcb_xkb_kt_map_entry_iterator_t -xcb_xkb_key_type_map_iterator (const xcb_xkb_key_type_t *R /**< */) +xcb_xkb_key_type_map_iterator (const xcb_xkb_key_type_t *R) { xcb_xkb_kt_map_entry_iterator_t i; i.data = (xcb_xkb_kt_map_entry_t *) (R + 1); @@ -358,20 +358,20 @@ xcb_xkb_key_type_map_iterator (const xcb_xkb_key_type_t *R /**< */) } xcb_xkb_mod_def_t * -xcb_xkb_key_type_preserve (const xcb_xkb_key_type_t *R /**< */) +xcb_xkb_key_type_preserve (const xcb_xkb_key_type_t *R) { xcb_generic_iterator_t prev = xcb_xkb_kt_map_entry_end(xcb_xkb_key_type_map_iterator(R)); return (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index) + 0); } int -xcb_xkb_key_type_preserve_length (const xcb_xkb_key_type_t *R /**< */) +xcb_xkb_key_type_preserve_length (const xcb_xkb_key_type_t *R) { return (R->hasPreserve * R->nMapEntries); } xcb_xkb_mod_def_iterator_t -xcb_xkb_key_type_preserve_iterator (const xcb_xkb_key_type_t *R /**< */) +xcb_xkb_key_type_preserve_iterator (const xcb_xkb_key_type_t *R) { xcb_xkb_mod_def_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_kt_map_entry_end(xcb_xkb_key_type_map_iterator(R)); @@ -382,7 +382,7 @@ xcb_xkb_key_type_preserve_iterator (const xcb_xkb_key_type_t *R /**< */) } void -xcb_xkb_key_type_next (xcb_xkb_key_type_iterator_t *i /**< */) +xcb_xkb_key_type_next (xcb_xkb_key_type_iterator_t *i) { xcb_xkb_key_type_t *R = i->data; xcb_generic_iterator_t child; @@ -393,7 +393,7 @@ xcb_xkb_key_type_next (xcb_xkb_key_type_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_key_type_end (xcb_xkb_key_type_iterator_t i /**< */) +xcb_xkb_key_type_end (xcb_xkb_key_type_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -405,7 +405,7 @@ xcb_xkb_key_type_end (xcb_xkb_key_type_iterator_t i /**< */) } int -xcb_xkb_key_sym_map_sizeof (const void *_buffer /**< */) +xcb_xkb_key_sym_map_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_key_sym_map_t *_aux = (xcb_xkb_key_sym_map_t *)_buffer; @@ -436,19 +436,19 @@ xcb_xkb_key_sym_map_sizeof (const void *_buffer /**< */) } xcb_keysym_t * -xcb_xkb_key_sym_map_syms (const xcb_xkb_key_sym_map_t *R /**< */) +xcb_xkb_key_sym_map_syms (const xcb_xkb_key_sym_map_t *R) { return (xcb_keysym_t *) (R + 1); } int -xcb_xkb_key_sym_map_syms_length (const xcb_xkb_key_sym_map_t *R /**< */) +xcb_xkb_key_sym_map_syms_length (const xcb_xkb_key_sym_map_t *R) { return R->nSyms; } xcb_generic_iterator_t -xcb_xkb_key_sym_map_syms_end (const xcb_xkb_key_sym_map_t *R /**< */) +xcb_xkb_key_sym_map_syms_end (const xcb_xkb_key_sym_map_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_keysym_t *) (R + 1)) + (R->nSyms); @@ -458,7 +458,7 @@ xcb_xkb_key_sym_map_syms_end (const xcb_xkb_key_sym_map_t *R /**< */) } void -xcb_xkb_key_sym_map_next (xcb_xkb_key_sym_map_iterator_t *i /**< */) +xcb_xkb_key_sym_map_next (xcb_xkb_key_sym_map_iterator_t *i) { xcb_xkb_key_sym_map_t *R = i->data; xcb_generic_iterator_t child; @@ -469,7 +469,7 @@ xcb_xkb_key_sym_map_next (xcb_xkb_key_sym_map_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_key_sym_map_end (xcb_xkb_key_sym_map_iterator_t i /**< */) +xcb_xkb_key_sym_map_end (xcb_xkb_key_sym_map_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -481,7 +481,7 @@ xcb_xkb_key_sym_map_end (xcb_xkb_key_sym_map_iterator_t i /**< */) } void -xcb_xkb_common_behavior_next (xcb_xkb_common_behavior_iterator_t *i /**< */) +xcb_xkb_common_behavior_next (xcb_xkb_common_behavior_iterator_t *i) { --i->rem; ++i->data; @@ -489,7 +489,7 @@ xcb_xkb_common_behavior_next (xcb_xkb_common_behavior_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_common_behavior_end (xcb_xkb_common_behavior_iterator_t i /**< */) +xcb_xkb_common_behavior_end (xcb_xkb_common_behavior_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -499,7 +499,7 @@ xcb_xkb_common_behavior_end (xcb_xkb_common_behavior_iterator_t i /**< */) } void -xcb_xkb_default_behavior_next (xcb_xkb_default_behavior_iterator_t *i /**< */) +xcb_xkb_default_behavior_next (xcb_xkb_default_behavior_iterator_t *i) { --i->rem; ++i->data; @@ -507,7 +507,7 @@ xcb_xkb_default_behavior_next (xcb_xkb_default_behavior_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_default_behavior_end (xcb_xkb_default_behavior_iterator_t i /**< */) +xcb_xkb_default_behavior_end (xcb_xkb_default_behavior_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -517,7 +517,7 @@ xcb_xkb_default_behavior_end (xcb_xkb_default_behavior_iterator_t i /**< */) } void -xcb_xkb_lock_behavior_next (xcb_xkb_lock_behavior_iterator_t *i /**< */) +xcb_xkb_lock_behavior_next (xcb_xkb_lock_behavior_iterator_t *i) { --i->rem; ++i->data; @@ -525,7 +525,7 @@ xcb_xkb_lock_behavior_next (xcb_xkb_lock_behavior_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_lock_behavior_end (xcb_xkb_lock_behavior_iterator_t i /**< */) +xcb_xkb_lock_behavior_end (xcb_xkb_lock_behavior_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -535,7 +535,7 @@ xcb_xkb_lock_behavior_end (xcb_xkb_lock_behavior_iterator_t i /**< */) } void -xcb_xkb_radio_group_behavior_next (xcb_xkb_radio_group_behavior_iterator_t *i /**< */) +xcb_xkb_radio_group_behavior_next (xcb_xkb_radio_group_behavior_iterator_t *i) { --i->rem; ++i->data; @@ -543,7 +543,7 @@ xcb_xkb_radio_group_behavior_next (xcb_xkb_radio_group_behavior_iterator_t *i / } xcb_generic_iterator_t -xcb_xkb_radio_group_behavior_end (xcb_xkb_radio_group_behavior_iterator_t i /**< */) +xcb_xkb_radio_group_behavior_end (xcb_xkb_radio_group_behavior_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -553,7 +553,7 @@ xcb_xkb_radio_group_behavior_end (xcb_xkb_radio_group_behavior_iterator_t i /** } void -xcb_xkb_overlay_behavior_next (xcb_xkb_overlay_behavior_iterator_t *i /**< */) +xcb_xkb_overlay_behavior_next (xcb_xkb_overlay_behavior_iterator_t *i) { --i->rem; ++i->data; @@ -561,7 +561,7 @@ xcb_xkb_overlay_behavior_next (xcb_xkb_overlay_behavior_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_overlay_behavior_end (xcb_xkb_overlay_behavior_iterator_t i /**< */) +xcb_xkb_overlay_behavior_end (xcb_xkb_overlay_behavior_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -571,7 +571,7 @@ xcb_xkb_overlay_behavior_end (xcb_xkb_overlay_behavior_iterator_t i /**< */) } void -xcb_xkb_permament_lock_behavior_next (xcb_xkb_permament_lock_behavior_iterator_t *i /**< */) +xcb_xkb_permament_lock_behavior_next (xcb_xkb_permament_lock_behavior_iterator_t *i) { --i->rem; ++i->data; @@ -579,7 +579,7 @@ xcb_xkb_permament_lock_behavior_next (xcb_xkb_permament_lock_behavior_iterator_t } xcb_generic_iterator_t -xcb_xkb_permament_lock_behavior_end (xcb_xkb_permament_lock_behavior_iterator_t i /**< */) +xcb_xkb_permament_lock_behavior_end (xcb_xkb_permament_lock_behavior_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -589,7 +589,7 @@ xcb_xkb_permament_lock_behavior_end (xcb_xkb_permament_lock_behavior_iterator_t } void -xcb_xkb_permament_radio_group_behavior_next (xcb_xkb_permament_radio_group_behavior_iterator_t *i /**< */) +xcb_xkb_permament_radio_group_behavior_next (xcb_xkb_permament_radio_group_behavior_iterator_t *i) { --i->rem; ++i->data; @@ -597,7 +597,7 @@ xcb_xkb_permament_radio_group_behavior_next (xcb_xkb_permament_radio_group_behav } xcb_generic_iterator_t -xcb_xkb_permament_radio_group_behavior_end (xcb_xkb_permament_radio_group_behavior_iterator_t i /**< */) +xcb_xkb_permament_radio_group_behavior_end (xcb_xkb_permament_radio_group_behavior_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -607,7 +607,7 @@ xcb_xkb_permament_radio_group_behavior_end (xcb_xkb_permament_radio_group_behavi } void -xcb_xkb_permament_overlay_behavior_next (xcb_xkb_permament_overlay_behavior_iterator_t *i /**< */) +xcb_xkb_permament_overlay_behavior_next (xcb_xkb_permament_overlay_behavior_iterator_t *i) { --i->rem; ++i->data; @@ -615,7 +615,7 @@ xcb_xkb_permament_overlay_behavior_next (xcb_xkb_permament_overlay_behavior_iter } xcb_generic_iterator_t -xcb_xkb_permament_overlay_behavior_end (xcb_xkb_permament_overlay_behavior_iterator_t i /**< */) +xcb_xkb_permament_overlay_behavior_end (xcb_xkb_permament_overlay_behavior_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -625,7 +625,7 @@ xcb_xkb_permament_overlay_behavior_end (xcb_xkb_permament_overlay_behavior_itera } void -xcb_xkb_behavior_next (xcb_xkb_behavior_iterator_t *i /**< */) +xcb_xkb_behavior_next (xcb_xkb_behavior_iterator_t *i) { --i->rem; ++i->data; @@ -633,7 +633,7 @@ xcb_xkb_behavior_next (xcb_xkb_behavior_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_behavior_end (xcb_xkb_behavior_iterator_t i /**< */) +xcb_xkb_behavior_end (xcb_xkb_behavior_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -643,7 +643,7 @@ xcb_xkb_behavior_end (xcb_xkb_behavior_iterator_t i /**< */) } void -xcb_xkb_set_behavior_next (xcb_xkb_set_behavior_iterator_t *i /**< */) +xcb_xkb_set_behavior_next (xcb_xkb_set_behavior_iterator_t *i) { --i->rem; ++i->data; @@ -651,7 +651,7 @@ xcb_xkb_set_behavior_next (xcb_xkb_set_behavior_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_set_behavior_end (xcb_xkb_set_behavior_iterator_t i /**< */) +xcb_xkb_set_behavior_end (xcb_xkb_set_behavior_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -661,7 +661,7 @@ xcb_xkb_set_behavior_end (xcb_xkb_set_behavior_iterator_t i /**< */) } void -xcb_xkb_set_explicit_next (xcb_xkb_set_explicit_iterator_t *i /**< */) +xcb_xkb_set_explicit_next (xcb_xkb_set_explicit_iterator_t *i) { --i->rem; ++i->data; @@ -669,7 +669,7 @@ xcb_xkb_set_explicit_next (xcb_xkb_set_explicit_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_set_explicit_end (xcb_xkb_set_explicit_iterator_t i /**< */) +xcb_xkb_set_explicit_end (xcb_xkb_set_explicit_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -679,7 +679,7 @@ xcb_xkb_set_explicit_end (xcb_xkb_set_explicit_iterator_t i /**< */) } void -xcb_xkb_key_mod_map_next (xcb_xkb_key_mod_map_iterator_t *i /**< */) +xcb_xkb_key_mod_map_next (xcb_xkb_key_mod_map_iterator_t *i) { --i->rem; ++i->data; @@ -687,7 +687,7 @@ xcb_xkb_key_mod_map_next (xcb_xkb_key_mod_map_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_key_mod_map_end (xcb_xkb_key_mod_map_iterator_t i /**< */) +xcb_xkb_key_mod_map_end (xcb_xkb_key_mod_map_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -697,7 +697,7 @@ xcb_xkb_key_mod_map_end (xcb_xkb_key_mod_map_iterator_t i /**< */) } void -xcb_xkb_key_v_mod_map_next (xcb_xkb_key_v_mod_map_iterator_t *i /**< */) +xcb_xkb_key_v_mod_map_next (xcb_xkb_key_v_mod_map_iterator_t *i) { --i->rem; ++i->data; @@ -705,7 +705,7 @@ xcb_xkb_key_v_mod_map_next (xcb_xkb_key_v_mod_map_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_key_v_mod_map_end (xcb_xkb_key_v_mod_map_iterator_t i /**< */) +xcb_xkb_key_v_mod_map_end (xcb_xkb_key_v_mod_map_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -715,7 +715,7 @@ xcb_xkb_key_v_mod_map_end (xcb_xkb_key_v_mod_map_iterator_t i /**< */) } void -xcb_xkb_kt_set_map_entry_next (xcb_xkb_kt_set_map_entry_iterator_t *i /**< */) +xcb_xkb_kt_set_map_entry_next (xcb_xkb_kt_set_map_entry_iterator_t *i) { --i->rem; ++i->data; @@ -723,7 +723,7 @@ xcb_xkb_kt_set_map_entry_next (xcb_xkb_kt_set_map_entry_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_kt_set_map_entry_end (xcb_xkb_kt_set_map_entry_iterator_t i /**< */) +xcb_xkb_kt_set_map_entry_end (xcb_xkb_kt_set_map_entry_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -733,7 +733,7 @@ xcb_xkb_kt_set_map_entry_end (xcb_xkb_kt_set_map_entry_iterator_t i /**< */) } int -xcb_xkb_set_key_type_sizeof (const void *_buffer /**< */) +xcb_xkb_set_key_type_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_set_key_type_t *_aux = (xcb_xkb_set_key_type_t *)_buffer; @@ -776,19 +776,19 @@ xcb_xkb_set_key_type_sizeof (const void *_buffer /**< */) } xcb_xkb_kt_set_map_entry_t * -xcb_xkb_set_key_type_entries (const xcb_xkb_set_key_type_t *R /**< */) +xcb_xkb_set_key_type_entries (const xcb_xkb_set_key_type_t *R) { return (xcb_xkb_kt_set_map_entry_t *) (R + 1); } int -xcb_xkb_set_key_type_entries_length (const xcb_xkb_set_key_type_t *R /**< */) +xcb_xkb_set_key_type_entries_length (const xcb_xkb_set_key_type_t *R) { return R->nMapEntries; } xcb_xkb_kt_set_map_entry_iterator_t -xcb_xkb_set_key_type_entries_iterator (const xcb_xkb_set_key_type_t *R /**< */) +xcb_xkb_set_key_type_entries_iterator (const xcb_xkb_set_key_type_t *R) { xcb_xkb_kt_set_map_entry_iterator_t i; i.data = (xcb_xkb_kt_set_map_entry_t *) (R + 1); @@ -798,20 +798,20 @@ xcb_xkb_set_key_type_entries_iterator (const xcb_xkb_set_key_type_t *R /**< */) } xcb_xkb_kt_set_map_entry_t * -xcb_xkb_set_key_type_preserve_entries (const xcb_xkb_set_key_type_t *R /**< */) +xcb_xkb_set_key_type_preserve_entries (const xcb_xkb_set_key_type_t *R) { xcb_generic_iterator_t prev = xcb_xkb_kt_set_map_entry_end(xcb_xkb_set_key_type_entries_iterator(R)); return (xcb_xkb_kt_set_map_entry_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_kt_set_map_entry_t, prev.index) + 0); } int -xcb_xkb_set_key_type_preserve_entries_length (const xcb_xkb_set_key_type_t *R /**< */) +xcb_xkb_set_key_type_preserve_entries_length (const xcb_xkb_set_key_type_t *R) { return (R->preserve * R->nMapEntries); } xcb_xkb_kt_set_map_entry_iterator_t -xcb_xkb_set_key_type_preserve_entries_iterator (const xcb_xkb_set_key_type_t *R /**< */) +xcb_xkb_set_key_type_preserve_entries_iterator (const xcb_xkb_set_key_type_t *R) { xcb_xkb_kt_set_map_entry_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_kt_set_map_entry_end(xcb_xkb_set_key_type_entries_iterator(R)); @@ -822,7 +822,7 @@ xcb_xkb_set_key_type_preserve_entries_iterator (const xcb_xkb_set_key_type_t *R } void -xcb_xkb_set_key_type_next (xcb_xkb_set_key_type_iterator_t *i /**< */) +xcb_xkb_set_key_type_next (xcb_xkb_set_key_type_iterator_t *i) { xcb_xkb_set_key_type_t *R = i->data; xcb_generic_iterator_t child; @@ -833,7 +833,7 @@ xcb_xkb_set_key_type_next (xcb_xkb_set_key_type_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_set_key_type_end (xcb_xkb_set_key_type_iterator_t i /**< */) +xcb_xkb_set_key_type_end (xcb_xkb_set_key_type_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -845,7 +845,7 @@ xcb_xkb_set_key_type_end (xcb_xkb_set_key_type_iterator_t i /**< */) } void -xcb_xkb_string8_next (xcb_xkb_string8_iterator_t *i /**< */) +xcb_xkb_string8_next (xcb_xkb_string8_iterator_t *i) { --i->rem; ++i->data; @@ -853,7 +853,7 @@ xcb_xkb_string8_next (xcb_xkb_string8_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_string8_end (xcb_xkb_string8_iterator_t i /**< */) +xcb_xkb_string8_end (xcb_xkb_string8_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -863,7 +863,7 @@ xcb_xkb_string8_end (xcb_xkb_string8_iterator_t i /**< */) } int -xcb_xkb_outline_sizeof (const void *_buffer /**< */) +xcb_xkb_outline_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_outline_t *_aux = (xcb_xkb_outline_t *)_buffer; @@ -894,19 +894,19 @@ xcb_xkb_outline_sizeof (const void *_buffer /**< */) } xcb_point_t * -xcb_xkb_outline_points (const xcb_xkb_outline_t *R /**< */) +xcb_xkb_outline_points (const xcb_xkb_outline_t *R) { return (xcb_point_t *) (R + 1); } int -xcb_xkb_outline_points_length (const xcb_xkb_outline_t *R /**< */) +xcb_xkb_outline_points_length (const xcb_xkb_outline_t *R) { return R->nPoints; } xcb_point_iterator_t -xcb_xkb_outline_points_iterator (const xcb_xkb_outline_t *R /**< */) +xcb_xkb_outline_points_iterator (const xcb_xkb_outline_t *R) { xcb_point_iterator_t i; i.data = (xcb_point_t *) (R + 1); @@ -916,7 +916,7 @@ xcb_xkb_outline_points_iterator (const xcb_xkb_outline_t *R /**< */) } void -xcb_xkb_outline_next (xcb_xkb_outline_iterator_t *i /**< */) +xcb_xkb_outline_next (xcb_xkb_outline_iterator_t *i) { xcb_xkb_outline_t *R = i->data; xcb_generic_iterator_t child; @@ -927,7 +927,7 @@ xcb_xkb_outline_next (xcb_xkb_outline_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_outline_end (xcb_xkb_outline_iterator_t i /**< */) +xcb_xkb_outline_end (xcb_xkb_outline_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -939,7 +939,7 @@ xcb_xkb_outline_end (xcb_xkb_outline_iterator_t i /**< */) } int -xcb_xkb_shape_sizeof (const void *_buffer /**< */) +xcb_xkb_shape_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_shape_t *_aux = (xcb_xkb_shape_t *)_buffer; @@ -975,13 +975,13 @@ xcb_xkb_shape_sizeof (const void *_buffer /**< */) } int -xcb_xkb_shape_outlines_length (const xcb_xkb_shape_t *R /**< */) +xcb_xkb_shape_outlines_length (const xcb_xkb_shape_t *R) { return R->nOutlines; } xcb_xkb_outline_iterator_t -xcb_xkb_shape_outlines_iterator (const xcb_xkb_shape_t *R /**< */) +xcb_xkb_shape_outlines_iterator (const xcb_xkb_shape_t *R) { xcb_xkb_outline_iterator_t i; i.data = (xcb_xkb_outline_t *) (R + 1); @@ -991,7 +991,7 @@ xcb_xkb_shape_outlines_iterator (const xcb_xkb_shape_t *R /**< */) } void -xcb_xkb_shape_next (xcb_xkb_shape_iterator_t *i /**< */) +xcb_xkb_shape_next (xcb_xkb_shape_iterator_t *i) { xcb_xkb_shape_t *R = i->data; xcb_generic_iterator_t child; @@ -1002,7 +1002,7 @@ xcb_xkb_shape_next (xcb_xkb_shape_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_shape_end (xcb_xkb_shape_iterator_t i /**< */) +xcb_xkb_shape_end (xcb_xkb_shape_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -1014,7 +1014,7 @@ xcb_xkb_shape_end (xcb_xkb_shape_iterator_t i /**< */) } void -xcb_xkb_key_next (xcb_xkb_key_iterator_t *i /**< */) +xcb_xkb_key_next (xcb_xkb_key_iterator_t *i) { --i->rem; ++i->data; @@ -1022,7 +1022,7 @@ xcb_xkb_key_next (xcb_xkb_key_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_key_end (xcb_xkb_key_iterator_t i /**< */) +xcb_xkb_key_end (xcb_xkb_key_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1032,7 +1032,7 @@ xcb_xkb_key_end (xcb_xkb_key_iterator_t i /**< */) } void -xcb_xkb_overlay_key_next (xcb_xkb_overlay_key_iterator_t *i /**< */) +xcb_xkb_overlay_key_next (xcb_xkb_overlay_key_iterator_t *i) { --i->rem; ++i->data; @@ -1040,7 +1040,7 @@ xcb_xkb_overlay_key_next (xcb_xkb_overlay_key_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_overlay_key_end (xcb_xkb_overlay_key_iterator_t i /**< */) +xcb_xkb_overlay_key_end (xcb_xkb_overlay_key_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1050,7 +1050,7 @@ xcb_xkb_overlay_key_end (xcb_xkb_overlay_key_iterator_t i /**< */) } int -xcb_xkb_overlay_row_sizeof (const void *_buffer /**< */) +xcb_xkb_overlay_row_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_overlay_row_t *_aux = (xcb_xkb_overlay_row_t *)_buffer; @@ -1081,19 +1081,19 @@ xcb_xkb_overlay_row_sizeof (const void *_buffer /**< */) } xcb_xkb_overlay_key_t * -xcb_xkb_overlay_row_keys (const xcb_xkb_overlay_row_t *R /**< */) +xcb_xkb_overlay_row_keys (const xcb_xkb_overlay_row_t *R) { return (xcb_xkb_overlay_key_t *) (R + 1); } int -xcb_xkb_overlay_row_keys_length (const xcb_xkb_overlay_row_t *R /**< */) +xcb_xkb_overlay_row_keys_length (const xcb_xkb_overlay_row_t *R) { return R->nKeys; } xcb_xkb_overlay_key_iterator_t -xcb_xkb_overlay_row_keys_iterator (const xcb_xkb_overlay_row_t *R /**< */) +xcb_xkb_overlay_row_keys_iterator (const xcb_xkb_overlay_row_t *R) { xcb_xkb_overlay_key_iterator_t i; i.data = (xcb_xkb_overlay_key_t *) (R + 1); @@ -1103,7 +1103,7 @@ xcb_xkb_overlay_row_keys_iterator (const xcb_xkb_overlay_row_t *R /**< */) } void -xcb_xkb_overlay_row_next (xcb_xkb_overlay_row_iterator_t *i /**< */) +xcb_xkb_overlay_row_next (xcb_xkb_overlay_row_iterator_t *i) { xcb_xkb_overlay_row_t *R = i->data; xcb_generic_iterator_t child; @@ -1114,7 +1114,7 @@ xcb_xkb_overlay_row_next (xcb_xkb_overlay_row_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_overlay_row_end (xcb_xkb_overlay_row_iterator_t i /**< */) +xcb_xkb_overlay_row_end (xcb_xkb_overlay_row_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -1126,7 +1126,7 @@ xcb_xkb_overlay_row_end (xcb_xkb_overlay_row_iterator_t i /**< */) } int -xcb_xkb_overlay_sizeof (const void *_buffer /**< */) +xcb_xkb_overlay_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_overlay_t *_aux = (xcb_xkb_overlay_t *)_buffer; @@ -1162,13 +1162,13 @@ xcb_xkb_overlay_sizeof (const void *_buffer /**< */) } int -xcb_xkb_overlay_rows_length (const xcb_xkb_overlay_t *R /**< */) +xcb_xkb_overlay_rows_length (const xcb_xkb_overlay_t *R) { return R->nRows; } xcb_xkb_overlay_row_iterator_t -xcb_xkb_overlay_rows_iterator (const xcb_xkb_overlay_t *R /**< */) +xcb_xkb_overlay_rows_iterator (const xcb_xkb_overlay_t *R) { xcb_xkb_overlay_row_iterator_t i; i.data = (xcb_xkb_overlay_row_t *) (R + 1); @@ -1178,7 +1178,7 @@ xcb_xkb_overlay_rows_iterator (const xcb_xkb_overlay_t *R /**< */) } void -xcb_xkb_overlay_next (xcb_xkb_overlay_iterator_t *i /**< */) +xcb_xkb_overlay_next (xcb_xkb_overlay_iterator_t *i) { xcb_xkb_overlay_t *R = i->data; xcb_generic_iterator_t child; @@ -1189,7 +1189,7 @@ xcb_xkb_overlay_next (xcb_xkb_overlay_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_overlay_end (xcb_xkb_overlay_iterator_t i /**< */) +xcb_xkb_overlay_end (xcb_xkb_overlay_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -1201,7 +1201,7 @@ xcb_xkb_overlay_end (xcb_xkb_overlay_iterator_t i /**< */) } int -xcb_xkb_row_sizeof (const void *_buffer /**< */) +xcb_xkb_row_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_row_t *_aux = (xcb_xkb_row_t *)_buffer; @@ -1232,19 +1232,19 @@ xcb_xkb_row_sizeof (const void *_buffer /**< */) } xcb_xkb_key_t * -xcb_xkb_row_keys (const xcb_xkb_row_t *R /**< */) +xcb_xkb_row_keys (const xcb_xkb_row_t *R) { return (xcb_xkb_key_t *) (R + 1); } int -xcb_xkb_row_keys_length (const xcb_xkb_row_t *R /**< */) +xcb_xkb_row_keys_length (const xcb_xkb_row_t *R) { return R->nKeys; } xcb_xkb_key_iterator_t -xcb_xkb_row_keys_iterator (const xcb_xkb_row_t *R /**< */) +xcb_xkb_row_keys_iterator (const xcb_xkb_row_t *R) { xcb_xkb_key_iterator_t i; i.data = (xcb_xkb_key_t *) (R + 1); @@ -1254,7 +1254,7 @@ xcb_xkb_row_keys_iterator (const xcb_xkb_row_t *R /**< */) } void -xcb_xkb_row_next (xcb_xkb_row_iterator_t *i /**< */) +xcb_xkb_row_next (xcb_xkb_row_iterator_t *i) { xcb_xkb_row_t *R = i->data; xcb_generic_iterator_t child; @@ -1265,7 +1265,7 @@ xcb_xkb_row_next (xcb_xkb_row_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_row_end (xcb_xkb_row_iterator_t i /**< */) +xcb_xkb_row_end (xcb_xkb_row_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -1277,7 +1277,7 @@ xcb_xkb_row_end (xcb_xkb_row_iterator_t i /**< */) } int -xcb_xkb_listing_sizeof (const void *_buffer /**< */) +xcb_xkb_listing_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_listing_t *_aux = (xcb_xkb_listing_t *)_buffer; @@ -1295,6 +1295,15 @@ xcb_xkb_listing_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->length * sizeof(xcb_xkb_string8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_xkb_string8_t); + xcb_align_to = 2; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -1308,19 +1317,19 @@ xcb_xkb_listing_sizeof (const void *_buffer /**< */) } xcb_xkb_string8_t * -xcb_xkb_listing_string (const xcb_xkb_listing_t *R /**< */) +xcb_xkb_listing_string (const xcb_xkb_listing_t *R) { return (xcb_xkb_string8_t *) (R + 1); } int -xcb_xkb_listing_string_length (const xcb_xkb_listing_t *R /**< */) +xcb_xkb_listing_string_length (const xcb_xkb_listing_t *R) { return R->length; } xcb_generic_iterator_t -xcb_xkb_listing_string_end (const xcb_xkb_listing_t *R /**< */) +xcb_xkb_listing_string_end (const xcb_xkb_listing_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_xkb_string8_t *) (R + 1)) + (R->length); @@ -1330,7 +1339,7 @@ xcb_xkb_listing_string_end (const xcb_xkb_listing_t *R /**< */) } void -xcb_xkb_listing_next (xcb_xkb_listing_iterator_t *i /**< */) +xcb_xkb_listing_next (xcb_xkb_listing_iterator_t *i) { xcb_xkb_listing_t *R = i->data; xcb_generic_iterator_t child; @@ -1341,7 +1350,7 @@ xcb_xkb_listing_next (xcb_xkb_listing_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_listing_end (xcb_xkb_listing_iterator_t i /**< */) +xcb_xkb_listing_end (xcb_xkb_listing_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -1353,7 +1362,7 @@ xcb_xkb_listing_end (xcb_xkb_listing_iterator_t i /**< */) } int -xcb_xkb_device_led_info_sizeof (const void *_buffer /**< */) +xcb_xkb_device_led_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_device_led_info_t *_aux = (xcb_xkb_device_led_info_t *)_buffer; @@ -1396,19 +1405,19 @@ xcb_xkb_device_led_info_sizeof (const void *_buffer /**< */) } xcb_atom_t * -xcb_xkb_device_led_info_names (const xcb_xkb_device_led_info_t *R /**< */) +xcb_xkb_device_led_info_names (const xcb_xkb_device_led_info_t *R) { return (xcb_atom_t *) (R + 1); } int -xcb_xkb_device_led_info_names_length (const xcb_xkb_device_led_info_t *R /**< */) +xcb_xkb_device_led_info_names_length (const xcb_xkb_device_led_info_t *R) { return xcb_popcount(R->namesPresent); } xcb_generic_iterator_t -xcb_xkb_device_led_info_names_end (const xcb_xkb_device_led_info_t *R /**< */) +xcb_xkb_device_led_info_names_end (const xcb_xkb_device_led_info_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_atom_t *) (R + 1)) + (xcb_popcount(R->namesPresent)); @@ -1418,20 +1427,20 @@ xcb_xkb_device_led_info_names_end (const xcb_xkb_device_led_info_t *R /**< */) } xcb_xkb_indicator_map_t * -xcb_xkb_device_led_info_maps (const xcb_xkb_device_led_info_t *R /**< */) +xcb_xkb_device_led_info_maps (const xcb_xkb_device_led_info_t *R) { xcb_generic_iterator_t prev = xcb_xkb_device_led_info_names_end(R); return (xcb_xkb_indicator_map_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_indicator_map_t, prev.index) + 0); } int -xcb_xkb_device_led_info_maps_length (const xcb_xkb_device_led_info_t *R /**< */) +xcb_xkb_device_led_info_maps_length (const xcb_xkb_device_led_info_t *R) { return xcb_popcount(R->mapsPresent); } xcb_xkb_indicator_map_iterator_t -xcb_xkb_device_led_info_maps_iterator (const xcb_xkb_device_led_info_t *R /**< */) +xcb_xkb_device_led_info_maps_iterator (const xcb_xkb_device_led_info_t *R) { xcb_xkb_indicator_map_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_device_led_info_names_end(R); @@ -1442,7 +1451,7 @@ xcb_xkb_device_led_info_maps_iterator (const xcb_xkb_device_led_info_t *R /**< } void -xcb_xkb_device_led_info_next (xcb_xkb_device_led_info_iterator_t *i /**< */) +xcb_xkb_device_led_info_next (xcb_xkb_device_led_info_iterator_t *i) { xcb_xkb_device_led_info_t *R = i->data; xcb_generic_iterator_t child; @@ -1453,7 +1462,7 @@ xcb_xkb_device_led_info_next (xcb_xkb_device_led_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_device_led_info_end (xcb_xkb_device_led_info_iterator_t i /**< */) +xcb_xkb_device_led_info_end (xcb_xkb_device_led_info_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -1465,7 +1474,7 @@ xcb_xkb_device_led_info_end (xcb_xkb_device_led_info_iterator_t i /**< */) } void -xcb_xkb_sa_no_action_next (xcb_xkb_sa_no_action_iterator_t *i /**< */) +xcb_xkb_sa_no_action_next (xcb_xkb_sa_no_action_iterator_t *i) { --i->rem; ++i->data; @@ -1473,7 +1482,7 @@ xcb_xkb_sa_no_action_next (xcb_xkb_sa_no_action_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_no_action_end (xcb_xkb_sa_no_action_iterator_t i /**< */) +xcb_xkb_sa_no_action_end (xcb_xkb_sa_no_action_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1483,7 +1492,7 @@ xcb_xkb_sa_no_action_end (xcb_xkb_sa_no_action_iterator_t i /**< */) } void -xcb_xkb_sa_set_mods_next (xcb_xkb_sa_set_mods_iterator_t *i /**< */) +xcb_xkb_sa_set_mods_next (xcb_xkb_sa_set_mods_iterator_t *i) { --i->rem; ++i->data; @@ -1491,7 +1500,7 @@ xcb_xkb_sa_set_mods_next (xcb_xkb_sa_set_mods_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_set_mods_end (xcb_xkb_sa_set_mods_iterator_t i /**< */) +xcb_xkb_sa_set_mods_end (xcb_xkb_sa_set_mods_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1501,7 +1510,7 @@ xcb_xkb_sa_set_mods_end (xcb_xkb_sa_set_mods_iterator_t i /**< */) } void -xcb_xkb_sa_latch_mods_next (xcb_xkb_sa_latch_mods_iterator_t *i /**< */) +xcb_xkb_sa_latch_mods_next (xcb_xkb_sa_latch_mods_iterator_t *i) { --i->rem; ++i->data; @@ -1509,7 +1518,7 @@ xcb_xkb_sa_latch_mods_next (xcb_xkb_sa_latch_mods_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_latch_mods_end (xcb_xkb_sa_latch_mods_iterator_t i /**< */) +xcb_xkb_sa_latch_mods_end (xcb_xkb_sa_latch_mods_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1519,7 +1528,7 @@ xcb_xkb_sa_latch_mods_end (xcb_xkb_sa_latch_mods_iterator_t i /**< */) } void -xcb_xkb_sa_lock_mods_next (xcb_xkb_sa_lock_mods_iterator_t *i /**< */) +xcb_xkb_sa_lock_mods_next (xcb_xkb_sa_lock_mods_iterator_t *i) { --i->rem; ++i->data; @@ -1527,7 +1536,7 @@ xcb_xkb_sa_lock_mods_next (xcb_xkb_sa_lock_mods_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_lock_mods_end (xcb_xkb_sa_lock_mods_iterator_t i /**< */) +xcb_xkb_sa_lock_mods_end (xcb_xkb_sa_lock_mods_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1537,7 +1546,7 @@ xcb_xkb_sa_lock_mods_end (xcb_xkb_sa_lock_mods_iterator_t i /**< */) } void -xcb_xkb_sa_set_group_next (xcb_xkb_sa_set_group_iterator_t *i /**< */) +xcb_xkb_sa_set_group_next (xcb_xkb_sa_set_group_iterator_t *i) { --i->rem; ++i->data; @@ -1545,7 +1554,7 @@ xcb_xkb_sa_set_group_next (xcb_xkb_sa_set_group_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_set_group_end (xcb_xkb_sa_set_group_iterator_t i /**< */) +xcb_xkb_sa_set_group_end (xcb_xkb_sa_set_group_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1555,7 +1564,7 @@ xcb_xkb_sa_set_group_end (xcb_xkb_sa_set_group_iterator_t i /**< */) } void -xcb_xkb_sa_latch_group_next (xcb_xkb_sa_latch_group_iterator_t *i /**< */) +xcb_xkb_sa_latch_group_next (xcb_xkb_sa_latch_group_iterator_t *i) { --i->rem; ++i->data; @@ -1563,7 +1572,7 @@ xcb_xkb_sa_latch_group_next (xcb_xkb_sa_latch_group_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_latch_group_end (xcb_xkb_sa_latch_group_iterator_t i /**< */) +xcb_xkb_sa_latch_group_end (xcb_xkb_sa_latch_group_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1573,7 +1582,7 @@ xcb_xkb_sa_latch_group_end (xcb_xkb_sa_latch_group_iterator_t i /**< */) } void -xcb_xkb_sa_lock_group_next (xcb_xkb_sa_lock_group_iterator_t *i /**< */) +xcb_xkb_sa_lock_group_next (xcb_xkb_sa_lock_group_iterator_t *i) { --i->rem; ++i->data; @@ -1581,7 +1590,7 @@ xcb_xkb_sa_lock_group_next (xcb_xkb_sa_lock_group_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_lock_group_end (xcb_xkb_sa_lock_group_iterator_t i /**< */) +xcb_xkb_sa_lock_group_end (xcb_xkb_sa_lock_group_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1591,7 +1600,7 @@ xcb_xkb_sa_lock_group_end (xcb_xkb_sa_lock_group_iterator_t i /**< */) } void -xcb_xkb_sa_move_ptr_next (xcb_xkb_sa_move_ptr_iterator_t *i /**< */) +xcb_xkb_sa_move_ptr_next (xcb_xkb_sa_move_ptr_iterator_t *i) { --i->rem; ++i->data; @@ -1599,7 +1608,7 @@ xcb_xkb_sa_move_ptr_next (xcb_xkb_sa_move_ptr_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_move_ptr_end (xcb_xkb_sa_move_ptr_iterator_t i /**< */) +xcb_xkb_sa_move_ptr_end (xcb_xkb_sa_move_ptr_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1609,7 +1618,7 @@ xcb_xkb_sa_move_ptr_end (xcb_xkb_sa_move_ptr_iterator_t i /**< */) } void -xcb_xkb_sa_ptr_btn_next (xcb_xkb_sa_ptr_btn_iterator_t *i /**< */) +xcb_xkb_sa_ptr_btn_next (xcb_xkb_sa_ptr_btn_iterator_t *i) { --i->rem; ++i->data; @@ -1617,7 +1626,7 @@ xcb_xkb_sa_ptr_btn_next (xcb_xkb_sa_ptr_btn_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_ptr_btn_end (xcb_xkb_sa_ptr_btn_iterator_t i /**< */) +xcb_xkb_sa_ptr_btn_end (xcb_xkb_sa_ptr_btn_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1627,7 +1636,7 @@ xcb_xkb_sa_ptr_btn_end (xcb_xkb_sa_ptr_btn_iterator_t i /**< */) } void -xcb_xkb_sa_lock_ptr_btn_next (xcb_xkb_sa_lock_ptr_btn_iterator_t *i /**< */) +xcb_xkb_sa_lock_ptr_btn_next (xcb_xkb_sa_lock_ptr_btn_iterator_t *i) { --i->rem; ++i->data; @@ -1635,7 +1644,7 @@ xcb_xkb_sa_lock_ptr_btn_next (xcb_xkb_sa_lock_ptr_btn_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_lock_ptr_btn_end (xcb_xkb_sa_lock_ptr_btn_iterator_t i /**< */) +xcb_xkb_sa_lock_ptr_btn_end (xcb_xkb_sa_lock_ptr_btn_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1645,7 +1654,7 @@ xcb_xkb_sa_lock_ptr_btn_end (xcb_xkb_sa_lock_ptr_btn_iterator_t i /**< */) } void -xcb_xkb_sa_set_ptr_dflt_next (xcb_xkb_sa_set_ptr_dflt_iterator_t *i /**< */) +xcb_xkb_sa_set_ptr_dflt_next (xcb_xkb_sa_set_ptr_dflt_iterator_t *i) { --i->rem; ++i->data; @@ -1653,7 +1662,7 @@ xcb_xkb_sa_set_ptr_dflt_next (xcb_xkb_sa_set_ptr_dflt_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_set_ptr_dflt_end (xcb_xkb_sa_set_ptr_dflt_iterator_t i /**< */) +xcb_xkb_sa_set_ptr_dflt_end (xcb_xkb_sa_set_ptr_dflt_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1663,7 +1672,7 @@ xcb_xkb_sa_set_ptr_dflt_end (xcb_xkb_sa_set_ptr_dflt_iterator_t i /**< */) } void -xcb_xkb_sa_iso_lock_next (xcb_xkb_sa_iso_lock_iterator_t *i /**< */) +xcb_xkb_sa_iso_lock_next (xcb_xkb_sa_iso_lock_iterator_t *i) { --i->rem; ++i->data; @@ -1671,7 +1680,7 @@ xcb_xkb_sa_iso_lock_next (xcb_xkb_sa_iso_lock_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_iso_lock_end (xcb_xkb_sa_iso_lock_iterator_t i /**< */) +xcb_xkb_sa_iso_lock_end (xcb_xkb_sa_iso_lock_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1681,7 +1690,7 @@ xcb_xkb_sa_iso_lock_end (xcb_xkb_sa_iso_lock_iterator_t i /**< */) } void -xcb_xkb_sa_terminate_next (xcb_xkb_sa_terminate_iterator_t *i /**< */) +xcb_xkb_sa_terminate_next (xcb_xkb_sa_terminate_iterator_t *i) { --i->rem; ++i->data; @@ -1689,7 +1698,7 @@ xcb_xkb_sa_terminate_next (xcb_xkb_sa_terminate_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_terminate_end (xcb_xkb_sa_terminate_iterator_t i /**< */) +xcb_xkb_sa_terminate_end (xcb_xkb_sa_terminate_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1699,7 +1708,7 @@ xcb_xkb_sa_terminate_end (xcb_xkb_sa_terminate_iterator_t i /**< */) } void -xcb_xkb_sa_switch_screen_next (xcb_xkb_sa_switch_screen_iterator_t *i /**< */) +xcb_xkb_sa_switch_screen_next (xcb_xkb_sa_switch_screen_iterator_t *i) { --i->rem; ++i->data; @@ -1707,7 +1716,7 @@ xcb_xkb_sa_switch_screen_next (xcb_xkb_sa_switch_screen_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_switch_screen_end (xcb_xkb_sa_switch_screen_iterator_t i /**< */) +xcb_xkb_sa_switch_screen_end (xcb_xkb_sa_switch_screen_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1717,7 +1726,7 @@ xcb_xkb_sa_switch_screen_end (xcb_xkb_sa_switch_screen_iterator_t i /**< */) } void -xcb_xkb_sa_set_controls_next (xcb_xkb_sa_set_controls_iterator_t *i /**< */) +xcb_xkb_sa_set_controls_next (xcb_xkb_sa_set_controls_iterator_t *i) { --i->rem; ++i->data; @@ -1725,7 +1734,7 @@ xcb_xkb_sa_set_controls_next (xcb_xkb_sa_set_controls_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_set_controls_end (xcb_xkb_sa_set_controls_iterator_t i /**< */) +xcb_xkb_sa_set_controls_end (xcb_xkb_sa_set_controls_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1735,7 +1744,7 @@ xcb_xkb_sa_set_controls_end (xcb_xkb_sa_set_controls_iterator_t i /**< */) } void -xcb_xkb_sa_lock_controls_next (xcb_xkb_sa_lock_controls_iterator_t *i /**< */) +xcb_xkb_sa_lock_controls_next (xcb_xkb_sa_lock_controls_iterator_t *i) { --i->rem; ++i->data; @@ -1743,7 +1752,7 @@ xcb_xkb_sa_lock_controls_next (xcb_xkb_sa_lock_controls_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_lock_controls_end (xcb_xkb_sa_lock_controls_iterator_t i /**< */) +xcb_xkb_sa_lock_controls_end (xcb_xkb_sa_lock_controls_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1753,7 +1762,7 @@ xcb_xkb_sa_lock_controls_end (xcb_xkb_sa_lock_controls_iterator_t i /**< */) } void -xcb_xkb_sa_action_message_next (xcb_xkb_sa_action_message_iterator_t *i /**< */) +xcb_xkb_sa_action_message_next (xcb_xkb_sa_action_message_iterator_t *i) { --i->rem; ++i->data; @@ -1761,7 +1770,7 @@ xcb_xkb_sa_action_message_next (xcb_xkb_sa_action_message_iterator_t *i /**< */ } xcb_generic_iterator_t -xcb_xkb_sa_action_message_end (xcb_xkb_sa_action_message_iterator_t i /**< */) +xcb_xkb_sa_action_message_end (xcb_xkb_sa_action_message_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1771,7 +1780,7 @@ xcb_xkb_sa_action_message_end (xcb_xkb_sa_action_message_iterator_t i /**< */) } void -xcb_xkb_sa_redirect_key_next (xcb_xkb_sa_redirect_key_iterator_t *i /**< */) +xcb_xkb_sa_redirect_key_next (xcb_xkb_sa_redirect_key_iterator_t *i) { --i->rem; ++i->data; @@ -1779,7 +1788,7 @@ xcb_xkb_sa_redirect_key_next (xcb_xkb_sa_redirect_key_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_redirect_key_end (xcb_xkb_sa_redirect_key_iterator_t i /**< */) +xcb_xkb_sa_redirect_key_end (xcb_xkb_sa_redirect_key_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1789,7 +1798,7 @@ xcb_xkb_sa_redirect_key_end (xcb_xkb_sa_redirect_key_iterator_t i /**< */) } void -xcb_xkb_sa_device_btn_next (xcb_xkb_sa_device_btn_iterator_t *i /**< */) +xcb_xkb_sa_device_btn_next (xcb_xkb_sa_device_btn_iterator_t *i) { --i->rem; ++i->data; @@ -1797,7 +1806,7 @@ xcb_xkb_sa_device_btn_next (xcb_xkb_sa_device_btn_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sa_device_btn_end (xcb_xkb_sa_device_btn_iterator_t i /**< */) +xcb_xkb_sa_device_btn_end (xcb_xkb_sa_device_btn_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1807,7 +1816,7 @@ xcb_xkb_sa_device_btn_end (xcb_xkb_sa_device_btn_iterator_t i /**< */) } void -xcb_xkb_sa_lock_device_btn_next (xcb_xkb_sa_lock_device_btn_iterator_t *i /**< */) +xcb_xkb_sa_lock_device_btn_next (xcb_xkb_sa_lock_device_btn_iterator_t *i) { --i->rem; ++i->data; @@ -1815,7 +1824,7 @@ xcb_xkb_sa_lock_device_btn_next (xcb_xkb_sa_lock_device_btn_iterator_t *i /**< } xcb_generic_iterator_t -xcb_xkb_sa_lock_device_btn_end (xcb_xkb_sa_lock_device_btn_iterator_t i /**< */) +xcb_xkb_sa_lock_device_btn_end (xcb_xkb_sa_lock_device_btn_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1825,7 +1834,7 @@ xcb_xkb_sa_lock_device_btn_end (xcb_xkb_sa_lock_device_btn_iterator_t i /**< */ } void -xcb_xkb_sa_device_valuator_next (xcb_xkb_sa_device_valuator_iterator_t *i /**< */) +xcb_xkb_sa_device_valuator_next (xcb_xkb_sa_device_valuator_iterator_t *i) { --i->rem; ++i->data; @@ -1833,7 +1842,7 @@ xcb_xkb_sa_device_valuator_next (xcb_xkb_sa_device_valuator_iterator_t *i /**< } xcb_generic_iterator_t -xcb_xkb_sa_device_valuator_end (xcb_xkb_sa_device_valuator_iterator_t i /**< */) +xcb_xkb_sa_device_valuator_end (xcb_xkb_sa_device_valuator_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1843,7 +1852,7 @@ xcb_xkb_sa_device_valuator_end (xcb_xkb_sa_device_valuator_iterator_t i /**< */ } void -xcb_xkb_si_action_next (xcb_xkb_si_action_iterator_t *i /**< */) +xcb_xkb_si_action_next (xcb_xkb_si_action_iterator_t *i) { --i->rem; ++i->data; @@ -1851,7 +1860,7 @@ xcb_xkb_si_action_next (xcb_xkb_si_action_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_si_action_end (xcb_xkb_si_action_iterator_t i /**< */) +xcb_xkb_si_action_end (xcb_xkb_si_action_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1861,7 +1870,7 @@ xcb_xkb_si_action_end (xcb_xkb_si_action_iterator_t i /**< */) } void -xcb_xkb_sym_interpret_next (xcb_xkb_sym_interpret_iterator_t *i /**< */) +xcb_xkb_sym_interpret_next (xcb_xkb_sym_interpret_iterator_t *i) { --i->rem; ++i->data; @@ -1869,7 +1878,7 @@ xcb_xkb_sym_interpret_next (xcb_xkb_sym_interpret_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_sym_interpret_end (xcb_xkb_sym_interpret_iterator_t i /**< */) +xcb_xkb_sym_interpret_end (xcb_xkb_sym_interpret_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1879,7 +1888,7 @@ xcb_xkb_sym_interpret_end (xcb_xkb_sym_interpret_iterator_t i /**< */) } void -xcb_xkb_action_next (xcb_xkb_action_iterator_t *i /**< */) +xcb_xkb_action_next (xcb_xkb_action_iterator_t *i) { --i->rem; ++i->data; @@ -1887,7 +1896,7 @@ xcb_xkb_action_next (xcb_xkb_action_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xkb_action_end (xcb_xkb_action_iterator_t i /**< */) +xcb_xkb_action_end (xcb_xkb_action_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -1897,15 +1906,15 @@ xcb_xkb_action_end (xcb_xkb_action_iterator_t i /**< */) } xcb_xkb_use_extension_cookie_t -xcb_xkb_use_extension (xcb_connection_t *c /**< */, - uint16_t wantedMajor /**< */, - uint16_t wantedMinor /**< */) +xcb_xkb_use_extension (xcb_connection_t *c, + uint16_t wantedMajor, + uint16_t wantedMinor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_USE_EXTENSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_USE_EXTENSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1925,15 +1934,15 @@ xcb_xkb_use_extension (xcb_connection_t *c /**< */, } xcb_xkb_use_extension_cookie_t -xcb_xkb_use_extension_unchecked (xcb_connection_t *c /**< */, - uint16_t wantedMajor /**< */, - uint16_t wantedMinor /**< */) +xcb_xkb_use_extension_unchecked (xcb_connection_t *c, + uint16_t wantedMajor, + uint16_t wantedMinor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_USE_EXTENSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_USE_EXTENSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1953,23 +1962,24 @@ xcb_xkb_use_extension_unchecked (xcb_connection_t *c /**< */, } xcb_xkb_use_extension_reply_t * -xcb_xkb_use_extension_reply (xcb_connection_t *c /**< */, +xcb_xkb_use_extension_reply (xcb_connection_t *c, xcb_xkb_use_extension_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_use_extension_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xkb_select_events_details_serialize (void **_buffer /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - const xcb_xkb_select_events_details_t *_aux /**< */) +xcb_xkb_select_events_details_serialize (void **_buffer, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + const xcb_xkb_select_events_details_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; @@ -2134,7 +2144,7 @@ xcb_xkb_select_events_details_serialize (void * xcb_align_to = ALIGNOF(uint16_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -2143,6 +2153,7 @@ xcb_xkb_select_events_details_serialize (void * xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -2162,17 +2173,18 @@ xcb_xkb_select_events_details_serialize (void * } int -xcb_xkb_select_events_details_unpack (const void *_buffer /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - xcb_xkb_select_events_details_t *_aux /**< */) +xcb_xkb_select_events_details_unpack (const void *_buffer, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + xcb_xkb_select_events_details_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY) { @@ -2308,6 +2320,48 @@ xcb_xkb_select_events_details_unpack (const void *_buffer xcb_align_to = ALIGNOF(uint16_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; +} + +int +xcb_xkb_select_events_details_sizeof (const void *_buffer, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll) +{ + xcb_xkb_select_events_details_t _aux; + return xcb_xkb_select_events_details_unpack(_buffer, affectWhich, clear, selectAll, &_aux); +} + +int +xcb_xkb_select_events_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xkb_select_events_request_t *_aux = (xcb_xkb_select_events_request_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; + + + xcb_block_len += sizeof(xcb_xkb_select_events_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* details */ + xcb_block_len += xcb_xkb_select_events_details_sizeof(xcb_tmp, _aux->affectWhich, _aux->clear, _aux->selectAll); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -2319,31 +2373,21 @@ xcb_xkb_select_events_details_unpack (const void *_buffer return xcb_buffer_len; } -int -xcb_xkb_select_events_details_sizeof (const void *_buffer /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */) -{ - xcb_xkb_select_events_details_t _aux; - return xcb_xkb_select_events_details_unpack(_buffer, affectWhich, clear, selectAll, &_aux); -} - xcb_void_cookie_t -xcb_xkb_select_events_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - uint16_t affectMap /**< */, - uint16_t map /**< */, - const void *details /**< */) +xcb_xkb_select_events_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + uint16_t affectMap, + uint16_t map, + const void *details) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SELECT_EVENTS, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SELECT_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -2371,20 +2415,20 @@ xcb_xkb_select_events_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_select_events (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - uint16_t affectMap /**< */, - uint16_t map /**< */, - const void *details /**< */) +xcb_xkb_select_events (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + uint16_t affectMap, + uint16_t map, + const void *details) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SELECT_EVENTS, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SELECT_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -2412,20 +2456,20 @@ xcb_xkb_select_events (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_select_events_aux_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - uint16_t affectMap /**< */, - uint16_t map /**< */, - const xcb_xkb_select_events_details_t *details /**< */) +xcb_xkb_select_events_aux_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + uint16_t affectMap, + uint16_t map, + const xcb_xkb_select_events_details_t *details) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SELECT_EVENTS, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SELECT_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -2455,20 +2499,20 @@ xcb_xkb_select_events_aux_checked (xcb_connection_t *c /** } xcb_void_cookie_t -xcb_xkb_select_events_aux (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - uint16_t affectMap /**< */, - uint16_t map /**< */, - const xcb_xkb_select_events_details_t *details /**< */) +xcb_xkb_select_events_aux (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + uint16_t affectMap, + uint16_t map, + const xcb_xkb_select_events_details_t *details) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SELECT_EVENTS, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SELECT_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -2497,24 +2541,30 @@ xcb_xkb_select_events_aux (xcb_connection_t *c /**< */, return xcb_ret; } +void * +xcb_xkb_select_events_details (const xcb_xkb_select_events_request_t *R) +{ + return (void *) (R + 1); +} + xcb_void_cookie_t -xcb_xkb_bell_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_bell_class_spec_t bellClass /**< */, - xcb_xkb_id_spec_t bellID /**< */, - int8_t percent /**< */, - uint8_t forceSound /**< */, - uint8_t eventOnly /**< */, - int16_t pitch /**< */, - int16_t duration /**< */, - xcb_atom_t name /**< */, - xcb_window_t window /**< */) +xcb_xkb_bell_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_bell_class_spec_t bellClass, + xcb_xkb_id_spec_t bellID, + int8_t percent, + uint8_t forceSound, + uint8_t eventOnly, + int16_t pitch, + int16_t duration, + xcb_atom_t name, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_BELL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_BELL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2544,23 +2594,23 @@ xcb_xkb_bell_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_bell (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_bell_class_spec_t bellClass /**< */, - xcb_xkb_id_spec_t bellID /**< */, - int8_t percent /**< */, - uint8_t forceSound /**< */, - uint8_t eventOnly /**< */, - int16_t pitch /**< */, - int16_t duration /**< */, - xcb_atom_t name /**< */, - xcb_window_t window /**< */) +xcb_xkb_bell (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_bell_class_spec_t bellClass, + xcb_xkb_id_spec_t bellID, + int8_t percent, + uint8_t forceSound, + uint8_t eventOnly, + int16_t pitch, + int16_t duration, + xcb_atom_t name, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_BELL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_BELL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2590,14 +2640,14 @@ xcb_xkb_bell (xcb_connection_t *c /**< */, } xcb_xkb_get_state_cookie_t -xcb_xkb_get_state (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */) +xcb_xkb_get_state (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_STATE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_STATE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2617,14 +2667,14 @@ xcb_xkb_get_state (xcb_connection_t *c /**< */, } xcb_xkb_get_state_cookie_t -xcb_xkb_get_state_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */) +xcb_xkb_get_state_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_STATE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_STATE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2644,29 +2694,29 @@ xcb_xkb_get_state_unchecked (xcb_connection_t *c /**< */, } xcb_xkb_get_state_reply_t * -xcb_xkb_get_state_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_state_reply (xcb_connection_t *c, xcb_xkb_get_state_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_get_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xkb_latch_lock_state_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t affectModLocks /**< */, - uint8_t modLocks /**< */, - uint8_t lockGroup /**< */, - uint8_t groupLock /**< */, - uint8_t affectModLatches /**< */, - uint8_t latchGroup /**< */, - uint16_t groupLatch /**< */) +xcb_xkb_latch_lock_state_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t affectModLocks, + uint8_t modLocks, + uint8_t lockGroup, + uint8_t groupLock, + uint8_t affectModLatches, + uint8_t latchGroup, + uint16_t groupLatch) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_LATCH_LOCK_STATE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_LATCH_LOCK_STATE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2694,21 +2744,21 @@ xcb_xkb_latch_lock_state_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_latch_lock_state (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t affectModLocks /**< */, - uint8_t modLocks /**< */, - uint8_t lockGroup /**< */, - uint8_t groupLock /**< */, - uint8_t affectModLatches /**< */, - uint8_t latchGroup /**< */, - uint16_t groupLatch /**< */) +xcb_xkb_latch_lock_state (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t affectModLocks, + uint8_t modLocks, + uint8_t lockGroup, + uint8_t groupLock, + uint8_t affectModLatches, + uint8_t latchGroup, + uint16_t groupLatch) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_LATCH_LOCK_STATE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_LATCH_LOCK_STATE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2736,14 +2786,14 @@ xcb_xkb_latch_lock_state (xcb_connection_t *c /**< */, } xcb_xkb_get_controls_cookie_t -xcb_xkb_get_controls (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */) +xcb_xkb_get_controls (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_CONTROLS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_CONTROLS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2763,14 +2813,14 @@ xcb_xkb_get_controls (xcb_connection_t *c /**< */, } xcb_xkb_get_controls_cookie_t -xcb_xkb_get_controls_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */) +xcb_xkb_get_controls_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_CONTROLS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_CONTROLS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2790,51 +2840,51 @@ xcb_xkb_get_controls_unchecked (xcb_connection_t *c /**< */, } xcb_xkb_get_controls_reply_t * -xcb_xkb_get_controls_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_controls_reply (xcb_connection_t *c, xcb_xkb_get_controls_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_get_controls_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xkb_set_controls_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t affectInternalRealMods /**< */, - uint8_t internalRealMods /**< */, - uint8_t affectIgnoreLockRealMods /**< */, - uint8_t ignoreLockRealMods /**< */, - uint16_t affectInternalVirtualMods /**< */, - uint16_t internalVirtualMods /**< */, - uint16_t affectIgnoreLockVirtualMods /**< */, - uint16_t ignoreLockVirtualMods /**< */, - uint8_t mouseKeysDfltBtn /**< */, - uint8_t groupsWrap /**< */, - uint16_t accessXOptions /**< */, - uint32_t affectEnabledControls /**< */, - uint32_t enabledControls /**< */, - uint32_t changeControls /**< */, - uint16_t repeatDelay /**< */, - uint16_t repeatInterval /**< */, - uint16_t slowKeysDelay /**< */, - uint16_t debounceDelay /**< */, - uint16_t mouseKeysDelay /**< */, - uint16_t mouseKeysInterval /**< */, - uint16_t mouseKeysTimeToMax /**< */, - uint16_t mouseKeysMaxSpeed /**< */, - int16_t mouseKeysCurve /**< */, - uint16_t accessXTimeout /**< */, - uint32_t accessXTimeoutMask /**< */, - uint32_t accessXTimeoutValues /**< */, - uint16_t accessXTimeoutOptionsMask /**< */, - uint16_t accessXTimeoutOptionsValues /**< */, - const uint8_t *perKeyRepeat /**< */) +xcb_xkb_set_controls_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t affectInternalRealMods, + uint8_t internalRealMods, + uint8_t affectIgnoreLockRealMods, + uint8_t ignoreLockRealMods, + uint16_t affectInternalVirtualMods, + uint16_t internalVirtualMods, + uint16_t affectIgnoreLockVirtualMods, + uint16_t ignoreLockVirtualMods, + uint8_t mouseKeysDfltBtn, + uint8_t groupsWrap, + uint16_t accessXOptions, + uint32_t affectEnabledControls, + uint32_t enabledControls, + uint32_t changeControls, + uint16_t repeatDelay, + uint16_t repeatInterval, + uint16_t slowKeysDelay, + uint16_t debounceDelay, + uint16_t mouseKeysDelay, + uint16_t mouseKeysInterval, + uint16_t mouseKeysTimeToMax, + uint16_t mouseKeysMaxSpeed, + int16_t mouseKeysCurve, + uint16_t accessXTimeout, + uint32_t accessXTimeoutMask, + uint32_t accessXTimeoutValues, + uint16_t accessXTimeoutOptionsMask, + uint16_t accessXTimeoutOptionsValues, + const uint8_t *perKeyRepeat) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_CONTROLS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_CONTROLS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2883,43 +2933,43 @@ xcb_xkb_set_controls_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_controls (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t affectInternalRealMods /**< */, - uint8_t internalRealMods /**< */, - uint8_t affectIgnoreLockRealMods /**< */, - uint8_t ignoreLockRealMods /**< */, - uint16_t affectInternalVirtualMods /**< */, - uint16_t internalVirtualMods /**< */, - uint16_t affectIgnoreLockVirtualMods /**< */, - uint16_t ignoreLockVirtualMods /**< */, - uint8_t mouseKeysDfltBtn /**< */, - uint8_t groupsWrap /**< */, - uint16_t accessXOptions /**< */, - uint32_t affectEnabledControls /**< */, - uint32_t enabledControls /**< */, - uint32_t changeControls /**< */, - uint16_t repeatDelay /**< */, - uint16_t repeatInterval /**< */, - uint16_t slowKeysDelay /**< */, - uint16_t debounceDelay /**< */, - uint16_t mouseKeysDelay /**< */, - uint16_t mouseKeysInterval /**< */, - uint16_t mouseKeysTimeToMax /**< */, - uint16_t mouseKeysMaxSpeed /**< */, - int16_t mouseKeysCurve /**< */, - uint16_t accessXTimeout /**< */, - uint32_t accessXTimeoutMask /**< */, - uint32_t accessXTimeoutValues /**< */, - uint16_t accessXTimeoutOptionsMask /**< */, - uint16_t accessXTimeoutOptionsValues /**< */, - const uint8_t *perKeyRepeat /**< */) +xcb_xkb_set_controls (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t affectInternalRealMods, + uint8_t internalRealMods, + uint8_t affectIgnoreLockRealMods, + uint8_t ignoreLockRealMods, + uint16_t affectInternalVirtualMods, + uint16_t internalVirtualMods, + uint16_t affectIgnoreLockVirtualMods, + uint16_t ignoreLockVirtualMods, + uint8_t mouseKeysDfltBtn, + uint8_t groupsWrap, + uint16_t accessXOptions, + uint32_t affectEnabledControls, + uint32_t enabledControls, + uint32_t changeControls, + uint16_t repeatDelay, + uint16_t repeatInterval, + uint16_t slowKeysDelay, + uint16_t debounceDelay, + uint16_t mouseKeysDelay, + uint16_t mouseKeysInterval, + uint16_t mouseKeysTimeToMax, + uint16_t mouseKeysMaxSpeed, + int16_t mouseKeysCurve, + uint16_t accessXTimeout, + uint32_t accessXTimeoutMask, + uint32_t accessXTimeoutValues, + uint16_t accessXTimeoutOptionsMask, + uint16_t accessXTimeoutOptionsValues, + const uint8_t *perKeyRepeat) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_CONTROLS, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_CONTROLS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2968,226 +3018,227 @@ xcb_xkb_set_controls (xcb_connection_t *c /**< */, } int -xcb_xkb_get_map_map_types_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_types_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { return R->nTypes; } xcb_xkb_key_type_iterator_t -xcb_xkb_get_map_map_types_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_types_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { xcb_xkb_key_type_iterator_t i; - i.data = /* map */ S->types_rtrn; + i.data = S->types_rtrn; i.rem = R->nTypes; i.index = (char *) i.data - (char *) S; return i; } int -xcb_xkb_get_map_map_syms_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_syms_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { return R->nKeySyms; } xcb_xkb_key_sym_map_iterator_t -xcb_xkb_get_map_map_syms_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_syms_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { xcb_xkb_key_sym_map_iterator_t i; - i.data = /* map */ S->syms_rtrn; + i.data = S->syms_rtrn; i.rem = R->nKeySyms; i.index = (char *) i.data - (char *) S; return i; } uint8_t * -xcb_xkb_get_map_map_acts_rtrn_count (const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_acts_rtrn_count (const xcb_xkb_get_map_map_t *S) { - return /* map */ S->acts_rtrn_count; + return S->acts_rtrn_count; } int -xcb_xkb_get_map_map_acts_rtrn_count_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_acts_rtrn_count_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { return R->nKeyActions; } xcb_generic_iterator_t -xcb_xkb_get_map_map_acts_rtrn_count_end (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_acts_rtrn_count_end (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { xcb_generic_iterator_t i; - i.data = /* map */ S->acts_rtrn_count + R->nKeyActions; + i.data = S->acts_rtrn_count + R->nKeyActions; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_action_t * -xcb_xkb_get_map_map_acts_rtrn_acts (const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_acts_rtrn_acts (const xcb_xkb_get_map_map_t *S) { - return /* map */ S->acts_rtrn_acts; + return S->acts_rtrn_acts; } int -xcb_xkb_get_map_map_acts_rtrn_acts_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_acts_rtrn_acts_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { return R->totalActions; } xcb_xkb_action_iterator_t -xcb_xkb_get_map_map_acts_rtrn_acts_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_acts_rtrn_acts_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { xcb_xkb_action_iterator_t i; - i.data = /* map */ S->acts_rtrn_acts; + i.data = S->acts_rtrn_acts; i.rem = R->totalActions; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_set_behavior_t * -xcb_xkb_get_map_map_behaviors_rtrn (const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_behaviors_rtrn (const xcb_xkb_get_map_map_t *S) { - return /* map */ S->behaviors_rtrn; + return S->behaviors_rtrn; } int -xcb_xkb_get_map_map_behaviors_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_behaviors_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { return R->totalKeyBehaviors; } xcb_xkb_set_behavior_iterator_t -xcb_xkb_get_map_map_behaviors_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_behaviors_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { xcb_xkb_set_behavior_iterator_t i; - i.data = /* map */ S->behaviors_rtrn; + i.data = S->behaviors_rtrn; i.rem = R->totalKeyBehaviors; i.index = (char *) i.data - (char *) S; return i; } uint8_t * -xcb_xkb_get_map_map_vmods_rtrn (const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_vmods_rtrn (const xcb_xkb_get_map_map_t *S) { - return /* map */ S->vmods_rtrn; + return S->vmods_rtrn; } int -xcb_xkb_get_map_map_vmods_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_vmods_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { return xcb_popcount(R->virtualMods); } xcb_generic_iterator_t -xcb_xkb_get_map_map_vmods_rtrn_end (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_vmods_rtrn_end (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { xcb_generic_iterator_t i; - i.data = /* map */ S->vmods_rtrn + xcb_popcount(R->virtualMods); + i.data = S->vmods_rtrn + xcb_popcount(R->virtualMods); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_set_explicit_t * -xcb_xkb_get_map_map_explicit_rtrn (const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_explicit_rtrn (const xcb_xkb_get_map_map_t *S) { - return /* map */ S->explicit_rtrn; + return S->explicit_rtrn; } int -xcb_xkb_get_map_map_explicit_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_explicit_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { return R->totalKeyExplicit; } xcb_xkb_set_explicit_iterator_t -xcb_xkb_get_map_map_explicit_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_explicit_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { xcb_xkb_set_explicit_iterator_t i; - i.data = /* map */ S->explicit_rtrn; + i.data = S->explicit_rtrn; i.rem = R->totalKeyExplicit; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_mod_map_t * -xcb_xkb_get_map_map_modmap_rtrn (const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_modmap_rtrn (const xcb_xkb_get_map_map_t *S) { - return /* map */ S->modmap_rtrn; + return S->modmap_rtrn; } int -xcb_xkb_get_map_map_modmap_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_modmap_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { return R->totalModMapKeys; } xcb_xkb_key_mod_map_iterator_t -xcb_xkb_get_map_map_modmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_modmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { xcb_xkb_key_mod_map_iterator_t i; - i.data = /* map */ S->modmap_rtrn; + i.data = S->modmap_rtrn; i.rem = R->totalModMapKeys; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_v_mod_map_t * -xcb_xkb_get_map_map_vmodmap_rtrn (const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_vmodmap_rtrn (const xcb_xkb_get_map_map_t *S) { - return /* map */ S->vmodmap_rtrn; + return S->vmodmap_rtrn; } int -xcb_xkb_get_map_map_vmodmap_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_vmodmap_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { return R->totalVModMapKeys; } xcb_xkb_key_v_mod_map_iterator_t -xcb_xkb_get_map_map_vmodmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */) +xcb_xkb_get_map_map_vmodmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S) { xcb_xkb_key_v_mod_map_iterator_t i; - i.data = /* map */ S->vmodmap_rtrn; + i.data = S->vmodmap_rtrn; i.rem = R->totalVModMapKeys; i.index = (char *) i.data - (char *) S; return i; } int -xcb_xkb_get_map_map_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - const xcb_xkb_get_map_map_t *_aux /**< */) +xcb_xkb_get_map_map_serialize (void **_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + const xcb_xkb_get_map_map_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; @@ -3199,7 +3250,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, if(present & XCB_XKB_MAP_PART_KEY_TYPES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3208,6 +3259,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* types_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->types_rtrn; xcb_parts[xcb_parts_idx].iov_len = 0; @@ -3222,7 +3274,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, } if(present & XCB_XKB_MAP_PART_KEY_SYMS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3231,6 +3283,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* syms_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->syms_rtrn; xcb_parts[xcb_parts_idx].iov_len = 0; @@ -3245,7 +3298,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, } if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3254,6 +3307,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* acts_rtrn_count */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_count; xcb_block_len += nKeyActions * sizeof(xcb_keycode_t); @@ -3262,7 +3316,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_align_to = ALIGNOF(uint8_t); xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3271,8 +3325,9 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3281,6 +3336,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* acts_rtrn_acts */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_acts; xcb_block_len += totalActions * sizeof(xcb_xkb_action_t); @@ -3290,7 +3346,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, } if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3299,6 +3355,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* behaviors_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->behaviors_rtrn; xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t); @@ -3308,7 +3365,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, } if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3317,6 +3374,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* vmods_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmods_rtrn; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t); @@ -3325,7 +3383,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_align_to = ALIGNOF(uint8_t); xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3334,10 +3392,11 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; } if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3346,6 +3405,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* explicit_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->explicit_rtrn; xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t); @@ -3354,7 +3414,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t); xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3363,10 +3423,11 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; } if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3375,6 +3436,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* modmap_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->modmap_rtrn; xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t); @@ -3383,7 +3445,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t); xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3392,10 +3454,11 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; } if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3404,6 +3467,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* vmodmap_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmodmap_rtrn; xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t); @@ -3412,7 +3476,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -3421,6 +3485,7 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -3440,37 +3505,39 @@ xcb_xkb_get_map_map_serialize (void **_buffer /**< */, } int -xcb_xkb_get_map_map_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - xcb_xkb_get_map_map_t *_aux /**< */) +xcb_xkb_get_map_map_unpack (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + xcb_xkb_get_map_map_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; unsigned int i; unsigned int xcb_tmp_len; if(present & XCB_XKB_MAP_PART_KEY_TYPES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* types_rtrn */ _aux->types_rtrn = (xcb_xkb_key_type_t *)xcb_tmp; for(i=0; isyms_rtrn = (xcb_xkb_key_sym_map_t *)xcb_tmp; for(i=0; iacts_rtrn_count = (uint8_t *)xcb_tmp; xcb_block_len += nKeyActions * sizeof(xcb_keycode_t); @@ -3514,21 +3583,23 @@ xcb_xkb_get_map_map_unpack (const void *_buffer /**< */, xcb_align_to = ALIGNOF(uint8_t); xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* acts_rtrn_acts */ _aux->acts_rtrn_acts = (xcb_xkb_action_t *)xcb_tmp; xcb_block_len += totalActions * sizeof(xcb_xkb_action_t); @@ -3537,13 +3608,14 @@ xcb_xkb_get_map_map_unpack (const void *_buffer /**< */, } if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* behaviors_rtrn */ _aux->behaviors_rtrn = (xcb_xkb_set_behavior_t *)xcb_tmp; xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t); @@ -3552,13 +3624,14 @@ xcb_xkb_get_map_map_unpack (const void *_buffer /**< */, } if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* vmods_rtrn */ _aux->vmods_rtrn = (uint8_t *)xcb_tmp; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t); @@ -3566,23 +3639,25 @@ xcb_xkb_get_map_map_unpack (const void *_buffer /**< */, xcb_align_to = ALIGNOF(uint8_t); xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; } if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* explicit_rtrn */ _aux->explicit_rtrn = (xcb_xkb_set_explicit_t *)xcb_tmp; xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t); @@ -3590,23 +3665,25 @@ xcb_xkb_get_map_map_unpack (const void *_buffer /**< */, xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t); xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; } if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* modmap_rtrn */ _aux->modmap_rtrn = (xcb_xkb_key_mod_map_t *)xcb_tmp; xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t); @@ -3614,23 +3691,25 @@ xcb_xkb_get_map_map_unpack (const void *_buffer /**< */, xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t); xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; } if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* vmodmap_rtrn */ _aux->vmodmap_rtrn = (xcb_xkb_key_v_mod_map_t *)xcb_tmp; xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t); @@ -3638,6 +3717,55 @@ xcb_xkb_get_map_map_unpack (const void *_buffer /**< */, xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_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; +} + +int +xcb_xkb_get_map_map_sizeof (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present) +{ + xcb_xkb_get_map_map_t _aux; + return xcb_xkb_get_map_map_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux); +} + +int +xcb_xkb_get_map_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xkb_get_map_reply_t *_aux = (xcb_xkb_get_map_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; + + + xcb_block_len += sizeof(xcb_xkb_get_map_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* map */ + xcb_block_len += xcb_xkb_get_map_map_sizeof(xcb_tmp, _aux->nTypes, _aux->nKeySyms, _aux->nKeyActions, _aux->totalActions, _aux->totalKeyBehaviors, _aux->virtualMods, _aux->totalKeyExplicit, _aux->totalModMapKeys, _aux->totalVModMapKeys, _aux->present); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -3649,49 +3777,32 @@ xcb_xkb_get_map_map_unpack (const void *_buffer /**< */, return xcb_buffer_len; } -int -xcb_xkb_get_map_map_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */) -{ - xcb_xkb_get_map_map_t _aux; - return xcb_xkb_get_map_map_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux); -} - xcb_xkb_get_map_cookie_t -xcb_xkb_get_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t full /**< */, - uint16_t partial /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */) +xcb_xkb_get_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t full, + uint16_t partial, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint16_t virtualMods, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_MAP, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_MAP, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3728,31 +3839,31 @@ xcb_xkb_get_map (xcb_connection_t *c /**< */, } xcb_xkb_get_map_cookie_t -xcb_xkb_get_map_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t full /**< */, - uint16_t partial /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */) +xcb_xkb_get_map_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t full, + uint16_t partial, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint16_t virtualMods, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_MAP, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_MAP, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3789,244 +3900,245 @@ xcb_xkb_get_map_unchecked (xcb_connection_t *c /**< */, } void * -xcb_xkb_get_map_map (const xcb_xkb_get_map_reply_t *R /**< */) +xcb_xkb_get_map_map (const xcb_xkb_get_map_reply_t *R) { return (void *) (R + 1); } xcb_xkb_get_map_reply_t * -xcb_xkb_get_map_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_map_reply (xcb_connection_t *c, xcb_xkb_get_map_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_get_map_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xkb_set_map_values_types_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_types_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { return R->nTypes; } xcb_xkb_set_key_type_iterator_t -xcb_xkb_set_map_values_types_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_types_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { xcb_xkb_set_key_type_iterator_t i; - i.data = /* values */ S->types; + i.data = S->types; i.rem = R->nTypes; i.index = (char *) i.data - (char *) S; return i; } int -xcb_xkb_set_map_values_syms_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_syms_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { return R->nKeySyms; } xcb_xkb_key_sym_map_iterator_t -xcb_xkb_set_map_values_syms_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_syms_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { xcb_xkb_key_sym_map_iterator_t i; - i.data = /* values */ S->syms; + i.data = S->syms; i.rem = R->nKeySyms; i.index = (char *) i.data - (char *) S; return i; } uint8_t * -xcb_xkb_set_map_values_actions_count (const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_actions_count (const xcb_xkb_set_map_values_t *S) { - return /* values */ S->actionsCount; + return S->actionsCount; } int -xcb_xkb_set_map_values_actions_count_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_actions_count_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { return R->nKeyActions; } xcb_generic_iterator_t -xcb_xkb_set_map_values_actions_count_end (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_actions_count_end (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { xcb_generic_iterator_t i; - i.data = /* values */ S->actionsCount + R->nKeyActions; + i.data = S->actionsCount + R->nKeyActions; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_action_t * -xcb_xkb_set_map_values_actions (const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_actions (const xcb_xkb_set_map_values_t *S) { - return /* values */ S->actions; + return S->actions; } int -xcb_xkb_set_map_values_actions_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_actions_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { return R->totalActions; } xcb_xkb_action_iterator_t -xcb_xkb_set_map_values_actions_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_actions_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { xcb_xkb_action_iterator_t i; - i.data = /* values */ S->actions; + i.data = S->actions; i.rem = R->totalActions; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_set_behavior_t * -xcb_xkb_set_map_values_behaviors (const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_behaviors (const xcb_xkb_set_map_values_t *S) { - return /* values */ S->behaviors; + return S->behaviors; } int -xcb_xkb_set_map_values_behaviors_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_behaviors_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { return R->totalKeyBehaviors; } xcb_xkb_set_behavior_iterator_t -xcb_xkb_set_map_values_behaviors_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_behaviors_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { xcb_xkb_set_behavior_iterator_t i; - i.data = /* values */ S->behaviors; + i.data = S->behaviors; i.rem = R->totalKeyBehaviors; i.index = (char *) i.data - (char *) S; return i; } uint8_t * -xcb_xkb_set_map_values_vmods (const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_vmods (const xcb_xkb_set_map_values_t *S) { - return /* values */ S->vmods; + return S->vmods; } int -xcb_xkb_set_map_values_vmods_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_vmods_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { return xcb_popcount(R->virtualMods); } xcb_generic_iterator_t -xcb_xkb_set_map_values_vmods_end (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_vmods_end (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { xcb_generic_iterator_t i; - i.data = /* values */ S->vmods + xcb_popcount(R->virtualMods); + i.data = S->vmods + xcb_popcount(R->virtualMods); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_set_explicit_t * -xcb_xkb_set_map_values_explicit (const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_explicit (const xcb_xkb_set_map_values_t *S) { - return /* values */ S->explicit; + return S->explicit; } int -xcb_xkb_set_map_values_explicit_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_explicit_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { return R->totalKeyExplicit; } xcb_xkb_set_explicit_iterator_t -xcb_xkb_set_map_values_explicit_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_explicit_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { xcb_xkb_set_explicit_iterator_t i; - i.data = /* values */ S->explicit; + i.data = S->explicit; i.rem = R->totalKeyExplicit; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_mod_map_t * -xcb_xkb_set_map_values_modmap (const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_modmap (const xcb_xkb_set_map_values_t *S) { - return /* values */ S->modmap; + return S->modmap; } int -xcb_xkb_set_map_values_modmap_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_modmap_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { return R->totalModMapKeys; } xcb_xkb_key_mod_map_iterator_t -xcb_xkb_set_map_values_modmap_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_modmap_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { xcb_xkb_key_mod_map_iterator_t i; - i.data = /* values */ S->modmap; + i.data = S->modmap; i.rem = R->totalModMapKeys; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_v_mod_map_t * -xcb_xkb_set_map_values_vmodmap (const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_vmodmap (const xcb_xkb_set_map_values_t *S) { - return /* values */ S->vmodmap; + return S->vmodmap; } int -xcb_xkb_set_map_values_vmodmap_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_vmodmap_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { return R->totalVModMapKeys; } xcb_xkb_key_v_mod_map_iterator_t -xcb_xkb_set_map_values_vmodmap_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */) +xcb_xkb_set_map_values_vmodmap_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S) { xcb_xkb_key_v_mod_map_iterator_t i; - i.data = /* values */ S->vmodmap; + i.data = S->vmodmap; i.rem = R->totalVModMapKeys; i.index = (char *) i.data - (char *) S; return i; } int -xcb_xkb_set_map_values_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - const xcb_xkb_set_map_values_t *_aux /**< */) +xcb_xkb_set_map_values_serialize (void **_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + const xcb_xkb_set_map_values_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[19]; + struct iovec xcb_parts[21]; unsigned int xcb_parts_idx = 0; unsigned int xcb_block_len = 0; unsigned int i; @@ -4034,7 +4146,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< if(present & XCB_XKB_MAP_PART_KEY_TYPES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -4043,6 +4155,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* types */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->types; xcb_parts[xcb_parts_idx].iov_len = 0; @@ -4057,7 +4170,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< } if(present & XCB_XKB_MAP_PART_KEY_SYMS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -4066,6 +4179,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* syms */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->syms; xcb_parts[xcb_parts_idx].iov_len = 0; @@ -4080,7 +4194,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< } if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -4089,14 +4203,16 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* actionsCount */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->actionsCount; xcb_block_len += nKeyActions * sizeof(xcb_keycode_t); xcb_parts[xcb_parts_idx].iov_len = nKeyActions * sizeof(xcb_keycode_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -4105,6 +4221,18 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* actions */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->actions; xcb_block_len += totalActions * sizeof(xcb_xkb_action_t); @@ -4114,7 +4242,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< } if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -4123,6 +4251,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* behaviors */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->behaviors; xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t); @@ -4132,7 +4261,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< } if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -4141,16 +4270,16 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* vmods */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmods; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t); xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_keycode_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); - } - if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -4159,6 +4288,20 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* explicit */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->explicit; xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t); @@ -4168,7 +4311,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< } if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -4177,6 +4320,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* modmap */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->modmap; xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t); @@ -4186,7 +4330,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< } if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -4195,6 +4339,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* vmodmap */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmodmap; xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t); @@ -4203,7 +4348,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -4212,6 +4357,7 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -4231,37 +4377,39 @@ xcb_xkb_set_map_values_serialize (void **_buffer /**< } int -xcb_xkb_set_map_values_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - xcb_xkb_set_map_values_t *_aux /**< */) +xcb_xkb_set_map_values_unpack (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + xcb_xkb_set_map_values_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; unsigned int i; unsigned int xcb_tmp_len; if(present & XCB_XKB_MAP_PART_KEY_TYPES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* types */ _aux->types = (xcb_xkb_set_key_type_t *)xcb_tmp; for(i=0; isyms = (xcb_xkb_key_sym_map_t *)xcb_tmp; for(i=0; iactionsCount = (uint8_t *)xcb_tmp; xcb_block_len += nKeyActions * sizeof(xcb_keycode_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + /* 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; /* actions */ _aux->actions = (xcb_xkb_action_t *)xcb_tmp; xcb_block_len += totalActions * sizeof(xcb_xkb_action_t); @@ -4319,13 +4480,14 @@ xcb_xkb_set_map_values_unpack (const void *_buffer /**< */, } if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* behaviors */ _aux->behaviors = (xcb_xkb_set_behavior_t *)xcb_tmp; xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t); @@ -4334,28 +4496,40 @@ xcb_xkb_set_map_values_unpack (const void *_buffer /**< */, } if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* vmods */ _aux->vmods = (uint8_t *)xcb_tmp; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); - } - if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) { + /* 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; /* explicit */ _aux->explicit = (xcb_xkb_set_explicit_t *)xcb_tmp; xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t); @@ -4364,13 +4538,14 @@ xcb_xkb_set_map_values_unpack (const void *_buffer /**< */, } if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* modmap */ _aux->modmap = (xcb_xkb_key_mod_map_t *)xcb_tmp; xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t); @@ -4379,13 +4554,14 @@ xcb_xkb_set_map_values_unpack (const void *_buffer /**< */, } if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* vmodmap */ _aux->vmodmap = (xcb_xkb_key_v_mod_map_t *)xcb_tmp; xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t); @@ -4393,6 +4569,55 @@ xcb_xkb_set_map_values_unpack (const void *_buffer /**< */, xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_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; +} + +int +xcb_xkb_set_map_values_sizeof (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present) +{ + xcb_xkb_set_map_values_t _aux; + return xcb_xkb_set_map_values_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux); +} + +int +xcb_xkb_set_map_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xkb_set_map_request_t *_aux = (xcb_xkb_set_map_request_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; + + + xcb_block_len += sizeof(xcb_xkb_set_map_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* values */ + xcb_block_len += xcb_xkb_set_map_values_sizeof(xcb_tmp, _aux->nTypes, _aux->nKeySyms, _aux->nKeyActions, _aux->totalActions, _aux->totalKeyBehaviors, _aux->virtualMods, _aux->totalKeyExplicit, _aux->totalModMapKeys, _aux->totalVModMapKeys, _aux->present); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -4404,58 +4629,41 @@ xcb_xkb_set_map_values_unpack (const void *_buffer /**< */, return xcb_buffer_len; } -int -xcb_xkb_set_map_values_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */) -{ - xcb_xkb_set_map_values_t _aux; - return xcb_xkb_set_map_values_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux); -} - xcb_void_cookie_t -xcb_xkb_set_map_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t present /**< */, - uint16_t flags /**< */, - xcb_keycode_t minKeyCode /**< */, - xcb_keycode_t maxKeyCode /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - uint16_t totalSyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint8_t totalKeyBehaviors /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - uint8_t totalKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - uint8_t totalModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t virtualMods /**< */, - const void *values /**< */) +xcb_xkb_set_map_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t present, + uint16_t flags, + xcb_keycode_t minKeyCode, + xcb_keycode_t maxKeyCode, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + uint16_t totalSyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + uint16_t totalActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint8_t totalKeyBehaviors, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + uint8_t totalKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + uint8_t totalModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys, + uint8_t totalVModMapKeys, + uint16_t virtualMods, + const void *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_MAP, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_MAP, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -4503,40 +4711,40 @@ xcb_xkb_set_map_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t present /**< */, - uint16_t flags /**< */, - xcb_keycode_t minKeyCode /**< */, - xcb_keycode_t maxKeyCode /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - uint16_t totalSyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint8_t totalKeyBehaviors /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - uint8_t totalKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - uint8_t totalModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t virtualMods /**< */, - const void *values /**< */) +xcb_xkb_set_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t present, + uint16_t flags, + xcb_keycode_t minKeyCode, + xcb_keycode_t maxKeyCode, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + uint16_t totalSyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + uint16_t totalActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint8_t totalKeyBehaviors, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + uint8_t totalKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + uint8_t totalModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys, + uint8_t totalVModMapKeys, + uint16_t virtualMods, + const void *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_MAP, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_MAP, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -4584,40 +4792,40 @@ xcb_xkb_set_map (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_map_aux_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t present /**< */, - uint16_t flags /**< */, - xcb_keycode_t minKeyCode /**< */, - xcb_keycode_t maxKeyCode /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - uint16_t totalSyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint8_t totalKeyBehaviors /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - uint8_t totalKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - uint8_t totalModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t virtualMods /**< */, - const xcb_xkb_set_map_values_t *values /**< */) +xcb_xkb_set_map_aux_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t present, + uint16_t flags, + xcb_keycode_t minKeyCode, + xcb_keycode_t maxKeyCode, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + uint16_t totalSyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + uint16_t totalActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint8_t totalKeyBehaviors, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + uint8_t totalKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + uint8_t totalModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys, + uint8_t totalVModMapKeys, + uint16_t virtualMods, + const xcb_xkb_set_map_values_t *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_MAP, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_MAP, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -4667,40 +4875,40 @@ xcb_xkb_set_map_aux_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_map_aux (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t present /**< */, - uint16_t flags /**< */, - xcb_keycode_t minKeyCode /**< */, - xcb_keycode_t maxKeyCode /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - uint16_t totalSyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint8_t totalKeyBehaviors /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - uint8_t totalKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - uint8_t totalModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t virtualMods /**< */, - const xcb_xkb_set_map_values_t *values /**< */) +xcb_xkb_set_map_aux (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t present, + uint16_t flags, + xcb_keycode_t minKeyCode, + xcb_keycode_t maxKeyCode, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + uint16_t totalSyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + uint16_t totalActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint8_t totalKeyBehaviors, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + uint8_t totalKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + uint8_t totalModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys, + uint8_t totalVModMapKeys, + uint16_t virtualMods, + const xcb_xkb_set_map_values_t *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_MAP, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_MAP, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -4749,8 +4957,14 @@ xcb_xkb_set_map_aux (xcb_connection_t *c /**< */, return xcb_ret; } +void * +xcb_xkb_set_map_values (const xcb_xkb_set_map_request_t *R) +{ + return (void *) (R + 1); +} + int -xcb_xkb_get_compat_map_sizeof (const void *_buffer /**< */) +xcb_xkb_get_compat_map_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_get_compat_map_reply_t *_aux = (xcb_xkb_get_compat_map_reply_t *)_buffer; @@ -4793,18 +5007,18 @@ xcb_xkb_get_compat_map_sizeof (const void *_buffer /**< */) } xcb_xkb_get_compat_map_cookie_t -xcb_xkb_get_compat_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t groups /**< */, - uint8_t getAllSI /**< */, - uint16_t firstSI /**< */, - uint16_t nSI /**< */) +xcb_xkb_get_compat_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t groups, + uint8_t getAllSI, + uint16_t firstSI, + uint16_t nSI) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_COMPAT_MAP, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_COMPAT_MAP, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4827,18 +5041,18 @@ xcb_xkb_get_compat_map (xcb_connection_t *c /**< */, } xcb_xkb_get_compat_map_cookie_t -xcb_xkb_get_compat_map_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t groups /**< */, - uint8_t getAllSI /**< */, - uint16_t firstSI /**< */, - uint16_t nSI /**< */) +xcb_xkb_get_compat_map_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t groups, + uint8_t getAllSI, + uint16_t firstSI, + uint16_t nSI) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_COMPAT_MAP, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_COMPAT_MAP, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4861,19 +5075,19 @@ xcb_xkb_get_compat_map_unchecked (xcb_connection_t *c /**< */, } xcb_xkb_sym_interpret_t * -xcb_xkb_get_compat_map_si_rtrn (const xcb_xkb_get_compat_map_reply_t *R /**< */) +xcb_xkb_get_compat_map_si_rtrn (const xcb_xkb_get_compat_map_reply_t *R) { return (xcb_xkb_sym_interpret_t *) (R + 1); } int -xcb_xkb_get_compat_map_si_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R /**< */) +xcb_xkb_get_compat_map_si_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R) { return R->nSIRtrn; } xcb_xkb_sym_interpret_iterator_t -xcb_xkb_get_compat_map_si_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R /**< */) +xcb_xkb_get_compat_map_si_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R) { xcb_xkb_sym_interpret_iterator_t i; i.data = (xcb_xkb_sym_interpret_t *) (R + 1); @@ -4883,20 +5097,20 @@ xcb_xkb_get_compat_map_si_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R } xcb_xkb_mod_def_t * -xcb_xkb_get_compat_map_group_rtrn (const xcb_xkb_get_compat_map_reply_t *R /**< */) +xcb_xkb_get_compat_map_group_rtrn (const xcb_xkb_get_compat_map_reply_t *R) { xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_get_compat_map_si_rtrn_iterator(R)); return (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index) + 0); } int -xcb_xkb_get_compat_map_group_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R /**< */) +xcb_xkb_get_compat_map_group_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R) { return xcb_popcount(R->groupsRtrn); } xcb_xkb_mod_def_iterator_t -xcb_xkb_get_compat_map_group_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R /**< */) +xcb_xkb_get_compat_map_group_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R) { xcb_xkb_mod_def_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_get_compat_map_si_rtrn_iterator(R)); @@ -4907,15 +5121,15 @@ xcb_xkb_get_compat_map_group_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t } xcb_xkb_get_compat_map_reply_t * -xcb_xkb_get_compat_map_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_compat_map_reply (xcb_connection_t *c, xcb_xkb_get_compat_map_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_get_compat_map_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xkb_set_compat_map_sizeof (const void *_buffer /**< */) +xcb_xkb_set_compat_map_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_set_compat_map_request_t *_aux = (xcb_xkb_set_compat_map_request_t *)_buffer; @@ -4958,21 +5172,21 @@ xcb_xkb_set_compat_map_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_xkb_set_compat_map_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t recomputeActions /**< */, - uint8_t truncateSI /**< */, - uint8_t groups /**< */, - uint16_t firstSI /**< */, - uint16_t nSI /**< */, - const xcb_xkb_sym_interpret_t *si /**< */, - const xcb_xkb_mod_def_t *groupMaps /**< */) +xcb_xkb_set_compat_map_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t recomputeActions, + uint8_t truncateSI, + uint8_t groups, + uint16_t firstSI, + uint16_t nSI, + const xcb_xkb_sym_interpret_t *si, + const xcb_xkb_mod_def_t *groupMaps) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_COMPAT_MAP, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_COMPAT_MAP, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -5008,21 +5222,21 @@ xcb_xkb_set_compat_map_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_compat_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t recomputeActions /**< */, - uint8_t truncateSI /**< */, - uint8_t groups /**< */, - uint16_t firstSI /**< */, - uint16_t nSI /**< */, - const xcb_xkb_sym_interpret_t *si /**< */, - const xcb_xkb_mod_def_t *groupMaps /**< */) +xcb_xkb_set_compat_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t recomputeActions, + uint8_t truncateSI, + uint8_t groups, + uint16_t firstSI, + uint16_t nSI, + const xcb_xkb_sym_interpret_t *si, + const xcb_xkb_mod_def_t *groupMaps) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_COMPAT_MAP, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_COMPAT_MAP, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -5057,15 +5271,61 @@ xcb_xkb_set_compat_map (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_xkb_sym_interpret_t * +xcb_xkb_set_compat_map_si (const xcb_xkb_set_compat_map_request_t *R) +{ + return (xcb_xkb_sym_interpret_t *) (R + 1); +} + +int +xcb_xkb_set_compat_map_si_length (const xcb_xkb_set_compat_map_request_t *R) +{ + return R->nSI; +} + +xcb_xkb_sym_interpret_iterator_t +xcb_xkb_set_compat_map_si_iterator (const xcb_xkb_set_compat_map_request_t *R) +{ + xcb_xkb_sym_interpret_iterator_t i; + i.data = (xcb_xkb_sym_interpret_t *) (R + 1); + i.rem = R->nSI; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_xkb_mod_def_t * +xcb_xkb_set_compat_map_group_maps (const xcb_xkb_set_compat_map_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_set_compat_map_si_iterator(R)); + return (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index) + 0); +} + +int +xcb_xkb_set_compat_map_group_maps_length (const xcb_xkb_set_compat_map_request_t *R) +{ + return xcb_popcount(R->groups); +} + +xcb_xkb_mod_def_iterator_t +xcb_xkb_set_compat_map_group_maps_iterator (const xcb_xkb_set_compat_map_request_t *R) +{ + xcb_xkb_mod_def_iterator_t i; + xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_set_compat_map_si_iterator(R)); + i.data = (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index)); + i.rem = xcb_popcount(R->groups); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_xkb_get_indicator_state_cookie_t -xcb_xkb_get_indicator_state (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */) +xcb_xkb_get_indicator_state (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_INDICATOR_STATE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_INDICATOR_STATE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5085,14 +5345,14 @@ xcb_xkb_get_indicator_state (xcb_connection_t *c /**< */, } xcb_xkb_get_indicator_state_cookie_t -xcb_xkb_get_indicator_state_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */) +xcb_xkb_get_indicator_state_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_INDICATOR_STATE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_INDICATOR_STATE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5112,15 +5372,15 @@ xcb_xkb_get_indicator_state_unchecked (xcb_connection_t *c /**< */, } xcb_xkb_get_indicator_state_reply_t * -xcb_xkb_get_indicator_state_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_indicator_state_reply (xcb_connection_t *c, xcb_xkb_get_indicator_state_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_get_indicator_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xkb_get_indicator_map_sizeof (const void *_buffer /**< */) +xcb_xkb_get_indicator_map_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_get_indicator_map_reply_t *_aux = (xcb_xkb_get_indicator_map_reply_t *)_buffer; @@ -5151,15 +5411,15 @@ xcb_xkb_get_indicator_map_sizeof (const void *_buffer /**< */) } xcb_xkb_get_indicator_map_cookie_t -xcb_xkb_get_indicator_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */) +xcb_xkb_get_indicator_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_INDICATOR_MAP, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_INDICATOR_MAP, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5180,15 +5440,15 @@ xcb_xkb_get_indicator_map (xcb_connection_t *c /**< */, } xcb_xkb_get_indicator_map_cookie_t -xcb_xkb_get_indicator_map_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */) +xcb_xkb_get_indicator_map_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_INDICATOR_MAP, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_INDICATOR_MAP, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5209,19 +5469,19 @@ xcb_xkb_get_indicator_map_unchecked (xcb_connection_t *c /**< */, } xcb_xkb_indicator_map_t * -xcb_xkb_get_indicator_map_maps (const xcb_xkb_get_indicator_map_reply_t *R /**< */) +xcb_xkb_get_indicator_map_maps (const xcb_xkb_get_indicator_map_reply_t *R) { return (xcb_xkb_indicator_map_t *) (R + 1); } int -xcb_xkb_get_indicator_map_maps_length (const xcb_xkb_get_indicator_map_reply_t *R /**< */) +xcb_xkb_get_indicator_map_maps_length (const xcb_xkb_get_indicator_map_reply_t *R) { return xcb_popcount(R->which); } xcb_xkb_indicator_map_iterator_t -xcb_xkb_get_indicator_map_maps_iterator (const xcb_xkb_get_indicator_map_reply_t *R /**< */) +xcb_xkb_get_indicator_map_maps_iterator (const xcb_xkb_get_indicator_map_reply_t *R) { xcb_xkb_indicator_map_iterator_t i; i.data = (xcb_xkb_indicator_map_t *) (R + 1); @@ -5231,15 +5491,15 @@ xcb_xkb_get_indicator_map_maps_iterator (const xcb_xkb_get_indicator_map_reply_t } xcb_xkb_get_indicator_map_reply_t * -xcb_xkb_get_indicator_map_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_indicator_map_reply (xcb_connection_t *c, xcb_xkb_get_indicator_map_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_get_indicator_map_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xkb_set_indicator_map_sizeof (const void *_buffer /**< */) +xcb_xkb_set_indicator_map_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_set_indicator_map_request_t *_aux = (xcb_xkb_set_indicator_map_request_t *)_buffer; @@ -5270,16 +5530,16 @@ xcb_xkb_set_indicator_map_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_xkb_set_indicator_map_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */, - const xcb_xkb_indicator_map_t *maps /**< */) +xcb_xkb_set_indicator_map_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which, + const xcb_xkb_indicator_map_t *maps) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_INDICATOR_MAP, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_INDICATOR_MAP, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -5305,16 +5565,16 @@ xcb_xkb_set_indicator_map_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_indicator_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */, - const xcb_xkb_indicator_map_t *maps /**< */) +xcb_xkb_set_indicator_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which, + const xcb_xkb_indicator_map_t *maps) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_INDICATOR_MAP, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_INDICATOR_MAP, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -5339,18 +5599,40 @@ xcb_xkb_set_indicator_map (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_xkb_indicator_map_t * +xcb_xkb_set_indicator_map_maps (const xcb_xkb_set_indicator_map_request_t *R) +{ + return (xcb_xkb_indicator_map_t *) (R + 1); +} + +int +xcb_xkb_set_indicator_map_maps_length (const xcb_xkb_set_indicator_map_request_t *R) +{ + return xcb_popcount(R->which); +} + +xcb_xkb_indicator_map_iterator_t +xcb_xkb_set_indicator_map_maps_iterator (const xcb_xkb_set_indicator_map_request_t *R) +{ + xcb_xkb_indicator_map_iterator_t i; + i.data = (xcb_xkb_indicator_map_t *) (R + 1); + i.rem = xcb_popcount(R->which); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_xkb_get_named_indicator_cookie_t -xcb_xkb_get_named_indicator (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */, - xcb_atom_t indicator /**< */) +xcb_xkb_get_named_indicator (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID, + xcb_atom_t indicator) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_NAMED_INDICATOR, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_NAMED_INDICATOR, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5373,17 +5655,17 @@ xcb_xkb_get_named_indicator (xcb_connection_t *c /**< */, } xcb_xkb_get_named_indicator_cookie_t -xcb_xkb_get_named_indicator_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */, - xcb_atom_t indicator /**< */) +xcb_xkb_get_named_indicator_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID, + xcb_atom_t indicator) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_NAMED_INDICATOR, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_NAMED_INDICATOR, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5406,36 +5688,36 @@ xcb_xkb_get_named_indicator_unchecked (xcb_connection_t *c /**< */, } xcb_xkb_get_named_indicator_reply_t * -xcb_xkb_get_named_indicator_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_named_indicator_reply (xcb_connection_t *c, xcb_xkb_get_named_indicator_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_get_named_indicator_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xkb_set_named_indicator_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */, - xcb_atom_t indicator /**< */, - uint8_t setState /**< */, - uint8_t on /**< */, - uint8_t setMap /**< */, - uint8_t createMap /**< */, - uint8_t map_flags /**< */, - uint8_t map_whichGroups /**< */, - uint8_t map_groups /**< */, - uint8_t map_whichMods /**< */, - uint8_t map_realMods /**< */, - uint16_t map_vmods /**< */, - uint32_t map_ctrls /**< */) +xcb_xkb_set_named_indicator_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID, + xcb_atom_t indicator, + uint8_t setState, + uint8_t on, + uint8_t setMap, + uint8_t createMap, + uint8_t map_flags, + uint8_t map_whichGroups, + uint8_t map_groups, + uint8_t map_whichMods, + uint8_t map_realMods, + uint16_t map_vmods, + uint32_t map_ctrls) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_NAMED_INDICATOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_NAMED_INDICATOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5470,28 +5752,28 @@ xcb_xkb_set_named_indicator_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_named_indicator (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */, - xcb_atom_t indicator /**< */, - uint8_t setState /**< */, - uint8_t on /**< */, - uint8_t setMap /**< */, - uint8_t createMap /**< */, - uint8_t map_flags /**< */, - uint8_t map_whichGroups /**< */, - uint8_t map_groups /**< */, - uint8_t map_whichMods /**< */, - uint8_t map_realMods /**< */, - uint16_t map_vmods /**< */, - uint32_t map_ctrls /**< */) +xcb_xkb_set_named_indicator (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID, + xcb_atom_t indicator, + uint8_t setState, + uint8_t on, + uint8_t setMap, + uint8_t createMap, + uint8_t map_flags, + uint8_t map_whichGroups, + uint8_t map_groups, + uint8_t map_whichMods, + uint8_t map_realMods, + uint16_t map_vmods, + uint32_t map_ctrls) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_NAMED_INDICATOR, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_NAMED_INDICATOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5526,264 +5808,271 @@ xcb_xkb_set_named_indicator (xcb_connection_t *c /**< */, } xcb_atom_t * -xcb_xkb_get_names_value_list_type_names (const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_type_names (const xcb_xkb_get_names_value_list_t *S) { - return /* valueList */ S->typeNames; + return S->typeNames; } int -xcb_xkb_get_names_value_list_type_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_type_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { return R->nTypes; } xcb_generic_iterator_t -xcb_xkb_get_names_value_list_type_names_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_type_names_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { xcb_generic_iterator_t i; - i.data = /* valueList */ S->typeNames + R->nTypes; + i.data = S->typeNames + R->nTypes; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint8_t * -xcb_xkb_get_names_value_list_n_levels_per_type (const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_n_levels_per_type (const xcb_xkb_get_names_value_list_t *S) { - return /* valueList */ S->nLevelsPerType; + return S->nLevelsPerType; } int -xcb_xkb_get_names_value_list_n_levels_per_type_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_n_levels_per_type_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { return R->nTypes; } xcb_generic_iterator_t -xcb_xkb_get_names_value_list_n_levels_per_type_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_n_levels_per_type_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { xcb_generic_iterator_t i; - i.data = /* valueList */ S->nLevelsPerType + R->nTypes; - i.rem = 0; - i.index = (char *) i.data - (char *) S; - return i; -} - -uint8_t * -xcb_xkb_get_names_value_list_alignment_pad (const xcb_xkb_get_names_value_list_t *S /**< */) -{ - return /* valueList */ S->alignment_pad; -} - -int -xcb_xkb_get_names_value_list_alignment_pad_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) -{ - return (((R->nTypes + 3) & (~3)) - R->nTypes); -} - -xcb_generic_iterator_t -xcb_xkb_get_names_value_list_alignment_pad_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) -{ - xcb_generic_iterator_t i; - i.data = /* valueList */ S->alignment_pad + (((R->nTypes + 3) & (~3)) - R->nTypes); + i.data = S->nLevelsPerType + R->nTypes; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_get_names_value_list_kt_level_names (const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_kt_level_names (const xcb_xkb_get_names_value_list_t *S) { - return /* valueList */ S->ktLevelNames; + return S->ktLevelNames; } int -xcb_xkb_get_names_value_list_kt_level_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_kt_level_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { - return xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_1 = R->nTypes; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = S->nLevelsPerType; + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += *xcb_pre_tmp_4; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + return xcb_pre_tmp_3; } xcb_generic_iterator_t -xcb_xkb_get_names_value_list_kt_level_names_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_kt_level_names_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { xcb_generic_iterator_t i; - i.data = /* valueList */ S->ktLevelNames + xcb_sumof(/* valueList */ S->nLevelsPerType, R->nTypes); + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint8_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = R->nTypes; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = S->nLevelsPerType; + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + xcb_pre_tmp_7 += *xcb_pre_tmp_8; + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + i.data = S->ktLevelNames + xcb_pre_tmp_7; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_get_names_value_list_indicator_names (const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_indicator_names (const xcb_xkb_get_names_value_list_t *S) { - return /* valueList */ S->indicatorNames; + return S->indicatorNames; } int -xcb_xkb_get_names_value_list_indicator_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_indicator_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { return xcb_popcount(R->indicators); } xcb_generic_iterator_t -xcb_xkb_get_names_value_list_indicator_names_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_indicator_names_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { xcb_generic_iterator_t i; - i.data = /* valueList */ S->indicatorNames + xcb_popcount(R->indicators); + i.data = S->indicatorNames + xcb_popcount(R->indicators); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_get_names_value_list_virtual_mod_names (const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_virtual_mod_names (const xcb_xkb_get_names_value_list_t *S) { - return /* valueList */ S->virtualModNames; + return S->virtualModNames; } int -xcb_xkb_get_names_value_list_virtual_mod_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_virtual_mod_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { return xcb_popcount(R->virtualMods); } xcb_generic_iterator_t -xcb_xkb_get_names_value_list_virtual_mod_names_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_virtual_mod_names_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { xcb_generic_iterator_t i; - i.data = /* valueList */ S->virtualModNames + xcb_popcount(R->virtualMods); + i.data = S->virtualModNames + xcb_popcount(R->virtualMods); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_get_names_value_list_groups (const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_groups (const xcb_xkb_get_names_value_list_t *S) { - return /* valueList */ S->groups; + return S->groups; } int -xcb_xkb_get_names_value_list_groups_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_groups_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { return xcb_popcount(R->groupNames); } xcb_generic_iterator_t -xcb_xkb_get_names_value_list_groups_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_groups_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { xcb_generic_iterator_t i; - i.data = /* valueList */ S->groups + xcb_popcount(R->groupNames); + i.data = S->groups + xcb_popcount(R->groupNames); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_name_t * -xcb_xkb_get_names_value_list_key_names (const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_key_names (const xcb_xkb_get_names_value_list_t *S) { - return /* valueList */ S->keyNames; + return S->keyNames; } int -xcb_xkb_get_names_value_list_key_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_key_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { return R->nKeys; } xcb_xkb_key_name_iterator_t -xcb_xkb_get_names_value_list_key_names_iterator (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_key_names_iterator (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { xcb_xkb_key_name_iterator_t i; - i.data = /* valueList */ S->keyNames; + i.data = S->keyNames; i.rem = R->nKeys; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_alias_t * -xcb_xkb_get_names_value_list_key_aliases (const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_key_aliases (const xcb_xkb_get_names_value_list_t *S) { - return /* valueList */ S->keyAliases; + return S->keyAliases; } int -xcb_xkb_get_names_value_list_key_aliases_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_key_aliases_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { return R->nKeyAliases; } xcb_xkb_key_alias_iterator_t -xcb_xkb_get_names_value_list_key_aliases_iterator (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_key_aliases_iterator (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { xcb_xkb_key_alias_iterator_t i; - i.data = /* valueList */ S->keyAliases; + i.data = S->keyAliases; i.rem = R->nKeyAliases; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_get_names_value_list_radio_group_names (const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_radio_group_names (const xcb_xkb_get_names_value_list_t *S) { - return /* valueList */ S->radioGroupNames; + return S->radioGroupNames; } int -xcb_xkb_get_names_value_list_radio_group_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_radio_group_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { return R->nRadioGroups; } xcb_generic_iterator_t -xcb_xkb_get_names_value_list_radio_group_names_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */) +xcb_xkb_get_names_value_list_radio_group_names_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S) { xcb_generic_iterator_t i; - i.data = /* valueList */ S->radioGroupNames + R->nRadioGroups; + i.data = S->radioGroupNames + R->nRadioGroups; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } int -xcb_xkb_get_names_value_list_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - const xcb_xkb_get_names_value_list_t *_aux /**< */) +xcb_xkb_get_names_value_list_serialize (void **_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + const xcb_xkb_get_names_value_list_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */ unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[27]; + struct iovec xcb_parts[26]; unsigned int xcb_parts_idx = 0; unsigned int xcb_block_len = 0; unsigned int i; @@ -5839,7 +6128,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ } if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5848,6 +6137,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* typeNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->typeNames; xcb_block_len += nTypes * sizeof(xcb_atom_t); @@ -5857,7 +6147,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ } if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5866,14 +6156,16 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* nLevelsPerType */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->nLevelsPerType; xcb_block_len += nTypes * sizeof(uint8_t); xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(uint8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5882,14 +6174,9 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; - /* alignment_pad */ - xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->alignment_pad; - xcb_block_len += (((nTypes + 3) & (~3)) - nTypes) * sizeof(uint8_t); - xcb_parts[xcb_parts_idx].iov_len = (((nTypes + 3) & (~3)) - nTypes) * sizeof(uint8_t); - xcb_parts_idx++; - xcb_align_to = ALIGNOF(uint8_t); + xcb_padding_offset = 0; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5898,16 +6185,26 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* ktLevelNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; - xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); - xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); + /* sumof start */ + xcb_pre_tmp_1 = nTypes; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = _aux->nLevelsPerType; + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += *xcb_pre_tmp_4; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t); + xcb_parts[xcb_parts_idx].iov_len = xcb_pre_tmp_3 * sizeof(xcb_atom_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_atom_t); } if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5916,6 +6213,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* indicatorNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicatorNames; xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t); @@ -5925,7 +6223,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ } if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5934,6 +6232,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* virtualModNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->virtualModNames; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t); @@ -5943,7 +6242,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ } if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5952,6 +6251,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* groups */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->groups; xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t); @@ -5961,7 +6261,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ } if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5970,6 +6270,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* keyNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyNames; xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t); @@ -5979,7 +6280,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ } if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -5988,6 +6289,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* keyAliases */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyAliases; xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t); @@ -5997,7 +6299,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ } if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6006,6 +6308,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* radioGroupNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->radioGroupNames; xcb_block_len += nRadioGroups * sizeof(xcb_atom_t); @@ -6014,7 +6317,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_align_to = ALIGNOF(xcb_atom_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6023,6 +6326,7 @@ xcb_xkb_get_names_value_list_serialize (void **_ xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -6042,23 +6346,28 @@ xcb_xkb_get_names_value_list_serialize (void **_ } int -xcb_xkb_get_names_value_list_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - xcb_xkb_get_names_value_list_t *_aux /**< */) +xcb_xkb_get_names_value_list_unpack (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + xcb_xkb_get_names_value_list_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */ if(which & XCB_XKB_NAME_DETAIL_KEYCODES) { /* xcb_xkb_get_names_value_list_t.keycodesName */ @@ -6104,13 +6413,14 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / } if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* typeNames */ _aux->typeNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += nTypes * sizeof(xcb_atom_t); @@ -6119,54 +6429,63 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / } if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* nLevelsPerType */ _aux->nLevelsPerType = (uint8_t *)xcb_tmp; xcb_block_len += nTypes * sizeof(uint8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; - /* alignment_pad */ - _aux->alignment_pad = (uint8_t *)xcb_tmp; - xcb_block_len += (((nTypes + 3) & (~3)) - nTypes) * sizeof(uint8_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint8_t); + xcb_padding_offset = 0; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* ktLevelNames */ _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; - xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); + /* sumof start */ + xcb_pre_tmp_1 = nTypes; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = _aux->nLevelsPerType; + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += *xcb_pre_tmp_4; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_atom_t); } if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* indicatorNames */ _aux->indicatorNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t); @@ -6175,13 +6494,14 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / } if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* virtualModNames */ _aux->virtualModNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t); @@ -6190,13 +6510,14 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / } if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* groups */ _aux->groups = (xcb_atom_t *)xcb_tmp; xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t); @@ -6205,13 +6526,14 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / } if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* keyNames */ _aux->keyNames = (xcb_xkb_key_name_t *)xcb_tmp; xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t); @@ -6220,13 +6542,14 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / } if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* keyAliases */ _aux->keyAliases = (xcb_xkb_key_alias_t *)xcb_tmp; xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t); @@ -6235,13 +6558,14 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / } if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* radioGroupNames */ _aux->radioGroupNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += nRadioGroups * sizeof(xcb_atom_t); @@ -6249,6 +6573,53 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / xcb_align_to = ALIGNOF(xcb_atom_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; +} + +int +xcb_xkb_get_names_value_list_sizeof (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which) +{ + xcb_xkb_get_names_value_list_t _aux; + return xcb_xkb_get_names_value_list_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux); +} + +int +xcb_xkb_get_names_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xkb_get_names_reply_t *_aux = (xcb_xkb_get_names_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; + + + xcb_block_len += sizeof(xcb_xkb_get_names_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* valueList */ + xcb_block_len += xcb_xkb_get_names_value_list_sizeof(xcb_tmp, _aux->nTypes, _aux->indicators, _aux->virtualMods, _aux->groupNames, _aux->nKeys, _aux->nKeyAliases, _aux->nRadioGroups, _aux->which); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -6260,31 +6631,16 @@ xcb_xkb_get_names_value_list_unpack (const void *_buffer / return xcb_buffer_len; } -int -xcb_xkb_get_names_value_list_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */) -{ - xcb_xkb_get_names_value_list_t _aux; - return xcb_xkb_get_names_value_list_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux); -} - xcb_xkb_get_names_cookie_t -xcb_xkb_get_names (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */) +xcb_xkb_get_names (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_NAMES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_NAMES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6305,15 +6661,15 @@ xcb_xkb_get_names (xcb_connection_t *c /**< */, } xcb_xkb_get_names_cookie_t -xcb_xkb_get_names_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */) +xcb_xkb_get_names_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_NAMES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_NAMES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -6334,254 +6690,285 @@ xcb_xkb_get_names_unchecked (xcb_connection_t *c /**< */, } void * -xcb_xkb_get_names_value_list (const xcb_xkb_get_names_reply_t *R /**< */) +xcb_xkb_get_names_value_list (const xcb_xkb_get_names_reply_t *R) { return (void *) (R + 1); } xcb_xkb_get_names_reply_t * -xcb_xkb_get_names_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_names_reply (xcb_connection_t *c, xcb_xkb_get_names_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_get_names_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_atom_t * -xcb_xkb_set_names_values_type_names (const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_type_names (const xcb_xkb_set_names_values_t *S) { - return /* values */ S->typeNames; + return S->typeNames; } int -xcb_xkb_set_names_values_type_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_type_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { return R->nTypes; } xcb_generic_iterator_t -xcb_xkb_set_names_values_type_names_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_type_names_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { xcb_generic_iterator_t i; - i.data = /* values */ S->typeNames + R->nTypes; + i.data = S->typeNames + R->nTypes; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint8_t * -xcb_xkb_set_names_values_n_levels_per_type (const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_n_levels_per_type (const xcb_xkb_set_names_values_t *S) { - return /* values */ S->nLevelsPerType; + return S->nLevelsPerType; } int -xcb_xkb_set_names_values_n_levels_per_type_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_n_levels_per_type_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { return R->nTypes; } xcb_generic_iterator_t -xcb_xkb_set_names_values_n_levels_per_type_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_n_levels_per_type_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { xcb_generic_iterator_t i; - i.data = /* values */ S->nLevelsPerType + R->nTypes; + i.data = S->nLevelsPerType + R->nTypes; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_set_names_values_kt_level_names (const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_kt_level_names (const xcb_xkb_set_names_values_t *S) { - return /* values */ S->ktLevelNames; + return S->ktLevelNames; } int -xcb_xkb_set_names_values_kt_level_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_kt_level_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { - return xcb_sumof(/* values */ S->nLevelsPerType, R->nTypes); + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_1 = R->nTypes; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = S->nLevelsPerType; + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += *xcb_pre_tmp_4; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + return xcb_pre_tmp_3; } xcb_generic_iterator_t -xcb_xkb_set_names_values_kt_level_names_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_kt_level_names_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { xcb_generic_iterator_t i; - i.data = /* values */ S->ktLevelNames + xcb_sumof(/* values */ S->nLevelsPerType, R->nTypes); + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint8_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = R->nTypes; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = S->nLevelsPerType; + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + xcb_pre_tmp_7 += *xcb_pre_tmp_8; + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + i.data = S->ktLevelNames + xcb_pre_tmp_7; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_set_names_values_indicator_names (const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_indicator_names (const xcb_xkb_set_names_values_t *S) { - return /* values */ S->indicatorNames; + return S->indicatorNames; } int -xcb_xkb_set_names_values_indicator_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_indicator_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { return xcb_popcount(R->indicators); } xcb_generic_iterator_t -xcb_xkb_set_names_values_indicator_names_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_indicator_names_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { xcb_generic_iterator_t i; - i.data = /* values */ S->indicatorNames + xcb_popcount(R->indicators); + i.data = S->indicatorNames + xcb_popcount(R->indicators); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_set_names_values_virtual_mod_names (const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_virtual_mod_names (const xcb_xkb_set_names_values_t *S) { - return /* values */ S->virtualModNames; + return S->virtualModNames; } int -xcb_xkb_set_names_values_virtual_mod_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_virtual_mod_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { return xcb_popcount(R->virtualMods); } xcb_generic_iterator_t -xcb_xkb_set_names_values_virtual_mod_names_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_virtual_mod_names_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { xcb_generic_iterator_t i; - i.data = /* values */ S->virtualModNames + xcb_popcount(R->virtualMods); + i.data = S->virtualModNames + xcb_popcount(R->virtualMods); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_set_names_values_groups (const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_groups (const xcb_xkb_set_names_values_t *S) { - return /* values */ S->groups; + return S->groups; } int -xcb_xkb_set_names_values_groups_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_groups_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { return xcb_popcount(R->groupNames); } xcb_generic_iterator_t -xcb_xkb_set_names_values_groups_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_groups_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { xcb_generic_iterator_t i; - i.data = /* values */ S->groups + xcb_popcount(R->groupNames); + i.data = S->groups + xcb_popcount(R->groupNames); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_name_t * -xcb_xkb_set_names_values_key_names (const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_key_names (const xcb_xkb_set_names_values_t *S) { - return /* values */ S->keyNames; + return S->keyNames; } int -xcb_xkb_set_names_values_key_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_key_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { return R->nKeys; } xcb_xkb_key_name_iterator_t -xcb_xkb_set_names_values_key_names_iterator (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_key_names_iterator (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { xcb_xkb_key_name_iterator_t i; - i.data = /* values */ S->keyNames; + i.data = S->keyNames; i.rem = R->nKeys; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_alias_t * -xcb_xkb_set_names_values_key_aliases (const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_key_aliases (const xcb_xkb_set_names_values_t *S) { - return /* values */ S->keyAliases; + return S->keyAliases; } int -xcb_xkb_set_names_values_key_aliases_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_key_aliases_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { return R->nKeyAliases; } xcb_xkb_key_alias_iterator_t -xcb_xkb_set_names_values_key_aliases_iterator (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_key_aliases_iterator (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { xcb_xkb_key_alias_iterator_t i; - i.data = /* values */ S->keyAliases; + i.data = S->keyAliases; i.rem = R->nKeyAliases; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_set_names_values_radio_group_names (const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_radio_group_names (const xcb_xkb_set_names_values_t *S) { - return /* values */ S->radioGroupNames; + return S->radioGroupNames; } int -xcb_xkb_set_names_values_radio_group_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_radio_group_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { return R->nRadioGroups; } xcb_generic_iterator_t -xcb_xkb_set_names_values_radio_group_names_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */) +xcb_xkb_set_names_values_radio_group_names_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S) { xcb_generic_iterator_t i; - i.data = /* values */ S->radioGroupNames + R->nRadioGroups; + i.data = S->radioGroupNames + R->nRadioGroups; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } int -xcb_xkb_set_names_values_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - const xcb_xkb_set_names_values_t *_aux /**< */) +xcb_xkb_set_names_values_serialize (void **_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + const xcb_xkb_set_names_values_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */ unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[25]; + struct iovec xcb_parts[26]; unsigned int xcb_parts_idx = 0; unsigned int xcb_block_len = 0; unsigned int i; @@ -6637,7 +7024,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer } if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6646,6 +7033,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* typeNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->typeNames; xcb_block_len += nTypes * sizeof(xcb_atom_t); @@ -6655,7 +7043,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer } if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6664,14 +7052,16 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* nLevelsPerType */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->nLevelsPerType; xcb_block_len += nTypes * sizeof(uint8_t); xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(uint8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6680,16 +7070,37 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* ktLevelNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; - xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); - xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); + /* sumof start */ + xcb_pre_tmp_1 = nTypes; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = _aux->nLevelsPerType; + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += *xcb_pre_tmp_4; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t); + xcb_parts[xcb_parts_idx].iov_len = xcb_pre_tmp_3 * sizeof(xcb_atom_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_atom_t); } if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6698,6 +7109,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* indicatorNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicatorNames; xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t); @@ -6707,7 +7119,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer } if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6716,6 +7128,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* virtualModNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->virtualModNames; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t); @@ -6725,7 +7138,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer } if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6734,6 +7147,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* groups */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->groups; xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t); @@ -6743,7 +7157,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer } if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6752,6 +7166,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* keyNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyNames; xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t); @@ -6761,7 +7176,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer } if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6770,6 +7185,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* keyAliases */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyAliases; xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t); @@ -6779,7 +7195,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer } if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6788,6 +7204,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* radioGroupNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->radioGroupNames; xcb_block_len += nRadioGroups * sizeof(xcb_atom_t); @@ -6796,7 +7213,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_align_to = ALIGNOF(xcb_atom_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -6805,6 +7222,7 @@ xcb_xkb_set_names_values_serialize (void **_buffer xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -6824,23 +7242,28 @@ xcb_xkb_set_names_values_serialize (void **_buffer } int -xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - xcb_xkb_set_names_values_t *_aux /**< */) +xcb_xkb_set_names_values_unpack (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + xcb_xkb_set_names_values_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */ if(which & XCB_XKB_NAME_DETAIL_KEYCODES) { /* xcb_xkb_set_names_values_t.keycodesName */ @@ -6886,13 +7309,14 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, } if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* typeNames */ _aux->typeNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += nTypes * sizeof(xcb_atom_t); @@ -6901,41 +7325,63 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, } if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* nLevelsPerType */ _aux->nLevelsPerType = (uint8_t *)xcb_tmp; xcb_block_len += nTypes * sizeof(uint8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + /* 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; /* ktLevelNames */ _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; - xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); + /* sumof start */ + xcb_pre_tmp_1 = nTypes; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = _aux->nLevelsPerType; + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += *xcb_pre_tmp_4; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_atom_t); } if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* indicatorNames */ _aux->indicatorNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t); @@ -6944,13 +7390,14 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, } if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* virtualModNames */ _aux->virtualModNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t); @@ -6959,13 +7406,14 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, } if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* groups */ _aux->groups = (xcb_atom_t *)xcb_tmp; xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t); @@ -6974,13 +7422,14 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, } if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* keyNames */ _aux->keyNames = (xcb_xkb_key_name_t *)xcb_tmp; xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t); @@ -6989,13 +7438,14 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, } if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* keyAliases */ _aux->keyAliases = (xcb_xkb_key_alias_t *)xcb_tmp; xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t); @@ -7004,13 +7454,14 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, } if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* radioGroupNames */ _aux->radioGroupNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += nRadioGroups * sizeof(xcb_atom_t); @@ -7018,6 +7469,53 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, xcb_align_to = ALIGNOF(xcb_atom_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; +} + +int +xcb_xkb_set_names_values_sizeof (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which) +{ + xcb_xkb_set_names_values_t _aux; + return xcb_xkb_set_names_values_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux); +} + +int +xcb_xkb_set_names_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xkb_set_names_request_t *_aux = (xcb_xkb_set_names_request_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; + + + xcb_block_len += sizeof(xcb_xkb_set_names_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* values */ + xcb_block_len += xcb_xkb_set_names_values_sizeof(xcb_tmp, _aux->nTypes, _aux->indicators, _aux->virtualMods, _aux->groupNames, _aux->nKeys, _aux->nKeyAliases, _aux->nRadioGroups, _aux->which); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -7029,44 +7527,29 @@ xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, return xcb_buffer_len; } -int -xcb_xkb_set_names_values_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */) -{ - xcb_xkb_set_names_values_t _aux; - return xcb_xkb_set_names_values_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux); -} - xcb_void_cookie_t -xcb_xkb_set_names_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t virtualMods /**< */, - uint32_t which /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - uint8_t firstKTLevelt /**< */, - uint8_t nKTLevels /**< */, - uint32_t indicators /**< */, - uint8_t groupNames /**< */, - uint8_t nRadioGroups /**< */, - xcb_keycode_t firstKey /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint16_t totalKTLevelNames /**< */, - const void *values /**< */) +xcb_xkb_set_names_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t virtualMods, + uint32_t which, + uint8_t firstType, + uint8_t nTypes, + uint8_t firstKTLevelt, + uint8_t nKTLevels, + uint32_t indicators, + uint8_t groupNames, + uint8_t nRadioGroups, + xcb_keycode_t firstKey, + uint8_t nKeys, + uint8_t nKeyAliases, + uint16_t totalKTLevelNames, + const void *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_NAMES, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_NAMES, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -7103,28 +7586,28 @@ xcb_xkb_set_names_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_names (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t virtualMods /**< */, - uint32_t which /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - uint8_t firstKTLevelt /**< */, - uint8_t nKTLevels /**< */, - uint32_t indicators /**< */, - uint8_t groupNames /**< */, - uint8_t nRadioGroups /**< */, - xcb_keycode_t firstKey /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint16_t totalKTLevelNames /**< */, - const void *values /**< */) +xcb_xkb_set_names (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t virtualMods, + uint32_t which, + uint8_t firstType, + uint8_t nTypes, + uint8_t firstKTLevelt, + uint8_t nKTLevels, + uint32_t indicators, + uint8_t groupNames, + uint8_t nRadioGroups, + xcb_keycode_t firstKey, + uint8_t nKeys, + uint8_t nKeyAliases, + uint16_t totalKTLevelNames, + const void *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_NAMES, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_NAMES, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -7161,28 +7644,28 @@ xcb_xkb_set_names (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_names_aux_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t virtualMods /**< */, - uint32_t which /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - uint8_t firstKTLevelt /**< */, - uint8_t nKTLevels /**< */, - uint32_t indicators /**< */, - uint8_t groupNames /**< */, - uint8_t nRadioGroups /**< */, - xcb_keycode_t firstKey /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint16_t totalKTLevelNames /**< */, - const xcb_xkb_set_names_values_t *values /**< */) +xcb_xkb_set_names_aux_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t virtualMods, + uint32_t which, + uint8_t firstType, + uint8_t nTypes, + uint8_t firstKTLevelt, + uint8_t nKTLevels, + uint32_t indicators, + uint8_t groupNames, + uint8_t nRadioGroups, + xcb_keycode_t firstKey, + uint8_t nKeys, + uint8_t nKeyAliases, + uint16_t totalKTLevelNames, + const xcb_xkb_set_names_values_t *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_NAMES, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_NAMES, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -7221,28 +7704,28 @@ xcb_xkb_set_names_aux_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_names_aux (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t virtualMods /**< */, - uint32_t which /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - uint8_t firstKTLevelt /**< */, - uint8_t nKTLevels /**< */, - uint32_t indicators /**< */, - uint8_t groupNames /**< */, - uint8_t nRadioGroups /**< */, - xcb_keycode_t firstKey /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint16_t totalKTLevelNames /**< */, - const xcb_xkb_set_names_values_t *values /**< */) +xcb_xkb_set_names_aux (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t virtualMods, + uint32_t which, + uint8_t firstType, + uint8_t nTypes, + uint8_t firstKTLevelt, + uint8_t nKTLevels, + uint32_t indicators, + uint8_t groupNames, + uint8_t nRadioGroups, + xcb_keycode_t firstKey, + uint8_t nKeys, + uint8_t nKeyAliases, + uint16_t totalKTLevelNames, + const xcb_xkb_set_names_values_t *values) { static const xcb_protocol_request_t xcb_req = { - /* count */ 3, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_NAMES, - /* isvoid */ 1 + .count = 3, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_NAMES, + .isvoid = 1 }; struct iovec xcb_parts[5]; @@ -7280,20 +7763,26 @@ xcb_xkb_set_names_aux (xcb_connection_t *c /**< */, return xcb_ret; } +void * +xcb_xkb_set_names_values (const xcb_xkb_set_names_request_t *R) +{ + return (void *) (R + 1); +} + xcb_xkb_per_client_flags_cookie_t -xcb_xkb_per_client_flags (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t change /**< */, - uint32_t value /**< */, - uint32_t ctrlsToChange /**< */, - uint32_t autoCtrls /**< */, - uint32_t autoCtrlsValues /**< */) +xcb_xkb_per_client_flags (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t change, + uint32_t value, + uint32_t ctrlsToChange, + uint32_t autoCtrls, + uint32_t autoCtrlsValues) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_PER_CLIENT_FLAGS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_PER_CLIENT_FLAGS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7318,19 +7807,19 @@ xcb_xkb_per_client_flags (xcb_connection_t *c /**< */, } xcb_xkb_per_client_flags_cookie_t -xcb_xkb_per_client_flags_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t change /**< */, - uint32_t value /**< */, - uint32_t ctrlsToChange /**< */, - uint32_t autoCtrls /**< */, - uint32_t autoCtrlsValues /**< */) +xcb_xkb_per_client_flags_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t change, + uint32_t value, + uint32_t ctrlsToChange, + uint32_t autoCtrls, + uint32_t autoCtrlsValues) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_PER_CLIENT_FLAGS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_PER_CLIENT_FLAGS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7355,15 +7844,15 @@ xcb_xkb_per_client_flags_unchecked (xcb_connection_t *c /**< */, } xcb_xkb_per_client_flags_reply_t * -xcb_xkb_per_client_flags_reply (xcb_connection_t *c /**< */, +xcb_xkb_per_client_flags_reply (xcb_connection_t *c, xcb_xkb_per_client_flags_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_per_client_flags_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xkb_list_components_sizeof (const void *_buffer /**< */) +xcb_xkb_list_components_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_list_components_reply_t *_aux = (xcb_xkb_list_components_reply_t *)_buffer; @@ -7474,15 +7963,15 @@ xcb_xkb_list_components_sizeof (const void *_buffer /**< */) } xcb_xkb_list_components_cookie_t -xcb_xkb_list_components (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t maxNames /**< */) +xcb_xkb_list_components (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t maxNames) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_LIST_COMPONENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_LIST_COMPONENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7502,15 +7991,15 @@ xcb_xkb_list_components (xcb_connection_t *c /**< */, } xcb_xkb_list_components_cookie_t -xcb_xkb_list_components_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t maxNames /**< */) +xcb_xkb_list_components_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t maxNames) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_LIST_COMPONENTS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_LIST_COMPONENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7530,13 +8019,13 @@ xcb_xkb_list_components_unchecked (xcb_connection_t *c /**< */, } int -xcb_xkb_list_components_keymaps_length (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_keymaps_length (const xcb_xkb_list_components_reply_t *R) { return R->nKeymaps; } xcb_xkb_listing_iterator_t -xcb_xkb_list_components_keymaps_iterator (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_keymaps_iterator (const xcb_xkb_list_components_reply_t *R) { xcb_xkb_listing_iterator_t i; i.data = (xcb_xkb_listing_t *) (R + 1); @@ -7546,13 +8035,13 @@ xcb_xkb_list_components_keymaps_iterator (const xcb_xkb_list_components_reply_t } int -xcb_xkb_list_components_keycodes_length (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_keycodes_length (const xcb_xkb_list_components_reply_t *R) { return R->nKeycodes; } xcb_xkb_listing_iterator_t -xcb_xkb_list_components_keycodes_iterator (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_keycodes_iterator (const xcb_xkb_list_components_reply_t *R) { xcb_xkb_listing_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_keymaps_iterator(R)); @@ -7563,13 +8052,13 @@ xcb_xkb_list_components_keycodes_iterator (const xcb_xkb_list_components_reply_t } int -xcb_xkb_list_components_types_length (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_types_length (const xcb_xkb_list_components_reply_t *R) { return R->nTypes; } xcb_xkb_listing_iterator_t -xcb_xkb_list_components_types_iterator (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_types_iterator (const xcb_xkb_list_components_reply_t *R) { xcb_xkb_listing_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_keycodes_iterator(R)); @@ -7580,13 +8069,13 @@ xcb_xkb_list_components_types_iterator (const xcb_xkb_list_components_reply_t *R } int -xcb_xkb_list_components_compat_maps_length (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_compat_maps_length (const xcb_xkb_list_components_reply_t *R) { return R->nCompatMaps; } xcb_xkb_listing_iterator_t -xcb_xkb_list_components_compat_maps_iterator (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_compat_maps_iterator (const xcb_xkb_list_components_reply_t *R) { xcb_xkb_listing_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_types_iterator(R)); @@ -7597,13 +8086,13 @@ xcb_xkb_list_components_compat_maps_iterator (const xcb_xkb_list_components_repl } int -xcb_xkb_list_components_symbols_length (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_symbols_length (const xcb_xkb_list_components_reply_t *R) { return R->nSymbols; } xcb_xkb_listing_iterator_t -xcb_xkb_list_components_symbols_iterator (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_symbols_iterator (const xcb_xkb_list_components_reply_t *R) { xcb_xkb_listing_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_compat_maps_iterator(R)); @@ -7614,13 +8103,13 @@ xcb_xkb_list_components_symbols_iterator (const xcb_xkb_list_components_reply_t } int -xcb_xkb_list_components_geometries_length (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_geometries_length (const xcb_xkb_list_components_reply_t *R) { return R->nGeometries; } xcb_xkb_listing_iterator_t -xcb_xkb_list_components_geometries_iterator (const xcb_xkb_list_components_reply_t *R /**< */) +xcb_xkb_list_components_geometries_iterator (const xcb_xkb_list_components_reply_t *R) { xcb_xkb_listing_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_symbols_iterator(R)); @@ -7631,238 +8120,239 @@ xcb_xkb_list_components_geometries_iterator (const xcb_xkb_list_components_reply } xcb_xkb_list_components_reply_t * -xcb_xkb_list_components_reply (xcb_connection_t *c /**< */, +xcb_xkb_list_components_reply (xcb_connection_t *c, xcb_xkb_list_components_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_list_components_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.nTypes; + return S->types.nTypes; } xcb_xkb_key_type_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_key_type_iterator_t i; - i.data = /* replies */ S->types.map.types_rtrn; - i.rem = /* replies */ S->types.nTypes; + i.data = S->types.map.types_rtrn; + i.rem = S->types.nTypes; i.index = (char *) i.data - (char *) S; return i; } int -xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.nKeySyms; + return S->types.nKeySyms; } xcb_xkb_key_sym_map_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_key_sym_map_iterator_t i; - i.data = /* replies */ S->types.map.syms_rtrn; - i.rem = /* replies */ S->types.nKeySyms; + i.data = S->types.map.syms_rtrn; + i.rem = S->types.nKeySyms; i.index = (char *) i.data - (char *) S; return i; } uint8_t * -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.map.acts_rtrn_count; + return S->types.map.acts_rtrn_count; } int -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.nKeyActions; + return S->types.nKeyActions; } xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_generic_iterator_t i; - i.data = /* replies */ S->types.map.acts_rtrn_count + /* replies */ S->types.nKeyActions; + i.data = S->types.map.acts_rtrn_count + S->types.nKeyActions; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_action_t * -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.map.acts_rtrn_acts; + return S->types.map.acts_rtrn_acts; } int -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.totalActions; + return S->types.totalActions; } xcb_xkb_action_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_action_iterator_t i; - i.data = /* replies */ S->types.map.acts_rtrn_acts; - i.rem = /* replies */ S->types.totalActions; + i.data = S->types.map.acts_rtrn_acts; + i.rem = S->types.totalActions; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_set_behavior_t * -xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.map.behaviors_rtrn; + return S->types.map.behaviors_rtrn; } int -xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.totalKeyBehaviors; + return S->types.totalKeyBehaviors; } xcb_xkb_set_behavior_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_set_behavior_iterator_t i; - i.data = /* replies */ S->types.map.behaviors_rtrn; - i.rem = /* replies */ S->types.totalKeyBehaviors; + i.data = S->types.map.behaviors_rtrn; + i.rem = S->types.totalKeyBehaviors; i.index = (char *) i.data - (char *) S; return i; } uint8_t * -xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.map.vmods_rtrn; + return S->types.map.vmods_rtrn; } int -xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return xcb_popcount(/* replies */ S->types.virtualMods); + return xcb_popcount(S->types.virtualMods); } xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_generic_iterator_t i; - i.data = /* replies */ S->types.map.vmods_rtrn + xcb_popcount(/* replies */ S->types.virtualMods); + i.data = S->types.map.vmods_rtrn + xcb_popcount(S->types.virtualMods); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_set_explicit_t * -xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.map.explicit_rtrn; + return S->types.map.explicit_rtrn; } int -xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.totalKeyExplicit; + return S->types.totalKeyExplicit; } xcb_xkb_set_explicit_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_set_explicit_iterator_t i; - i.data = /* replies */ S->types.map.explicit_rtrn; - i.rem = /* replies */ S->types.totalKeyExplicit; + i.data = S->types.map.explicit_rtrn; + i.rem = S->types.totalKeyExplicit; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_mod_map_t * -xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.map.modmap_rtrn; + return S->types.map.modmap_rtrn; } int -xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.totalModMapKeys; + return S->types.totalModMapKeys; } xcb_xkb_key_mod_map_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_key_mod_map_iterator_t i; - i.data = /* replies */ S->types.map.modmap_rtrn; - i.rem = /* replies */ S->types.totalModMapKeys; + i.data = S->types.map.modmap_rtrn; + i.rem = S->types.totalModMapKeys; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_v_mod_map_t * -xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.map.vmodmap_rtrn; + return S->types.map.vmodmap_rtrn; } int -xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->types.totalVModMapKeys; + return S->types.totalVModMapKeys; } xcb_xkb_key_v_mod_map_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_key_v_mod_map_iterator_t i; - i.data = /* replies */ S->types.map.vmodmap_rtrn; - i.rem = /* replies */ S->types.totalVModMapKeys; + i.data = S->types.map.vmodmap_rtrn; + i.rem = S->types.totalVModMapKeys; i.index = (char *) i.data - (char *) S; return i; } int -xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - const xcb_xkb_get_kbd_by_name_replies_types_map_t *_aux /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void **_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + const xcb_xkb_get_kbd_by_name_replies_types_map_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[19]; + struct iovec xcb_parts[23]; unsigned int xcb_parts_idx = 0; unsigned int xcb_block_len = 0; unsigned int i; @@ -7870,7 +8360,7 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void if(present & XCB_XKB_MAP_PART_KEY_TYPES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -7879,6 +8369,7 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* types_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->types_rtrn; xcb_parts[xcb_parts_idx].iov_len = 0; @@ -7893,7 +8384,7 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void } if(present & XCB_XKB_MAP_PART_KEY_SYMS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -7902,6 +8393,7 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* syms_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->syms_rtrn; xcb_parts[xcb_parts_idx].iov_len = 0; @@ -7916,7 +8408,7 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void } if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -7925,14 +8417,16 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* acts_rtrn_count */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_count; xcb_block_len += nKeyActions * sizeof(xcb_keycode_t); xcb_parts[xcb_parts_idx].iov_len = nKeyActions * sizeof(xcb_keycode_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -7941,6 +8435,18 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* acts_rtrn_acts */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_acts; xcb_block_len += totalActions * sizeof(xcb_xkb_action_t); @@ -7950,7 +8456,7 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void } if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -7959,6 +8465,7 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* behaviors_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->behaviors_rtrn; xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t); @@ -7968,7 +8475,7 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void } if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -7977,16 +8484,16 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* vmods_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmods_rtrn; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t); xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_keycode_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); - } - if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -7995,16 +8502,29 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* explicit_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->explicit_rtrn; xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t); xcb_parts[xcb_parts_idx].iov_len = totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t); - } - if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8013,16 +8533,29 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* modmap_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->modmap_rtrn; xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t); xcb_parts[xcb_parts_idx].iov_len = totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t); - } - if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8031,6 +8564,20 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + } + if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) { + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* vmodmap_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmodmap_rtrn; xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t); @@ -8039,7 +8586,7 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8048,6 +8595,7 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -8067,37 +8615,39 @@ xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void } int -xcb_xkb_get_kbd_by_name_replies_types_map_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - xcb_xkb_get_kbd_by_name_replies_types_map_t *_aux /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_unpack (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + xcb_xkb_get_kbd_by_name_replies_types_map_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; unsigned int i; unsigned int xcb_tmp_len; if(present & XCB_XKB_MAP_PART_KEY_TYPES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* types_rtrn */ _aux->types_rtrn = (xcb_xkb_key_type_t *)xcb_tmp; for(i=0; isyms_rtrn = (xcb_xkb_key_sym_map_t *)xcb_tmp; for(i=0; iacts_rtrn_count = (uint8_t *)xcb_tmp; xcb_block_len += nKeyActions * sizeof(xcb_keycode_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + /* 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; /* acts_rtrn_acts */ _aux->acts_rtrn_acts = (xcb_xkb_action_t *)xcb_tmp; xcb_block_len += totalActions * sizeof(xcb_xkb_action_t); @@ -8155,13 +8718,14 @@ xcb_xkb_get_kbd_by_name_replies_types_map_unpack (const void } if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* behaviors_rtrn */ _aux->behaviors_rtrn = (xcb_xkb_set_behavior_t *)xcb_tmp; xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t); @@ -8170,58 +8734,92 @@ xcb_xkb_get_kbd_by_name_replies_types_map_unpack (const void } if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* vmods_rtrn */ _aux->vmods_rtrn = (uint8_t *)xcb_tmp; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); - } - if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) { + /* 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; /* explicit_rtrn */ _aux->explicit_rtrn = (xcb_xkb_set_explicit_t *)xcb_tmp; xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t); - } - if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) { + /* 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; /* modmap_rtrn */ _aux->modmap_rtrn = (xcb_xkb_key_mod_map_t *)xcb_tmp; xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t); - } - if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) { + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + } + if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) { + /* 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; /* vmodmap_rtrn */ _aux->vmodmap_rtrn = (xcb_xkb_key_v_mod_map_t *)xcb_tmp; xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t); @@ -8229,269 +8827,301 @@ xcb_xkb_get_kbd_by_name_replies_types_map_unpack (const void xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; } int -xcb_xkb_get_kbd_by_name_replies_types_map_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map_sizeof (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present) { xcb_xkb_get_kbd_by_name_replies_types_map_t _aux; return xcb_xkb_get_kbd_by_name_replies_types_map_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux); } xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.valueList.typeNames; + return S->key_names.valueList.typeNames; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.nTypes; + return S->key_names.nTypes; } xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_generic_iterator_t i; - i.data = /* replies */ S->key_names.valueList.typeNames + /* replies */ S->key_names.nTypes; + i.data = S->key_names.valueList.typeNames + S->key_names.nTypes; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } uint8_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.valueList.nLevelsPerType; + return S->key_names.valueList.nLevelsPerType; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.nTypes; + return S->key_names.nTypes; } xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_generic_iterator_t i; - i.data = /* replies */ S->key_names.valueList.nLevelsPerType + /* replies */ S->key_names.nTypes; + i.data = S->key_names.valueList.nLevelsPerType + S->key_names.nTypes; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.valueList.ktLevelNames; + return S->key_names.valueList.ktLevelNames; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nTypes); + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_1 = S->key_names.nTypes; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = S->key_names.valueList.nLevelsPerType; + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += *xcb_pre_tmp_4; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + return xcb_pre_tmp_3; } xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_generic_iterator_t i; - i.data = /* replies */ S->key_names.valueList.ktLevelNames + xcb_sumof(/* replies */ S->key_names.valueList.nLevelsPerType, /* replies */ S->key_names.nTypes); + int xcb_pre_tmp_5; /* sumof length */ + int xcb_pre_tmp_6; /* sumof loop counter */ + int64_t xcb_pre_tmp_7; /* sumof sum */ + const uint8_t* xcb_pre_tmp_8; /* sumof list ptr */ + /* sumof start */ + xcb_pre_tmp_5 = S->key_names.nTypes; + xcb_pre_tmp_7 = 0; + xcb_pre_tmp_8 = S->key_names.valueList.nLevelsPerType; + for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) { + xcb_pre_tmp_7 += *xcb_pre_tmp_8; + xcb_pre_tmp_8++; + } + /* sumof end. Result is in xcb_pre_tmp_7 */ + i.data = S->key_names.valueList.ktLevelNames + xcb_pre_tmp_7; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.valueList.indicatorNames; + return S->key_names.valueList.indicatorNames; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return xcb_popcount(/* replies */ S->key_names.indicators); + return xcb_popcount(S->key_names.indicators); } xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_generic_iterator_t i; - i.data = /* replies */ S->key_names.valueList.indicatorNames + xcb_popcount(/* replies */ S->key_names.indicators); + i.data = S->key_names.valueList.indicatorNames + xcb_popcount(S->key_names.indicators); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.valueList.virtualModNames; + return S->key_names.valueList.virtualModNames; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return xcb_popcount(/* replies */ S->key_names.virtualMods); + return xcb_popcount(S->key_names.virtualMods); } xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_generic_iterator_t i; - i.data = /* replies */ S->key_names.valueList.virtualModNames + xcb_popcount(/* replies */ S->key_names.virtualMods); + i.data = S->key_names.valueList.virtualModNames + xcb_popcount(S->key_names.virtualMods); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.valueList.groups; + return S->key_names.valueList.groups; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return xcb_popcount(/* replies */ S->key_names.groupNames); + return xcb_popcount(S->key_names.groupNames); } xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_generic_iterator_t i; - i.data = /* replies */ S->key_names.valueList.groups + xcb_popcount(/* replies */ S->key_names.groupNames); + i.data = S->key_names.valueList.groups + xcb_popcount(S->key_names.groupNames); i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_name_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.valueList.keyNames; + return S->key_names.valueList.keyNames; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.nKeys; + return S->key_names.nKeys; } xcb_xkb_key_name_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_key_name_iterator_t i; - i.data = /* replies */ S->key_names.valueList.keyNames; - i.rem = /* replies */ S->key_names.nKeys; + i.data = S->key_names.valueList.keyNames; + i.rem = S->key_names.nKeys; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_key_alias_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.valueList.keyAliases; + return S->key_names.valueList.keyAliases; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.nKeyAliases; + return S->key_names.nKeyAliases; } xcb_xkb_key_alias_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_key_alias_iterator_t i; - i.data = /* replies */ S->key_names.valueList.keyAliases; - i.rem = /* replies */ S->key_names.nKeyAliases; + i.data = S->key_names.valueList.keyAliases; + i.rem = S->key_names.nKeyAliases; i.index = (char *) i.data - (char *) S; return i; } xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.valueList.radioGroupNames; + return S->key_names.valueList.radioGroupNames; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->key_names.nRadioGroups; + return S->key_names.nRadioGroups; } xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_generic_iterator_t i; - i.data = /* replies */ S->key_names.valueList.radioGroupNames + /* replies */ S->key_names.nRadioGroups; + i.data = S->key_names.valueList.radioGroupNames + S->key_names.nRadioGroups; i.rem = 0; i.index = (char *) i.data - (char *) S; return i; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - const xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *_aux /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void **_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + const xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */ unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[25]; + struct iovec xcb_parts[26]; unsigned int xcb_parts_idx = 0; unsigned int xcb_block_len = 0; unsigned int i; @@ -8547,7 +9177,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void } if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8556,6 +9186,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* typeNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->typeNames; xcb_block_len += nTypes * sizeof(xcb_atom_t); @@ -8565,7 +9196,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void } if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8574,14 +9205,16 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* nLevelsPerType */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->nLevelsPerType; xcb_block_len += nTypes * sizeof(uint8_t); xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(uint8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8590,16 +9223,37 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; + /* 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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; /* ktLevelNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames; - xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); - xcb_parts[xcb_parts_idx].iov_len = xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); + /* sumof start */ + xcb_pre_tmp_1 = nTypes; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = _aux->nLevelsPerType; + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += *xcb_pre_tmp_4; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t); + xcb_parts[xcb_parts_idx].iov_len = xcb_pre_tmp_3 * sizeof(xcb_atom_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_atom_t); } if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8608,6 +9262,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* indicatorNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicatorNames; xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t); @@ -8617,7 +9272,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void } if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8626,6 +9281,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* virtualModNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->virtualModNames; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t); @@ -8635,7 +9291,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void } if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8644,6 +9300,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* groups */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->groups; xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t); @@ -8653,7 +9310,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void } if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8662,6 +9319,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* keyNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyNames; xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t); @@ -8671,7 +9329,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void } if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8680,6 +9338,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* keyAliases */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyAliases; xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t); @@ -8689,7 +9348,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void } if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8698,6 +9357,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* radioGroupNames */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->radioGroupNames; xcb_block_len += nRadioGroups * sizeof(xcb_atom_t); @@ -8706,7 +9366,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_align_to = ALIGNOF(xcb_atom_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -8715,6 +9375,7 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -8734,23 +9395,28 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *_aux /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; + int xcb_pre_tmp_1; /* sumof length */ + int xcb_pre_tmp_2; /* sumof loop counter */ + int64_t xcb_pre_tmp_3; /* sumof sum */ + const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */ if(which & XCB_XKB_NAME_DETAIL_KEYCODES) { /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.keycodesName */ @@ -8796,13 +9462,14 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void } if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* typeNames */ _aux->typeNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += nTypes * sizeof(xcb_atom_t); @@ -8811,41 +9478,63 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void } if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* nLevelsPerType */ _aux->nLevelsPerType = (uint8_t *)xcb_tmp; xcb_block_len += nTypes * sizeof(uint8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; + /* 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; /* ktLevelNames */ _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp; - xcb_block_len += xcb_sumof(_aux->nLevelsPerType, nTypes) * sizeof(xcb_atom_t); + /* sumof start */ + xcb_pre_tmp_1 = nTypes; + xcb_pre_tmp_3 = 0; + xcb_pre_tmp_4 = _aux->nLevelsPerType; + for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) { + xcb_pre_tmp_3 += *xcb_pre_tmp_4; + xcb_pre_tmp_4++; + } + /* sumof end. Result is in xcb_pre_tmp_3 */ + xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_atom_t); } if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* indicatorNames */ _aux->indicatorNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t); @@ -8854,13 +9543,14 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void } if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* virtualModNames */ _aux->virtualModNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t); @@ -8869,13 +9559,14 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void } if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* groups */ _aux->groups = (xcb_atom_t *)xcb_tmp; xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t); @@ -8884,13 +9575,14 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void } if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* keyNames */ _aux->keyNames = (xcb_xkb_key_name_t *)xcb_tmp; xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t); @@ -8899,13 +9591,14 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void } if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* keyAliases */ _aux->keyAliases = (xcb_xkb_key_alias_t *)xcb_tmp; xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t); @@ -8914,13 +9607,14 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void } if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) { /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* radioGroupNames */ _aux->radioGroupNames = (xcb_atom_t *)xcb_tmp; xcb_block_len += nRadioGroups * sizeof(xcb_atom_t); @@ -8928,130 +9622,132 @@ xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void xcb_align_to = ALIGNOF(xcb_atom_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; } int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_sizeof (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which) { xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t _aux; return xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux); } xcb_xkb_get_kbd_by_name_replies_types_map_t * -xcb_xkb_get_kbd_by_name_replies_types_map (const xcb_xkb_get_kbd_by_name_replies_t *R /**< */) +xcb_xkb_get_kbd_by_name_replies_types_map (const xcb_xkb_get_kbd_by_name_replies_t *R) { return (xcb_xkb_get_kbd_by_name_replies_types_map_t *) (R + 1); } xcb_xkb_sym_interpret_t * -xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->compat_map.si_rtrn; + return S->compat_map.si_rtrn; } int -xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->compat_map.nSIRtrn; + return S->compat_map.nSIRtrn; } xcb_xkb_sym_interpret_iterator_t -xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_sym_interpret_iterator_t i; - i.data = /* replies */ S->compat_map.si_rtrn; - i.rem = /* replies */ S->compat_map.nSIRtrn; + i.data = S->compat_map.si_rtrn; + i.rem = S->compat_map.nSIRtrn; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_mod_def_t * -xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->compat_map.group_rtrn; + return S->compat_map.group_rtrn; } int -xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return xcb_popcount(/* replies */ S->compat_map.groupsRtrn); + return xcb_popcount(S->compat_map.groupsRtrn); } xcb_xkb_mod_def_iterator_t -xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_mod_def_iterator_t i; - i.data = /* replies */ S->compat_map.group_rtrn; - i.rem = xcb_popcount(/* replies */ S->compat_map.groupsRtrn); + i.data = S->compat_map.group_rtrn; + i.rem = xcb_popcount(S->compat_map.groupsRtrn); i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_indicator_map_t * -xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps (const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->indicator_maps.maps; + return S->indicator_maps.maps; } int -xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { - return /* replies */ S->indicator_maps.nIndicators; + return S->indicator_maps.nIndicators; } xcb_xkb_indicator_map_iterator_t -xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */) +xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S) { xcb_xkb_indicator_map_iterator_t i; - i.data = /* replies */ S->indicator_maps.maps; - i.rem = /* replies */ S->indicator_maps.nIndicators; + i.data = S->indicator_maps.maps; + i.rem = S->indicator_maps.nIndicators; i.index = (char *) i.data - (char *) S; return i; } xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list (const xcb_xkb_get_kbd_by_name_replies_t *R /**< */) +xcb_xkb_get_kbd_by_name_replies_key_names_value_list (const xcb_xkb_get_kbd_by_name_replies_t *R) { return (xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *) (R + 1); } xcb_xkb_counted_string_16_t * -xcb_xkb_get_kbd_by_name_replies_geometry_label_font (const xcb_xkb_get_kbd_by_name_replies_t *R /**< */) +xcb_xkb_get_kbd_by_name_replies_geometry_label_font (const xcb_xkb_get_kbd_by_name_replies_t *R) { return (xcb_xkb_counted_string_16_t *) (R + 1); } int -xcb_xkb_get_kbd_by_name_replies_serialize (void **_buffer /**< */, - uint16_t reported /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *_aux /**< */) +xcb_xkb_get_kbd_by_name_replies_serialize (void **_buffer, + uint16_t reported, + const xcb_xkb_get_kbd_by_name_replies_t *_aux) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; @@ -9251,7 +9947,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_parts_idx++; xcb_align_to = ALIGNOF(uint16_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -9260,12 +9956,13 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* map */ xcb_parts[xcb_parts_idx].iov_base = (char *)0; xcb_block_len += xcb_xkb_get_kbd_by_name_replies_types_map_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->types.nTypes, _aux->types.nKeySyms, _aux->types.nKeyActions, _aux->types.totalActions, _aux->types.totalKeyBehaviors, _aux->types.virtualMods, _aux->types.totalKeyExplicit, _aux->types.totalModMapKeys, _aux->types.totalVModMapKeys, _aux->types.present, &_aux->types.map); xcb_parts[xcb_parts_idx].iov_len = xcb_xkb_get_kbd_by_name_replies_types_map_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->types.nTypes, _aux->types.nKeySyms, _aux->types.nKeyActions, _aux->types.totalActions, _aux->types.totalKeyBehaviors, _aux->types.virtualMods, _aux->types.totalKeyExplicit, _aux->types.totalModMapKeys, _aux->types.totalVModMapKeys, _aux->types.present, &_aux->types.map); xcb_parts_idx++; - xcb_align_to = ALIGNOF(xcb_xkb_get_kbd_by_name_replies_types_map_t); + xcb_align_to = ALIGNOF(char); } if(reported & XCB_XKB_GBN_DETAIL_COMPAT_MAP) { /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_type */ @@ -9298,7 +9995,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); - /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad3 */ + /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad7 */ xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; xcb_block_len += sizeof(uint8_t); xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); @@ -9322,14 +10019,14 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint16_t); - /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad4 */ + /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad8 */ xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; xcb_block_len += sizeof(uint8_t)*16; xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*16; xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -9338,6 +10035,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* si_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->compat_map.si_rtrn; xcb_block_len += _aux->compat_map.nSIRtrn * sizeof(xcb_xkb_sym_interpret_t); @@ -9345,7 +10043,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_xkb_sym_interpret_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -9354,6 +10052,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* group_rtrn */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->compat_map.group_rtrn; xcb_block_len += xcb_popcount(_aux->compat_map.groupsRtrn) * sizeof(xcb_xkb_mod_def_t); @@ -9404,14 +10103,14 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); - /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.pad5 */ + /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.pad9 */ xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; xcb_block_len += sizeof(uint8_t)*15; xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*15; xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -9420,6 +10119,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* maps */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicator_maps.maps; xcb_block_len += _aux->indicator_maps.nIndicators * sizeof(xcb_xkb_indicator_map_t); @@ -9525,14 +10225,14 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint16_t); - /* xcb_xkb_get_kbd_by_name_replies_t.key_names.pad6 */ + /* xcb_xkb_get_kbd_by_name_replies_t.key_names.pad10 */ xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; xcb_block_len += sizeof(uint8_t)*4; xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*4; xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -9541,12 +10241,13 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* valueList */ xcb_parts[xcb_parts_idx].iov_base = (char *)0; xcb_block_len += xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->key_names.nTypes, _aux->key_names.indicators, _aux->key_names.virtualMods, _aux->key_names.groupNames, _aux->key_names.nKeys, _aux->key_names.nKeyAliases, _aux->key_names.nRadioGroups, _aux->key_names.which, &_aux->key_names.valueList); xcb_parts[xcb_parts_idx].iov_len = xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->key_names.nTypes, _aux->key_names.indicators, _aux->key_names.virtualMods, _aux->key_names.groupNames, _aux->key_names.nKeys, _aux->key_names.nKeyAliases, _aux->key_names.nRadioGroups, _aux->key_names.which, &_aux->key_names.valueList); xcb_parts_idx++; - xcb_align_to = ALIGNOF(xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t); + xcb_align_to = ALIGNOF(char); } if(reported & XCB_XKB_GBN_DETAIL_GEOMETRY) { /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_type */ @@ -9585,7 +10286,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); - /* xcb_xkb_get_kbd_by_name_replies_t.geometry.pad7 */ + /* xcb_xkb_get_kbd_by_name_replies_t.geometry.pad12 */ xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; xcb_block_len += sizeof(uint8_t); xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); @@ -9652,7 +10353,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_parts_idx++; xcb_align_to = ALIGNOF(uint8_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -9661,6 +10362,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; /* labelFont */ xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->geometry.labelFont; xcb_block_len += xcb_xkb_counted_string_16_sizeof(_aux->geometry.labelFont); @@ -9669,7 +10371,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_align_to = ALIGNOF(xcb_xkb_counted_string_16_t); } /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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_parts[xcb_parts_idx].iov_base = xcb_pad0; @@ -9678,6 +10380,7 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void xcb_pad = 0; } xcb_block_len = 0; + xcb_padding_offset = 0; if (NULL == xcb_out) { /* allocate memory */ @@ -9697,15 +10400,16 @@ xcb_xkb_get_kbd_by_name_replies_serialize (void } int -xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buffer /**< */, - uint16_t reported /**< */, - xcb_xkb_get_kbd_by_name_replies_t *_aux /**< */) +xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buffer, + uint16_t reported, + xcb_xkb_get_kbd_by_name_replies_t *_aux) { char *xcb_tmp = (char *)_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 xcb_padding_offset = 0; if((reported & XCB_XKB_GBN_DETAIL_TYPES) || @@ -9868,17 +10572,18 @@ xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buf xcb_tmp += sizeof(uint16_t); xcb_align_to = ALIGNOF(uint16_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* map */ xcb_block_len += xcb_xkb_get_kbd_by_name_replies_types_map_unpack(xcb_tmp, _aux->types.nTypes, _aux->types.nKeySyms, _aux->types.nKeyActions, _aux->types.totalActions, _aux->types.totalKeyBehaviors, _aux->types.virtualMods, _aux->types.totalKeyExplicit, _aux->types.totalModMapKeys, _aux->types.totalVModMapKeys, _aux->types.present, &_aux->types.map); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(xcb_xkb_get_kbd_by_name_replies_types_map_t); + xcb_align_to = ALIGNOF(char); } if(reported & XCB_XKB_GBN_DETAIL_COMPAT_MAP) { /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_type */ @@ -9906,8 +10611,8 @@ xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buf xcb_block_len += sizeof(uint8_t); xcb_tmp += sizeof(uint8_t); xcb_align_to = ALIGNOF(uint8_t); - /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad3 */ - _aux->compat_map.pad3 = *(uint8_t *)xcb_tmp; + /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad7 */ + _aux->compat_map.pad7 = *(uint8_t *)xcb_tmp; xcb_block_len += sizeof(uint8_t); xcb_tmp += sizeof(uint8_t); xcb_align_to = ALIGNOF(uint8_t); @@ -9926,47 +10631,49 @@ xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buf xcb_block_len += sizeof(uint16_t); xcb_tmp += sizeof(uint16_t); xcb_align_to = ALIGNOF(uint16_t); - /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad4 */ - _aux->compat_map.pad4[0] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[1] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[2] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[3] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[4] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[5] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[6] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[7] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[8] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[9] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[10] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[11] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[12] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[13] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[14] = *(uint8_t *)xcb_tmp; - _aux->compat_map.pad4[15] = *(uint8_t *)xcb_tmp; + /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad8 */ + _aux->compat_map.pad8[0] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[1] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[2] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[3] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[4] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[5] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[6] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[7] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[8] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[9] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[10] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[11] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[12] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[13] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[14] = *(uint8_t *)xcb_tmp; + _aux->compat_map.pad8[15] = *(uint8_t *)xcb_tmp; xcb_block_len += sizeof(uint8_t) * 16; xcb_tmp += sizeof(uint8_t) * 16; xcb_align_to = ALIGNOF(uint8_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* si_rtrn */ _aux->compat_map.si_rtrn = (xcb_xkb_sym_interpret_t *)xcb_tmp; xcb_block_len += _aux->compat_map.nSIRtrn * sizeof(xcb_xkb_sym_interpret_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_xkb_sym_interpret_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* group_rtrn */ _aux->compat_map.group_rtrn = (xcb_xkb_mod_def_t *)xcb_tmp; xcb_block_len += xcb_popcount(_aux->compat_map.groupsRtrn) * sizeof(xcb_xkb_mod_def_t); @@ -10009,33 +10716,34 @@ xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buf xcb_block_len += sizeof(uint8_t); xcb_tmp += sizeof(uint8_t); xcb_align_to = ALIGNOF(uint8_t); - /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.pad5 */ - _aux->indicator_maps.pad5[0] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[1] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[2] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[3] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[4] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[5] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[6] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[7] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[8] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[9] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[10] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[11] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[12] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[13] = *(uint8_t *)xcb_tmp; - _aux->indicator_maps.pad5[14] = *(uint8_t *)xcb_tmp; + /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.pad9 */ + _aux->indicator_maps.pad9[0] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[1] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[2] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[3] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[4] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[5] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[6] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[7] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[8] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[9] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[10] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[11] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[12] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[13] = *(uint8_t *)xcb_tmp; + _aux->indicator_maps.pad9[14] = *(uint8_t *)xcb_tmp; xcb_block_len += sizeof(uint8_t) * 15; xcb_tmp += sizeof(uint8_t) * 15; xcb_align_to = ALIGNOF(uint8_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* maps */ _aux->indicator_maps.maps = (xcb_xkb_indicator_map_t *)xcb_tmp; xcb_block_len += _aux->indicator_maps.nIndicators * sizeof(xcb_xkb_indicator_map_t); @@ -10124,26 +10832,27 @@ xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buf xcb_block_len += sizeof(uint16_t); xcb_tmp += sizeof(uint16_t); xcb_align_to = ALIGNOF(uint16_t); - /* xcb_xkb_get_kbd_by_name_replies_t.key_names.pad6 */ - _aux->key_names.pad6[0] = *(uint8_t *)xcb_tmp; - _aux->key_names.pad6[1] = *(uint8_t *)xcb_tmp; - _aux->key_names.pad6[2] = *(uint8_t *)xcb_tmp; - _aux->key_names.pad6[3] = *(uint8_t *)xcb_tmp; + /* xcb_xkb_get_kbd_by_name_replies_t.key_names.pad10 */ + _aux->key_names.pad10[0] = *(uint8_t *)xcb_tmp; + _aux->key_names.pad10[1] = *(uint8_t *)xcb_tmp; + _aux->key_names.pad10[2] = *(uint8_t *)xcb_tmp; + _aux->key_names.pad10[3] = *(uint8_t *)xcb_tmp; xcb_block_len += sizeof(uint8_t) * 4; xcb_tmp += sizeof(uint8_t) * 4; xcb_align_to = ALIGNOF(uint8_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* valueList */ xcb_block_len += xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack(xcb_tmp, _aux->key_names.nTypes, _aux->key_names.indicators, _aux->key_names.virtualMods, _aux->key_names.groupNames, _aux->key_names.nKeys, _aux->key_names.nKeyAliases, _aux->key_names.nRadioGroups, _aux->key_names.which, &_aux->key_names.valueList); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t); + xcb_align_to = ALIGNOF(char); } if(reported & XCB_XKB_GBN_DETAIL_GEOMETRY) { /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_type */ @@ -10176,8 +10885,8 @@ xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buf xcb_block_len += sizeof(uint8_t); xcb_tmp += sizeof(uint8_t); xcb_align_to = ALIGNOF(uint8_t); - /* xcb_xkb_get_kbd_by_name_replies_t.geometry.pad7 */ - _aux->geometry.pad7 = *(uint8_t *)xcb_tmp; + /* xcb_xkb_get_kbd_by_name_replies_t.geometry.pad12 */ + _aux->geometry.pad12 = *(uint8_t *)xcb_tmp; xcb_block_len += sizeof(uint8_t); xcb_tmp += sizeof(uint8_t); xcb_align_to = ALIGNOF(uint8_t); @@ -10232,13 +10941,14 @@ xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buf xcb_tmp += sizeof(uint8_t); xcb_align_to = ALIGNOF(uint8_t); /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); + 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; /* labelFont */ _aux->geometry.labelFont = (xcb_xkb_counted_string_16_t *)xcb_tmp; xcb_block_len += xcb_xkb_counted_string_16_sizeof(xcb_tmp); @@ -10246,6 +10956,46 @@ xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buf xcb_align_to = ALIGNOF(xcb_xkb_counted_string_16_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; +} + +int +xcb_xkb_get_kbd_by_name_replies_sizeof (const void *_buffer, + uint16_t reported) +{ + xcb_xkb_get_kbd_by_name_replies_t _aux; + return xcb_xkb_get_kbd_by_name_replies_unpack(_buffer, reported, &_aux); +} + +int +xcb_xkb_get_kbd_by_name_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xkb_get_kbd_by_name_reply_t *_aux = (xcb_xkb_get_kbd_by_name_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; + + + xcb_block_len += sizeof(xcb_xkb_get_kbd_by_name_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* replies */ + xcb_block_len += xcb_xkb_get_kbd_by_name_replies_sizeof(xcb_tmp, _aux->reported); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; if (0 != xcb_pad) { @@ -10257,26 +11007,18 @@ xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buf return xcb_buffer_len; } -int -xcb_xkb_get_kbd_by_name_replies_sizeof (const void *_buffer /**< */, - uint16_t reported /**< */) -{ - xcb_xkb_get_kbd_by_name_replies_t _aux; - return xcb_xkb_get_kbd_by_name_replies_unpack(_buffer, reported, &_aux); -} - xcb_xkb_get_kbd_by_name_cookie_t -xcb_xkb_get_kbd_by_name (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t need /**< */, - uint16_t want /**< */, - uint8_t load /**< */) +xcb_xkb_get_kbd_by_name (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t need, + uint16_t want, + uint8_t load) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_KBD_BY_NAME, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_KBD_BY_NAME, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10299,17 +11041,17 @@ xcb_xkb_get_kbd_by_name (xcb_connection_t *c /**< */, } xcb_xkb_get_kbd_by_name_cookie_t -xcb_xkb_get_kbd_by_name_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t need /**< */, - uint16_t want /**< */, - uint8_t load /**< */) +xcb_xkb_get_kbd_by_name_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t need, + uint16_t want, + uint8_t load) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_KBD_BY_NAME, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_KBD_BY_NAME, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10332,21 +11074,21 @@ xcb_xkb_get_kbd_by_name_unchecked (xcb_connection_t *c /**< */, } void * -xcb_xkb_get_kbd_by_name_replies (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */) +xcb_xkb_get_kbd_by_name_replies (const xcb_xkb_get_kbd_by_name_reply_t *R) { return (void *) (R + 1); } xcb_xkb_get_kbd_by_name_reply_t * -xcb_xkb_get_kbd_by_name_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_kbd_by_name_reply (xcb_connection_t *c, xcb_xkb_get_kbd_by_name_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_get_kbd_by_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xkb_get_device_info_sizeof (const void *_buffer /**< */) +xcb_xkb_get_device_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_get_device_info_reply_t *_aux = (xcb_xkb_get_device_info_reply_t *)_buffer; @@ -10366,6 +11108,15 @@ xcb_xkb_get_device_info_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->nameLen * sizeof(xcb_xkb_string8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_xkb_string8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -10406,20 +11157,20 @@ xcb_xkb_get_device_info_sizeof (const void *_buffer /**< */) } xcb_xkb_get_device_info_cookie_t -xcb_xkb_get_device_info (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t wanted /**< */, - uint8_t allButtons /**< */, - uint8_t firstButton /**< */, - uint8_t nButtons /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */) +xcb_xkb_get_device_info (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t wanted, + uint8_t allButtons, + uint8_t firstButton, + uint8_t nButtons, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_DEVICE_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_DEVICE_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10445,20 +11196,20 @@ xcb_xkb_get_device_info (xcb_connection_t *c /**< */, } xcb_xkb_get_device_info_cookie_t -xcb_xkb_get_device_info_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t wanted /**< */, - uint8_t allButtons /**< */, - uint8_t firstButton /**< */, - uint8_t nButtons /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */) +xcb_xkb_get_device_info_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t wanted, + uint8_t allButtons, + uint8_t firstButton, + uint8_t nButtons, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_GET_DEVICE_INFO, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_GET_DEVICE_INFO, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10484,19 +11235,19 @@ xcb_xkb_get_device_info_unchecked (xcb_connection_t *c /**< */, } xcb_xkb_string8_t * -xcb_xkb_get_device_info_name (const xcb_xkb_get_device_info_reply_t *R /**< */) +xcb_xkb_get_device_info_name (const xcb_xkb_get_device_info_reply_t *R) { return (xcb_xkb_string8_t *) (R + 1); } int -xcb_xkb_get_device_info_name_length (const xcb_xkb_get_device_info_reply_t *R /**< */) +xcb_xkb_get_device_info_name_length (const xcb_xkb_get_device_info_reply_t *R) { return R->nameLen; } xcb_generic_iterator_t -xcb_xkb_get_device_info_name_end (const xcb_xkb_get_device_info_reply_t *R /**< */) +xcb_xkb_get_device_info_name_end (const xcb_xkb_get_device_info_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_xkb_string8_t *) (R + 1)) + (R->nameLen); @@ -10506,37 +11257,37 @@ xcb_xkb_get_device_info_name_end (const xcb_xkb_get_device_info_reply_t *R /**< } xcb_xkb_action_t * -xcb_xkb_get_device_info_btn_actions (const xcb_xkb_get_device_info_reply_t *R /**< */) +xcb_xkb_get_device_info_btn_actions (const xcb_xkb_get_device_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_xkb_get_device_info_name_end(R); - return (xcb_xkb_action_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_action_t, prev.index) + 0); + return (xcb_xkb_action_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); } int -xcb_xkb_get_device_info_btn_actions_length (const xcb_xkb_get_device_info_reply_t *R /**< */) +xcb_xkb_get_device_info_btn_actions_length (const xcb_xkb_get_device_info_reply_t *R) { return R->nBtnsRtrn; } xcb_xkb_action_iterator_t -xcb_xkb_get_device_info_btn_actions_iterator (const xcb_xkb_get_device_info_reply_t *R /**< */) +xcb_xkb_get_device_info_btn_actions_iterator (const xcb_xkb_get_device_info_reply_t *R) { xcb_xkb_action_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_get_device_info_name_end(R); - i.data = (xcb_xkb_action_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_action_t, prev.index)); + i.data = (xcb_xkb_action_t *) ((char *) prev.data + ((-prev.index) & (4 - 1))); i.rem = R->nBtnsRtrn; i.index = (char *) i.data - (char *) R; return i; } int -xcb_xkb_get_device_info_leds_length (const xcb_xkb_get_device_info_reply_t *R /**< */) +xcb_xkb_get_device_info_leds_length (const xcb_xkb_get_device_info_reply_t *R) { return R->nDeviceLedFBs; } xcb_xkb_device_led_info_iterator_t -xcb_xkb_get_device_info_leds_iterator (const xcb_xkb_get_device_info_reply_t *R /**< */) +xcb_xkb_get_device_info_leds_iterator (const xcb_xkb_get_device_info_reply_t *R) { xcb_xkb_device_led_info_iterator_t i; xcb_generic_iterator_t prev = xcb_xkb_action_end(xcb_xkb_get_device_info_btn_actions_iterator(R)); @@ -10547,15 +11298,15 @@ xcb_xkb_get_device_info_leds_iterator (const xcb_xkb_get_device_info_reply_t *R } xcb_xkb_get_device_info_reply_t * -xcb_xkb_get_device_info_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_device_info_reply (xcb_connection_t *c, xcb_xkb_get_device_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_get_device_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xkb_set_device_info_sizeof (const void *_buffer /**< */) +xcb_xkb_set_device_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_set_device_info_request_t *_aux = (xcb_xkb_set_device_info_request_t *)_buffer; @@ -10603,20 +11354,20 @@ xcb_xkb_set_device_info_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_xkb_set_device_info_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t firstBtn /**< */, - uint8_t nBtns /**< */, - uint16_t change /**< */, - uint16_t nDeviceLedFBs /**< */, - const xcb_xkb_action_t *btnActions /**< */, - const xcb_xkb_device_led_info_t *leds /**< */) +xcb_xkb_set_device_info_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t firstBtn, + uint8_t nBtns, + uint16_t change, + uint16_t nDeviceLedFBs, + const xcb_xkb_action_t *btnActions, + const xcb_xkb_device_led_info_t *leds) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_DEVICE_INFO, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_DEVICE_INFO, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -10658,20 +11409,20 @@ xcb_xkb_set_device_info_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xkb_set_device_info (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t firstBtn /**< */, - uint8_t nBtns /**< */, - uint16_t change /**< */, - uint16_t nDeviceLedFBs /**< */, - const xcb_xkb_action_t *btnActions /**< */, - const xcb_xkb_device_led_info_t *leds /**< */) +xcb_xkb_set_device_info (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t firstBtn, + uint8_t nBtns, + uint16_t change, + uint16_t nDeviceLedFBs, + const xcb_xkb_action_t *btnActions, + const xcb_xkb_device_led_info_t *leds) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_DEVICE_INFO, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_DEVICE_INFO, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -10712,8 +11463,47 @@ xcb_xkb_set_device_info (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_xkb_action_t * +xcb_xkb_set_device_info_btn_actions (const xcb_xkb_set_device_info_request_t *R) +{ + return (xcb_xkb_action_t *) (R + 1); +} + int -xcb_xkb_set_debugging_flags_sizeof (const void *_buffer /**< */) +xcb_xkb_set_device_info_btn_actions_length (const xcb_xkb_set_device_info_request_t *R) +{ + return R->nBtns; +} + +xcb_xkb_action_iterator_t +xcb_xkb_set_device_info_btn_actions_iterator (const xcb_xkb_set_device_info_request_t *R) +{ + xcb_xkb_action_iterator_t i; + i.data = (xcb_xkb_action_t *) (R + 1); + i.rem = R->nBtns; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_xkb_set_device_info_leds_length (const xcb_xkb_set_device_info_request_t *R) +{ + return R->nDeviceLedFBs; +} + +xcb_xkb_device_led_info_iterator_t +xcb_xkb_set_device_info_leds_iterator (const xcb_xkb_set_device_info_request_t *R) +{ + xcb_xkb_device_led_info_iterator_t i; + xcb_generic_iterator_t prev = xcb_xkb_action_end(xcb_xkb_set_device_info_btn_actions_iterator(R)); + i.data = (xcb_xkb_device_led_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_device_led_info_t, prev.index)); + i.rem = R->nDeviceLedFBs; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_xkb_set_debugging_flags_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xkb_set_debugging_flags_request_t *_aux = (xcb_xkb_set_debugging_flags_request_t *)_buffer; @@ -10744,19 +11534,19 @@ xcb_xkb_set_debugging_flags_sizeof (const void *_buffer /**< */) } xcb_xkb_set_debugging_flags_cookie_t -xcb_xkb_set_debugging_flags (xcb_connection_t *c /**< */, - uint16_t msgLength /**< */, - uint32_t affectFlags /**< */, - uint32_t flags /**< */, - uint32_t affectCtrls /**< */, - uint32_t ctrls /**< */, - const xcb_xkb_string8_t *message /**< */) +xcb_xkb_set_debugging_flags (xcb_connection_t *c, + uint16_t msgLength, + uint32_t affectFlags, + uint32_t flags, + uint32_t affectCtrls, + uint32_t ctrls, + const xcb_xkb_string8_t *message) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_DEBUGGING_FLAGS, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_DEBUGGING_FLAGS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -10785,19 +11575,19 @@ xcb_xkb_set_debugging_flags (xcb_connection_t *c /**< */, } xcb_xkb_set_debugging_flags_cookie_t -xcb_xkb_set_debugging_flags_unchecked (xcb_connection_t *c /**< */, - uint16_t msgLength /**< */, - uint32_t affectFlags /**< */, - uint32_t flags /**< */, - uint32_t affectCtrls /**< */, - uint32_t ctrls /**< */, - const xcb_xkb_string8_t *message /**< */) +xcb_xkb_set_debugging_flags_unchecked (xcb_connection_t *c, + uint16_t msgLength, + uint32_t affectFlags, + uint32_t flags, + uint32_t affectCtrls, + uint32_t ctrls, + const xcb_xkb_string8_t *message) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xkb_id, - /* opcode */ XCB_XKB_SET_DEBUGGING_FLAGS, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_xkb_id, + .opcode = XCB_XKB_SET_DEBUGGING_FLAGS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -10826,9 +11616,9 @@ xcb_xkb_set_debugging_flags_unchecked (xcb_connection_t *c /**< */, } xcb_xkb_set_debugging_flags_reply_t * -xcb_xkb_set_debugging_flags_reply (xcb_connection_t *c /**< */, +xcb_xkb_set_debugging_flags_reply (xcb_connection_t *c, xcb_xkb_set_debugging_flags_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xkb_set_debugging_flags_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/xkb.h b/lib/libxcb/src/xkb.h index d061455e6..056585b21 100644 --- a/lib/libxcb/src/xkb.h +++ b/lib/libxcb/src/xkb.h @@ -139,9 +139,9 @@ typedef uint16_t xcb_xkb_device_spec_t; * @brief xcb_xkb_device_spec_iterator_t **/ typedef struct xcb_xkb_device_spec_iterator_t { - xcb_xkb_device_spec_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_device_spec_t *data; + int rem; + int index; } xcb_xkb_device_spec_iterator_t; typedef enum xcb_xkb_led_class_result_t { @@ -162,9 +162,9 @@ typedef uint16_t xcb_xkb_led_class_spec_t; * @brief xcb_xkb_led_class_spec_iterator_t **/ typedef struct xcb_xkb_led_class_spec_iterator_t { - xcb_xkb_led_class_spec_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_led_class_spec_t *data; + int rem; + int index; } xcb_xkb_led_class_spec_iterator_t; typedef enum xcb_xkb_bell_class_result_t { @@ -184,9 +184,9 @@ typedef uint16_t xcb_xkb_bell_class_spec_t; * @brief xcb_xkb_bell_class_spec_iterator_t **/ typedef struct xcb_xkb_bell_class_spec_iterator_t { - xcb_xkb_bell_class_spec_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_bell_class_spec_t *data; + int rem; + int index; } xcb_xkb_bell_class_spec_iterator_t; typedef enum xcb_xkb_id_t { @@ -205,9 +205,9 @@ typedef uint16_t xcb_xkb_id_spec_t; * @brief xcb_xkb_id_spec_iterator_t **/ typedef struct xcb_xkb_id_spec_iterator_t { - xcb_xkb_id_spec_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_id_spec_t *data; + int rem; + int index; } xcb_xkb_id_spec_iterator_t; typedef enum xcb_xkb_group_t { @@ -330,23 +330,23 @@ typedef enum xcb_xkb_im_groups_which_t { * @brief xcb_xkb_indicator_map_t **/ typedef struct xcb_xkb_indicator_map_t { - uint8_t flags; /**< */ - uint8_t whichGroups; /**< */ - uint8_t groups; /**< */ - uint8_t whichMods; /**< */ - uint8_t mods; /**< */ - uint8_t realMods; /**< */ - uint16_t vmods; /**< */ - uint32_t ctrls; /**< */ + uint8_t flags; + uint8_t whichGroups; + uint8_t groups; + uint8_t whichMods; + uint8_t mods; + uint8_t realMods; + uint16_t vmods; + uint32_t ctrls; } xcb_xkb_indicator_map_t; /** * @brief xcb_xkb_indicator_map_iterator_t **/ typedef struct xcb_xkb_indicator_map_iterator_t { - xcb_xkb_indicator_map_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_indicator_map_t *data; + int rem; + int index; } xcb_xkb_indicator_map_iterator_t; typedef enum xcb_xkb_cm_detail_t { @@ -402,291 +402,291 @@ typedef enum xcb_xkb_per_client_flag_t { * @brief xcb_xkb_mod_def_t **/ typedef struct xcb_xkb_mod_def_t { - uint8_t mask; /**< */ - uint8_t realMods; /**< */ - uint16_t vmods; /**< */ + uint8_t mask; + uint8_t realMods; + uint16_t vmods; } xcb_xkb_mod_def_t; /** * @brief xcb_xkb_mod_def_iterator_t **/ typedef struct xcb_xkb_mod_def_iterator_t { - xcb_xkb_mod_def_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_mod_def_t *data; + int rem; + int index; } xcb_xkb_mod_def_iterator_t; /** * @brief xcb_xkb_key_name_t **/ typedef struct xcb_xkb_key_name_t { - char name[4]; /**< */ + char name[4]; } xcb_xkb_key_name_t; /** * @brief xcb_xkb_key_name_iterator_t **/ typedef struct xcb_xkb_key_name_iterator_t { - xcb_xkb_key_name_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_key_name_t *data; + int rem; + int index; } xcb_xkb_key_name_iterator_t; /** * @brief xcb_xkb_key_alias_t **/ typedef struct xcb_xkb_key_alias_t { - char real[4]; /**< */ - char alias[4]; /**< */ + char real[4]; + char alias[4]; } xcb_xkb_key_alias_t; /** * @brief xcb_xkb_key_alias_iterator_t **/ typedef struct xcb_xkb_key_alias_iterator_t { - xcb_xkb_key_alias_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_key_alias_t *data; + int rem; + int index; } xcb_xkb_key_alias_iterator_t; /** * @brief xcb_xkb_counted_string_16_t **/ typedef struct xcb_xkb_counted_string_16_t { - uint16_t length; /**< */ + uint16_t length; } xcb_xkb_counted_string_16_t; /** * @brief xcb_xkb_counted_string_16_iterator_t **/ typedef struct xcb_xkb_counted_string_16_iterator_t { - xcb_xkb_counted_string_16_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_counted_string_16_t *data; + int rem; + int index; } xcb_xkb_counted_string_16_iterator_t; /** * @brief xcb_xkb_kt_map_entry_t **/ typedef struct xcb_xkb_kt_map_entry_t { - uint8_t active; /**< */ - uint8_t mods_mask; /**< */ - uint8_t level; /**< */ - uint8_t mods_mods; /**< */ - uint16_t mods_vmods; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t active; + uint8_t mods_mask; + uint8_t level; + uint8_t mods_mods; + uint16_t mods_vmods; + uint8_t pad0[2]; } xcb_xkb_kt_map_entry_t; /** * @brief xcb_xkb_kt_map_entry_iterator_t **/ typedef struct xcb_xkb_kt_map_entry_iterator_t { - xcb_xkb_kt_map_entry_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_kt_map_entry_t *data; + int rem; + int index; } xcb_xkb_kt_map_entry_iterator_t; /** * @brief xcb_xkb_key_type_t **/ typedef struct xcb_xkb_key_type_t { - uint8_t mods_mask; /**< */ - uint8_t mods_mods; /**< */ - uint16_t mods_vmods; /**< */ - uint8_t numLevels; /**< */ - uint8_t nMapEntries; /**< */ - uint8_t hasPreserve; /**< */ - uint8_t pad0; /**< */ + uint8_t mods_mask; + uint8_t mods_mods; + uint16_t mods_vmods; + uint8_t numLevels; + uint8_t nMapEntries; + uint8_t hasPreserve; + uint8_t pad0; } xcb_xkb_key_type_t; /** * @brief xcb_xkb_key_type_iterator_t **/ typedef struct xcb_xkb_key_type_iterator_t { - xcb_xkb_key_type_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_key_type_t *data; + int rem; + int index; } xcb_xkb_key_type_iterator_t; /** * @brief xcb_xkb_key_sym_map_t **/ typedef struct xcb_xkb_key_sym_map_t { - uint8_t kt_index[4]; /**< */ - uint8_t groupInfo; /**< */ - uint8_t width; /**< */ - uint16_t nSyms; /**< */ + uint8_t kt_index[4]; + uint8_t groupInfo; + uint8_t width; + uint16_t nSyms; } xcb_xkb_key_sym_map_t; /** * @brief xcb_xkb_key_sym_map_iterator_t **/ typedef struct xcb_xkb_key_sym_map_iterator_t { - xcb_xkb_key_sym_map_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_key_sym_map_t *data; + int rem; + int index; } xcb_xkb_key_sym_map_iterator_t; /** * @brief xcb_xkb_common_behavior_t **/ typedef struct xcb_xkb_common_behavior_t { - uint8_t type; /**< */ - uint8_t data; /**< */ + uint8_t type; + uint8_t data; } xcb_xkb_common_behavior_t; /** * @brief xcb_xkb_common_behavior_iterator_t **/ typedef struct xcb_xkb_common_behavior_iterator_t { - xcb_xkb_common_behavior_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_common_behavior_t *data; + int rem; + int index; } xcb_xkb_common_behavior_iterator_t; /** * @brief xcb_xkb_default_behavior_t **/ typedef struct xcb_xkb_default_behavior_t { - uint8_t type; /**< */ - uint8_t pad0; /**< */ + uint8_t type; + uint8_t pad0; } xcb_xkb_default_behavior_t; /** * @brief xcb_xkb_default_behavior_iterator_t **/ typedef struct xcb_xkb_default_behavior_iterator_t { - xcb_xkb_default_behavior_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_default_behavior_t *data; + int rem; + int index; } xcb_xkb_default_behavior_iterator_t; /** * @brief xcb_xkb_lock_behavior_t **/ typedef struct xcb_xkb_lock_behavior_t { - uint8_t type; /**< */ - uint8_t pad0; /**< */ + uint8_t type; + uint8_t pad0; } xcb_xkb_lock_behavior_t; /** * @brief xcb_xkb_lock_behavior_iterator_t **/ typedef struct xcb_xkb_lock_behavior_iterator_t { - xcb_xkb_lock_behavior_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_lock_behavior_t *data; + int rem; + int index; } xcb_xkb_lock_behavior_iterator_t; /** * @brief xcb_xkb_radio_group_behavior_t **/ typedef struct xcb_xkb_radio_group_behavior_t { - uint8_t type; /**< */ - uint8_t group; /**< */ + uint8_t type; + uint8_t group; } xcb_xkb_radio_group_behavior_t; /** * @brief xcb_xkb_radio_group_behavior_iterator_t **/ typedef struct xcb_xkb_radio_group_behavior_iterator_t { - xcb_xkb_radio_group_behavior_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_radio_group_behavior_t *data; + int rem; + int index; } xcb_xkb_radio_group_behavior_iterator_t; /** * @brief xcb_xkb_overlay_behavior_t **/ typedef struct xcb_xkb_overlay_behavior_t { - uint8_t type; /**< */ - xcb_keycode_t key; /**< */ + uint8_t type; + xcb_keycode_t key; } xcb_xkb_overlay_behavior_t; /** * @brief xcb_xkb_overlay_behavior_iterator_t **/ typedef struct xcb_xkb_overlay_behavior_iterator_t { - xcb_xkb_overlay_behavior_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_overlay_behavior_t *data; + int rem; + int index; } xcb_xkb_overlay_behavior_iterator_t; /** * @brief xcb_xkb_permament_lock_behavior_t **/ typedef struct xcb_xkb_permament_lock_behavior_t { - uint8_t type; /**< */ - uint8_t pad0; /**< */ + uint8_t type; + uint8_t pad0; } xcb_xkb_permament_lock_behavior_t; /** * @brief xcb_xkb_permament_lock_behavior_iterator_t **/ typedef struct xcb_xkb_permament_lock_behavior_iterator_t { - xcb_xkb_permament_lock_behavior_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_permament_lock_behavior_t *data; + int rem; + int index; } xcb_xkb_permament_lock_behavior_iterator_t; /** * @brief xcb_xkb_permament_radio_group_behavior_t **/ typedef struct xcb_xkb_permament_radio_group_behavior_t { - uint8_t type; /**< */ - uint8_t group; /**< */ + uint8_t type; + uint8_t group; } xcb_xkb_permament_radio_group_behavior_t; /** * @brief xcb_xkb_permament_radio_group_behavior_iterator_t **/ typedef struct xcb_xkb_permament_radio_group_behavior_iterator_t { - xcb_xkb_permament_radio_group_behavior_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_permament_radio_group_behavior_t *data; + int rem; + int index; } xcb_xkb_permament_radio_group_behavior_iterator_t; /** * @brief xcb_xkb_permament_overlay_behavior_t **/ typedef struct xcb_xkb_permament_overlay_behavior_t { - uint8_t type; /**< */ - xcb_keycode_t key; /**< */ + uint8_t type; + xcb_keycode_t key; } xcb_xkb_permament_overlay_behavior_t; /** * @brief xcb_xkb_permament_overlay_behavior_iterator_t **/ typedef struct xcb_xkb_permament_overlay_behavior_iterator_t { - xcb_xkb_permament_overlay_behavior_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_permament_overlay_behavior_t *data; + int rem; + int index; } xcb_xkb_permament_overlay_behavior_iterator_t; /** * @brief xcb_xkb_behavior_t **/ typedef union xcb_xkb_behavior_t { - xcb_xkb_common_behavior_t common; /**< */ - xcb_xkb_default_behavior_t _default; /**< */ - xcb_xkb_lock_behavior_t lock; /**< */ - xcb_xkb_radio_group_behavior_t radioGroup; /**< */ - xcb_xkb_overlay_behavior_t overlay1; /**< */ - xcb_xkb_overlay_behavior_t overlay2; /**< */ - xcb_xkb_permament_lock_behavior_t permamentLock; /**< */ - xcb_xkb_permament_radio_group_behavior_t permamentRadioGroup; /**< */ - xcb_xkb_permament_overlay_behavior_t permamentOverlay1; /**< */ - xcb_xkb_permament_overlay_behavior_t permamentOverlay2; /**< */ - uint8_t type; /**< */ + xcb_xkb_common_behavior_t common; + xcb_xkb_default_behavior_t _default; + xcb_xkb_lock_behavior_t lock; + xcb_xkb_radio_group_behavior_t radioGroup; + xcb_xkb_overlay_behavior_t overlay1; + xcb_xkb_overlay_behavior_t overlay2; + xcb_xkb_permament_lock_behavior_t permamentLock; + xcb_xkb_permament_radio_group_behavior_t permamentRadioGroup; + xcb_xkb_permament_overlay_behavior_t permamentOverlay1; + xcb_xkb_permament_overlay_behavior_t permamentOverlay2; + uint8_t type; } xcb_xkb_behavior_t; /** * @brief xcb_xkb_behavior_iterator_t **/ typedef struct xcb_xkb_behavior_iterator_t { - xcb_xkb_behavior_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_behavior_t *data; + int rem; + int index; } xcb_xkb_behavior_iterator_t; typedef enum xcb_xkb_behavior_type_t { @@ -705,110 +705,110 @@ typedef enum xcb_xkb_behavior_type_t { * @brief xcb_xkb_set_behavior_t **/ typedef struct xcb_xkb_set_behavior_t { - xcb_keycode_t keycode; /**< */ - xcb_xkb_behavior_t behavior; /**< */ - uint8_t pad0; /**< */ + xcb_keycode_t keycode; + xcb_xkb_behavior_t behavior; + uint8_t pad0; } xcb_xkb_set_behavior_t; /** * @brief xcb_xkb_set_behavior_iterator_t **/ typedef struct xcb_xkb_set_behavior_iterator_t { - xcb_xkb_set_behavior_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_set_behavior_t *data; + int rem; + int index; } xcb_xkb_set_behavior_iterator_t; /** * @brief xcb_xkb_set_explicit_t **/ typedef struct xcb_xkb_set_explicit_t { - xcb_keycode_t keycode; /**< */ - uint8_t explicit; /**< */ + xcb_keycode_t keycode; + uint8_t explicit; } xcb_xkb_set_explicit_t; /** * @brief xcb_xkb_set_explicit_iterator_t **/ typedef struct xcb_xkb_set_explicit_iterator_t { - xcb_xkb_set_explicit_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_set_explicit_t *data; + int rem; + int index; } xcb_xkb_set_explicit_iterator_t; /** * @brief xcb_xkb_key_mod_map_t **/ typedef struct xcb_xkb_key_mod_map_t { - xcb_keycode_t keycode; /**< */ - uint8_t mods; /**< */ + xcb_keycode_t keycode; + uint8_t mods; } xcb_xkb_key_mod_map_t; /** * @brief xcb_xkb_key_mod_map_iterator_t **/ typedef struct xcb_xkb_key_mod_map_iterator_t { - xcb_xkb_key_mod_map_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_key_mod_map_t *data; + int rem; + int index; } xcb_xkb_key_mod_map_iterator_t; /** * @brief xcb_xkb_key_v_mod_map_t **/ typedef struct xcb_xkb_key_v_mod_map_t { - xcb_keycode_t keycode; /**< */ - uint8_t pad0; /**< */ - uint16_t vmods; /**< */ + xcb_keycode_t keycode; + uint8_t pad0; + uint16_t vmods; } xcb_xkb_key_v_mod_map_t; /** * @brief xcb_xkb_key_v_mod_map_iterator_t **/ typedef struct xcb_xkb_key_v_mod_map_iterator_t { - xcb_xkb_key_v_mod_map_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_key_v_mod_map_t *data; + int rem; + int index; } xcb_xkb_key_v_mod_map_iterator_t; /** * @brief xcb_xkb_kt_set_map_entry_t **/ typedef struct xcb_xkb_kt_set_map_entry_t { - uint8_t level; /**< */ - uint8_t realMods; /**< */ - uint16_t virtualMods; /**< */ + uint8_t level; + uint8_t realMods; + uint16_t virtualMods; } xcb_xkb_kt_set_map_entry_t; /** * @brief xcb_xkb_kt_set_map_entry_iterator_t **/ typedef struct xcb_xkb_kt_set_map_entry_iterator_t { - xcb_xkb_kt_set_map_entry_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_kt_set_map_entry_t *data; + int rem; + int index; } xcb_xkb_kt_set_map_entry_iterator_t; /** * @brief xcb_xkb_set_key_type_t **/ typedef struct xcb_xkb_set_key_type_t { - uint8_t mask; /**< */ - uint8_t realMods; /**< */ - uint16_t virtualMods; /**< */ - uint8_t numLevels; /**< */ - uint8_t nMapEntries; /**< */ - uint8_t preserve; /**< */ - uint8_t pad0; /**< */ + uint8_t mask; + uint8_t realMods; + uint16_t virtualMods; + uint8_t numLevels; + uint8_t nMapEntries; + uint8_t preserve; + uint8_t pad0; } xcb_xkb_set_key_type_t; /** * @brief xcb_xkb_set_key_type_iterator_t **/ typedef struct xcb_xkb_set_key_type_iterator_t { - xcb_xkb_set_key_type_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_set_key_type_t *data; + int rem; + int index; } xcb_xkb_set_key_type_iterator_t; typedef char xcb_xkb_string8_t; @@ -817,139 +817,139 @@ typedef char xcb_xkb_string8_t; * @brief xcb_xkb_string8_iterator_t **/ typedef struct xcb_xkb_string8_iterator_t { - xcb_xkb_string8_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_string8_t *data; + int rem; + int index; } xcb_xkb_string8_iterator_t; /** * @brief xcb_xkb_outline_t **/ typedef struct xcb_xkb_outline_t { - uint8_t nPoints; /**< */ - uint8_t cornerRadius; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t nPoints; + uint8_t cornerRadius; + uint8_t pad0[2]; } xcb_xkb_outline_t; /** * @brief xcb_xkb_outline_iterator_t **/ typedef struct xcb_xkb_outline_iterator_t { - xcb_xkb_outline_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_outline_t *data; + int rem; + int index; } xcb_xkb_outline_iterator_t; /** * @brief xcb_xkb_shape_t **/ typedef struct xcb_xkb_shape_t { - xcb_atom_t name; /**< */ - uint8_t nOutlines; /**< */ - uint8_t primaryNdx; /**< */ - uint8_t approxNdx; /**< */ - uint8_t pad0; /**< */ + xcb_atom_t name; + uint8_t nOutlines; + uint8_t primaryNdx; + uint8_t approxNdx; + uint8_t pad0; } xcb_xkb_shape_t; /** * @brief xcb_xkb_shape_iterator_t **/ typedef struct xcb_xkb_shape_iterator_t { - xcb_xkb_shape_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_shape_t *data; + int rem; + int index; } xcb_xkb_shape_iterator_t; /** * @brief xcb_xkb_key_t **/ typedef struct xcb_xkb_key_t { - xcb_xkb_string8_t name[4]; /**< */ - int16_t gap; /**< */ - uint8_t shapeNdx; /**< */ - uint8_t colorNdx; /**< */ + xcb_xkb_string8_t name[4]; + int16_t gap; + uint8_t shapeNdx; + uint8_t colorNdx; } xcb_xkb_key_t; /** * @brief xcb_xkb_key_iterator_t **/ typedef struct xcb_xkb_key_iterator_t { - xcb_xkb_key_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_key_t *data; + int rem; + int index; } xcb_xkb_key_iterator_t; /** * @brief xcb_xkb_overlay_key_t **/ typedef struct xcb_xkb_overlay_key_t { - xcb_xkb_string8_t over[4]; /**< */ - xcb_xkb_string8_t under[4]; /**< */ + xcb_xkb_string8_t over[4]; + xcb_xkb_string8_t under[4]; } xcb_xkb_overlay_key_t; /** * @brief xcb_xkb_overlay_key_iterator_t **/ typedef struct xcb_xkb_overlay_key_iterator_t { - xcb_xkb_overlay_key_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_overlay_key_t *data; + int rem; + int index; } xcb_xkb_overlay_key_iterator_t; /** * @brief xcb_xkb_overlay_row_t **/ typedef struct xcb_xkb_overlay_row_t { - uint8_t rowUnder; /**< */ - uint8_t nKeys; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t rowUnder; + uint8_t nKeys; + uint8_t pad0[2]; } xcb_xkb_overlay_row_t; /** * @brief xcb_xkb_overlay_row_iterator_t **/ typedef struct xcb_xkb_overlay_row_iterator_t { - xcb_xkb_overlay_row_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_overlay_row_t *data; + int rem; + int index; } xcb_xkb_overlay_row_iterator_t; /** * @brief xcb_xkb_overlay_t **/ typedef struct xcb_xkb_overlay_t { - xcb_atom_t name; /**< */ - uint8_t nRows; /**< */ - uint8_t pad0[3]; /**< */ + xcb_atom_t name; + uint8_t nRows; + uint8_t pad0[3]; } xcb_xkb_overlay_t; /** * @brief xcb_xkb_overlay_iterator_t **/ typedef struct xcb_xkb_overlay_iterator_t { - xcb_xkb_overlay_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_overlay_t *data; + int rem; + int index; } xcb_xkb_overlay_iterator_t; /** * @brief xcb_xkb_row_t **/ typedef struct xcb_xkb_row_t { - int16_t top; /**< */ - int16_t left; /**< */ - uint8_t nKeys; /**< */ - uint8_t vertical; /**< */ - uint8_t pad0[2]; /**< */ + int16_t top; + int16_t left; + uint8_t nKeys; + uint8_t vertical; + uint8_t pad0[2]; } xcb_xkb_row_t; /** * @brief xcb_xkb_row_iterator_t **/ typedef struct xcb_xkb_row_iterator_t { - xcb_xkb_row_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_row_t *data; + int rem; + int index; } xcb_xkb_row_iterator_t; typedef enum xcb_xkb_doodad_type_t { @@ -964,38 +964,38 @@ typedef enum xcb_xkb_doodad_type_t { * @brief xcb_xkb_listing_t **/ typedef struct xcb_xkb_listing_t { - uint16_t flags; /**< */ - uint16_t length; /**< */ + uint16_t flags; + uint16_t length; } xcb_xkb_listing_t; /** * @brief xcb_xkb_listing_iterator_t **/ typedef struct xcb_xkb_listing_iterator_t { - xcb_xkb_listing_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_listing_t *data; + int rem; + int index; } xcb_xkb_listing_iterator_t; /** * @brief xcb_xkb_device_led_info_t **/ typedef struct xcb_xkb_device_led_info_t { - xcb_xkb_led_class_spec_t ledClass; /**< */ - xcb_xkb_id_spec_t ledID; /**< */ - uint32_t namesPresent; /**< */ - uint32_t mapsPresent; /**< */ - uint32_t physIndicators; /**< */ - uint32_t state; /**< */ + xcb_xkb_led_class_spec_t ledClass; + xcb_xkb_id_spec_t ledID; + uint32_t namesPresent; + uint32_t mapsPresent; + uint32_t physIndicators; + uint32_t state; } xcb_xkb_device_led_info_t; /** * @brief xcb_xkb_device_led_info_iterator_t **/ typedef struct xcb_xkb_device_led_info_iterator_t { - xcb_xkb_device_led_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_device_led_info_t *data; + int rem; + int index; } xcb_xkb_device_led_info_iterator_t; typedef enum xcb_xkb_error_t { @@ -1011,13 +1011,13 @@ typedef enum xcb_xkb_error_t { * @brief xcb_xkb_keyboard_error_t **/ typedef struct xcb_xkb_keyboard_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ - uint32_t value; /**< */ - uint16_t minorOpcode; /**< */ - uint8_t majorOpcode; /**< */ - uint8_t pad0[21]; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; + uint32_t value; + uint16_t minorOpcode; + uint8_t majorOpcode; + uint8_t pad0[21]; } xcb_xkb_keyboard_error_t; typedef enum xcb_xkb_sa_t { @@ -1055,140 +1055,140 @@ typedef enum xcb_xkb_sa_type_t { * @brief xcb_xkb_sa_no_action_t **/ typedef struct xcb_xkb_sa_no_action_t { - uint8_t type; /**< */ - uint8_t pad0[7]; /**< */ + uint8_t type; + uint8_t pad0[7]; } xcb_xkb_sa_no_action_t; /** * @brief xcb_xkb_sa_no_action_iterator_t **/ typedef struct xcb_xkb_sa_no_action_iterator_t { - xcb_xkb_sa_no_action_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_no_action_t *data; + int rem; + int index; } xcb_xkb_sa_no_action_iterator_t; /** * @brief xcb_xkb_sa_set_mods_t **/ typedef struct xcb_xkb_sa_set_mods_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - uint8_t mask; /**< */ - uint8_t realMods; /**< */ - uint8_t vmodsHigh; /**< */ - uint8_t vmodsLow; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t type; + uint8_t flags; + uint8_t mask; + uint8_t realMods; + uint8_t vmodsHigh; + uint8_t vmodsLow; + uint8_t pad0[2]; } xcb_xkb_sa_set_mods_t; /** * @brief xcb_xkb_sa_set_mods_iterator_t **/ typedef struct xcb_xkb_sa_set_mods_iterator_t { - xcb_xkb_sa_set_mods_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_set_mods_t *data; + int rem; + int index; } xcb_xkb_sa_set_mods_iterator_t; /** * @brief xcb_xkb_sa_latch_mods_t **/ typedef struct xcb_xkb_sa_latch_mods_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - uint8_t mask; /**< */ - uint8_t realMods; /**< */ - uint8_t vmodsHigh; /**< */ - uint8_t vmodsLow; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t type; + uint8_t flags; + uint8_t mask; + uint8_t realMods; + uint8_t vmodsHigh; + uint8_t vmodsLow; + uint8_t pad0[2]; } xcb_xkb_sa_latch_mods_t; /** * @brief xcb_xkb_sa_latch_mods_iterator_t **/ typedef struct xcb_xkb_sa_latch_mods_iterator_t { - xcb_xkb_sa_latch_mods_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_latch_mods_t *data; + int rem; + int index; } xcb_xkb_sa_latch_mods_iterator_t; /** * @brief xcb_xkb_sa_lock_mods_t **/ typedef struct xcb_xkb_sa_lock_mods_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - uint8_t mask; /**< */ - uint8_t realMods; /**< */ - uint8_t vmodsHigh; /**< */ - uint8_t vmodsLow; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t type; + uint8_t flags; + uint8_t mask; + uint8_t realMods; + uint8_t vmodsHigh; + uint8_t vmodsLow; + uint8_t pad0[2]; } xcb_xkb_sa_lock_mods_t; /** * @brief xcb_xkb_sa_lock_mods_iterator_t **/ typedef struct xcb_xkb_sa_lock_mods_iterator_t { - xcb_xkb_sa_lock_mods_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_lock_mods_t *data; + int rem; + int index; } xcb_xkb_sa_lock_mods_iterator_t; /** * @brief xcb_xkb_sa_set_group_t **/ typedef struct xcb_xkb_sa_set_group_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - int8_t group; /**< */ - uint8_t pad0[5]; /**< */ + uint8_t type; + uint8_t flags; + int8_t group; + uint8_t pad0[5]; } xcb_xkb_sa_set_group_t; /** * @brief xcb_xkb_sa_set_group_iterator_t **/ typedef struct xcb_xkb_sa_set_group_iterator_t { - xcb_xkb_sa_set_group_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_set_group_t *data; + int rem; + int index; } xcb_xkb_sa_set_group_iterator_t; /** * @brief xcb_xkb_sa_latch_group_t **/ typedef struct xcb_xkb_sa_latch_group_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - int8_t group; /**< */ - uint8_t pad0[5]; /**< */ + uint8_t type; + uint8_t flags; + int8_t group; + uint8_t pad0[5]; } xcb_xkb_sa_latch_group_t; /** * @brief xcb_xkb_sa_latch_group_iterator_t **/ typedef struct xcb_xkb_sa_latch_group_iterator_t { - xcb_xkb_sa_latch_group_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_latch_group_t *data; + int rem; + int index; } xcb_xkb_sa_latch_group_iterator_t; /** * @brief xcb_xkb_sa_lock_group_t **/ typedef struct xcb_xkb_sa_lock_group_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - int8_t group; /**< */ - uint8_t pad0[5]; /**< */ + uint8_t type; + uint8_t flags; + int8_t group; + uint8_t pad0[5]; } xcb_xkb_sa_lock_group_t; /** * @brief xcb_xkb_sa_lock_group_iterator_t **/ typedef struct xcb_xkb_sa_lock_group_iterator_t { - xcb_xkb_sa_lock_group_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_lock_group_t *data; + int rem; + int index; } xcb_xkb_sa_lock_group_iterator_t; typedef enum xcb_xkb_sa_move_ptr_flag_t { @@ -1201,62 +1201,62 @@ typedef enum xcb_xkb_sa_move_ptr_flag_t { * @brief xcb_xkb_sa_move_ptr_t **/ typedef struct xcb_xkb_sa_move_ptr_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - int8_t xHigh; /**< */ - uint8_t xLow; /**< */ - int8_t yHigh; /**< */ - uint8_t yLow; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t type; + uint8_t flags; + int8_t xHigh; + uint8_t xLow; + int8_t yHigh; + uint8_t yLow; + uint8_t pad0[2]; } xcb_xkb_sa_move_ptr_t; /** * @brief xcb_xkb_sa_move_ptr_iterator_t **/ typedef struct xcb_xkb_sa_move_ptr_iterator_t { - xcb_xkb_sa_move_ptr_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_move_ptr_t *data; + int rem; + int index; } xcb_xkb_sa_move_ptr_iterator_t; /** * @brief xcb_xkb_sa_ptr_btn_t **/ typedef struct xcb_xkb_sa_ptr_btn_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - uint8_t count; /**< */ - uint8_t button; /**< */ - uint8_t pad0[4]; /**< */ + uint8_t type; + uint8_t flags; + uint8_t count; + uint8_t button; + uint8_t pad0[4]; } xcb_xkb_sa_ptr_btn_t; /** * @brief xcb_xkb_sa_ptr_btn_iterator_t **/ typedef struct xcb_xkb_sa_ptr_btn_iterator_t { - xcb_xkb_sa_ptr_btn_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_ptr_btn_t *data; + int rem; + int index; } xcb_xkb_sa_ptr_btn_iterator_t; /** * @brief xcb_xkb_sa_lock_ptr_btn_t **/ typedef struct xcb_xkb_sa_lock_ptr_btn_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - uint8_t pad0; /**< */ - uint8_t button; /**< */ - uint8_t pad1[4]; /**< */ + uint8_t type; + uint8_t flags; + uint8_t pad0; + uint8_t button; + uint8_t pad1[4]; } xcb_xkb_sa_lock_ptr_btn_t; /** * @brief xcb_xkb_sa_lock_ptr_btn_iterator_t **/ typedef struct xcb_xkb_sa_lock_ptr_btn_iterator_t { - xcb_xkb_sa_lock_ptr_btn_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_lock_ptr_btn_t *data; + int rem; + int index; } xcb_xkb_sa_lock_ptr_btn_iterator_t; typedef enum xcb_xkb_sa_set_ptr_dflt_flag_t { @@ -1268,20 +1268,20 @@ typedef enum xcb_xkb_sa_set_ptr_dflt_flag_t { * @brief xcb_xkb_sa_set_ptr_dflt_t **/ typedef struct xcb_xkb_sa_set_ptr_dflt_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - uint8_t affect; /**< */ - int8_t value; /**< */ - uint8_t pad0[4]; /**< */ + uint8_t type; + uint8_t flags; + uint8_t affect; + int8_t value; + uint8_t pad0[4]; } xcb_xkb_sa_set_ptr_dflt_t; /** * @brief xcb_xkb_sa_set_ptr_dflt_iterator_t **/ typedef struct xcb_xkb_sa_set_ptr_dflt_iterator_t { - xcb_xkb_sa_set_ptr_dflt_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_set_ptr_dflt_t *data; + int rem; + int index; } xcb_xkb_sa_set_ptr_dflt_iterator_t; typedef enum xcb_xkb_sa_iso_lock_flag_t { @@ -1303,40 +1303,40 @@ typedef enum xcb_xkb_sa_iso_lock_no_affect_t { * @brief xcb_xkb_sa_iso_lock_t **/ typedef struct xcb_xkb_sa_iso_lock_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - uint8_t mask; /**< */ - uint8_t realMods; /**< */ - int8_t group; /**< */ - uint8_t affect; /**< */ - uint8_t vmodsHigh; /**< */ - uint8_t vmodsLow; /**< */ + uint8_t type; + uint8_t flags; + uint8_t mask; + uint8_t realMods; + int8_t group; + uint8_t affect; + uint8_t vmodsHigh; + uint8_t vmodsLow; } xcb_xkb_sa_iso_lock_t; /** * @brief xcb_xkb_sa_iso_lock_iterator_t **/ typedef struct xcb_xkb_sa_iso_lock_iterator_t { - xcb_xkb_sa_iso_lock_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_iso_lock_t *data; + int rem; + int index; } xcb_xkb_sa_iso_lock_iterator_t; /** * @brief xcb_xkb_sa_terminate_t **/ typedef struct xcb_xkb_sa_terminate_t { - uint8_t type; /**< */ - uint8_t pad0[7]; /**< */ + uint8_t type; + uint8_t pad0[7]; } xcb_xkb_sa_terminate_t; /** * @brief xcb_xkb_sa_terminate_iterator_t **/ typedef struct xcb_xkb_sa_terminate_iterator_t { - xcb_xkb_sa_terminate_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_terminate_t *data; + int rem; + int index; } xcb_xkb_sa_terminate_iterator_t; typedef enum xcb_xkb_switch_screen_flag_t { @@ -1348,19 +1348,19 @@ typedef enum xcb_xkb_switch_screen_flag_t { * @brief xcb_xkb_sa_switch_screen_t **/ typedef struct xcb_xkb_sa_switch_screen_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - int8_t newScreen; /**< */ - uint8_t pad0[5]; /**< */ + uint8_t type; + uint8_t flags; + int8_t newScreen; + uint8_t pad0[5]; } xcb_xkb_sa_switch_screen_t; /** * @brief xcb_xkb_sa_switch_screen_iterator_t **/ typedef struct xcb_xkb_sa_switch_screen_iterator_t { - xcb_xkb_sa_switch_screen_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_switch_screen_t *data; + int rem; + int index; } xcb_xkb_sa_switch_screen_iterator_t; typedef enum xcb_xkb_bool_ctrls_high_t { @@ -1386,40 +1386,40 @@ typedef enum xcb_xkb_bool_ctrls_low_t { * @brief xcb_xkb_sa_set_controls_t **/ typedef struct xcb_xkb_sa_set_controls_t { - uint8_t type; /**< */ - uint8_t pad0[3]; /**< */ - uint8_t boolCtrlsHigh; /**< */ - uint8_t boolCtrlsLow; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t type; + uint8_t pad0[3]; + uint8_t boolCtrlsHigh; + uint8_t boolCtrlsLow; + uint8_t pad1[2]; } xcb_xkb_sa_set_controls_t; /** * @brief xcb_xkb_sa_set_controls_iterator_t **/ typedef struct xcb_xkb_sa_set_controls_iterator_t { - xcb_xkb_sa_set_controls_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_set_controls_t *data; + int rem; + int index; } xcb_xkb_sa_set_controls_iterator_t; /** * @brief xcb_xkb_sa_lock_controls_t **/ typedef struct xcb_xkb_sa_lock_controls_t { - uint8_t type; /**< */ - uint8_t pad0[3]; /**< */ - uint8_t boolCtrlsHigh; /**< */ - uint8_t boolCtrlsLow; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t type; + uint8_t pad0[3]; + uint8_t boolCtrlsHigh; + uint8_t boolCtrlsLow; + uint8_t pad1[2]; } xcb_xkb_sa_lock_controls_t; /** * @brief xcb_xkb_sa_lock_controls_iterator_t **/ typedef struct xcb_xkb_sa_lock_controls_iterator_t { - xcb_xkb_sa_lock_controls_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_lock_controls_t *data; + int rem; + int index; } xcb_xkb_sa_lock_controls_iterator_t; typedef enum xcb_xkb_action_message_flag_t { @@ -1432,62 +1432,62 @@ typedef enum xcb_xkb_action_message_flag_t { * @brief xcb_xkb_sa_action_message_t **/ typedef struct xcb_xkb_sa_action_message_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - uint8_t message[6]; /**< */ + uint8_t type; + uint8_t flags; + uint8_t message[6]; } xcb_xkb_sa_action_message_t; /** * @brief xcb_xkb_sa_action_message_iterator_t **/ typedef struct xcb_xkb_sa_action_message_iterator_t { - xcb_xkb_sa_action_message_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_action_message_t *data; + int rem; + int index; } xcb_xkb_sa_action_message_iterator_t; /** * @brief xcb_xkb_sa_redirect_key_t **/ typedef struct xcb_xkb_sa_redirect_key_t { - uint8_t type; /**< */ - xcb_keycode_t newkey; /**< */ - uint8_t mask; /**< */ - uint8_t realModifiers; /**< */ - uint8_t vmodsMaskHigh; /**< */ - uint8_t vmodsMaskLow; /**< */ - uint8_t vmodsHigh; /**< */ - uint8_t vmodsLow; /**< */ + uint8_t type; + xcb_keycode_t newkey; + uint8_t mask; + uint8_t realModifiers; + uint8_t vmodsMaskHigh; + uint8_t vmodsMaskLow; + uint8_t vmodsHigh; + uint8_t vmodsLow; } xcb_xkb_sa_redirect_key_t; /** * @brief xcb_xkb_sa_redirect_key_iterator_t **/ typedef struct xcb_xkb_sa_redirect_key_iterator_t { - xcb_xkb_sa_redirect_key_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_redirect_key_t *data; + int rem; + int index; } xcb_xkb_sa_redirect_key_iterator_t; /** * @brief xcb_xkb_sa_device_btn_t **/ typedef struct xcb_xkb_sa_device_btn_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - uint8_t count; /**< */ - uint8_t button; /**< */ - uint8_t device; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t type; + uint8_t flags; + uint8_t count; + uint8_t button; + uint8_t device; + uint8_t pad0[3]; } xcb_xkb_sa_device_btn_t; /** * @brief xcb_xkb_sa_device_btn_iterator_t **/ typedef struct xcb_xkb_sa_device_btn_iterator_t { - xcb_xkb_sa_device_btn_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_device_btn_t *data; + int rem; + int index; } xcb_xkb_sa_device_btn_iterator_t; typedef enum xcb_xkb_lock_device_flags_t { @@ -1499,21 +1499,21 @@ typedef enum xcb_xkb_lock_device_flags_t { * @brief xcb_xkb_sa_lock_device_btn_t **/ typedef struct xcb_xkb_sa_lock_device_btn_t { - uint8_t type; /**< */ - uint8_t flags; /**< */ - uint8_t pad0; /**< */ - uint8_t button; /**< */ - uint8_t device; /**< */ - uint8_t pad1[3]; /**< */ + uint8_t type; + uint8_t flags; + uint8_t pad0; + uint8_t button; + uint8_t device; + uint8_t pad1[3]; } xcb_xkb_sa_lock_device_btn_t; /** * @brief xcb_xkb_sa_lock_device_btn_iterator_t **/ typedef struct xcb_xkb_sa_lock_device_btn_iterator_t { - xcb_xkb_sa_lock_device_btn_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_lock_device_btn_t *data; + int rem; + int index; } xcb_xkb_sa_lock_device_btn_iterator_t; typedef enum xcb_xkb_sa_val_what_t { @@ -1529,105 +1529,105 @@ typedef enum xcb_xkb_sa_val_what_t { * @brief xcb_xkb_sa_device_valuator_t **/ typedef struct xcb_xkb_sa_device_valuator_t { - uint8_t type; /**< */ - uint8_t device; /**< */ - uint8_t val1what; /**< */ - uint8_t val1index; /**< */ - uint8_t val1value; /**< */ - uint8_t val2what; /**< */ - uint8_t val2index; /**< */ - uint8_t val2value; /**< */ + uint8_t type; + uint8_t device; + uint8_t val1what; + uint8_t val1index; + uint8_t val1value; + uint8_t val2what; + uint8_t val2index; + uint8_t val2value; } xcb_xkb_sa_device_valuator_t; /** * @brief xcb_xkb_sa_device_valuator_iterator_t **/ typedef struct xcb_xkb_sa_device_valuator_iterator_t { - xcb_xkb_sa_device_valuator_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sa_device_valuator_t *data; + int rem; + int index; } xcb_xkb_sa_device_valuator_iterator_t; /** * @brief xcb_xkb_si_action_t **/ typedef struct xcb_xkb_si_action_t { - uint8_t type; /**< */ - uint8_t data[7]; /**< */ + uint8_t type; + uint8_t data[7]; } xcb_xkb_si_action_t; /** * @brief xcb_xkb_si_action_iterator_t **/ typedef struct xcb_xkb_si_action_iterator_t { - xcb_xkb_si_action_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_si_action_t *data; + int rem; + int index; } xcb_xkb_si_action_iterator_t; /** * @brief xcb_xkb_sym_interpret_t **/ typedef struct xcb_xkb_sym_interpret_t { - xcb_keysym_t sym; /**< */ - uint8_t mods; /**< */ - uint8_t match; /**< */ - uint8_t virtualMod; /**< */ - uint8_t flags; /**< */ - xcb_xkb_si_action_t action; /**< */ + xcb_keysym_t sym; + uint8_t mods; + uint8_t match; + uint8_t virtualMod; + uint8_t flags; + xcb_xkb_si_action_t action; } xcb_xkb_sym_interpret_t; /** * @brief xcb_xkb_sym_interpret_iterator_t **/ typedef struct xcb_xkb_sym_interpret_iterator_t { - xcb_xkb_sym_interpret_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_sym_interpret_t *data; + int rem; + int index; } xcb_xkb_sym_interpret_iterator_t; /** * @brief xcb_xkb_action_t **/ typedef union xcb_xkb_action_t { - xcb_xkb_sa_no_action_t noaction; /**< */ - xcb_xkb_sa_set_mods_t setmods; /**< */ - xcb_xkb_sa_latch_mods_t latchmods; /**< */ - xcb_xkb_sa_lock_mods_t lockmods; /**< */ - xcb_xkb_sa_set_group_t setgroup; /**< */ - xcb_xkb_sa_latch_group_t latchgroup; /**< */ - xcb_xkb_sa_lock_group_t lockgroup; /**< */ - xcb_xkb_sa_move_ptr_t moveptr; /**< */ - xcb_xkb_sa_ptr_btn_t ptrbtn; /**< */ - xcb_xkb_sa_lock_ptr_btn_t lockptrbtn; /**< */ - xcb_xkb_sa_set_ptr_dflt_t setptrdflt; /**< */ - xcb_xkb_sa_iso_lock_t isolock; /**< */ - xcb_xkb_sa_terminate_t terminate; /**< */ - xcb_xkb_sa_switch_screen_t switchscreen; /**< */ - xcb_xkb_sa_set_controls_t setcontrols; /**< */ - xcb_xkb_sa_lock_controls_t lockcontrols; /**< */ - xcb_xkb_sa_action_message_t message; /**< */ - xcb_xkb_sa_redirect_key_t redirect; /**< */ - xcb_xkb_sa_device_btn_t devbtn; /**< */ - xcb_xkb_sa_lock_device_btn_t lockdevbtn; /**< */ - xcb_xkb_sa_device_valuator_t devval; /**< */ - uint8_t type; /**< */ + xcb_xkb_sa_no_action_t noaction; + xcb_xkb_sa_set_mods_t setmods; + xcb_xkb_sa_latch_mods_t latchmods; + xcb_xkb_sa_lock_mods_t lockmods; + xcb_xkb_sa_set_group_t setgroup; + xcb_xkb_sa_latch_group_t latchgroup; + xcb_xkb_sa_lock_group_t lockgroup; + xcb_xkb_sa_move_ptr_t moveptr; + xcb_xkb_sa_ptr_btn_t ptrbtn; + xcb_xkb_sa_lock_ptr_btn_t lockptrbtn; + xcb_xkb_sa_set_ptr_dflt_t setptrdflt; + xcb_xkb_sa_iso_lock_t isolock; + xcb_xkb_sa_terminate_t terminate; + xcb_xkb_sa_switch_screen_t switchscreen; + xcb_xkb_sa_set_controls_t setcontrols; + xcb_xkb_sa_lock_controls_t lockcontrols; + xcb_xkb_sa_action_message_t message; + xcb_xkb_sa_redirect_key_t redirect; + xcb_xkb_sa_device_btn_t devbtn; + xcb_xkb_sa_lock_device_btn_t lockdevbtn; + xcb_xkb_sa_device_valuator_t devval; + uint8_t type; } xcb_xkb_action_t; /** * @brief xcb_xkb_action_iterator_t **/ typedef struct xcb_xkb_action_iterator_t { - xcb_xkb_action_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xkb_action_t *data; + int rem; + int index; } xcb_xkb_action_iterator_t; /** * @brief xcb_xkb_use_extension_cookie_t **/ typedef struct xcb_xkb_use_extension_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_use_extension_cookie_t; /** Opcode for xcb_xkb_use_extension. */ @@ -1637,52 +1637,52 @@ typedef struct xcb_xkb_use_extension_cookie_t { * @brief xcb_xkb_use_extension_request_t **/ typedef struct xcb_xkb_use_extension_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t wantedMajor; /**< */ - uint16_t wantedMinor; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t wantedMajor; + uint16_t wantedMinor; } xcb_xkb_use_extension_request_t; /** * @brief xcb_xkb_use_extension_reply_t **/ typedef struct xcb_xkb_use_extension_reply_t { - uint8_t response_type; /**< */ - uint8_t supported; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t serverMajor; /**< */ - uint16_t serverMinor; /**< */ - uint8_t pad0[20]; /**< */ + uint8_t response_type; + uint8_t supported; + uint16_t sequence; + uint32_t length; + uint16_t serverMajor; + uint16_t serverMinor; + uint8_t pad0[20]; } xcb_xkb_use_extension_reply_t; /** * @brief xcb_xkb_select_events_details_t **/ typedef struct xcb_xkb_select_events_details_t { - uint16_t affectNewKeyboard; /**< */ - uint16_t newKeyboardDetails; /**< */ - uint16_t affectState; /**< */ - uint16_t stateDetails; /**< */ - uint32_t affectCtrls; /**< */ - uint32_t ctrlDetails; /**< */ - uint32_t affectIndicatorState; /**< */ - uint32_t indicatorStateDetails; /**< */ - uint32_t affectIndicatorMap; /**< */ - uint32_t indicatorMapDetails; /**< */ - uint16_t affectNames; /**< */ - uint16_t namesDetails; /**< */ - uint8_t affectCompat; /**< */ - uint8_t compatDetails; /**< */ - uint8_t affectBell; /**< */ - uint8_t bellDetails; /**< */ - uint8_t affectMsgDetails; /**< */ - uint8_t msgDetails; /**< */ - uint16_t affectAccessX; /**< */ - uint16_t accessXDetails; /**< */ - uint16_t affectExtDev; /**< */ - uint16_t extdevDetails; /**< */ + uint16_t affectNewKeyboard; + uint16_t newKeyboardDetails; + uint16_t affectState; + uint16_t stateDetails; + uint32_t affectCtrls; + uint32_t ctrlDetails; + uint32_t affectIndicatorState; + uint32_t indicatorStateDetails; + uint32_t affectIndicatorMap; + uint32_t indicatorMapDetails; + uint16_t affectNames; + uint16_t namesDetails; + uint8_t affectCompat; + uint8_t compatDetails; + uint8_t affectBell; + uint8_t bellDetails; + uint8_t affectMsgDetails; + uint8_t msgDetails; + uint16_t affectAccessX; + uint16_t accessXDetails; + uint16_t affectExtDev; + uint16_t extdevDetails; } xcb_xkb_select_events_details_t; /** Opcode for xcb_xkb_select_events. */ @@ -1692,15 +1692,15 @@ typedef struct xcb_xkb_select_events_details_t { * @brief xcb_xkb_select_events_request_t **/ typedef struct xcb_xkb_select_events_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint16_t affectWhich; /**< */ - uint16_t clear; /**< */ - uint16_t selectAll; /**< */ - uint16_t affectMap; /**< */ - uint16_t map; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint16_t affectWhich; + uint16_t clear; + uint16_t selectAll; + uint16_t affectMap; + uint16_t map; } xcb_xkb_select_events_request_t; /** Opcode for xcb_xkb_bell. */ @@ -1710,28 +1710,28 @@ typedef struct xcb_xkb_select_events_request_t { * @brief xcb_xkb_bell_request_t **/ typedef struct xcb_xkb_bell_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - xcb_xkb_bell_class_spec_t bellClass; /**< */ - xcb_xkb_id_spec_t bellID; /**< */ - int8_t percent; /**< */ - uint8_t forceSound; /**< */ - uint8_t eventOnly; /**< */ - uint8_t pad0; /**< */ - int16_t pitch; /**< */ - int16_t duration; /**< */ - uint8_t pad1[2]; /**< */ - xcb_atom_t name; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + xcb_xkb_bell_class_spec_t bellClass; + xcb_xkb_id_spec_t bellID; + int8_t percent; + uint8_t forceSound; + uint8_t eventOnly; + uint8_t pad0; + int16_t pitch; + int16_t duration; + uint8_t pad1[2]; + xcb_atom_t name; + xcb_window_t window; } xcb_xkb_bell_request_t; /** * @brief xcb_xkb_get_state_cookie_t **/ typedef struct xcb_xkb_get_state_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_get_state_cookie_t; /** Opcode for xcb_xkb_get_state. */ @@ -1741,37 +1741,37 @@ typedef struct xcb_xkb_get_state_cookie_t { * @brief xcb_xkb_get_state_request_t **/ typedef struct xcb_xkb_get_state_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t pad0[2]; } xcb_xkb_get_state_request_t; /** * @brief xcb_xkb_get_state_reply_t **/ typedef struct xcb_xkb_get_state_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t mods; /**< */ - uint8_t baseMods; /**< */ - uint8_t latchedMods; /**< */ - uint8_t lockedMods; /**< */ - uint8_t group; /**< */ - uint8_t lockedGroup; /**< */ - int16_t baseGroup; /**< */ - int16_t latchedGroup; /**< */ - uint8_t compatState; /**< */ - uint8_t grabMods; /**< */ - uint8_t compatGrabMods; /**< */ - uint8_t lookupMods; /**< */ - uint8_t compatLookupMods; /**< */ - uint8_t pad0; /**< */ - uint16_t ptrBtnState; /**< */ - uint8_t pad1[6]; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + uint8_t mods; + uint8_t baseMods; + uint8_t latchedMods; + uint8_t lockedMods; + uint8_t group; + uint8_t lockedGroup; + int16_t baseGroup; + int16_t latchedGroup; + uint8_t compatState; + uint8_t grabMods; + uint8_t compatGrabMods; + uint8_t lookupMods; + uint8_t compatLookupMods; + uint8_t pad0; + uint16_t ptrBtnState; + uint8_t pad1[6]; } xcb_xkb_get_state_reply_t; /** Opcode for xcb_xkb_latch_lock_state. */ @@ -1781,26 +1781,26 @@ typedef struct xcb_xkb_get_state_reply_t { * @brief xcb_xkb_latch_lock_state_request_t **/ typedef struct xcb_xkb_latch_lock_state_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t affectModLocks; /**< */ - uint8_t modLocks; /**< */ - uint8_t lockGroup; /**< */ - uint8_t groupLock; /**< */ - uint8_t affectModLatches; /**< */ - uint8_t pad0; /**< */ - uint8_t pad1; /**< */ - uint8_t latchGroup; /**< */ - uint16_t groupLatch; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t affectModLocks; + uint8_t modLocks; + uint8_t lockGroup; + uint8_t groupLock; + uint8_t affectModLatches; + uint8_t pad0; + uint8_t pad1; + uint8_t latchGroup; + uint16_t groupLatch; } xcb_xkb_latch_lock_state_request_t; /** * @brief xcb_xkb_get_controls_cookie_t **/ typedef struct xcb_xkb_get_controls_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_get_controls_cookie_t; /** Opcode for xcb_xkb_get_controls. */ @@ -1810,49 +1810,49 @@ typedef struct xcb_xkb_get_controls_cookie_t { * @brief xcb_xkb_get_controls_request_t **/ typedef struct xcb_xkb_get_controls_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t pad0[2]; } xcb_xkb_get_controls_request_t; /** * @brief xcb_xkb_get_controls_reply_t **/ typedef struct xcb_xkb_get_controls_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t mouseKeysDfltBtn; /**< */ - uint8_t numGroups; /**< */ - uint8_t groupsWrap; /**< */ - uint8_t internalModsMask; /**< */ - uint8_t ignoreLockModsMask; /**< */ - uint8_t internalModsRealMods; /**< */ - uint8_t ignoreLockModsRealMods; /**< */ - uint8_t pad0; /**< */ - uint16_t internalModsVmods; /**< */ - uint16_t ignoreLockModsVmods; /**< */ - uint16_t repeatDelay; /**< */ - uint16_t repeatInterval; /**< */ - uint16_t slowKeysDelay; /**< */ - uint16_t debounceDelay; /**< */ - uint16_t mouseKeysDelay; /**< */ - uint16_t mouseKeysInterval; /**< */ - uint16_t mouseKeysTimeToMax; /**< */ - uint16_t mouseKeysMaxSpeed; /**< */ - int16_t mouseKeysCurve; /**< */ - uint16_t accessXOption; /**< */ - uint16_t accessXTimeout; /**< */ - uint16_t accessXTimeoutOptionsMask; /**< */ - uint16_t accessXTimeoutOptionsValues; /**< */ - uint8_t pad1[2]; /**< */ - uint32_t accessXTimeoutMask; /**< */ - uint32_t accessXTimeoutValues; /**< */ - uint32_t enabledControls; /**< */ - uint8_t perKeyRepeat[32]; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + uint8_t mouseKeysDfltBtn; + uint8_t numGroups; + uint8_t groupsWrap; + uint8_t internalModsMask; + uint8_t ignoreLockModsMask; + uint8_t internalModsRealMods; + uint8_t ignoreLockModsRealMods; + uint8_t pad0; + uint16_t internalModsVmods; + uint16_t ignoreLockModsVmods; + uint16_t repeatDelay; + uint16_t repeatInterval; + uint16_t slowKeysDelay; + uint16_t debounceDelay; + uint16_t mouseKeysDelay; + uint16_t mouseKeysInterval; + uint16_t mouseKeysTimeToMax; + uint16_t mouseKeysMaxSpeed; + int16_t mouseKeysCurve; + uint16_t accessXOption; + uint16_t accessXTimeout; + uint16_t accessXTimeoutOptionsMask; + uint16_t accessXTimeoutOptionsValues; + uint8_t pad1[2]; + uint32_t accessXTimeoutMask; + uint32_t accessXTimeoutValues; + uint32_t enabledControls; + uint8_t perKeyRepeat[32]; } xcb_xkb_get_controls_reply_t; /** Opcode for xcb_xkb_set_controls. */ @@ -1862,47 +1862,47 @@ typedef struct xcb_xkb_get_controls_reply_t { * @brief xcb_xkb_set_controls_request_t **/ typedef struct xcb_xkb_set_controls_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t affectInternalRealMods; /**< */ - uint8_t internalRealMods; /**< */ - uint8_t affectIgnoreLockRealMods; /**< */ - uint8_t ignoreLockRealMods; /**< */ - uint16_t affectInternalVirtualMods; /**< */ - uint16_t internalVirtualMods; /**< */ - uint16_t affectIgnoreLockVirtualMods; /**< */ - uint16_t ignoreLockVirtualMods; /**< */ - uint8_t mouseKeysDfltBtn; /**< */ - uint8_t groupsWrap; /**< */ - uint16_t accessXOptions; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t affectEnabledControls; /**< */ - uint32_t enabledControls; /**< */ - uint32_t changeControls; /**< */ - uint16_t repeatDelay; /**< */ - uint16_t repeatInterval; /**< */ - uint16_t slowKeysDelay; /**< */ - uint16_t debounceDelay; /**< */ - uint16_t mouseKeysDelay; /**< */ - uint16_t mouseKeysInterval; /**< */ - uint16_t mouseKeysTimeToMax; /**< */ - uint16_t mouseKeysMaxSpeed; /**< */ - int16_t mouseKeysCurve; /**< */ - uint16_t accessXTimeout; /**< */ - uint32_t accessXTimeoutMask; /**< */ - uint32_t accessXTimeoutValues; /**< */ - uint16_t accessXTimeoutOptionsMask; /**< */ - uint16_t accessXTimeoutOptionsValues; /**< */ - uint8_t perKeyRepeat[32]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t affectInternalRealMods; + uint8_t internalRealMods; + uint8_t affectIgnoreLockRealMods; + uint8_t ignoreLockRealMods; + uint16_t affectInternalVirtualMods; + uint16_t internalVirtualMods; + uint16_t affectIgnoreLockVirtualMods; + uint16_t ignoreLockVirtualMods; + uint8_t mouseKeysDfltBtn; + uint8_t groupsWrap; + uint16_t accessXOptions; + uint8_t pad0[2]; + uint32_t affectEnabledControls; + uint32_t enabledControls; + uint32_t changeControls; + uint16_t repeatDelay; + uint16_t repeatInterval; + uint16_t slowKeysDelay; + uint16_t debounceDelay; + uint16_t mouseKeysDelay; + uint16_t mouseKeysInterval; + uint16_t mouseKeysTimeToMax; + uint16_t mouseKeysMaxSpeed; + int16_t mouseKeysCurve; + uint16_t accessXTimeout; + uint32_t accessXTimeoutMask; + uint32_t accessXTimeoutValues; + uint16_t accessXTimeoutOptionsMask; + uint16_t accessXTimeoutOptionsValues; + uint8_t perKeyRepeat[32]; } xcb_xkb_set_controls_request_t; /** * @brief xcb_xkb_get_map_cookie_t **/ typedef struct xcb_xkb_get_map_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_get_map_cookie_t; /** Opcode for xcb_xkb_get_map. */ @@ -1912,99 +1912,99 @@ typedef struct xcb_xkb_get_map_cookie_t { * @brief xcb_xkb_get_map_request_t **/ typedef struct xcb_xkb_get_map_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint16_t full; /**< */ - uint16_t partial; /**< */ - uint8_t firstType; /**< */ - uint8_t nTypes; /**< */ - xcb_keycode_t firstKeySym; /**< */ - uint8_t nKeySyms; /**< */ - xcb_keycode_t firstKeyAction; /**< */ - uint8_t nKeyActions; /**< */ - xcb_keycode_t firstKeyBehavior; /**< */ - uint8_t nKeyBehaviors; /**< */ - uint16_t virtualMods; /**< */ - xcb_keycode_t firstKeyExplicit; /**< */ - uint8_t nKeyExplicit; /**< */ - xcb_keycode_t firstModMapKey; /**< */ - uint8_t nModMapKeys; /**< */ - xcb_keycode_t firstVModMapKey; /**< */ - uint8_t nVModMapKeys; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint16_t full; + uint16_t partial; + uint8_t firstType; + uint8_t nTypes; + xcb_keycode_t firstKeySym; + uint8_t nKeySyms; + xcb_keycode_t firstKeyAction; + uint8_t nKeyActions; + xcb_keycode_t firstKeyBehavior; + uint8_t nKeyBehaviors; + uint16_t virtualMods; + xcb_keycode_t firstKeyExplicit; + uint8_t nKeyExplicit; + xcb_keycode_t firstModMapKey; + uint8_t nModMapKeys; + xcb_keycode_t firstVModMapKey; + uint8_t nVModMapKeys; + uint8_t pad0[2]; } xcb_xkb_get_map_request_t; /** * @brief xcb_xkb_get_map_map_t **/ typedef struct xcb_xkb_get_map_map_t { - xcb_xkb_key_type_t *types_rtrn; /**< */ - xcb_xkb_key_sym_map_t *syms_rtrn; /**< */ - uint8_t *acts_rtrn_count; /**< */ - uint8_t *pad2; /**< */ - xcb_xkb_action_t *acts_rtrn_acts; /**< */ - xcb_xkb_set_behavior_t *behaviors_rtrn; /**< */ - uint8_t *vmods_rtrn; /**< */ - uint8_t *pad3; /**< */ - xcb_xkb_set_explicit_t *explicit_rtrn; /**< */ - uint8_t *pad4; /**< */ - xcb_xkb_key_mod_map_t *modmap_rtrn; /**< */ - uint8_t *pad5; /**< */ - xcb_xkb_key_v_mod_map_t *vmodmap_rtrn; /**< */ + xcb_xkb_key_type_t *types_rtrn; + xcb_xkb_key_sym_map_t *syms_rtrn; + uint8_t *acts_rtrn_count; + uint8_t *pad2; + xcb_xkb_action_t *acts_rtrn_acts; + xcb_xkb_set_behavior_t *behaviors_rtrn; + uint8_t *vmods_rtrn; + uint8_t *pad3; + xcb_xkb_set_explicit_t *explicit_rtrn; + uint8_t *pad4; + xcb_xkb_key_mod_map_t *modmap_rtrn; + uint8_t *pad5; + xcb_xkb_key_v_mod_map_t *vmodmap_rtrn; } xcb_xkb_get_map_map_t; /** * @brief xcb_xkb_get_map_reply_t **/ typedef struct xcb_xkb_get_map_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad0[2]; /**< */ - xcb_keycode_t minKeyCode; /**< */ - xcb_keycode_t maxKeyCode; /**< */ - uint16_t present; /**< */ - uint8_t firstType; /**< */ - uint8_t nTypes; /**< */ - uint8_t totalTypes; /**< */ - xcb_keycode_t firstKeySym; /**< */ - uint16_t totalSyms; /**< */ - uint8_t nKeySyms; /**< */ - xcb_keycode_t firstKeyAction; /**< */ - uint16_t totalActions; /**< */ - uint8_t nKeyActions; /**< */ - xcb_keycode_t firstKeyBehavior; /**< */ - uint8_t nKeyBehaviors; /**< */ - uint8_t totalKeyBehaviors; /**< */ - xcb_keycode_t firstKeyExplicit; /**< */ - uint8_t nKeyExplicit; /**< */ - uint8_t totalKeyExplicit; /**< */ - xcb_keycode_t firstModMapKey; /**< */ - uint8_t nModMapKeys; /**< */ - uint8_t totalModMapKeys; /**< */ - xcb_keycode_t firstVModMapKey; /**< */ - uint8_t nVModMapKeys; /**< */ - uint8_t totalVModMapKeys; /**< */ - uint8_t pad1; /**< */ - uint16_t virtualMods; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + uint8_t pad0[2]; + xcb_keycode_t minKeyCode; + xcb_keycode_t maxKeyCode; + uint16_t present; + uint8_t firstType; + uint8_t nTypes; + uint8_t totalTypes; + xcb_keycode_t firstKeySym; + uint16_t totalSyms; + uint8_t nKeySyms; + xcb_keycode_t firstKeyAction; + uint16_t totalActions; + uint8_t nKeyActions; + xcb_keycode_t firstKeyBehavior; + uint8_t nKeyBehaviors; + uint8_t totalKeyBehaviors; + xcb_keycode_t firstKeyExplicit; + uint8_t nKeyExplicit; + uint8_t totalKeyExplicit; + xcb_keycode_t firstModMapKey; + uint8_t nModMapKeys; + uint8_t totalModMapKeys; + xcb_keycode_t firstVModMapKey; + uint8_t nVModMapKeys; + uint8_t totalVModMapKeys; + uint8_t pad1; + uint16_t virtualMods; } xcb_xkb_get_map_reply_t; /** * @brief xcb_xkb_set_map_values_t **/ typedef struct xcb_xkb_set_map_values_t { - xcb_xkb_set_key_type_t *types; /**< */ - xcb_xkb_key_sym_map_t *syms; /**< */ - uint8_t *actionsCount; /**< */ - xcb_xkb_action_t *actions; /**< */ - xcb_xkb_set_behavior_t *behaviors; /**< */ - uint8_t *vmods; /**< */ - xcb_xkb_set_explicit_t *explicit; /**< */ - xcb_xkb_key_mod_map_t *modmap; /**< */ - xcb_xkb_key_v_mod_map_t *vmodmap; /**< */ + xcb_xkb_set_key_type_t *types; + xcb_xkb_key_sym_map_t *syms; + uint8_t *actionsCount; + xcb_xkb_action_t *actions; + xcb_xkb_set_behavior_t *behaviors; + uint8_t *vmods; + xcb_xkb_set_explicit_t *explicit; + xcb_xkb_key_mod_map_t *modmap; + xcb_xkb_key_v_mod_map_t *vmodmap; } xcb_xkb_set_map_values_t; /** Opcode for xcb_xkb_set_map. */ @@ -2014,42 +2014,42 @@ typedef struct xcb_xkb_set_map_values_t { * @brief xcb_xkb_set_map_request_t **/ typedef struct xcb_xkb_set_map_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint16_t present; /**< */ - uint16_t flags; /**< */ - xcb_keycode_t minKeyCode; /**< */ - xcb_keycode_t maxKeyCode; /**< */ - uint8_t firstType; /**< */ - uint8_t nTypes; /**< */ - xcb_keycode_t firstKeySym; /**< */ - uint8_t nKeySyms; /**< */ - uint16_t totalSyms; /**< */ - xcb_keycode_t firstKeyAction; /**< */ - uint8_t nKeyActions; /**< */ - uint16_t totalActions; /**< */ - xcb_keycode_t firstKeyBehavior; /**< */ - uint8_t nKeyBehaviors; /**< */ - uint8_t totalKeyBehaviors; /**< */ - xcb_keycode_t firstKeyExplicit; /**< */ - uint8_t nKeyExplicit; /**< */ - uint8_t totalKeyExplicit; /**< */ - xcb_keycode_t firstModMapKey; /**< */ - uint8_t nModMapKeys; /**< */ - uint8_t totalModMapKeys; /**< */ - xcb_keycode_t firstVModMapKey; /**< */ - uint8_t nVModMapKeys; /**< */ - uint8_t totalVModMapKeys; /**< */ - uint16_t virtualMods; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint16_t present; + uint16_t flags; + xcb_keycode_t minKeyCode; + xcb_keycode_t maxKeyCode; + uint8_t firstType; + uint8_t nTypes; + xcb_keycode_t firstKeySym; + uint8_t nKeySyms; + uint16_t totalSyms; + xcb_keycode_t firstKeyAction; + uint8_t nKeyActions; + uint16_t totalActions; + xcb_keycode_t firstKeyBehavior; + uint8_t nKeyBehaviors; + uint8_t totalKeyBehaviors; + xcb_keycode_t firstKeyExplicit; + uint8_t nKeyExplicit; + uint8_t totalKeyExplicit; + xcb_keycode_t firstModMapKey; + uint8_t nModMapKeys; + uint8_t totalModMapKeys; + xcb_keycode_t firstVModMapKey; + uint8_t nVModMapKeys; + uint8_t totalVModMapKeys; + uint16_t virtualMods; } xcb_xkb_set_map_request_t; /** * @brief xcb_xkb_get_compat_map_cookie_t **/ typedef struct xcb_xkb_get_compat_map_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_get_compat_map_cookie_t; /** Opcode for xcb_xkb_get_compat_map. */ @@ -2059,30 +2059,30 @@ typedef struct xcb_xkb_get_compat_map_cookie_t { * @brief xcb_xkb_get_compat_map_request_t **/ typedef struct xcb_xkb_get_compat_map_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t groups; /**< */ - uint8_t getAllSI; /**< */ - uint16_t firstSI; /**< */ - uint16_t nSI; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t groups; + uint8_t getAllSI; + uint16_t firstSI; + uint16_t nSI; } xcb_xkb_get_compat_map_request_t; /** * @brief xcb_xkb_get_compat_map_reply_t **/ typedef struct xcb_xkb_get_compat_map_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t groupsRtrn; /**< */ - uint8_t pad0; /**< */ - uint16_t firstSIRtrn; /**< */ - uint16_t nSIRtrn; /**< */ - uint16_t nTotalSI; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + uint8_t groupsRtrn; + uint8_t pad0; + uint16_t firstSIRtrn; + uint16_t nSIRtrn; + uint16_t nTotalSI; + uint8_t pad1[16]; } xcb_xkb_get_compat_map_reply_t; /** Opcode for xcb_xkb_set_compat_map. */ @@ -2092,24 +2092,24 @@ typedef struct xcb_xkb_get_compat_map_reply_t { * @brief xcb_xkb_set_compat_map_request_t **/ typedef struct xcb_xkb_set_compat_map_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t pad0; /**< */ - uint8_t recomputeActions; /**< */ - uint8_t truncateSI; /**< */ - uint8_t groups; /**< */ - uint16_t firstSI; /**< */ - uint16_t nSI; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t pad0; + uint8_t recomputeActions; + uint8_t truncateSI; + uint8_t groups; + uint16_t firstSI; + uint16_t nSI; + uint8_t pad1[2]; } xcb_xkb_set_compat_map_request_t; /** * @brief xcb_xkb_get_indicator_state_cookie_t **/ typedef struct xcb_xkb_get_indicator_state_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_get_indicator_state_cookie_t; /** Opcode for xcb_xkb_get_indicator_state. */ @@ -2119,30 +2119,30 @@ typedef struct xcb_xkb_get_indicator_state_cookie_t { * @brief xcb_xkb_get_indicator_state_request_t **/ typedef struct xcb_xkb_get_indicator_state_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t pad0[2]; } xcb_xkb_get_indicator_state_request_t; /** * @brief xcb_xkb_get_indicator_state_reply_t **/ typedef struct xcb_xkb_get_indicator_state_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t state; /**< */ - uint8_t pad0[20]; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + uint32_t state; + uint8_t pad0[20]; } xcb_xkb_get_indicator_state_reply_t; /** * @brief xcb_xkb_get_indicator_map_cookie_t **/ typedef struct xcb_xkb_get_indicator_map_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_get_indicator_map_cookie_t; /** Opcode for xcb_xkb_get_indicator_map. */ @@ -2152,26 +2152,26 @@ typedef struct xcb_xkb_get_indicator_map_cookie_t { * @brief xcb_xkb_get_indicator_map_request_t **/ typedef struct xcb_xkb_get_indicator_map_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t which; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t pad0[2]; + uint32_t which; } xcb_xkb_get_indicator_map_request_t; /** * @brief xcb_xkb_get_indicator_map_reply_t **/ typedef struct xcb_xkb_get_indicator_map_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t which; /**< */ - uint32_t realIndicators; /**< */ - uint8_t nIndicators; /**< */ - uint8_t pad0[15]; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + uint32_t which; + uint32_t realIndicators; + uint8_t nIndicators; + uint8_t pad0[15]; } xcb_xkb_get_indicator_map_reply_t; /** Opcode for xcb_xkb_set_indicator_map. */ @@ -2181,19 +2181,19 @@ typedef struct xcb_xkb_get_indicator_map_reply_t { * @brief xcb_xkb_set_indicator_map_request_t **/ typedef struct xcb_xkb_set_indicator_map_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t which; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t pad0[2]; + uint32_t which; } xcb_xkb_set_indicator_map_request_t; /** * @brief xcb_xkb_get_named_indicator_cookie_t **/ typedef struct xcb_xkb_get_named_indicator_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_get_named_indicator_cookie_t; /** Opcode for xcb_xkb_get_named_indicator. */ @@ -2203,39 +2203,39 @@ typedef struct xcb_xkb_get_named_indicator_cookie_t { * @brief xcb_xkb_get_named_indicator_request_t **/ typedef struct xcb_xkb_get_named_indicator_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - xcb_xkb_led_class_spec_t ledClass; /**< */ - xcb_xkb_id_spec_t ledID; /**< */ - uint8_t pad0[2]; /**< */ - xcb_atom_t indicator; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + xcb_xkb_led_class_spec_t ledClass; + xcb_xkb_id_spec_t ledID; + uint8_t pad0[2]; + xcb_atom_t indicator; } xcb_xkb_get_named_indicator_request_t; /** * @brief xcb_xkb_get_named_indicator_reply_t **/ typedef struct xcb_xkb_get_named_indicator_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_atom_t indicator; /**< */ - uint8_t found; /**< */ - uint8_t on; /**< */ - uint8_t realIndicator; /**< */ - uint8_t ndx; /**< */ - uint8_t map_flags; /**< */ - uint8_t map_whichGroups; /**< */ - uint8_t map_groups; /**< */ - uint8_t map_whichMods; /**< */ - uint8_t map_mods; /**< */ - uint8_t map_realMods; /**< */ - uint16_t map_vmod; /**< */ - uint32_t map_ctrls; /**< */ - uint8_t supported; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + xcb_atom_t indicator; + uint8_t found; + uint8_t on; + uint8_t realIndicator; + uint8_t ndx; + uint8_t map_flags; + uint8_t map_whichGroups; + uint8_t map_groups; + uint8_t map_whichMods; + uint8_t map_mods; + uint8_t map_realMods; + uint16_t map_vmod; + uint32_t map_ctrls; + uint8_t supported; + uint8_t pad0[3]; } xcb_xkb_get_named_indicator_reply_t; /** Opcode for xcb_xkb_set_named_indicator. */ @@ -2245,33 +2245,33 @@ typedef struct xcb_xkb_get_named_indicator_reply_t { * @brief xcb_xkb_set_named_indicator_request_t **/ typedef struct xcb_xkb_set_named_indicator_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - xcb_xkb_led_class_spec_t ledClass; /**< */ - xcb_xkb_id_spec_t ledID; /**< */ - uint8_t pad0[2]; /**< */ - xcb_atom_t indicator; /**< */ - uint8_t setState; /**< */ - uint8_t on; /**< */ - uint8_t setMap; /**< */ - uint8_t createMap; /**< */ - uint8_t pad1; /**< */ - uint8_t map_flags; /**< */ - uint8_t map_whichGroups; /**< */ - uint8_t map_groups; /**< */ - uint8_t map_whichMods; /**< */ - uint8_t map_realMods; /**< */ - uint16_t map_vmods; /**< */ - uint32_t map_ctrls; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + xcb_xkb_led_class_spec_t ledClass; + xcb_xkb_id_spec_t ledID; + uint8_t pad0[2]; + xcb_atom_t indicator; + uint8_t setState; + uint8_t on; + uint8_t setMap; + uint8_t createMap; + uint8_t pad1; + uint8_t map_flags; + uint8_t map_whichGroups; + uint8_t map_groups; + uint8_t map_whichMods; + uint8_t map_realMods; + uint16_t map_vmods; + uint32_t map_ctrls; } xcb_xkb_set_named_indicator_request_t; /** * @brief xcb_xkb_get_names_cookie_t **/ typedef struct xcb_xkb_get_names_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_get_names_cookie_t; /** Opcode for xcb_xkb_get_names. */ @@ -2281,78 +2281,78 @@ typedef struct xcb_xkb_get_names_cookie_t { * @brief xcb_xkb_get_names_request_t **/ typedef struct xcb_xkb_get_names_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t which; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t pad0[2]; + uint32_t which; } xcb_xkb_get_names_request_t; /** * @brief xcb_xkb_get_names_value_list_t **/ typedef struct xcb_xkb_get_names_value_list_t { - xcb_atom_t keycodesName; /**< */ - xcb_atom_t geometryName; /**< */ - xcb_atom_t symbolsName; /**< */ - xcb_atom_t physSymbolsName; /**< */ - xcb_atom_t typesName; /**< */ - xcb_atom_t compatName; /**< */ - xcb_atom_t *typeNames; /**< */ - uint8_t *nLevelsPerType; /**< */ - uint8_t *alignment_pad; /**< */ - xcb_atom_t *ktLevelNames; /**< */ - xcb_atom_t *indicatorNames; /**< */ - xcb_atom_t *virtualModNames; /**< */ - xcb_atom_t *groups; /**< */ - xcb_xkb_key_name_t *keyNames; /**< */ - xcb_xkb_key_alias_t *keyAliases; /**< */ - xcb_atom_t *radioGroupNames; /**< */ + xcb_atom_t keycodesName; + xcb_atom_t geometryName; + xcb_atom_t symbolsName; + xcb_atom_t physSymbolsName; + xcb_atom_t typesName; + xcb_atom_t compatName; + xcb_atom_t *typeNames; + uint8_t *nLevelsPerType; + uint8_t *pad1; + xcb_atom_t *ktLevelNames; + xcb_atom_t *indicatorNames; + xcb_atom_t *virtualModNames; + xcb_atom_t *groups; + xcb_xkb_key_name_t *keyNames; + xcb_xkb_key_alias_t *keyAliases; + xcb_atom_t *radioGroupNames; } xcb_xkb_get_names_value_list_t; /** * @brief xcb_xkb_get_names_reply_t **/ typedef struct xcb_xkb_get_names_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t which; /**< */ - xcb_keycode_t minKeyCode; /**< */ - xcb_keycode_t maxKeyCode; /**< */ - uint8_t nTypes; /**< */ - uint8_t groupNames; /**< */ - uint16_t virtualMods; /**< */ - xcb_keycode_t firstKey; /**< */ - uint8_t nKeys; /**< */ - uint32_t indicators; /**< */ - uint8_t nRadioGroups; /**< */ - uint8_t nKeyAliases; /**< */ - uint16_t nKTLevels; /**< */ - uint8_t pad0[4]; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + uint32_t which; + xcb_keycode_t minKeyCode; + xcb_keycode_t maxKeyCode; + uint8_t nTypes; + uint8_t groupNames; + uint16_t virtualMods; + xcb_keycode_t firstKey; + uint8_t nKeys; + uint32_t indicators; + uint8_t nRadioGroups; + uint8_t nKeyAliases; + uint16_t nKTLevels; + uint8_t pad0[4]; } xcb_xkb_get_names_reply_t; /** * @brief xcb_xkb_set_names_values_t **/ typedef struct xcb_xkb_set_names_values_t { - xcb_atom_t keycodesName; /**< */ - xcb_atom_t geometryName; /**< */ - xcb_atom_t symbolsName; /**< */ - xcb_atom_t physSymbolsName; /**< */ - xcb_atom_t typesName; /**< */ - xcb_atom_t compatName; /**< */ - xcb_atom_t *typeNames; /**< */ - uint8_t *nLevelsPerType; /**< */ - xcb_atom_t *ktLevelNames; /**< */ - xcb_atom_t *indicatorNames; /**< */ - xcb_atom_t *virtualModNames; /**< */ - xcb_atom_t *groups; /**< */ - xcb_xkb_key_name_t *keyNames; /**< */ - xcb_xkb_key_alias_t *keyAliases; /**< */ - xcb_atom_t *radioGroupNames; /**< */ + xcb_atom_t keycodesName; + xcb_atom_t geometryName; + xcb_atom_t symbolsName; + xcb_atom_t physSymbolsName; + xcb_atom_t typesName; + xcb_atom_t compatName; + xcb_atom_t *typeNames; + uint8_t *nLevelsPerType; + xcb_atom_t *ktLevelNames; + xcb_atom_t *indicatorNames; + xcb_atom_t *virtualModNames; + xcb_atom_t *groups; + xcb_xkb_key_name_t *keyNames; + xcb_xkb_key_alias_t *keyAliases; + xcb_atom_t *radioGroupNames; } xcb_xkb_set_names_values_t; /** Opcode for xcb_xkb_set_names. */ @@ -2362,31 +2362,31 @@ typedef struct xcb_xkb_set_names_values_t { * @brief xcb_xkb_set_names_request_t **/ typedef struct xcb_xkb_set_names_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint16_t virtualMods; /**< */ - uint32_t which; /**< */ - uint8_t firstType; /**< */ - uint8_t nTypes; /**< */ - uint8_t firstKTLevelt; /**< */ - uint8_t nKTLevels; /**< */ - uint32_t indicators; /**< */ - uint8_t groupNames; /**< */ - uint8_t nRadioGroups; /**< */ - xcb_keycode_t firstKey; /**< */ - uint8_t nKeys; /**< */ - uint8_t nKeyAliases; /**< */ - uint8_t pad0; /**< */ - uint16_t totalKTLevelNames; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint16_t virtualMods; + uint32_t which; + uint8_t firstType; + uint8_t nTypes; + uint8_t firstKTLevelt; + uint8_t nKTLevels; + uint32_t indicators; + uint8_t groupNames; + uint8_t nRadioGroups; + xcb_keycode_t firstKey; + uint8_t nKeys; + uint8_t nKeyAliases; + uint8_t pad0; + uint16_t totalKTLevelNames; } xcb_xkb_set_names_request_t; /** * @brief xcb_xkb_per_client_flags_cookie_t **/ typedef struct xcb_xkb_per_client_flags_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_per_client_flags_cookie_t; /** Opcode for xcb_xkb_per_client_flags. */ @@ -2396,38 +2396,38 @@ typedef struct xcb_xkb_per_client_flags_cookie_t { * @brief xcb_xkb_per_client_flags_request_t **/ typedef struct xcb_xkb_per_client_flags_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t change; /**< */ - uint32_t value; /**< */ - uint32_t ctrlsToChange; /**< */ - uint32_t autoCtrls; /**< */ - uint32_t autoCtrlsValues; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t pad0[2]; + uint32_t change; + uint32_t value; + uint32_t ctrlsToChange; + uint32_t autoCtrls; + uint32_t autoCtrlsValues; } xcb_xkb_per_client_flags_request_t; /** * @brief xcb_xkb_per_client_flags_reply_t **/ typedef struct xcb_xkb_per_client_flags_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t supported; /**< */ - uint32_t value; /**< */ - uint32_t autoCtrls; /**< */ - uint32_t autoCtrlsValues; /**< */ - uint8_t pad0[8]; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + uint32_t supported; + uint32_t value; + uint32_t autoCtrls; + uint32_t autoCtrlsValues; + uint8_t pad0[8]; } xcb_xkb_per_client_flags_reply_t; /** * @brief xcb_xkb_list_components_cookie_t **/ typedef struct xcb_xkb_list_components_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_list_components_cookie_t; /** Opcode for xcb_xkb_list_components. */ @@ -2437,36 +2437,36 @@ typedef struct xcb_xkb_list_components_cookie_t { * @brief xcb_xkb_list_components_request_t **/ typedef struct xcb_xkb_list_components_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint16_t maxNames; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint16_t maxNames; } xcb_xkb_list_components_request_t; /** * @brief xcb_xkb_list_components_reply_t **/ typedef struct xcb_xkb_list_components_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t nKeymaps; /**< */ - uint16_t nKeycodes; /**< */ - uint16_t nTypes; /**< */ - uint16_t nCompatMaps; /**< */ - uint16_t nSymbols; /**< */ - uint16_t nGeometries; /**< */ - uint16_t extra; /**< */ - uint8_t pad0[10]; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + uint16_t nKeymaps; + uint16_t nKeycodes; + uint16_t nTypes; + uint16_t nCompatMaps; + uint16_t nSymbols; + uint16_t nGeometries; + uint16_t extra; + uint8_t pad0[10]; } xcb_xkb_list_components_reply_t; /** * @brief xcb_xkb_get_kbd_by_name_cookie_t **/ typedef struct xcb_xkb_get_kbd_by_name_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_get_kbd_by_name_cookie_t; /** Opcode for xcb_xkb_get_kbd_by_name. */ @@ -2476,182 +2476,182 @@ typedef struct xcb_xkb_get_kbd_by_name_cookie_t { * @brief xcb_xkb_get_kbd_by_name_request_t **/ typedef struct xcb_xkb_get_kbd_by_name_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint16_t need; /**< */ - uint16_t want; /**< */ - uint8_t load; /**< */ - uint8_t pad0; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint16_t need; + uint16_t want; + uint8_t load; + uint8_t pad0; } xcb_xkb_get_kbd_by_name_request_t; /** * @brief xcb_xkb_get_kbd_by_name_replies_types_map_t **/ typedef struct xcb_xkb_get_kbd_by_name_replies_types_map_t { - xcb_xkb_key_type_t *types_rtrn; /**< */ - xcb_xkb_key_sym_map_t *syms_rtrn; /**< */ - uint8_t *acts_rtrn_count; /**< */ - xcb_xkb_action_t *acts_rtrn_acts; /**< */ - xcb_xkb_set_behavior_t *behaviors_rtrn; /**< */ - uint8_t *vmods_rtrn; /**< */ - xcb_xkb_set_explicit_t *explicit_rtrn; /**< */ - xcb_xkb_key_mod_map_t *modmap_rtrn; /**< */ - xcb_xkb_key_v_mod_map_t *vmodmap_rtrn; /**< */ + xcb_xkb_key_type_t *types_rtrn; + xcb_xkb_key_sym_map_t *syms_rtrn; + uint8_t *acts_rtrn_count; + xcb_xkb_action_t *acts_rtrn_acts; + xcb_xkb_set_behavior_t *behaviors_rtrn; + uint8_t *vmods_rtrn; + xcb_xkb_set_explicit_t *explicit_rtrn; + xcb_xkb_key_mod_map_t *modmap_rtrn; + xcb_xkb_key_v_mod_map_t *vmodmap_rtrn; } xcb_xkb_get_kbd_by_name_replies_types_map_t; /** * @brief xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t **/ typedef struct xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t { - xcb_atom_t keycodesName; /**< */ - xcb_atom_t geometryName; /**< */ - xcb_atom_t symbolsName; /**< */ - xcb_atom_t physSymbolsName; /**< */ - xcb_atom_t typesName; /**< */ - xcb_atom_t compatName; /**< */ - xcb_atom_t *typeNames; /**< */ - uint8_t *nLevelsPerType; /**< */ - xcb_atom_t *ktLevelNames; /**< */ - xcb_atom_t *indicatorNames; /**< */ - xcb_atom_t *virtualModNames; /**< */ - xcb_atom_t *groups; /**< */ - xcb_xkb_key_name_t *keyNames; /**< */ - xcb_xkb_key_alias_t *keyAliases; /**< */ - xcb_atom_t *radioGroupNames; /**< */ + xcb_atom_t keycodesName; + xcb_atom_t geometryName; + xcb_atom_t symbolsName; + xcb_atom_t physSymbolsName; + xcb_atom_t typesName; + xcb_atom_t compatName; + xcb_atom_t *typeNames; + uint8_t *nLevelsPerType; + xcb_atom_t *ktLevelNames; + xcb_atom_t *indicatorNames; + xcb_atom_t *virtualModNames; + xcb_atom_t *groups; + xcb_xkb_key_name_t *keyNames; + xcb_xkb_key_alias_t *keyAliases; + xcb_atom_t *radioGroupNames; } xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t; /** * @brief xcb_xkb_get_kbd_by_name_replies_t **/ typedef struct xcb_xkb_get_kbd_by_name_replies_t { - struct _types { - uint8_t getmap_type; /**< */ - uint8_t typeDeviceID; /**< */ - uint16_t getmap_sequence; /**< */ - uint32_t getmap_length; /**< */ - uint8_t pad1[2]; /**< */ - xcb_keycode_t typeMinKeyCode; /**< */ - xcb_keycode_t typeMaxKeyCode; /**< */ - uint16_t present; /**< */ - uint8_t firstType; /**< */ - uint8_t nTypes; /**< */ - uint8_t totalTypes; /**< */ - xcb_keycode_t firstKeySym; /**< */ - uint16_t totalSyms; /**< */ - uint8_t nKeySyms; /**< */ - xcb_keycode_t firstKeyAction; /**< */ - uint16_t totalActions; /**< */ - uint8_t nKeyActions; /**< */ - xcb_keycode_t firstKeyBehavior; /**< */ - uint8_t nKeyBehaviors; /**< */ - uint8_t totalKeyBehaviors; /**< */ - xcb_keycode_t firstKeyExplicit; /**< */ - uint8_t nKeyExplicit; /**< */ - uint8_t totalKeyExplicit; /**< */ - xcb_keycode_t firstModMapKey; /**< */ - uint8_t nModMapKeys; /**< */ - uint8_t totalModMapKeys; /**< */ - xcb_keycode_t firstVModMapKey; /**< */ - uint8_t nVModMapKeys; /**< */ - uint8_t totalVModMapKeys; /**< */ - uint8_t pad2; /**< */ - uint16_t virtualMods; /**< */ - xcb_xkb_get_kbd_by_name_replies_types_map_t map; /**< */ + struct { + uint8_t getmap_type; + uint8_t typeDeviceID; + uint16_t getmap_sequence; + uint32_t getmap_length; + uint8_t pad1[2]; + xcb_keycode_t typeMinKeyCode; + xcb_keycode_t typeMaxKeyCode; + uint16_t present; + uint8_t firstType; + uint8_t nTypes; + uint8_t totalTypes; + xcb_keycode_t firstKeySym; + uint16_t totalSyms; + uint8_t nKeySyms; + xcb_keycode_t firstKeyAction; + uint16_t totalActions; + uint8_t nKeyActions; + xcb_keycode_t firstKeyBehavior; + uint8_t nKeyBehaviors; + uint8_t totalKeyBehaviors; + xcb_keycode_t firstKeyExplicit; + uint8_t nKeyExplicit; + uint8_t totalKeyExplicit; + xcb_keycode_t firstModMapKey; + uint8_t nModMapKeys; + uint8_t totalModMapKeys; + xcb_keycode_t firstVModMapKey; + uint8_t nVModMapKeys; + uint8_t totalVModMapKeys; + uint8_t pad2; + uint16_t virtualMods; + xcb_xkb_get_kbd_by_name_replies_types_map_t map; } types; - struct _compat_map { - uint8_t compatmap_type; /**< */ - uint8_t compatDeviceID; /**< */ - uint16_t compatmap_sequence; /**< */ - uint32_t compatmap_length; /**< */ - uint8_t groupsRtrn; /**< */ - uint8_t pad3; /**< */ - uint16_t firstSIRtrn; /**< */ - uint16_t nSIRtrn; /**< */ - uint16_t nTotalSI; /**< */ - uint8_t pad4[16]; /**< */ - xcb_xkb_sym_interpret_t *si_rtrn; /**< */ - xcb_xkb_mod_def_t *group_rtrn; /**< */ + struct { + uint8_t compatmap_type; + uint8_t compatDeviceID; + uint16_t compatmap_sequence; + uint32_t compatmap_length; + uint8_t groupsRtrn; + uint8_t pad7; + uint16_t firstSIRtrn; + uint16_t nSIRtrn; + uint16_t nTotalSI; + uint8_t pad8[16]; + xcb_xkb_sym_interpret_t *si_rtrn; + xcb_xkb_mod_def_t *group_rtrn; } compat_map; - struct _indicator_maps { - uint8_t indicatormap_type; /**< */ - uint8_t indicatorDeviceID; /**< */ - uint16_t indicatormap_sequence; /**< */ - uint32_t indicatormap_length; /**< */ - uint32_t which; /**< */ - uint32_t realIndicators; /**< */ - uint8_t nIndicators; /**< */ - uint8_t pad5[15]; /**< */ - xcb_xkb_indicator_map_t *maps; /**< */ + struct { + uint8_t indicatormap_type; + uint8_t indicatorDeviceID; + uint16_t indicatormap_sequence; + uint32_t indicatormap_length; + uint32_t which; + uint32_t realIndicators; + uint8_t nIndicators; + uint8_t pad9[15]; + xcb_xkb_indicator_map_t *maps; } indicator_maps; - struct _key_names { - uint8_t keyname_type; /**< */ - uint8_t keyDeviceID; /**< */ - uint16_t keyname_sequence; /**< */ - uint32_t keyname_length; /**< */ - uint32_t which; /**< */ - xcb_keycode_t keyMinKeyCode; /**< */ - xcb_keycode_t keyMaxKeyCode; /**< */ - uint8_t nTypes; /**< */ - uint8_t groupNames; /**< */ - uint16_t virtualMods; /**< */ - xcb_keycode_t firstKey; /**< */ - uint8_t nKeys; /**< */ - uint32_t indicators; /**< */ - uint8_t nRadioGroups; /**< */ - uint8_t nKeyAliases; /**< */ - uint16_t nKTLevels; /**< */ - uint8_t pad6[4]; /**< */ - xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t valueList; /**< */ + struct { + uint8_t keyname_type; + uint8_t keyDeviceID; + uint16_t keyname_sequence; + uint32_t keyname_length; + uint32_t which; + xcb_keycode_t keyMinKeyCode; + xcb_keycode_t keyMaxKeyCode; + uint8_t nTypes; + uint8_t groupNames; + uint16_t virtualMods; + xcb_keycode_t firstKey; + uint8_t nKeys; + uint32_t indicators; + uint8_t nRadioGroups; + uint8_t nKeyAliases; + uint16_t nKTLevels; + uint8_t pad10[4]; + xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t valueList; } key_names; - struct _geometry { - uint8_t geometry_type; /**< */ - uint8_t geometryDeviceID; /**< */ - uint16_t geometry_sequence; /**< */ - uint32_t geometry_length; /**< */ - xcb_atom_t name; /**< */ - uint8_t geometryFound; /**< */ - uint8_t pad7; /**< */ - uint16_t widthMM; /**< */ - uint16_t heightMM; /**< */ - uint16_t nProperties; /**< */ - uint16_t nColors; /**< */ - uint16_t nShapes; /**< */ - uint16_t nSections; /**< */ - uint16_t nDoodads; /**< */ - uint16_t nKeyAliases; /**< */ - uint8_t baseColorNdx; /**< */ - uint8_t labelColorNdx; /**< */ - xcb_xkb_counted_string_16_t *labelFont; /**< */ + struct { + uint8_t geometry_type; + uint8_t geometryDeviceID; + uint16_t geometry_sequence; + uint32_t geometry_length; + xcb_atom_t name; + uint8_t geometryFound; + uint8_t pad12; + uint16_t widthMM; + uint16_t heightMM; + uint16_t nProperties; + uint16_t nColors; + uint16_t nShapes; + uint16_t nSections; + uint16_t nDoodads; + uint16_t nKeyAliases; + uint8_t baseColorNdx; + uint8_t labelColorNdx; + xcb_xkb_counted_string_16_t *labelFont; } geometry; } xcb_xkb_get_kbd_by_name_replies_t; xcb_xkb_get_kbd_by_name_replies_types_map_t * -xcb_xkb_get_kbd_by_name_replies_types_map (const xcb_xkb_get_kbd_by_name_replies_t *R /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map (const xcb_xkb_get_kbd_by_name_replies_t *R); /** * @brief xcb_xkb_get_kbd_by_name_reply_t **/ typedef struct xcb_xkb_get_kbd_by_name_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_keycode_t minKeyCode; /**< */ - xcb_keycode_t maxKeyCode; /**< */ - uint8_t loaded; /**< */ - uint8_t newKeyboard; /**< */ - uint16_t found; /**< */ - uint16_t reported; /**< */ - uint8_t pad0[16]; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + xcb_keycode_t minKeyCode; + xcb_keycode_t maxKeyCode; + uint8_t loaded; + uint8_t newKeyboard; + uint16_t found; + uint16_t reported; + uint8_t pad0[16]; } xcb_xkb_get_kbd_by_name_reply_t; /** * @brief xcb_xkb_get_device_info_cookie_t **/ typedef struct xcb_xkb_get_device_info_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_get_device_info_cookie_t; /** Opcode for xcb_xkb_get_device_info. */ @@ -2661,42 +2661,42 @@ typedef struct xcb_xkb_get_device_info_cookie_t { * @brief xcb_xkb_get_device_info_request_t **/ typedef struct xcb_xkb_get_device_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint16_t wanted; /**< */ - uint8_t allButtons; /**< */ - uint8_t firstButton; /**< */ - uint8_t nButtons; /**< */ - uint8_t pad0; /**< */ - xcb_xkb_led_class_spec_t ledClass; /**< */ - xcb_xkb_id_spec_t ledID; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint16_t wanted; + uint8_t allButtons; + uint8_t firstButton; + uint8_t nButtons; + uint8_t pad0; + xcb_xkb_led_class_spec_t ledClass; + xcb_xkb_id_spec_t ledID; } xcb_xkb_get_device_info_request_t; /** * @brief xcb_xkb_get_device_info_reply_t **/ typedef struct xcb_xkb_get_device_info_reply_t { - uint8_t response_type; /**< */ - uint8_t deviceID; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t present; /**< */ - uint16_t supported; /**< */ - uint16_t unsupported; /**< */ - uint16_t nDeviceLedFBs; /**< */ - uint8_t firstBtnWanted; /**< */ - uint8_t nBtnsWanted; /**< */ - uint8_t firstBtnRtrn; /**< */ - uint8_t nBtnsRtrn; /**< */ - uint8_t totalBtns; /**< */ - uint8_t hasOwnState; /**< */ - uint16_t dfltKbdFB; /**< */ - uint16_t dfltLedFB; /**< */ - uint8_t pad0[2]; /**< */ - xcb_atom_t devType; /**< */ - uint16_t nameLen; /**< */ + uint8_t response_type; + uint8_t deviceID; + uint16_t sequence; + uint32_t length; + uint16_t present; + uint16_t supported; + uint16_t unsupported; + uint16_t nDeviceLedFBs; + uint8_t firstBtnWanted; + uint8_t nBtnsWanted; + uint8_t firstBtnRtrn; + uint8_t nBtnsRtrn; + uint8_t totalBtns; + uint8_t hasOwnState; + uint16_t dfltKbdFB; + uint16_t dfltLedFB; + uint8_t pad0[2]; + xcb_atom_t devType; + uint16_t nameLen; } xcb_xkb_get_device_info_reply_t; /** Opcode for xcb_xkb_set_device_info. */ @@ -2706,21 +2706,21 @@ typedef struct xcb_xkb_get_device_info_reply_t { * @brief xcb_xkb_set_device_info_request_t **/ typedef struct xcb_xkb_set_device_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xkb_device_spec_t deviceSpec; /**< */ - uint8_t firstBtn; /**< */ - uint8_t nBtns; /**< */ - uint16_t change; /**< */ - uint16_t nDeviceLedFBs; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xkb_device_spec_t deviceSpec; + uint8_t firstBtn; + uint8_t nBtns; + uint16_t change; + uint16_t nDeviceLedFBs; } xcb_xkb_set_device_info_request_t; /** * @brief xcb_xkb_set_debugging_flags_cookie_t **/ typedef struct xcb_xkb_set_debugging_flags_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xkb_set_debugging_flags_cookie_t; /** Opcode for xcb_xkb_set_debugging_flags. */ @@ -2730,30 +2730,30 @@ typedef struct xcb_xkb_set_debugging_flags_cookie_t { * @brief xcb_xkb_set_debugging_flags_request_t **/ typedef struct xcb_xkb_set_debugging_flags_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint16_t msgLength; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t affectFlags; /**< */ - uint32_t flags; /**< */ - uint32_t affectCtrls; /**< */ - uint32_t ctrls; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint16_t msgLength; + uint8_t pad0[2]; + uint32_t affectFlags; + uint32_t flags; + uint32_t affectCtrls; + uint32_t ctrls; } xcb_xkb_set_debugging_flags_request_t; /** * @brief xcb_xkb_set_debugging_flags_reply_t **/ typedef struct xcb_xkb_set_debugging_flags_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t currentFlags; /**< */ - uint32_t currentCtrls; /**< */ - uint32_t supportedFlags; /**< */ - uint32_t supportedCtrls; /**< */ - uint8_t pad1[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t currentFlags; + uint32_t currentCtrls; + uint32_t supportedFlags; + uint32_t supportedCtrls; + uint8_t pad1[8]; } xcb_xkb_set_debugging_flags_reply_t; /** Opcode for xcb_xkb_new_keyboard_notify. */ @@ -2763,20 +2763,20 @@ typedef struct xcb_xkb_set_debugging_flags_reply_t { * @brief xcb_xkb_new_keyboard_notify_event_t **/ typedef struct xcb_xkb_new_keyboard_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - uint8_t oldDeviceID; /**< */ - xcb_keycode_t minKeyCode; /**< */ - xcb_keycode_t maxKeyCode; /**< */ - xcb_keycode_t oldMinKeyCode; /**< */ - xcb_keycode_t oldMaxKeyCode; /**< */ - uint8_t requestMajor; /**< */ - uint8_t requestMinor; /**< */ - uint16_t changed; /**< */ - uint8_t pad0[14]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + uint8_t oldDeviceID; + xcb_keycode_t minKeyCode; + xcb_keycode_t maxKeyCode; + xcb_keycode_t oldMinKeyCode; + xcb_keycode_t oldMaxKeyCode; + uint8_t requestMajor; + uint8_t requestMinor; + uint16_t changed; + uint8_t pad0[14]; } xcb_xkb_new_keyboard_notify_event_t; /** Opcode for xcb_xkb_map_notify. */ @@ -2786,31 +2786,31 @@ typedef struct xcb_xkb_new_keyboard_notify_event_t { * @brief xcb_xkb_map_notify_event_t **/ typedef struct xcb_xkb_map_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - uint8_t ptrBtnActions; /**< */ - uint16_t changed; /**< */ - xcb_keycode_t minKeyCode; /**< */ - xcb_keycode_t maxKeyCode; /**< */ - uint8_t firstType; /**< */ - uint8_t nTypes; /**< */ - xcb_keycode_t firstKeySym; /**< */ - uint8_t nKeySyms; /**< */ - xcb_keycode_t firstKeyAct; /**< */ - uint8_t nKeyActs; /**< */ - xcb_keycode_t firstKeyBehavior; /**< */ - uint8_t nKeyBehavior; /**< */ - xcb_keycode_t firstKeyExplicit; /**< */ - uint8_t nKeyExplicit; /**< */ - xcb_keycode_t firstModMapKey; /**< */ - uint8_t nModMapKeys; /**< */ - xcb_keycode_t firstVModMapKey; /**< */ - uint8_t nVModMapKeys; /**< */ - uint16_t virtualMods; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + uint8_t ptrBtnActions; + uint16_t changed; + xcb_keycode_t minKeyCode; + xcb_keycode_t maxKeyCode; + uint8_t firstType; + uint8_t nTypes; + xcb_keycode_t firstKeySym; + uint8_t nKeySyms; + xcb_keycode_t firstKeyAct; + uint8_t nKeyActs; + xcb_keycode_t firstKeyBehavior; + uint8_t nKeyBehavior; + xcb_keycode_t firstKeyExplicit; + uint8_t nKeyExplicit; + xcb_keycode_t firstModMapKey; + uint8_t nModMapKeys; + xcb_keycode_t firstVModMapKey; + uint8_t nVModMapKeys; + uint16_t virtualMods; + uint8_t pad0[2]; } xcb_xkb_map_notify_event_t; /** Opcode for xcb_xkb_state_notify. */ @@ -2820,30 +2820,30 @@ typedef struct xcb_xkb_map_notify_event_t { * @brief xcb_xkb_state_notify_event_t **/ typedef struct xcb_xkb_state_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - uint8_t mods; /**< */ - uint8_t baseMods; /**< */ - uint8_t latchedMods; /**< */ - uint8_t lockedMods; /**< */ - uint8_t group; /**< */ - int16_t baseGroup; /**< */ - int16_t latchedGroup; /**< */ - uint8_t lockedGroup; /**< */ - uint8_t compatState; /**< */ - uint8_t grabMods; /**< */ - uint8_t compatGrabMods; /**< */ - uint8_t lookupMods; /**< */ - uint8_t compatLoockupMods; /**< */ - uint16_t ptrBtnState; /**< */ - uint16_t changed; /**< */ - xcb_keycode_t keycode; /**< */ - uint8_t eventType; /**< */ - uint8_t requestMajor; /**< */ - uint8_t requestMinor; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + uint8_t mods; + uint8_t baseMods; + uint8_t latchedMods; + uint8_t lockedMods; + uint8_t group; + int16_t baseGroup; + int16_t latchedGroup; + uint8_t lockedGroup; + uint8_t compatState; + uint8_t grabMods; + uint8_t compatGrabMods; + uint8_t lookupMods; + uint8_t compatLoockupMods; + uint16_t ptrBtnState; + uint16_t changed; + xcb_keycode_t keycode; + uint8_t eventType; + uint8_t requestMajor; + uint8_t requestMinor; } xcb_xkb_state_notify_event_t; /** Opcode for xcb_xkb_controls_notify. */ @@ -2853,21 +2853,21 @@ typedef struct xcb_xkb_state_notify_event_t { * @brief xcb_xkb_controls_notify_event_t **/ typedef struct xcb_xkb_controls_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - uint8_t numGroups; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t changedControls; /**< */ - uint32_t enabledControls; /**< */ - uint32_t enabledControlChanges; /**< */ - xcb_keycode_t keycode; /**< */ - uint8_t eventType; /**< */ - uint8_t requestMajor; /**< */ - uint8_t requestMinor; /**< */ - uint8_t pad1[4]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + uint8_t numGroups; + uint8_t pad0[2]; + uint32_t changedControls; + uint32_t enabledControls; + uint32_t enabledControlChanges; + xcb_keycode_t keycode; + uint8_t eventType; + uint8_t requestMajor; + uint8_t requestMinor; + uint8_t pad1[4]; } xcb_xkb_controls_notify_event_t; /** Opcode for xcb_xkb_indicator_state_notify. */ @@ -2877,15 +2877,15 @@ typedef struct xcb_xkb_controls_notify_event_t { * @brief xcb_xkb_indicator_state_notify_event_t **/ typedef struct xcb_xkb_indicator_state_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - uint8_t pad0[3]; /**< */ - uint32_t state; /**< */ - uint32_t stateChanged; /**< */ - uint8_t pad1[12]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + uint8_t pad0[3]; + uint32_t state; + uint32_t stateChanged; + uint8_t pad1[12]; } xcb_xkb_indicator_state_notify_event_t; /** Opcode for xcb_xkb_indicator_map_notify. */ @@ -2895,15 +2895,15 @@ typedef struct xcb_xkb_indicator_state_notify_event_t { * @brief xcb_xkb_indicator_map_notify_event_t **/ typedef struct xcb_xkb_indicator_map_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - uint8_t pad0[3]; /**< */ - uint32_t state; /**< */ - uint32_t mapChanged; /**< */ - uint8_t pad1[12]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + uint8_t pad0[3]; + uint32_t state; + uint32_t mapChanged; + uint8_t pad1[12]; } xcb_xkb_indicator_map_notify_event_t; /** Opcode for xcb_xkb_names_notify. */ @@ -2913,26 +2913,26 @@ typedef struct xcb_xkb_indicator_map_notify_event_t { * @brief xcb_xkb_names_notify_event_t **/ typedef struct xcb_xkb_names_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - uint8_t pad0; /**< */ - uint16_t changed; /**< */ - uint8_t firstType; /**< */ - uint8_t nTypes; /**< */ - uint8_t firstLevelName; /**< */ - uint8_t nLevelNames; /**< */ - uint8_t pad1; /**< */ - uint8_t nRadioGroups; /**< */ - uint8_t nKeyAliases; /**< */ - uint8_t changedGroupNames; /**< */ - uint16_t changedVirtualMods; /**< */ - xcb_keycode_t firstKey; /**< */ - uint8_t nKeys; /**< */ - uint32_t changedIndicators; /**< */ - uint8_t pad2[4]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + uint8_t pad0; + uint16_t changed; + uint8_t firstType; + uint8_t nTypes; + uint8_t firstLevelName; + uint8_t nLevelNames; + uint8_t pad1; + uint8_t nRadioGroups; + uint8_t nKeyAliases; + uint8_t changedGroupNames; + uint16_t changedVirtualMods; + xcb_keycode_t firstKey; + uint8_t nKeys; + uint32_t changedIndicators; + uint8_t pad2[4]; } xcb_xkb_names_notify_event_t; /** Opcode for xcb_xkb_compat_map_notify. */ @@ -2942,16 +2942,16 @@ typedef struct xcb_xkb_names_notify_event_t { * @brief xcb_xkb_compat_map_notify_event_t **/ typedef struct xcb_xkb_compat_map_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - uint8_t changedGroups; /**< */ - uint16_t firstSI; /**< */ - uint16_t nSI; /**< */ - uint16_t nTotalSI; /**< */ - uint8_t pad0[16]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + uint8_t changedGroups; + uint16_t firstSI; + uint16_t nSI; + uint16_t nTotalSI; + uint8_t pad0[16]; } xcb_xkb_compat_map_notify_event_t; /** Opcode for xcb_xkb_bell_notify. */ @@ -2961,20 +2961,20 @@ typedef struct xcb_xkb_compat_map_notify_event_t { * @brief xcb_xkb_bell_notify_event_t **/ typedef struct xcb_xkb_bell_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - uint8_t bellClass; /**< */ - uint8_t bellID; /**< */ - uint8_t percent; /**< */ - uint16_t pitch; /**< */ - uint16_t duration; /**< */ - xcb_atom_t name; /**< */ - xcb_window_t window; /**< */ - uint8_t eventOnly; /**< */ - uint8_t pad0[7]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + uint8_t bellClass; + uint8_t bellID; + uint8_t percent; + uint16_t pitch; + uint16_t duration; + xcb_atom_t name; + xcb_window_t window; + uint8_t eventOnly; + uint8_t pad0[7]; } xcb_xkb_bell_notify_event_t; /** Opcode for xcb_xkb_action_message. */ @@ -2984,18 +2984,18 @@ typedef struct xcb_xkb_bell_notify_event_t { * @brief xcb_xkb_action_message_event_t **/ typedef struct xcb_xkb_action_message_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - xcb_keycode_t keycode; /**< */ - uint8_t press; /**< */ - uint8_t keyEventFollows; /**< */ - uint8_t mods; /**< */ - uint8_t group; /**< */ - xcb_xkb_string8_t message[8]; /**< */ - uint8_t pad0[10]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + xcb_keycode_t keycode; + uint8_t press; + uint8_t keyEventFollows; + uint8_t mods; + uint8_t group; + xcb_xkb_string8_t message[8]; + uint8_t pad0[10]; } xcb_xkb_action_message_event_t; /** Opcode for xcb_xkb_access_x_notify. */ @@ -3005,16 +3005,16 @@ typedef struct xcb_xkb_action_message_event_t { * @brief xcb_xkb_access_x_notify_event_t **/ typedef struct xcb_xkb_access_x_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - xcb_keycode_t keycode; /**< */ - uint16_t detailt; /**< */ - uint16_t slowKeysDelay; /**< */ - uint16_t debounceDelay; /**< */ - uint8_t pad0[16]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + xcb_keycode_t keycode; + uint16_t detailt; + uint16_t slowKeysDelay; + uint16_t debounceDelay; + uint8_t pad0[16]; } xcb_xkb_access_x_notify_event_t; /** Opcode for xcb_xkb_extension_device_notify. */ @@ -3024,22 +3024,22 @@ typedef struct xcb_xkb_access_x_notify_event_t { * @brief xcb_xkb_extension_device_notify_event_t **/ typedef struct xcb_xkb_extension_device_notify_event_t { - uint8_t response_type; /**< */ - uint8_t xkbType; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t deviceID; /**< */ - uint8_t pad0; /**< */ - uint16_t reason; /**< */ - uint16_t ledClass; /**< */ - uint16_t ledID; /**< */ - uint32_t ledsDefined; /**< */ - uint32_t ledState; /**< */ - uint8_t firstButton; /**< */ - uint8_t nButtons; /**< */ - uint16_t supported; /**< */ - uint16_t unsupported; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t response_type; + uint8_t xkbType; + uint16_t sequence; + xcb_timestamp_t time; + uint8_t deviceID; + uint8_t pad0; + uint16_t reason; + uint16_t ledClass; + uint16_t ledID; + uint32_t ledsDefined; + uint32_t ledState; + uint8_t firstButton; + uint8_t nButtons; + uint16_t supported; + uint16_t unsupported; + uint8_t pad1[2]; } xcb_xkb_extension_device_notify_event_t; /** @@ -3051,7 +3051,7 @@ typedef struct xcb_xkb_extension_device_notify_event_t { * element. The member index is increased by sizeof(xcb_xkb_device_spec_t) */ void -xcb_xkb_device_spec_next (xcb_xkb_device_spec_iterator_t *i /**< */); +xcb_xkb_device_spec_next (xcb_xkb_device_spec_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3063,7 +3063,7 @@ xcb_xkb_device_spec_next (xcb_xkb_device_spec_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_device_spec_end (xcb_xkb_device_spec_iterator_t i /**< */); +xcb_xkb_device_spec_end (xcb_xkb_device_spec_iterator_t i); /** * Get the next element of the iterator @@ -3074,7 +3074,7 @@ xcb_xkb_device_spec_end (xcb_xkb_device_spec_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_led_class_spec_t) */ void -xcb_xkb_led_class_spec_next (xcb_xkb_led_class_spec_iterator_t *i /**< */); +xcb_xkb_led_class_spec_next (xcb_xkb_led_class_spec_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3086,7 +3086,7 @@ xcb_xkb_led_class_spec_next (xcb_xkb_led_class_spec_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_led_class_spec_end (xcb_xkb_led_class_spec_iterator_t i /**< */); +xcb_xkb_led_class_spec_end (xcb_xkb_led_class_spec_iterator_t i); /** * Get the next element of the iterator @@ -3097,7 +3097,7 @@ xcb_xkb_led_class_spec_end (xcb_xkb_led_class_spec_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_bell_class_spec_t) */ void -xcb_xkb_bell_class_spec_next (xcb_xkb_bell_class_spec_iterator_t *i /**< */); +xcb_xkb_bell_class_spec_next (xcb_xkb_bell_class_spec_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3109,7 +3109,7 @@ xcb_xkb_bell_class_spec_next (xcb_xkb_bell_class_spec_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_bell_class_spec_end (xcb_xkb_bell_class_spec_iterator_t i /**< */); +xcb_xkb_bell_class_spec_end (xcb_xkb_bell_class_spec_iterator_t i); /** * Get the next element of the iterator @@ -3120,7 +3120,7 @@ xcb_xkb_bell_class_spec_end (xcb_xkb_bell_class_spec_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_id_spec_t) */ void -xcb_xkb_id_spec_next (xcb_xkb_id_spec_iterator_t *i /**< */); +xcb_xkb_id_spec_next (xcb_xkb_id_spec_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3132,7 +3132,7 @@ xcb_xkb_id_spec_next (xcb_xkb_id_spec_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_id_spec_end (xcb_xkb_id_spec_iterator_t i /**< */); +xcb_xkb_id_spec_end (xcb_xkb_id_spec_iterator_t i); /** * Get the next element of the iterator @@ -3143,7 +3143,7 @@ xcb_xkb_id_spec_end (xcb_xkb_id_spec_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_indicator_map_t) */ void -xcb_xkb_indicator_map_next (xcb_xkb_indicator_map_iterator_t *i /**< */); +xcb_xkb_indicator_map_next (xcb_xkb_indicator_map_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3155,7 +3155,7 @@ xcb_xkb_indicator_map_next (xcb_xkb_indicator_map_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_indicator_map_end (xcb_xkb_indicator_map_iterator_t i /**< */); +xcb_xkb_indicator_map_end (xcb_xkb_indicator_map_iterator_t i); /** * Get the next element of the iterator @@ -3166,7 +3166,7 @@ xcb_xkb_indicator_map_end (xcb_xkb_indicator_map_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_mod_def_t) */ void -xcb_xkb_mod_def_next (xcb_xkb_mod_def_iterator_t *i /**< */); +xcb_xkb_mod_def_next (xcb_xkb_mod_def_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3178,7 +3178,7 @@ xcb_xkb_mod_def_next (xcb_xkb_mod_def_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_mod_def_end (xcb_xkb_mod_def_iterator_t i /**< */); +xcb_xkb_mod_def_end (xcb_xkb_mod_def_iterator_t i); /** * Get the next element of the iterator @@ -3189,7 +3189,7 @@ xcb_xkb_mod_def_end (xcb_xkb_mod_def_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_key_name_t) */ void -xcb_xkb_key_name_next (xcb_xkb_key_name_iterator_t *i /**< */); +xcb_xkb_key_name_next (xcb_xkb_key_name_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3201,7 +3201,7 @@ xcb_xkb_key_name_next (xcb_xkb_key_name_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_key_name_end (xcb_xkb_key_name_iterator_t i /**< */); +xcb_xkb_key_name_end (xcb_xkb_key_name_iterator_t i); /** * Get the next element of the iterator @@ -3212,7 +3212,7 @@ xcb_xkb_key_name_end (xcb_xkb_key_name_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_key_alias_t) */ void -xcb_xkb_key_alias_next (xcb_xkb_key_alias_iterator_t *i /**< */); +xcb_xkb_key_alias_next (xcb_xkb_key_alias_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3224,28 +3224,28 @@ xcb_xkb_key_alias_next (xcb_xkb_key_alias_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_key_alias_end (xcb_xkb_key_alias_iterator_t i /**< */); +xcb_xkb_key_alias_end (xcb_xkb_key_alias_iterator_t i); int -xcb_xkb_counted_string_16_sizeof (const void *_buffer /**< */); +xcb_xkb_counted_string_16_sizeof (const void *_buffer); char * -xcb_xkb_counted_string_16_string (const xcb_xkb_counted_string_16_t *R /**< */); +xcb_xkb_counted_string_16_string (const xcb_xkb_counted_string_16_t *R); int -xcb_xkb_counted_string_16_string_length (const xcb_xkb_counted_string_16_t *R /**< */); +xcb_xkb_counted_string_16_string_length (const xcb_xkb_counted_string_16_t *R); xcb_generic_iterator_t -xcb_xkb_counted_string_16_string_end (const xcb_xkb_counted_string_16_t *R /**< */); +xcb_xkb_counted_string_16_string_end (const xcb_xkb_counted_string_16_t *R); void * -xcb_xkb_counted_string_16_alignment_pad (const xcb_xkb_counted_string_16_t *R /**< */); +xcb_xkb_counted_string_16_alignment_pad (const xcb_xkb_counted_string_16_t *R); int -xcb_xkb_counted_string_16_alignment_pad_length (const xcb_xkb_counted_string_16_t *R /**< */); +xcb_xkb_counted_string_16_alignment_pad_length (const xcb_xkb_counted_string_16_t *R); xcb_generic_iterator_t -xcb_xkb_counted_string_16_alignment_pad_end (const xcb_xkb_counted_string_16_t *R /**< */); +xcb_xkb_counted_string_16_alignment_pad_end (const xcb_xkb_counted_string_16_t *R); /** * Get the next element of the iterator @@ -3256,7 +3256,7 @@ xcb_xkb_counted_string_16_alignment_pad_end (const xcb_xkb_counted_string_16_t * * element. The member index is increased by sizeof(xcb_xkb_counted_string_16_t) */ void -xcb_xkb_counted_string_16_next (xcb_xkb_counted_string_16_iterator_t *i /**< */); +xcb_xkb_counted_string_16_next (xcb_xkb_counted_string_16_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3268,7 +3268,7 @@ xcb_xkb_counted_string_16_next (xcb_xkb_counted_string_16_iterator_t *i /**< */ * last element. */ xcb_generic_iterator_t -xcb_xkb_counted_string_16_end (xcb_xkb_counted_string_16_iterator_t i /**< */); +xcb_xkb_counted_string_16_end (xcb_xkb_counted_string_16_iterator_t i); /** * Get the next element of the iterator @@ -3279,7 +3279,7 @@ xcb_xkb_counted_string_16_end (xcb_xkb_counted_string_16_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_kt_map_entry_t) */ void -xcb_xkb_kt_map_entry_next (xcb_xkb_kt_map_entry_iterator_t *i /**< */); +xcb_xkb_kt_map_entry_next (xcb_xkb_kt_map_entry_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3291,28 +3291,28 @@ xcb_xkb_kt_map_entry_next (xcb_xkb_kt_map_entry_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_kt_map_entry_end (xcb_xkb_kt_map_entry_iterator_t i /**< */); +xcb_xkb_kt_map_entry_end (xcb_xkb_kt_map_entry_iterator_t i); int -xcb_xkb_key_type_sizeof (const void *_buffer /**< */); +xcb_xkb_key_type_sizeof (const void *_buffer); xcb_xkb_kt_map_entry_t * -xcb_xkb_key_type_map (const xcb_xkb_key_type_t *R /**< */); +xcb_xkb_key_type_map (const xcb_xkb_key_type_t *R); int -xcb_xkb_key_type_map_length (const xcb_xkb_key_type_t *R /**< */); +xcb_xkb_key_type_map_length (const xcb_xkb_key_type_t *R); xcb_xkb_kt_map_entry_iterator_t -xcb_xkb_key_type_map_iterator (const xcb_xkb_key_type_t *R /**< */); +xcb_xkb_key_type_map_iterator (const xcb_xkb_key_type_t *R); xcb_xkb_mod_def_t * -xcb_xkb_key_type_preserve (const xcb_xkb_key_type_t *R /**< */); +xcb_xkb_key_type_preserve (const xcb_xkb_key_type_t *R); int -xcb_xkb_key_type_preserve_length (const xcb_xkb_key_type_t *R /**< */); +xcb_xkb_key_type_preserve_length (const xcb_xkb_key_type_t *R); xcb_xkb_mod_def_iterator_t -xcb_xkb_key_type_preserve_iterator (const xcb_xkb_key_type_t *R /**< */); +xcb_xkb_key_type_preserve_iterator (const xcb_xkb_key_type_t *R); /** * Get the next element of the iterator @@ -3323,7 +3323,7 @@ xcb_xkb_key_type_preserve_iterator (const xcb_xkb_key_type_t *R /**< */); * element. The member index is increased by sizeof(xcb_xkb_key_type_t) */ void -xcb_xkb_key_type_next (xcb_xkb_key_type_iterator_t *i /**< */); +xcb_xkb_key_type_next (xcb_xkb_key_type_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3335,19 +3335,19 @@ xcb_xkb_key_type_next (xcb_xkb_key_type_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_key_type_end (xcb_xkb_key_type_iterator_t i /**< */); +xcb_xkb_key_type_end (xcb_xkb_key_type_iterator_t i); int -xcb_xkb_key_sym_map_sizeof (const void *_buffer /**< */); +xcb_xkb_key_sym_map_sizeof (const void *_buffer); xcb_keysym_t * -xcb_xkb_key_sym_map_syms (const xcb_xkb_key_sym_map_t *R /**< */); +xcb_xkb_key_sym_map_syms (const xcb_xkb_key_sym_map_t *R); int -xcb_xkb_key_sym_map_syms_length (const xcb_xkb_key_sym_map_t *R /**< */); +xcb_xkb_key_sym_map_syms_length (const xcb_xkb_key_sym_map_t *R); xcb_generic_iterator_t -xcb_xkb_key_sym_map_syms_end (const xcb_xkb_key_sym_map_t *R /**< */); +xcb_xkb_key_sym_map_syms_end (const xcb_xkb_key_sym_map_t *R); /** * Get the next element of the iterator @@ -3358,7 +3358,7 @@ xcb_xkb_key_sym_map_syms_end (const xcb_xkb_key_sym_map_t *R /**< */); * element. The member index is increased by sizeof(xcb_xkb_key_sym_map_t) */ void -xcb_xkb_key_sym_map_next (xcb_xkb_key_sym_map_iterator_t *i /**< */); +xcb_xkb_key_sym_map_next (xcb_xkb_key_sym_map_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3370,7 +3370,7 @@ xcb_xkb_key_sym_map_next (xcb_xkb_key_sym_map_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_key_sym_map_end (xcb_xkb_key_sym_map_iterator_t i /**< */); +xcb_xkb_key_sym_map_end (xcb_xkb_key_sym_map_iterator_t i); /** * Get the next element of the iterator @@ -3381,7 +3381,7 @@ xcb_xkb_key_sym_map_end (xcb_xkb_key_sym_map_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_common_behavior_t) */ void -xcb_xkb_common_behavior_next (xcb_xkb_common_behavior_iterator_t *i /**< */); +xcb_xkb_common_behavior_next (xcb_xkb_common_behavior_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3393,7 +3393,7 @@ xcb_xkb_common_behavior_next (xcb_xkb_common_behavior_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_common_behavior_end (xcb_xkb_common_behavior_iterator_t i /**< */); +xcb_xkb_common_behavior_end (xcb_xkb_common_behavior_iterator_t i); /** * Get the next element of the iterator @@ -3404,7 +3404,7 @@ xcb_xkb_common_behavior_end (xcb_xkb_common_behavior_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_default_behavior_t) */ void -xcb_xkb_default_behavior_next (xcb_xkb_default_behavior_iterator_t *i /**< */); +xcb_xkb_default_behavior_next (xcb_xkb_default_behavior_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3416,7 +3416,7 @@ xcb_xkb_default_behavior_next (xcb_xkb_default_behavior_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_default_behavior_end (xcb_xkb_default_behavior_iterator_t i /**< */); +xcb_xkb_default_behavior_end (xcb_xkb_default_behavior_iterator_t i); /** * Get the next element of the iterator @@ -3427,7 +3427,7 @@ xcb_xkb_default_behavior_end (xcb_xkb_default_behavior_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_lock_behavior_t) */ void -xcb_xkb_lock_behavior_next (xcb_xkb_lock_behavior_iterator_t *i /**< */); +xcb_xkb_lock_behavior_next (xcb_xkb_lock_behavior_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3439,7 +3439,7 @@ xcb_xkb_lock_behavior_next (xcb_xkb_lock_behavior_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_lock_behavior_end (xcb_xkb_lock_behavior_iterator_t i /**< */); +xcb_xkb_lock_behavior_end (xcb_xkb_lock_behavior_iterator_t i); /** * Get the next element of the iterator @@ -3450,7 +3450,7 @@ xcb_xkb_lock_behavior_end (xcb_xkb_lock_behavior_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_radio_group_behavior_t) */ void -xcb_xkb_radio_group_behavior_next (xcb_xkb_radio_group_behavior_iterator_t *i /**< */); +xcb_xkb_radio_group_behavior_next (xcb_xkb_radio_group_behavior_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3462,7 +3462,7 @@ xcb_xkb_radio_group_behavior_next (xcb_xkb_radio_group_behavior_iterator_t *i / * last element. */ xcb_generic_iterator_t -xcb_xkb_radio_group_behavior_end (xcb_xkb_radio_group_behavior_iterator_t i /**< */); +xcb_xkb_radio_group_behavior_end (xcb_xkb_radio_group_behavior_iterator_t i); /** * Get the next element of the iterator @@ -3473,7 +3473,7 @@ xcb_xkb_radio_group_behavior_end (xcb_xkb_radio_group_behavior_iterator_t i /** * element. The member index is increased by sizeof(xcb_xkb_overlay_behavior_t) */ void -xcb_xkb_overlay_behavior_next (xcb_xkb_overlay_behavior_iterator_t *i /**< */); +xcb_xkb_overlay_behavior_next (xcb_xkb_overlay_behavior_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3485,7 +3485,7 @@ xcb_xkb_overlay_behavior_next (xcb_xkb_overlay_behavior_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_overlay_behavior_end (xcb_xkb_overlay_behavior_iterator_t i /**< */); +xcb_xkb_overlay_behavior_end (xcb_xkb_overlay_behavior_iterator_t i); /** * Get the next element of the iterator @@ -3496,7 +3496,7 @@ xcb_xkb_overlay_behavior_end (xcb_xkb_overlay_behavior_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_permament_lock_behavior_t) */ void -xcb_xkb_permament_lock_behavior_next (xcb_xkb_permament_lock_behavior_iterator_t *i /**< */); +xcb_xkb_permament_lock_behavior_next (xcb_xkb_permament_lock_behavior_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3508,7 +3508,7 @@ xcb_xkb_permament_lock_behavior_next (xcb_xkb_permament_lock_behavior_iterator_t * last element. */ xcb_generic_iterator_t -xcb_xkb_permament_lock_behavior_end (xcb_xkb_permament_lock_behavior_iterator_t i /**< */); +xcb_xkb_permament_lock_behavior_end (xcb_xkb_permament_lock_behavior_iterator_t i); /** * Get the next element of the iterator @@ -3519,7 +3519,7 @@ xcb_xkb_permament_lock_behavior_end (xcb_xkb_permament_lock_behavior_iterator_t * element. The member index is increased by sizeof(xcb_xkb_permament_radio_group_behavior_t) */ void -xcb_xkb_permament_radio_group_behavior_next (xcb_xkb_permament_radio_group_behavior_iterator_t *i /**< */); +xcb_xkb_permament_radio_group_behavior_next (xcb_xkb_permament_radio_group_behavior_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3531,7 +3531,7 @@ xcb_xkb_permament_radio_group_behavior_next (xcb_xkb_permament_radio_group_behav * last element. */ xcb_generic_iterator_t -xcb_xkb_permament_radio_group_behavior_end (xcb_xkb_permament_radio_group_behavior_iterator_t i /**< */); +xcb_xkb_permament_radio_group_behavior_end (xcb_xkb_permament_radio_group_behavior_iterator_t i); /** * Get the next element of the iterator @@ -3542,7 +3542,7 @@ xcb_xkb_permament_radio_group_behavior_end (xcb_xkb_permament_radio_group_behavi * element. The member index is increased by sizeof(xcb_xkb_permament_overlay_behavior_t) */ void -xcb_xkb_permament_overlay_behavior_next (xcb_xkb_permament_overlay_behavior_iterator_t *i /**< */); +xcb_xkb_permament_overlay_behavior_next (xcb_xkb_permament_overlay_behavior_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3554,7 +3554,7 @@ xcb_xkb_permament_overlay_behavior_next (xcb_xkb_permament_overlay_behavior_iter * last element. */ xcb_generic_iterator_t -xcb_xkb_permament_overlay_behavior_end (xcb_xkb_permament_overlay_behavior_iterator_t i /**< */); +xcb_xkb_permament_overlay_behavior_end (xcb_xkb_permament_overlay_behavior_iterator_t i); /** * Get the next element of the iterator @@ -3565,7 +3565,7 @@ xcb_xkb_permament_overlay_behavior_end (xcb_xkb_permament_overlay_behavior_itera * element. The member index is increased by sizeof(xcb_xkb_behavior_t) */ void -xcb_xkb_behavior_next (xcb_xkb_behavior_iterator_t *i /**< */); +xcb_xkb_behavior_next (xcb_xkb_behavior_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3577,7 +3577,7 @@ xcb_xkb_behavior_next (xcb_xkb_behavior_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_behavior_end (xcb_xkb_behavior_iterator_t i /**< */); +xcb_xkb_behavior_end (xcb_xkb_behavior_iterator_t i); /** * Get the next element of the iterator @@ -3588,7 +3588,7 @@ xcb_xkb_behavior_end (xcb_xkb_behavior_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_set_behavior_t) */ void -xcb_xkb_set_behavior_next (xcb_xkb_set_behavior_iterator_t *i /**< */); +xcb_xkb_set_behavior_next (xcb_xkb_set_behavior_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3600,7 +3600,7 @@ xcb_xkb_set_behavior_next (xcb_xkb_set_behavior_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_set_behavior_end (xcb_xkb_set_behavior_iterator_t i /**< */); +xcb_xkb_set_behavior_end (xcb_xkb_set_behavior_iterator_t i); /** * Get the next element of the iterator @@ -3611,7 +3611,7 @@ xcb_xkb_set_behavior_end (xcb_xkb_set_behavior_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_set_explicit_t) */ void -xcb_xkb_set_explicit_next (xcb_xkb_set_explicit_iterator_t *i /**< */); +xcb_xkb_set_explicit_next (xcb_xkb_set_explicit_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3623,7 +3623,7 @@ xcb_xkb_set_explicit_next (xcb_xkb_set_explicit_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_set_explicit_end (xcb_xkb_set_explicit_iterator_t i /**< */); +xcb_xkb_set_explicit_end (xcb_xkb_set_explicit_iterator_t i); /** * Get the next element of the iterator @@ -3634,7 +3634,7 @@ xcb_xkb_set_explicit_end (xcb_xkb_set_explicit_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_key_mod_map_t) */ void -xcb_xkb_key_mod_map_next (xcb_xkb_key_mod_map_iterator_t *i /**< */); +xcb_xkb_key_mod_map_next (xcb_xkb_key_mod_map_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3646,7 +3646,7 @@ xcb_xkb_key_mod_map_next (xcb_xkb_key_mod_map_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_key_mod_map_end (xcb_xkb_key_mod_map_iterator_t i /**< */); +xcb_xkb_key_mod_map_end (xcb_xkb_key_mod_map_iterator_t i); /** * Get the next element of the iterator @@ -3657,7 +3657,7 @@ xcb_xkb_key_mod_map_end (xcb_xkb_key_mod_map_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_key_v_mod_map_t) */ void -xcb_xkb_key_v_mod_map_next (xcb_xkb_key_v_mod_map_iterator_t *i /**< */); +xcb_xkb_key_v_mod_map_next (xcb_xkb_key_v_mod_map_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3669,7 +3669,7 @@ xcb_xkb_key_v_mod_map_next (xcb_xkb_key_v_mod_map_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_key_v_mod_map_end (xcb_xkb_key_v_mod_map_iterator_t i /**< */); +xcb_xkb_key_v_mod_map_end (xcb_xkb_key_v_mod_map_iterator_t i); /** * Get the next element of the iterator @@ -3680,7 +3680,7 @@ xcb_xkb_key_v_mod_map_end (xcb_xkb_key_v_mod_map_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_kt_set_map_entry_t) */ void -xcb_xkb_kt_set_map_entry_next (xcb_xkb_kt_set_map_entry_iterator_t *i /**< */); +xcb_xkb_kt_set_map_entry_next (xcb_xkb_kt_set_map_entry_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3692,28 +3692,28 @@ xcb_xkb_kt_set_map_entry_next (xcb_xkb_kt_set_map_entry_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_kt_set_map_entry_end (xcb_xkb_kt_set_map_entry_iterator_t i /**< */); +xcb_xkb_kt_set_map_entry_end (xcb_xkb_kt_set_map_entry_iterator_t i); int -xcb_xkb_set_key_type_sizeof (const void *_buffer /**< */); +xcb_xkb_set_key_type_sizeof (const void *_buffer); xcb_xkb_kt_set_map_entry_t * -xcb_xkb_set_key_type_entries (const xcb_xkb_set_key_type_t *R /**< */); +xcb_xkb_set_key_type_entries (const xcb_xkb_set_key_type_t *R); int -xcb_xkb_set_key_type_entries_length (const xcb_xkb_set_key_type_t *R /**< */); +xcb_xkb_set_key_type_entries_length (const xcb_xkb_set_key_type_t *R); xcb_xkb_kt_set_map_entry_iterator_t -xcb_xkb_set_key_type_entries_iterator (const xcb_xkb_set_key_type_t *R /**< */); +xcb_xkb_set_key_type_entries_iterator (const xcb_xkb_set_key_type_t *R); xcb_xkb_kt_set_map_entry_t * -xcb_xkb_set_key_type_preserve_entries (const xcb_xkb_set_key_type_t *R /**< */); +xcb_xkb_set_key_type_preserve_entries (const xcb_xkb_set_key_type_t *R); int -xcb_xkb_set_key_type_preserve_entries_length (const xcb_xkb_set_key_type_t *R /**< */); +xcb_xkb_set_key_type_preserve_entries_length (const xcb_xkb_set_key_type_t *R); xcb_xkb_kt_set_map_entry_iterator_t -xcb_xkb_set_key_type_preserve_entries_iterator (const xcb_xkb_set_key_type_t *R /**< */); +xcb_xkb_set_key_type_preserve_entries_iterator (const xcb_xkb_set_key_type_t *R); /** * Get the next element of the iterator @@ -3724,7 +3724,7 @@ xcb_xkb_set_key_type_preserve_entries_iterator (const xcb_xkb_set_key_type_t *R * element. The member index is increased by sizeof(xcb_xkb_set_key_type_t) */ void -xcb_xkb_set_key_type_next (xcb_xkb_set_key_type_iterator_t *i /**< */); +xcb_xkb_set_key_type_next (xcb_xkb_set_key_type_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3736,7 +3736,7 @@ xcb_xkb_set_key_type_next (xcb_xkb_set_key_type_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_set_key_type_end (xcb_xkb_set_key_type_iterator_t i /**< */); +xcb_xkb_set_key_type_end (xcb_xkb_set_key_type_iterator_t i); /** * Get the next element of the iterator @@ -3747,7 +3747,7 @@ xcb_xkb_set_key_type_end (xcb_xkb_set_key_type_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_string8_t) */ void -xcb_xkb_string8_next (xcb_xkb_string8_iterator_t *i /**< */); +xcb_xkb_string8_next (xcb_xkb_string8_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3759,19 +3759,19 @@ xcb_xkb_string8_next (xcb_xkb_string8_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_string8_end (xcb_xkb_string8_iterator_t i /**< */); +xcb_xkb_string8_end (xcb_xkb_string8_iterator_t i); int -xcb_xkb_outline_sizeof (const void *_buffer /**< */); +xcb_xkb_outline_sizeof (const void *_buffer); xcb_point_t * -xcb_xkb_outline_points (const xcb_xkb_outline_t *R /**< */); +xcb_xkb_outline_points (const xcb_xkb_outline_t *R); int -xcb_xkb_outline_points_length (const xcb_xkb_outline_t *R /**< */); +xcb_xkb_outline_points_length (const xcb_xkb_outline_t *R); xcb_point_iterator_t -xcb_xkb_outline_points_iterator (const xcb_xkb_outline_t *R /**< */); +xcb_xkb_outline_points_iterator (const xcb_xkb_outline_t *R); /** * Get the next element of the iterator @@ -3782,7 +3782,7 @@ xcb_xkb_outline_points_iterator (const xcb_xkb_outline_t *R /**< */); * element. The member index is increased by sizeof(xcb_xkb_outline_t) */ void -xcb_xkb_outline_next (xcb_xkb_outline_iterator_t *i /**< */); +xcb_xkb_outline_next (xcb_xkb_outline_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3794,16 +3794,16 @@ xcb_xkb_outline_next (xcb_xkb_outline_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_outline_end (xcb_xkb_outline_iterator_t i /**< */); +xcb_xkb_outline_end (xcb_xkb_outline_iterator_t i); int -xcb_xkb_shape_sizeof (const void *_buffer /**< */); +xcb_xkb_shape_sizeof (const void *_buffer); int -xcb_xkb_shape_outlines_length (const xcb_xkb_shape_t *R /**< */); +xcb_xkb_shape_outlines_length (const xcb_xkb_shape_t *R); xcb_xkb_outline_iterator_t -xcb_xkb_shape_outlines_iterator (const xcb_xkb_shape_t *R /**< */); +xcb_xkb_shape_outlines_iterator (const xcb_xkb_shape_t *R); /** * Get the next element of the iterator @@ -3814,7 +3814,7 @@ xcb_xkb_shape_outlines_iterator (const xcb_xkb_shape_t *R /**< */); * element. The member index is increased by sizeof(xcb_xkb_shape_t) */ void -xcb_xkb_shape_next (xcb_xkb_shape_iterator_t *i /**< */); +xcb_xkb_shape_next (xcb_xkb_shape_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3826,7 +3826,7 @@ xcb_xkb_shape_next (xcb_xkb_shape_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_shape_end (xcb_xkb_shape_iterator_t i /**< */); +xcb_xkb_shape_end (xcb_xkb_shape_iterator_t i); /** * Get the next element of the iterator @@ -3837,7 +3837,7 @@ xcb_xkb_shape_end (xcb_xkb_shape_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_key_t) */ void -xcb_xkb_key_next (xcb_xkb_key_iterator_t *i /**< */); +xcb_xkb_key_next (xcb_xkb_key_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3849,7 +3849,7 @@ xcb_xkb_key_next (xcb_xkb_key_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_key_end (xcb_xkb_key_iterator_t i /**< */); +xcb_xkb_key_end (xcb_xkb_key_iterator_t i); /** * Get the next element of the iterator @@ -3860,7 +3860,7 @@ xcb_xkb_key_end (xcb_xkb_key_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_overlay_key_t) */ void -xcb_xkb_overlay_key_next (xcb_xkb_overlay_key_iterator_t *i /**< */); +xcb_xkb_overlay_key_next (xcb_xkb_overlay_key_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3872,19 +3872,19 @@ xcb_xkb_overlay_key_next (xcb_xkb_overlay_key_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_overlay_key_end (xcb_xkb_overlay_key_iterator_t i /**< */); +xcb_xkb_overlay_key_end (xcb_xkb_overlay_key_iterator_t i); int -xcb_xkb_overlay_row_sizeof (const void *_buffer /**< */); +xcb_xkb_overlay_row_sizeof (const void *_buffer); xcb_xkb_overlay_key_t * -xcb_xkb_overlay_row_keys (const xcb_xkb_overlay_row_t *R /**< */); +xcb_xkb_overlay_row_keys (const xcb_xkb_overlay_row_t *R); int -xcb_xkb_overlay_row_keys_length (const xcb_xkb_overlay_row_t *R /**< */); +xcb_xkb_overlay_row_keys_length (const xcb_xkb_overlay_row_t *R); xcb_xkb_overlay_key_iterator_t -xcb_xkb_overlay_row_keys_iterator (const xcb_xkb_overlay_row_t *R /**< */); +xcb_xkb_overlay_row_keys_iterator (const xcb_xkb_overlay_row_t *R); /** * Get the next element of the iterator @@ -3895,7 +3895,7 @@ xcb_xkb_overlay_row_keys_iterator (const xcb_xkb_overlay_row_t *R /**< */); * element. The member index is increased by sizeof(xcb_xkb_overlay_row_t) */ void -xcb_xkb_overlay_row_next (xcb_xkb_overlay_row_iterator_t *i /**< */); +xcb_xkb_overlay_row_next (xcb_xkb_overlay_row_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3907,16 +3907,16 @@ xcb_xkb_overlay_row_next (xcb_xkb_overlay_row_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_overlay_row_end (xcb_xkb_overlay_row_iterator_t i /**< */); +xcb_xkb_overlay_row_end (xcb_xkb_overlay_row_iterator_t i); int -xcb_xkb_overlay_sizeof (const void *_buffer /**< */); +xcb_xkb_overlay_sizeof (const void *_buffer); int -xcb_xkb_overlay_rows_length (const xcb_xkb_overlay_t *R /**< */); +xcb_xkb_overlay_rows_length (const xcb_xkb_overlay_t *R); xcb_xkb_overlay_row_iterator_t -xcb_xkb_overlay_rows_iterator (const xcb_xkb_overlay_t *R /**< */); +xcb_xkb_overlay_rows_iterator (const xcb_xkb_overlay_t *R); /** * Get the next element of the iterator @@ -3927,7 +3927,7 @@ xcb_xkb_overlay_rows_iterator (const xcb_xkb_overlay_t *R /**< */); * element. The member index is increased by sizeof(xcb_xkb_overlay_t) */ void -xcb_xkb_overlay_next (xcb_xkb_overlay_iterator_t *i /**< */); +xcb_xkb_overlay_next (xcb_xkb_overlay_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3939,19 +3939,19 @@ xcb_xkb_overlay_next (xcb_xkb_overlay_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_overlay_end (xcb_xkb_overlay_iterator_t i /**< */); +xcb_xkb_overlay_end (xcb_xkb_overlay_iterator_t i); int -xcb_xkb_row_sizeof (const void *_buffer /**< */); +xcb_xkb_row_sizeof (const void *_buffer); xcb_xkb_key_t * -xcb_xkb_row_keys (const xcb_xkb_row_t *R /**< */); +xcb_xkb_row_keys (const xcb_xkb_row_t *R); int -xcb_xkb_row_keys_length (const xcb_xkb_row_t *R /**< */); +xcb_xkb_row_keys_length (const xcb_xkb_row_t *R); xcb_xkb_key_iterator_t -xcb_xkb_row_keys_iterator (const xcb_xkb_row_t *R /**< */); +xcb_xkb_row_keys_iterator (const xcb_xkb_row_t *R); /** * Get the next element of the iterator @@ -3962,7 +3962,7 @@ xcb_xkb_row_keys_iterator (const xcb_xkb_row_t *R /**< */); * element. The member index is increased by sizeof(xcb_xkb_row_t) */ void -xcb_xkb_row_next (xcb_xkb_row_iterator_t *i /**< */); +xcb_xkb_row_next (xcb_xkb_row_iterator_t *i); /** * Return the iterator pointing to the last element @@ -3974,19 +3974,19 @@ xcb_xkb_row_next (xcb_xkb_row_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_row_end (xcb_xkb_row_iterator_t i /**< */); +xcb_xkb_row_end (xcb_xkb_row_iterator_t i); int -xcb_xkb_listing_sizeof (const void *_buffer /**< */); +xcb_xkb_listing_sizeof (const void *_buffer); xcb_xkb_string8_t * -xcb_xkb_listing_string (const xcb_xkb_listing_t *R /**< */); +xcb_xkb_listing_string (const xcb_xkb_listing_t *R); int -xcb_xkb_listing_string_length (const xcb_xkb_listing_t *R /**< */); +xcb_xkb_listing_string_length (const xcb_xkb_listing_t *R); xcb_generic_iterator_t -xcb_xkb_listing_string_end (const xcb_xkb_listing_t *R /**< */); +xcb_xkb_listing_string_end (const xcb_xkb_listing_t *R); /** * Get the next element of the iterator @@ -3997,7 +3997,7 @@ xcb_xkb_listing_string_end (const xcb_xkb_listing_t *R /**< */); * element. The member index is increased by sizeof(xcb_xkb_listing_t) */ void -xcb_xkb_listing_next (xcb_xkb_listing_iterator_t *i /**< */); +xcb_xkb_listing_next (xcb_xkb_listing_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4009,28 +4009,28 @@ xcb_xkb_listing_next (xcb_xkb_listing_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_listing_end (xcb_xkb_listing_iterator_t i /**< */); +xcb_xkb_listing_end (xcb_xkb_listing_iterator_t i); int -xcb_xkb_device_led_info_sizeof (const void *_buffer /**< */); +xcb_xkb_device_led_info_sizeof (const void *_buffer); xcb_atom_t * -xcb_xkb_device_led_info_names (const xcb_xkb_device_led_info_t *R /**< */); +xcb_xkb_device_led_info_names (const xcb_xkb_device_led_info_t *R); int -xcb_xkb_device_led_info_names_length (const xcb_xkb_device_led_info_t *R /**< */); +xcb_xkb_device_led_info_names_length (const xcb_xkb_device_led_info_t *R); xcb_generic_iterator_t -xcb_xkb_device_led_info_names_end (const xcb_xkb_device_led_info_t *R /**< */); +xcb_xkb_device_led_info_names_end (const xcb_xkb_device_led_info_t *R); xcb_xkb_indicator_map_t * -xcb_xkb_device_led_info_maps (const xcb_xkb_device_led_info_t *R /**< */); +xcb_xkb_device_led_info_maps (const xcb_xkb_device_led_info_t *R); int -xcb_xkb_device_led_info_maps_length (const xcb_xkb_device_led_info_t *R /**< */); +xcb_xkb_device_led_info_maps_length (const xcb_xkb_device_led_info_t *R); xcb_xkb_indicator_map_iterator_t -xcb_xkb_device_led_info_maps_iterator (const xcb_xkb_device_led_info_t *R /**< */); +xcb_xkb_device_led_info_maps_iterator (const xcb_xkb_device_led_info_t *R); /** * Get the next element of the iterator @@ -4041,7 +4041,7 @@ xcb_xkb_device_led_info_maps_iterator (const xcb_xkb_device_led_info_t *R /**< * element. The member index is increased by sizeof(xcb_xkb_device_led_info_t) */ void -xcb_xkb_device_led_info_next (xcb_xkb_device_led_info_iterator_t *i /**< */); +xcb_xkb_device_led_info_next (xcb_xkb_device_led_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4053,7 +4053,7 @@ xcb_xkb_device_led_info_next (xcb_xkb_device_led_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_device_led_info_end (xcb_xkb_device_led_info_iterator_t i /**< */); +xcb_xkb_device_led_info_end (xcb_xkb_device_led_info_iterator_t i); /** * Get the next element of the iterator @@ -4064,7 +4064,7 @@ xcb_xkb_device_led_info_end (xcb_xkb_device_led_info_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_no_action_t) */ void -xcb_xkb_sa_no_action_next (xcb_xkb_sa_no_action_iterator_t *i /**< */); +xcb_xkb_sa_no_action_next (xcb_xkb_sa_no_action_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4076,7 +4076,7 @@ xcb_xkb_sa_no_action_next (xcb_xkb_sa_no_action_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_no_action_end (xcb_xkb_sa_no_action_iterator_t i /**< */); +xcb_xkb_sa_no_action_end (xcb_xkb_sa_no_action_iterator_t i); /** * Get the next element of the iterator @@ -4087,7 +4087,7 @@ xcb_xkb_sa_no_action_end (xcb_xkb_sa_no_action_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_set_mods_t) */ void -xcb_xkb_sa_set_mods_next (xcb_xkb_sa_set_mods_iterator_t *i /**< */); +xcb_xkb_sa_set_mods_next (xcb_xkb_sa_set_mods_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4099,7 +4099,7 @@ xcb_xkb_sa_set_mods_next (xcb_xkb_sa_set_mods_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_set_mods_end (xcb_xkb_sa_set_mods_iterator_t i /**< */); +xcb_xkb_sa_set_mods_end (xcb_xkb_sa_set_mods_iterator_t i); /** * Get the next element of the iterator @@ -4110,7 +4110,7 @@ xcb_xkb_sa_set_mods_end (xcb_xkb_sa_set_mods_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_latch_mods_t) */ void -xcb_xkb_sa_latch_mods_next (xcb_xkb_sa_latch_mods_iterator_t *i /**< */); +xcb_xkb_sa_latch_mods_next (xcb_xkb_sa_latch_mods_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4122,7 +4122,7 @@ xcb_xkb_sa_latch_mods_next (xcb_xkb_sa_latch_mods_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_latch_mods_end (xcb_xkb_sa_latch_mods_iterator_t i /**< */); +xcb_xkb_sa_latch_mods_end (xcb_xkb_sa_latch_mods_iterator_t i); /** * Get the next element of the iterator @@ -4133,7 +4133,7 @@ xcb_xkb_sa_latch_mods_end (xcb_xkb_sa_latch_mods_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_lock_mods_t) */ void -xcb_xkb_sa_lock_mods_next (xcb_xkb_sa_lock_mods_iterator_t *i /**< */); +xcb_xkb_sa_lock_mods_next (xcb_xkb_sa_lock_mods_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4145,7 +4145,7 @@ xcb_xkb_sa_lock_mods_next (xcb_xkb_sa_lock_mods_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_lock_mods_end (xcb_xkb_sa_lock_mods_iterator_t i /**< */); +xcb_xkb_sa_lock_mods_end (xcb_xkb_sa_lock_mods_iterator_t i); /** * Get the next element of the iterator @@ -4156,7 +4156,7 @@ xcb_xkb_sa_lock_mods_end (xcb_xkb_sa_lock_mods_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_set_group_t) */ void -xcb_xkb_sa_set_group_next (xcb_xkb_sa_set_group_iterator_t *i /**< */); +xcb_xkb_sa_set_group_next (xcb_xkb_sa_set_group_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4168,7 +4168,7 @@ xcb_xkb_sa_set_group_next (xcb_xkb_sa_set_group_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_set_group_end (xcb_xkb_sa_set_group_iterator_t i /**< */); +xcb_xkb_sa_set_group_end (xcb_xkb_sa_set_group_iterator_t i); /** * Get the next element of the iterator @@ -4179,7 +4179,7 @@ xcb_xkb_sa_set_group_end (xcb_xkb_sa_set_group_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_latch_group_t) */ void -xcb_xkb_sa_latch_group_next (xcb_xkb_sa_latch_group_iterator_t *i /**< */); +xcb_xkb_sa_latch_group_next (xcb_xkb_sa_latch_group_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4191,7 +4191,7 @@ xcb_xkb_sa_latch_group_next (xcb_xkb_sa_latch_group_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_latch_group_end (xcb_xkb_sa_latch_group_iterator_t i /**< */); +xcb_xkb_sa_latch_group_end (xcb_xkb_sa_latch_group_iterator_t i); /** * Get the next element of the iterator @@ -4202,7 +4202,7 @@ xcb_xkb_sa_latch_group_end (xcb_xkb_sa_latch_group_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_lock_group_t) */ void -xcb_xkb_sa_lock_group_next (xcb_xkb_sa_lock_group_iterator_t *i /**< */); +xcb_xkb_sa_lock_group_next (xcb_xkb_sa_lock_group_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4214,7 +4214,7 @@ xcb_xkb_sa_lock_group_next (xcb_xkb_sa_lock_group_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_lock_group_end (xcb_xkb_sa_lock_group_iterator_t i /**< */); +xcb_xkb_sa_lock_group_end (xcb_xkb_sa_lock_group_iterator_t i); /** * Get the next element of the iterator @@ -4225,7 +4225,7 @@ xcb_xkb_sa_lock_group_end (xcb_xkb_sa_lock_group_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_move_ptr_t) */ void -xcb_xkb_sa_move_ptr_next (xcb_xkb_sa_move_ptr_iterator_t *i /**< */); +xcb_xkb_sa_move_ptr_next (xcb_xkb_sa_move_ptr_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4237,7 +4237,7 @@ xcb_xkb_sa_move_ptr_next (xcb_xkb_sa_move_ptr_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_move_ptr_end (xcb_xkb_sa_move_ptr_iterator_t i /**< */); +xcb_xkb_sa_move_ptr_end (xcb_xkb_sa_move_ptr_iterator_t i); /** * Get the next element of the iterator @@ -4248,7 +4248,7 @@ xcb_xkb_sa_move_ptr_end (xcb_xkb_sa_move_ptr_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_ptr_btn_t) */ void -xcb_xkb_sa_ptr_btn_next (xcb_xkb_sa_ptr_btn_iterator_t *i /**< */); +xcb_xkb_sa_ptr_btn_next (xcb_xkb_sa_ptr_btn_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4260,7 +4260,7 @@ xcb_xkb_sa_ptr_btn_next (xcb_xkb_sa_ptr_btn_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_ptr_btn_end (xcb_xkb_sa_ptr_btn_iterator_t i /**< */); +xcb_xkb_sa_ptr_btn_end (xcb_xkb_sa_ptr_btn_iterator_t i); /** * Get the next element of the iterator @@ -4271,7 +4271,7 @@ xcb_xkb_sa_ptr_btn_end (xcb_xkb_sa_ptr_btn_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_lock_ptr_btn_t) */ void -xcb_xkb_sa_lock_ptr_btn_next (xcb_xkb_sa_lock_ptr_btn_iterator_t *i /**< */); +xcb_xkb_sa_lock_ptr_btn_next (xcb_xkb_sa_lock_ptr_btn_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4283,7 +4283,7 @@ xcb_xkb_sa_lock_ptr_btn_next (xcb_xkb_sa_lock_ptr_btn_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_lock_ptr_btn_end (xcb_xkb_sa_lock_ptr_btn_iterator_t i /**< */); +xcb_xkb_sa_lock_ptr_btn_end (xcb_xkb_sa_lock_ptr_btn_iterator_t i); /** * Get the next element of the iterator @@ -4294,7 +4294,7 @@ xcb_xkb_sa_lock_ptr_btn_end (xcb_xkb_sa_lock_ptr_btn_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_set_ptr_dflt_t) */ void -xcb_xkb_sa_set_ptr_dflt_next (xcb_xkb_sa_set_ptr_dflt_iterator_t *i /**< */); +xcb_xkb_sa_set_ptr_dflt_next (xcb_xkb_sa_set_ptr_dflt_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4306,7 +4306,7 @@ xcb_xkb_sa_set_ptr_dflt_next (xcb_xkb_sa_set_ptr_dflt_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_set_ptr_dflt_end (xcb_xkb_sa_set_ptr_dflt_iterator_t i /**< */); +xcb_xkb_sa_set_ptr_dflt_end (xcb_xkb_sa_set_ptr_dflt_iterator_t i); /** * Get the next element of the iterator @@ -4317,7 +4317,7 @@ xcb_xkb_sa_set_ptr_dflt_end (xcb_xkb_sa_set_ptr_dflt_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_iso_lock_t) */ void -xcb_xkb_sa_iso_lock_next (xcb_xkb_sa_iso_lock_iterator_t *i /**< */); +xcb_xkb_sa_iso_lock_next (xcb_xkb_sa_iso_lock_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4329,7 +4329,7 @@ xcb_xkb_sa_iso_lock_next (xcb_xkb_sa_iso_lock_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_iso_lock_end (xcb_xkb_sa_iso_lock_iterator_t i /**< */); +xcb_xkb_sa_iso_lock_end (xcb_xkb_sa_iso_lock_iterator_t i); /** * Get the next element of the iterator @@ -4340,7 +4340,7 @@ xcb_xkb_sa_iso_lock_end (xcb_xkb_sa_iso_lock_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_terminate_t) */ void -xcb_xkb_sa_terminate_next (xcb_xkb_sa_terminate_iterator_t *i /**< */); +xcb_xkb_sa_terminate_next (xcb_xkb_sa_terminate_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4352,7 +4352,7 @@ xcb_xkb_sa_terminate_next (xcb_xkb_sa_terminate_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_terminate_end (xcb_xkb_sa_terminate_iterator_t i /**< */); +xcb_xkb_sa_terminate_end (xcb_xkb_sa_terminate_iterator_t i); /** * Get the next element of the iterator @@ -4363,7 +4363,7 @@ xcb_xkb_sa_terminate_end (xcb_xkb_sa_terminate_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_switch_screen_t) */ void -xcb_xkb_sa_switch_screen_next (xcb_xkb_sa_switch_screen_iterator_t *i /**< */); +xcb_xkb_sa_switch_screen_next (xcb_xkb_sa_switch_screen_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4375,7 +4375,7 @@ xcb_xkb_sa_switch_screen_next (xcb_xkb_sa_switch_screen_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_switch_screen_end (xcb_xkb_sa_switch_screen_iterator_t i /**< */); +xcb_xkb_sa_switch_screen_end (xcb_xkb_sa_switch_screen_iterator_t i); /** * Get the next element of the iterator @@ -4386,7 +4386,7 @@ xcb_xkb_sa_switch_screen_end (xcb_xkb_sa_switch_screen_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_set_controls_t) */ void -xcb_xkb_sa_set_controls_next (xcb_xkb_sa_set_controls_iterator_t *i /**< */); +xcb_xkb_sa_set_controls_next (xcb_xkb_sa_set_controls_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4398,7 +4398,7 @@ xcb_xkb_sa_set_controls_next (xcb_xkb_sa_set_controls_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_set_controls_end (xcb_xkb_sa_set_controls_iterator_t i /**< */); +xcb_xkb_sa_set_controls_end (xcb_xkb_sa_set_controls_iterator_t i); /** * Get the next element of the iterator @@ -4409,7 +4409,7 @@ xcb_xkb_sa_set_controls_end (xcb_xkb_sa_set_controls_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_lock_controls_t) */ void -xcb_xkb_sa_lock_controls_next (xcb_xkb_sa_lock_controls_iterator_t *i /**< */); +xcb_xkb_sa_lock_controls_next (xcb_xkb_sa_lock_controls_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4421,7 +4421,7 @@ xcb_xkb_sa_lock_controls_next (xcb_xkb_sa_lock_controls_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_lock_controls_end (xcb_xkb_sa_lock_controls_iterator_t i /**< */); +xcb_xkb_sa_lock_controls_end (xcb_xkb_sa_lock_controls_iterator_t i); /** * Get the next element of the iterator @@ -4432,7 +4432,7 @@ xcb_xkb_sa_lock_controls_end (xcb_xkb_sa_lock_controls_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_action_message_t) */ void -xcb_xkb_sa_action_message_next (xcb_xkb_sa_action_message_iterator_t *i /**< */); +xcb_xkb_sa_action_message_next (xcb_xkb_sa_action_message_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4444,7 +4444,7 @@ xcb_xkb_sa_action_message_next (xcb_xkb_sa_action_message_iterator_t *i /**< */ * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_action_message_end (xcb_xkb_sa_action_message_iterator_t i /**< */); +xcb_xkb_sa_action_message_end (xcb_xkb_sa_action_message_iterator_t i); /** * Get the next element of the iterator @@ -4455,7 +4455,7 @@ xcb_xkb_sa_action_message_end (xcb_xkb_sa_action_message_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_redirect_key_t) */ void -xcb_xkb_sa_redirect_key_next (xcb_xkb_sa_redirect_key_iterator_t *i /**< */); +xcb_xkb_sa_redirect_key_next (xcb_xkb_sa_redirect_key_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4467,7 +4467,7 @@ xcb_xkb_sa_redirect_key_next (xcb_xkb_sa_redirect_key_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_redirect_key_end (xcb_xkb_sa_redirect_key_iterator_t i /**< */); +xcb_xkb_sa_redirect_key_end (xcb_xkb_sa_redirect_key_iterator_t i); /** * Get the next element of the iterator @@ -4478,7 +4478,7 @@ xcb_xkb_sa_redirect_key_end (xcb_xkb_sa_redirect_key_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_device_btn_t) */ void -xcb_xkb_sa_device_btn_next (xcb_xkb_sa_device_btn_iterator_t *i /**< */); +xcb_xkb_sa_device_btn_next (xcb_xkb_sa_device_btn_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4490,7 +4490,7 @@ xcb_xkb_sa_device_btn_next (xcb_xkb_sa_device_btn_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_device_btn_end (xcb_xkb_sa_device_btn_iterator_t i /**< */); +xcb_xkb_sa_device_btn_end (xcb_xkb_sa_device_btn_iterator_t i); /** * Get the next element of the iterator @@ -4501,7 +4501,7 @@ xcb_xkb_sa_device_btn_end (xcb_xkb_sa_device_btn_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sa_lock_device_btn_t) */ void -xcb_xkb_sa_lock_device_btn_next (xcb_xkb_sa_lock_device_btn_iterator_t *i /**< */); +xcb_xkb_sa_lock_device_btn_next (xcb_xkb_sa_lock_device_btn_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4513,7 +4513,7 @@ xcb_xkb_sa_lock_device_btn_next (xcb_xkb_sa_lock_device_btn_iterator_t *i /**< * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_lock_device_btn_end (xcb_xkb_sa_lock_device_btn_iterator_t i /**< */); +xcb_xkb_sa_lock_device_btn_end (xcb_xkb_sa_lock_device_btn_iterator_t i); /** * Get the next element of the iterator @@ -4524,7 +4524,7 @@ xcb_xkb_sa_lock_device_btn_end (xcb_xkb_sa_lock_device_btn_iterator_t i /**< */ * element. The member index is increased by sizeof(xcb_xkb_sa_device_valuator_t) */ void -xcb_xkb_sa_device_valuator_next (xcb_xkb_sa_device_valuator_iterator_t *i /**< */); +xcb_xkb_sa_device_valuator_next (xcb_xkb_sa_device_valuator_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4536,7 +4536,7 @@ xcb_xkb_sa_device_valuator_next (xcb_xkb_sa_device_valuator_iterator_t *i /**< * last element. */ xcb_generic_iterator_t -xcb_xkb_sa_device_valuator_end (xcb_xkb_sa_device_valuator_iterator_t i /**< */); +xcb_xkb_sa_device_valuator_end (xcb_xkb_sa_device_valuator_iterator_t i); /** * Get the next element of the iterator @@ -4547,7 +4547,7 @@ xcb_xkb_sa_device_valuator_end (xcb_xkb_sa_device_valuator_iterator_t i /**< */ * element. The member index is increased by sizeof(xcb_xkb_si_action_t) */ void -xcb_xkb_si_action_next (xcb_xkb_si_action_iterator_t *i /**< */); +xcb_xkb_si_action_next (xcb_xkb_si_action_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4559,7 +4559,7 @@ xcb_xkb_si_action_next (xcb_xkb_si_action_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_si_action_end (xcb_xkb_si_action_iterator_t i /**< */); +xcb_xkb_si_action_end (xcb_xkb_si_action_iterator_t i); /** * Get the next element of the iterator @@ -4570,7 +4570,7 @@ xcb_xkb_si_action_end (xcb_xkb_si_action_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_sym_interpret_t) */ void -xcb_xkb_sym_interpret_next (xcb_xkb_sym_interpret_iterator_t *i /**< */); +xcb_xkb_sym_interpret_next (xcb_xkb_sym_interpret_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4582,7 +4582,7 @@ xcb_xkb_sym_interpret_next (xcb_xkb_sym_interpret_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_sym_interpret_end (xcb_xkb_sym_interpret_iterator_t i /**< */); +xcb_xkb_sym_interpret_end (xcb_xkb_sym_interpret_iterator_t i); /** * Get the next element of the iterator @@ -4593,7 +4593,7 @@ xcb_xkb_sym_interpret_end (xcb_xkb_sym_interpret_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xkb_action_t) */ void -xcb_xkb_action_next (xcb_xkb_action_iterator_t *i /**< */); +xcb_xkb_action_next (xcb_xkb_action_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4605,7 +4605,7 @@ xcb_xkb_action_next (xcb_xkb_action_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xkb_action_end (xcb_xkb_action_iterator_t i /**< */); +xcb_xkb_action_end (xcb_xkb_action_iterator_t i); /** * @@ -4616,9 +4616,9 @@ xcb_xkb_action_end (xcb_xkb_action_iterator_t i /**< */); * */ xcb_xkb_use_extension_cookie_t -xcb_xkb_use_extension (xcb_connection_t *c /**< */, - uint16_t wantedMajor /**< */, - uint16_t wantedMinor /**< */); +xcb_xkb_use_extension (xcb_connection_t *c, + uint16_t wantedMajor, + uint16_t wantedMinor); /** * @@ -4632,9 +4632,9 @@ xcb_xkb_use_extension (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_use_extension_cookie_t -xcb_xkb_use_extension_unchecked (xcb_connection_t *c /**< */, - uint16_t wantedMajor /**< */, - uint16_t wantedMinor /**< */); +xcb_xkb_use_extension_unchecked (xcb_connection_t *c, + uint16_t wantedMajor, + uint16_t wantedMinor); /** * Return the reply @@ -4651,29 +4651,32 @@ xcb_xkb_use_extension_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xkb_use_extension_reply_t * -xcb_xkb_use_extension_reply (xcb_connection_t *c /**< */, +xcb_xkb_use_extension_reply (xcb_connection_t *c, xcb_xkb_use_extension_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xkb_select_events_details_serialize (void **_buffer /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - const xcb_xkb_select_events_details_t *_aux /**< */); +xcb_xkb_select_events_details_serialize (void **_buffer, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + const xcb_xkb_select_events_details_t *_aux); int -xcb_xkb_select_events_details_unpack (const void *_buffer /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - xcb_xkb_select_events_details_t *_aux /**< */); +xcb_xkb_select_events_details_unpack (const void *_buffer, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + xcb_xkb_select_events_details_t *_aux); int -xcb_xkb_select_events_details_sizeof (const void *_buffer /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */); +xcb_xkb_select_events_details_sizeof (const void *_buffer, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll); + +int +xcb_xkb_select_events_sizeof (const void *_buffer); /** * @@ -4687,14 +4690,14 @@ xcb_xkb_select_events_details_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_select_events_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - uint16_t affectMap /**< */, - uint16_t map /**< */, - const void *details /**< */); +xcb_xkb_select_events_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + uint16_t affectMap, + uint16_t map, + const void *details); /** * @@ -4705,14 +4708,14 @@ xcb_xkb_select_events_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_select_events (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - uint16_t affectMap /**< */, - uint16_t map /**< */, - const void *details /**< */); +xcb_xkb_select_events (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + uint16_t affectMap, + uint16_t map, + const void *details); /** * @@ -4726,14 +4729,14 @@ xcb_xkb_select_events (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_select_events_aux_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - uint16_t affectMap /**< */, - uint16_t map /**< */, - const xcb_xkb_select_events_details_t *details /**< */); +xcb_xkb_select_events_aux_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + uint16_t affectMap, + uint16_t map, + const xcb_xkb_select_events_details_t *details); /** * @@ -4744,14 +4747,17 @@ xcb_xkb_select_events_aux_checked (xcb_connection_t *c /** * */ xcb_void_cookie_t -xcb_xkb_select_events_aux (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t affectWhich /**< */, - uint16_t clear /**< */, - uint16_t selectAll /**< */, - uint16_t affectMap /**< */, - uint16_t map /**< */, - const xcb_xkb_select_events_details_t *details /**< */); +xcb_xkb_select_events_aux (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t affectWhich, + uint16_t clear, + uint16_t selectAll, + uint16_t affectMap, + uint16_t map, + const xcb_xkb_select_events_details_t *details); + +void * +xcb_xkb_select_events_details (const xcb_xkb_select_events_request_t *R); /** * @@ -4765,17 +4771,17 @@ xcb_xkb_select_events_aux (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_bell_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_bell_class_spec_t bellClass /**< */, - xcb_xkb_id_spec_t bellID /**< */, - int8_t percent /**< */, - uint8_t forceSound /**< */, - uint8_t eventOnly /**< */, - int16_t pitch /**< */, - int16_t duration /**< */, - xcb_atom_t name /**< */, - xcb_window_t window /**< */); +xcb_xkb_bell_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_bell_class_spec_t bellClass, + xcb_xkb_id_spec_t bellID, + int8_t percent, + uint8_t forceSound, + uint8_t eventOnly, + int16_t pitch, + int16_t duration, + xcb_atom_t name, + xcb_window_t window); /** * @@ -4786,17 +4792,17 @@ xcb_xkb_bell_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_bell (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_bell_class_spec_t bellClass /**< */, - xcb_xkb_id_spec_t bellID /**< */, - int8_t percent /**< */, - uint8_t forceSound /**< */, - uint8_t eventOnly /**< */, - int16_t pitch /**< */, - int16_t duration /**< */, - xcb_atom_t name /**< */, - xcb_window_t window /**< */); +xcb_xkb_bell (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_bell_class_spec_t bellClass, + xcb_xkb_id_spec_t bellID, + int8_t percent, + uint8_t forceSound, + uint8_t eventOnly, + int16_t pitch, + int16_t duration, + xcb_atom_t name, + xcb_window_t window); /** * @@ -4807,8 +4813,8 @@ xcb_xkb_bell (xcb_connection_t *c /**< */, * */ xcb_xkb_get_state_cookie_t -xcb_xkb_get_state (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */); +xcb_xkb_get_state (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec); /** * @@ -4822,8 +4828,8 @@ xcb_xkb_get_state (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_get_state_cookie_t -xcb_xkb_get_state_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */); +xcb_xkb_get_state_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec); /** * Return the reply @@ -4840,9 +4846,9 @@ xcb_xkb_get_state_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xkb_get_state_reply_t * -xcb_xkb_get_state_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_state_reply (xcb_connection_t *c, xcb_xkb_get_state_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -4856,15 +4862,15 @@ xcb_xkb_get_state_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_latch_lock_state_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t affectModLocks /**< */, - uint8_t modLocks /**< */, - uint8_t lockGroup /**< */, - uint8_t groupLock /**< */, - uint8_t affectModLatches /**< */, - uint8_t latchGroup /**< */, - uint16_t groupLatch /**< */); +xcb_xkb_latch_lock_state_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t affectModLocks, + uint8_t modLocks, + uint8_t lockGroup, + uint8_t groupLock, + uint8_t affectModLatches, + uint8_t latchGroup, + uint16_t groupLatch); /** * @@ -4875,15 +4881,15 @@ xcb_xkb_latch_lock_state_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_latch_lock_state (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t affectModLocks /**< */, - uint8_t modLocks /**< */, - uint8_t lockGroup /**< */, - uint8_t groupLock /**< */, - uint8_t affectModLatches /**< */, - uint8_t latchGroup /**< */, - uint16_t groupLatch /**< */); +xcb_xkb_latch_lock_state (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t affectModLocks, + uint8_t modLocks, + uint8_t lockGroup, + uint8_t groupLock, + uint8_t affectModLatches, + uint8_t latchGroup, + uint16_t groupLatch); /** * @@ -4894,8 +4900,8 @@ xcb_xkb_latch_lock_state (xcb_connection_t *c /**< */, * */ xcb_xkb_get_controls_cookie_t -xcb_xkb_get_controls (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */); +xcb_xkb_get_controls (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec); /** * @@ -4909,8 +4915,8 @@ xcb_xkb_get_controls (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_get_controls_cookie_t -xcb_xkb_get_controls_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */); +xcb_xkb_get_controls_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec); /** * Return the reply @@ -4927,9 +4933,9 @@ xcb_xkb_get_controls_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xkb_get_controls_reply_t * -xcb_xkb_get_controls_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_controls_reply (xcb_connection_t *c, xcb_xkb_get_controls_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -4943,37 +4949,37 @@ xcb_xkb_get_controls_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_set_controls_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t affectInternalRealMods /**< */, - uint8_t internalRealMods /**< */, - uint8_t affectIgnoreLockRealMods /**< */, - uint8_t ignoreLockRealMods /**< */, - uint16_t affectInternalVirtualMods /**< */, - uint16_t internalVirtualMods /**< */, - uint16_t affectIgnoreLockVirtualMods /**< */, - uint16_t ignoreLockVirtualMods /**< */, - uint8_t mouseKeysDfltBtn /**< */, - uint8_t groupsWrap /**< */, - uint16_t accessXOptions /**< */, - uint32_t affectEnabledControls /**< */, - uint32_t enabledControls /**< */, - uint32_t changeControls /**< */, - uint16_t repeatDelay /**< */, - uint16_t repeatInterval /**< */, - uint16_t slowKeysDelay /**< */, - uint16_t debounceDelay /**< */, - uint16_t mouseKeysDelay /**< */, - uint16_t mouseKeysInterval /**< */, - uint16_t mouseKeysTimeToMax /**< */, - uint16_t mouseKeysMaxSpeed /**< */, - int16_t mouseKeysCurve /**< */, - uint16_t accessXTimeout /**< */, - uint32_t accessXTimeoutMask /**< */, - uint32_t accessXTimeoutValues /**< */, - uint16_t accessXTimeoutOptionsMask /**< */, - uint16_t accessXTimeoutOptionsValues /**< */, - const uint8_t *perKeyRepeat /**< */); +xcb_xkb_set_controls_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t affectInternalRealMods, + uint8_t internalRealMods, + uint8_t affectIgnoreLockRealMods, + uint8_t ignoreLockRealMods, + uint16_t affectInternalVirtualMods, + uint16_t internalVirtualMods, + uint16_t affectIgnoreLockVirtualMods, + uint16_t ignoreLockVirtualMods, + uint8_t mouseKeysDfltBtn, + uint8_t groupsWrap, + uint16_t accessXOptions, + uint32_t affectEnabledControls, + uint32_t enabledControls, + uint32_t changeControls, + uint16_t repeatDelay, + uint16_t repeatInterval, + uint16_t slowKeysDelay, + uint16_t debounceDelay, + uint16_t mouseKeysDelay, + uint16_t mouseKeysInterval, + uint16_t mouseKeysTimeToMax, + uint16_t mouseKeysMaxSpeed, + int16_t mouseKeysCurve, + uint16_t accessXTimeout, + uint32_t accessXTimeoutMask, + uint32_t accessXTimeoutValues, + uint16_t accessXTimeoutOptionsMask, + uint16_t accessXTimeoutOptionsValues, + const uint8_t *perKeyRepeat); /** * @@ -4984,171 +4990,174 @@ xcb_xkb_set_controls_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_set_controls (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t affectInternalRealMods /**< */, - uint8_t internalRealMods /**< */, - uint8_t affectIgnoreLockRealMods /**< */, - uint8_t ignoreLockRealMods /**< */, - uint16_t affectInternalVirtualMods /**< */, - uint16_t internalVirtualMods /**< */, - uint16_t affectIgnoreLockVirtualMods /**< */, - uint16_t ignoreLockVirtualMods /**< */, - uint8_t mouseKeysDfltBtn /**< */, - uint8_t groupsWrap /**< */, - uint16_t accessXOptions /**< */, - uint32_t affectEnabledControls /**< */, - uint32_t enabledControls /**< */, - uint32_t changeControls /**< */, - uint16_t repeatDelay /**< */, - uint16_t repeatInterval /**< */, - uint16_t slowKeysDelay /**< */, - uint16_t debounceDelay /**< */, - uint16_t mouseKeysDelay /**< */, - uint16_t mouseKeysInterval /**< */, - uint16_t mouseKeysTimeToMax /**< */, - uint16_t mouseKeysMaxSpeed /**< */, - int16_t mouseKeysCurve /**< */, - uint16_t accessXTimeout /**< */, - uint32_t accessXTimeoutMask /**< */, - uint32_t accessXTimeoutValues /**< */, - uint16_t accessXTimeoutOptionsMask /**< */, - uint16_t accessXTimeoutOptionsValues /**< */, - const uint8_t *perKeyRepeat /**< */); +xcb_xkb_set_controls (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t affectInternalRealMods, + uint8_t internalRealMods, + uint8_t affectIgnoreLockRealMods, + uint8_t ignoreLockRealMods, + uint16_t affectInternalVirtualMods, + uint16_t internalVirtualMods, + uint16_t affectIgnoreLockVirtualMods, + uint16_t ignoreLockVirtualMods, + uint8_t mouseKeysDfltBtn, + uint8_t groupsWrap, + uint16_t accessXOptions, + uint32_t affectEnabledControls, + uint32_t enabledControls, + uint32_t changeControls, + uint16_t repeatDelay, + uint16_t repeatInterval, + uint16_t slowKeysDelay, + uint16_t debounceDelay, + uint16_t mouseKeysDelay, + uint16_t mouseKeysInterval, + uint16_t mouseKeysTimeToMax, + uint16_t mouseKeysMaxSpeed, + int16_t mouseKeysCurve, + uint16_t accessXTimeout, + uint32_t accessXTimeoutMask, + uint32_t accessXTimeoutValues, + uint16_t accessXTimeoutOptionsMask, + uint16_t accessXTimeoutOptionsValues, + const uint8_t *perKeyRepeat); int -xcb_xkb_get_map_map_types_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_types_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_key_type_iterator_t -xcb_xkb_get_map_map_types_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_types_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); int -xcb_xkb_get_map_map_syms_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_syms_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_key_sym_map_iterator_t -xcb_xkb_get_map_map_syms_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_syms_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); uint8_t * -xcb_xkb_get_map_map_acts_rtrn_count (const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_acts_rtrn_count (const xcb_xkb_get_map_map_t *S); int -xcb_xkb_get_map_map_acts_rtrn_count_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_acts_rtrn_count_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_generic_iterator_t -xcb_xkb_get_map_map_acts_rtrn_count_end (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_acts_rtrn_count_end (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_action_t * -xcb_xkb_get_map_map_acts_rtrn_acts (const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_acts_rtrn_acts (const xcb_xkb_get_map_map_t *S); int -xcb_xkb_get_map_map_acts_rtrn_acts_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_acts_rtrn_acts_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_action_iterator_t -xcb_xkb_get_map_map_acts_rtrn_acts_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_acts_rtrn_acts_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_set_behavior_t * -xcb_xkb_get_map_map_behaviors_rtrn (const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_behaviors_rtrn (const xcb_xkb_get_map_map_t *S); int -xcb_xkb_get_map_map_behaviors_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_behaviors_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_set_behavior_iterator_t -xcb_xkb_get_map_map_behaviors_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_behaviors_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); uint8_t * -xcb_xkb_get_map_map_vmods_rtrn (const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_vmods_rtrn (const xcb_xkb_get_map_map_t *S); int -xcb_xkb_get_map_map_vmods_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_vmods_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_generic_iterator_t -xcb_xkb_get_map_map_vmods_rtrn_end (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_vmods_rtrn_end (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_set_explicit_t * -xcb_xkb_get_map_map_explicit_rtrn (const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_explicit_rtrn (const xcb_xkb_get_map_map_t *S); int -xcb_xkb_get_map_map_explicit_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_explicit_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_set_explicit_iterator_t -xcb_xkb_get_map_map_explicit_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_explicit_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_key_mod_map_t * -xcb_xkb_get_map_map_modmap_rtrn (const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_modmap_rtrn (const xcb_xkb_get_map_map_t *S); int -xcb_xkb_get_map_map_modmap_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_modmap_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_key_mod_map_iterator_t -xcb_xkb_get_map_map_modmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_modmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_key_v_mod_map_t * -xcb_xkb_get_map_map_vmodmap_rtrn (const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_vmodmap_rtrn (const xcb_xkb_get_map_map_t *S); int -xcb_xkb_get_map_map_vmodmap_rtrn_length (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_vmodmap_rtrn_length (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); xcb_xkb_key_v_mod_map_iterator_t -xcb_xkb_get_map_map_vmodmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R /**< */, - const xcb_xkb_get_map_map_t *S /**< */); +xcb_xkb_get_map_map_vmodmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R, + const xcb_xkb_get_map_map_t *S); int -xcb_xkb_get_map_map_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - const xcb_xkb_get_map_map_t *_aux /**< */); +xcb_xkb_get_map_map_serialize (void **_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + const xcb_xkb_get_map_map_t *_aux); int -xcb_xkb_get_map_map_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - xcb_xkb_get_map_map_t *_aux /**< */); +xcb_xkb_get_map_map_unpack (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + xcb_xkb_get_map_map_t *_aux); int -xcb_xkb_get_map_map_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */); +xcb_xkb_get_map_map_sizeof (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present); + +int +xcb_xkb_get_map_sizeof (const void *_buffer); /** * @@ -5159,25 +5168,25 @@ xcb_xkb_get_map_map_sizeof (const void *_buffer /**< */, * */ xcb_xkb_get_map_cookie_t -xcb_xkb_get_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t full /**< */, - uint16_t partial /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */); +xcb_xkb_get_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t full, + uint16_t partial, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint16_t virtualMods, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys); /** * @@ -5191,28 +5200,28 @@ xcb_xkb_get_map (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_get_map_cookie_t -xcb_xkb_get_map_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t full /**< */, - uint16_t partial /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */); +xcb_xkb_get_map_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t full, + uint16_t partial, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint16_t virtualMods, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys); void * -xcb_xkb_get_map_map (const xcb_xkb_get_map_reply_t *R /**< */); +xcb_xkb_get_map_map (const xcb_xkb_get_map_reply_t *R); /** * Return the reply @@ -5229,143 +5238,146 @@ xcb_xkb_get_map_map (const xcb_xkb_get_map_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_xkb_get_map_reply_t * -xcb_xkb_get_map_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_map_reply (xcb_connection_t *c, xcb_xkb_get_map_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xkb_set_map_values_types_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_types_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_set_key_type_iterator_t -xcb_xkb_set_map_values_types_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_types_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); int -xcb_xkb_set_map_values_syms_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_syms_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_key_sym_map_iterator_t -xcb_xkb_set_map_values_syms_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_syms_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); uint8_t * -xcb_xkb_set_map_values_actions_count (const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_actions_count (const xcb_xkb_set_map_values_t *S); int -xcb_xkb_set_map_values_actions_count_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_actions_count_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_generic_iterator_t -xcb_xkb_set_map_values_actions_count_end (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_actions_count_end (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_action_t * -xcb_xkb_set_map_values_actions (const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_actions (const xcb_xkb_set_map_values_t *S); int -xcb_xkb_set_map_values_actions_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_actions_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_action_iterator_t -xcb_xkb_set_map_values_actions_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_actions_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_set_behavior_t * -xcb_xkb_set_map_values_behaviors (const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_behaviors (const xcb_xkb_set_map_values_t *S); int -xcb_xkb_set_map_values_behaviors_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_behaviors_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_set_behavior_iterator_t -xcb_xkb_set_map_values_behaviors_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_behaviors_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); uint8_t * -xcb_xkb_set_map_values_vmods (const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_vmods (const xcb_xkb_set_map_values_t *S); int -xcb_xkb_set_map_values_vmods_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_vmods_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_generic_iterator_t -xcb_xkb_set_map_values_vmods_end (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_vmods_end (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_set_explicit_t * -xcb_xkb_set_map_values_explicit (const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_explicit (const xcb_xkb_set_map_values_t *S); int -xcb_xkb_set_map_values_explicit_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_explicit_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_set_explicit_iterator_t -xcb_xkb_set_map_values_explicit_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_explicit_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_key_mod_map_t * -xcb_xkb_set_map_values_modmap (const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_modmap (const xcb_xkb_set_map_values_t *S); int -xcb_xkb_set_map_values_modmap_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_modmap_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_key_mod_map_iterator_t -xcb_xkb_set_map_values_modmap_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_modmap_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_key_v_mod_map_t * -xcb_xkb_set_map_values_vmodmap (const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_vmodmap (const xcb_xkb_set_map_values_t *S); int -xcb_xkb_set_map_values_vmodmap_length (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_vmodmap_length (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); xcb_xkb_key_v_mod_map_iterator_t -xcb_xkb_set_map_values_vmodmap_iterator (const xcb_xkb_set_map_request_t *R /**< */, - const xcb_xkb_set_map_values_t *S /**< */); +xcb_xkb_set_map_values_vmodmap_iterator (const xcb_xkb_set_map_request_t *R, + const xcb_xkb_set_map_values_t *S); int -xcb_xkb_set_map_values_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - const xcb_xkb_set_map_values_t *_aux /**< */); +xcb_xkb_set_map_values_serialize (void **_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + const xcb_xkb_set_map_values_t *_aux); int -xcb_xkb_set_map_values_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - xcb_xkb_set_map_values_t *_aux /**< */); +xcb_xkb_set_map_values_unpack (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + xcb_xkb_set_map_values_t *_aux); int -xcb_xkb_set_map_values_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */); +xcb_xkb_set_map_values_sizeof (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present); + +int +xcb_xkb_set_map_sizeof (const void *_buffer); /** * @@ -5379,34 +5391,34 @@ xcb_xkb_set_map_values_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_set_map_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t present /**< */, - uint16_t flags /**< */, - xcb_keycode_t minKeyCode /**< */, - xcb_keycode_t maxKeyCode /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - uint16_t totalSyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint8_t totalKeyBehaviors /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - uint8_t totalKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - uint8_t totalModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t virtualMods /**< */, - const void *values /**< */); +xcb_xkb_set_map_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t present, + uint16_t flags, + xcb_keycode_t minKeyCode, + xcb_keycode_t maxKeyCode, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + uint16_t totalSyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + uint16_t totalActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint8_t totalKeyBehaviors, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + uint8_t totalKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + uint8_t totalModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys, + uint8_t totalVModMapKeys, + uint16_t virtualMods, + const void *values); /** * @@ -5417,34 +5429,34 @@ xcb_xkb_set_map_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_set_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t present /**< */, - uint16_t flags /**< */, - xcb_keycode_t minKeyCode /**< */, - xcb_keycode_t maxKeyCode /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - uint16_t totalSyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint8_t totalKeyBehaviors /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - uint8_t totalKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - uint8_t totalModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t virtualMods /**< */, - const void *values /**< */); +xcb_xkb_set_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t present, + uint16_t flags, + xcb_keycode_t minKeyCode, + xcb_keycode_t maxKeyCode, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + uint16_t totalSyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + uint16_t totalActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint8_t totalKeyBehaviors, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + uint8_t totalKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + uint8_t totalModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys, + uint8_t totalVModMapKeys, + uint16_t virtualMods, + const void *values); /** * @@ -5458,34 +5470,34 @@ xcb_xkb_set_map (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_set_map_aux_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t present /**< */, - uint16_t flags /**< */, - xcb_keycode_t minKeyCode /**< */, - xcb_keycode_t maxKeyCode /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - uint16_t totalSyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint8_t totalKeyBehaviors /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - uint8_t totalKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - uint8_t totalModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t virtualMods /**< */, - const xcb_xkb_set_map_values_t *values /**< */); +xcb_xkb_set_map_aux_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t present, + uint16_t flags, + xcb_keycode_t minKeyCode, + xcb_keycode_t maxKeyCode, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + uint16_t totalSyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + uint16_t totalActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint8_t totalKeyBehaviors, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + uint8_t totalKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + uint8_t totalModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys, + uint8_t totalVModMapKeys, + uint16_t virtualMods, + const xcb_xkb_set_map_values_t *values); /** * @@ -5496,37 +5508,40 @@ xcb_xkb_set_map_aux_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_set_map_aux (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t present /**< */, - uint16_t flags /**< */, - xcb_keycode_t minKeyCode /**< */, - xcb_keycode_t maxKeyCode /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - xcb_keycode_t firstKeySym /**< */, - uint8_t nKeySyms /**< */, - uint16_t totalSyms /**< */, - xcb_keycode_t firstKeyAction /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - xcb_keycode_t firstKeyBehavior /**< */, - uint8_t nKeyBehaviors /**< */, - uint8_t totalKeyBehaviors /**< */, - xcb_keycode_t firstKeyExplicit /**< */, - uint8_t nKeyExplicit /**< */, - uint8_t totalKeyExplicit /**< */, - xcb_keycode_t firstModMapKey /**< */, - uint8_t nModMapKeys /**< */, - uint8_t totalModMapKeys /**< */, - xcb_keycode_t firstVModMapKey /**< */, - uint8_t nVModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t virtualMods /**< */, - const xcb_xkb_set_map_values_t *values /**< */); +xcb_xkb_set_map_aux (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t present, + uint16_t flags, + xcb_keycode_t minKeyCode, + xcb_keycode_t maxKeyCode, + uint8_t firstType, + uint8_t nTypes, + xcb_keycode_t firstKeySym, + uint8_t nKeySyms, + uint16_t totalSyms, + xcb_keycode_t firstKeyAction, + uint8_t nKeyActions, + uint16_t totalActions, + xcb_keycode_t firstKeyBehavior, + uint8_t nKeyBehaviors, + uint8_t totalKeyBehaviors, + xcb_keycode_t firstKeyExplicit, + uint8_t nKeyExplicit, + uint8_t totalKeyExplicit, + xcb_keycode_t firstModMapKey, + uint8_t nModMapKeys, + uint8_t totalModMapKeys, + xcb_keycode_t firstVModMapKey, + uint8_t nVModMapKeys, + uint8_t totalVModMapKeys, + uint16_t virtualMods, + const xcb_xkb_set_map_values_t *values); + +void * +xcb_xkb_set_map_values (const xcb_xkb_set_map_request_t *R); int -xcb_xkb_get_compat_map_sizeof (const void *_buffer /**< */); +xcb_xkb_get_compat_map_sizeof (const void *_buffer); /** * @@ -5537,12 +5552,12 @@ xcb_xkb_get_compat_map_sizeof (const void *_buffer /**< */); * */ xcb_xkb_get_compat_map_cookie_t -xcb_xkb_get_compat_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t groups /**< */, - uint8_t getAllSI /**< */, - uint16_t firstSI /**< */, - uint16_t nSI /**< */); +xcb_xkb_get_compat_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t groups, + uint8_t getAllSI, + uint16_t firstSI, + uint16_t nSI); /** * @@ -5556,30 +5571,30 @@ xcb_xkb_get_compat_map (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_get_compat_map_cookie_t -xcb_xkb_get_compat_map_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t groups /**< */, - uint8_t getAllSI /**< */, - uint16_t firstSI /**< */, - uint16_t nSI /**< */); +xcb_xkb_get_compat_map_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t groups, + uint8_t getAllSI, + uint16_t firstSI, + uint16_t nSI); xcb_xkb_sym_interpret_t * -xcb_xkb_get_compat_map_si_rtrn (const xcb_xkb_get_compat_map_reply_t *R /**< */); +xcb_xkb_get_compat_map_si_rtrn (const xcb_xkb_get_compat_map_reply_t *R); int -xcb_xkb_get_compat_map_si_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R /**< */); +xcb_xkb_get_compat_map_si_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R); xcb_xkb_sym_interpret_iterator_t -xcb_xkb_get_compat_map_si_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R /**< */); +xcb_xkb_get_compat_map_si_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R); xcb_xkb_mod_def_t * -xcb_xkb_get_compat_map_group_rtrn (const xcb_xkb_get_compat_map_reply_t *R /**< */); +xcb_xkb_get_compat_map_group_rtrn (const xcb_xkb_get_compat_map_reply_t *R); int -xcb_xkb_get_compat_map_group_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R /**< */); +xcb_xkb_get_compat_map_group_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R); xcb_xkb_mod_def_iterator_t -xcb_xkb_get_compat_map_group_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R /**< */); +xcb_xkb_get_compat_map_group_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R); /** * Return the reply @@ -5596,12 +5611,12 @@ xcb_xkb_get_compat_map_group_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t * The returned value must be freed by the caller using free(). */ xcb_xkb_get_compat_map_reply_t * -xcb_xkb_get_compat_map_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_compat_map_reply (xcb_connection_t *c, xcb_xkb_get_compat_map_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xkb_set_compat_map_sizeof (const void *_buffer /**< */); +xcb_xkb_set_compat_map_sizeof (const void *_buffer); /** * @@ -5615,15 +5630,15 @@ xcb_xkb_set_compat_map_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_set_compat_map_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t recomputeActions /**< */, - uint8_t truncateSI /**< */, - uint8_t groups /**< */, - uint16_t firstSI /**< */, - uint16_t nSI /**< */, - const xcb_xkb_sym_interpret_t *si /**< */, - const xcb_xkb_mod_def_t *groupMaps /**< */); +xcb_xkb_set_compat_map_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t recomputeActions, + uint8_t truncateSI, + uint8_t groups, + uint16_t firstSI, + uint16_t nSI, + const xcb_xkb_sym_interpret_t *si, + const xcb_xkb_mod_def_t *groupMaps); /** * @@ -5634,15 +5649,33 @@ xcb_xkb_set_compat_map_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_set_compat_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t recomputeActions /**< */, - uint8_t truncateSI /**< */, - uint8_t groups /**< */, - uint16_t firstSI /**< */, - uint16_t nSI /**< */, - const xcb_xkb_sym_interpret_t *si /**< */, - const xcb_xkb_mod_def_t *groupMaps /**< */); +xcb_xkb_set_compat_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t recomputeActions, + uint8_t truncateSI, + uint8_t groups, + uint16_t firstSI, + uint16_t nSI, + const xcb_xkb_sym_interpret_t *si, + const xcb_xkb_mod_def_t *groupMaps); + +xcb_xkb_sym_interpret_t * +xcb_xkb_set_compat_map_si (const xcb_xkb_set_compat_map_request_t *R); + +int +xcb_xkb_set_compat_map_si_length (const xcb_xkb_set_compat_map_request_t *R); + +xcb_xkb_sym_interpret_iterator_t +xcb_xkb_set_compat_map_si_iterator (const xcb_xkb_set_compat_map_request_t *R); + +xcb_xkb_mod_def_t * +xcb_xkb_set_compat_map_group_maps (const xcb_xkb_set_compat_map_request_t *R); + +int +xcb_xkb_set_compat_map_group_maps_length (const xcb_xkb_set_compat_map_request_t *R); + +xcb_xkb_mod_def_iterator_t +xcb_xkb_set_compat_map_group_maps_iterator (const xcb_xkb_set_compat_map_request_t *R); /** * @@ -5653,8 +5686,8 @@ xcb_xkb_set_compat_map (xcb_connection_t *c /**< */, * */ xcb_xkb_get_indicator_state_cookie_t -xcb_xkb_get_indicator_state (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */); +xcb_xkb_get_indicator_state (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec); /** * @@ -5668,8 +5701,8 @@ xcb_xkb_get_indicator_state (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_get_indicator_state_cookie_t -xcb_xkb_get_indicator_state_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */); +xcb_xkb_get_indicator_state_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec); /** * Return the reply @@ -5686,12 +5719,12 @@ xcb_xkb_get_indicator_state_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xkb_get_indicator_state_reply_t * -xcb_xkb_get_indicator_state_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_indicator_state_reply (xcb_connection_t *c, xcb_xkb_get_indicator_state_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xkb_get_indicator_map_sizeof (const void *_buffer /**< */); +xcb_xkb_get_indicator_map_sizeof (const void *_buffer); /** * @@ -5702,9 +5735,9 @@ xcb_xkb_get_indicator_map_sizeof (const void *_buffer /**< */); * */ xcb_xkb_get_indicator_map_cookie_t -xcb_xkb_get_indicator_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */); +xcb_xkb_get_indicator_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which); /** * @@ -5718,18 +5751,18 @@ xcb_xkb_get_indicator_map (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_get_indicator_map_cookie_t -xcb_xkb_get_indicator_map_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */); +xcb_xkb_get_indicator_map_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which); xcb_xkb_indicator_map_t * -xcb_xkb_get_indicator_map_maps (const xcb_xkb_get_indicator_map_reply_t *R /**< */); +xcb_xkb_get_indicator_map_maps (const xcb_xkb_get_indicator_map_reply_t *R); int -xcb_xkb_get_indicator_map_maps_length (const xcb_xkb_get_indicator_map_reply_t *R /**< */); +xcb_xkb_get_indicator_map_maps_length (const xcb_xkb_get_indicator_map_reply_t *R); xcb_xkb_indicator_map_iterator_t -xcb_xkb_get_indicator_map_maps_iterator (const xcb_xkb_get_indicator_map_reply_t *R /**< */); +xcb_xkb_get_indicator_map_maps_iterator (const xcb_xkb_get_indicator_map_reply_t *R); /** * Return the reply @@ -5746,12 +5779,12 @@ xcb_xkb_get_indicator_map_maps_iterator (const xcb_xkb_get_indicator_map_reply_t * The returned value must be freed by the caller using free(). */ xcb_xkb_get_indicator_map_reply_t * -xcb_xkb_get_indicator_map_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_indicator_map_reply (xcb_connection_t *c, xcb_xkb_get_indicator_map_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xkb_set_indicator_map_sizeof (const void *_buffer /**< */); +xcb_xkb_set_indicator_map_sizeof (const void *_buffer); /** * @@ -5765,10 +5798,10 @@ xcb_xkb_set_indicator_map_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_set_indicator_map_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */, - const xcb_xkb_indicator_map_t *maps /**< */); +xcb_xkb_set_indicator_map_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which, + const xcb_xkb_indicator_map_t *maps); /** * @@ -5779,10 +5812,19 @@ xcb_xkb_set_indicator_map_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_set_indicator_map (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */, - const xcb_xkb_indicator_map_t *maps /**< */); +xcb_xkb_set_indicator_map (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which, + const xcb_xkb_indicator_map_t *maps); + +xcb_xkb_indicator_map_t * +xcb_xkb_set_indicator_map_maps (const xcb_xkb_set_indicator_map_request_t *R); + +int +xcb_xkb_set_indicator_map_maps_length (const xcb_xkb_set_indicator_map_request_t *R); + +xcb_xkb_indicator_map_iterator_t +xcb_xkb_set_indicator_map_maps_iterator (const xcb_xkb_set_indicator_map_request_t *R); /** * @@ -5793,11 +5835,11 @@ xcb_xkb_set_indicator_map (xcb_connection_t *c /**< */, * */ xcb_xkb_get_named_indicator_cookie_t -xcb_xkb_get_named_indicator (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */, - xcb_atom_t indicator /**< */); +xcb_xkb_get_named_indicator (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID, + xcb_atom_t indicator); /** * @@ -5811,11 +5853,11 @@ xcb_xkb_get_named_indicator (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_get_named_indicator_cookie_t -xcb_xkb_get_named_indicator_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */, - xcb_atom_t indicator /**< */); +xcb_xkb_get_named_indicator_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID, + xcb_atom_t indicator); /** * Return the reply @@ -5832,9 +5874,9 @@ xcb_xkb_get_named_indicator_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xkb_get_named_indicator_reply_t * -xcb_xkb_get_named_indicator_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_named_indicator_reply (xcb_connection_t *c, xcb_xkb_get_named_indicator_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -5848,22 +5890,22 @@ xcb_xkb_get_named_indicator_reply (xcb_connection_t *c /** * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_set_named_indicator_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */, - xcb_atom_t indicator /**< */, - uint8_t setState /**< */, - uint8_t on /**< */, - uint8_t setMap /**< */, - uint8_t createMap /**< */, - uint8_t map_flags /**< */, - uint8_t map_whichGroups /**< */, - uint8_t map_groups /**< */, - uint8_t map_whichMods /**< */, - uint8_t map_realMods /**< */, - uint16_t map_vmods /**< */, - uint32_t map_ctrls /**< */); +xcb_xkb_set_named_indicator_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID, + xcb_atom_t indicator, + uint8_t setState, + uint8_t on, + uint8_t setMap, + uint8_t createMap, + uint8_t map_flags, + uint8_t map_whichGroups, + uint8_t map_groups, + uint8_t map_whichMods, + uint8_t map_realMods, + uint16_t map_vmods, + uint32_t map_ctrls); /** * @@ -5874,167 +5916,159 @@ xcb_xkb_set_named_indicator_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_set_named_indicator (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */, - xcb_atom_t indicator /**< */, - uint8_t setState /**< */, - uint8_t on /**< */, - uint8_t setMap /**< */, - uint8_t createMap /**< */, - uint8_t map_flags /**< */, - uint8_t map_whichGroups /**< */, - uint8_t map_groups /**< */, - uint8_t map_whichMods /**< */, - uint8_t map_realMods /**< */, - uint16_t map_vmods /**< */, - uint32_t map_ctrls /**< */); +xcb_xkb_set_named_indicator (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID, + xcb_atom_t indicator, + uint8_t setState, + uint8_t on, + uint8_t setMap, + uint8_t createMap, + uint8_t map_flags, + uint8_t map_whichGroups, + uint8_t map_groups, + uint8_t map_whichMods, + uint8_t map_realMods, + uint16_t map_vmods, + uint32_t map_ctrls); xcb_atom_t * -xcb_xkb_get_names_value_list_type_names (const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_type_names (const xcb_xkb_get_names_value_list_t *S); int -xcb_xkb_get_names_value_list_type_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_type_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_generic_iterator_t -xcb_xkb_get_names_value_list_type_names_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_type_names_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); uint8_t * -xcb_xkb_get_names_value_list_n_levels_per_type (const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_n_levels_per_type (const xcb_xkb_get_names_value_list_t *S); int -xcb_xkb_get_names_value_list_n_levels_per_type_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_n_levels_per_type_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_generic_iterator_t -xcb_xkb_get_names_value_list_n_levels_per_type_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); - -uint8_t * -xcb_xkb_get_names_value_list_alignment_pad (const xcb_xkb_get_names_value_list_t *S /**< */); - -int -xcb_xkb_get_names_value_list_alignment_pad_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); - -xcb_generic_iterator_t -xcb_xkb_get_names_value_list_alignment_pad_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_n_levels_per_type_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_atom_t * -xcb_xkb_get_names_value_list_kt_level_names (const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_kt_level_names (const xcb_xkb_get_names_value_list_t *S); int -xcb_xkb_get_names_value_list_kt_level_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_kt_level_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_generic_iterator_t -xcb_xkb_get_names_value_list_kt_level_names_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_kt_level_names_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_atom_t * -xcb_xkb_get_names_value_list_indicator_names (const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_indicator_names (const xcb_xkb_get_names_value_list_t *S); int -xcb_xkb_get_names_value_list_indicator_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_indicator_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_generic_iterator_t -xcb_xkb_get_names_value_list_indicator_names_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_indicator_names_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_atom_t * -xcb_xkb_get_names_value_list_virtual_mod_names (const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_virtual_mod_names (const xcb_xkb_get_names_value_list_t *S); int -xcb_xkb_get_names_value_list_virtual_mod_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_virtual_mod_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_generic_iterator_t -xcb_xkb_get_names_value_list_virtual_mod_names_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_virtual_mod_names_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_atom_t * -xcb_xkb_get_names_value_list_groups (const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_groups (const xcb_xkb_get_names_value_list_t *S); int -xcb_xkb_get_names_value_list_groups_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_groups_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_generic_iterator_t -xcb_xkb_get_names_value_list_groups_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_groups_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_xkb_key_name_t * -xcb_xkb_get_names_value_list_key_names (const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_key_names (const xcb_xkb_get_names_value_list_t *S); int -xcb_xkb_get_names_value_list_key_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_key_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_xkb_key_name_iterator_t -xcb_xkb_get_names_value_list_key_names_iterator (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_key_names_iterator (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_xkb_key_alias_t * -xcb_xkb_get_names_value_list_key_aliases (const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_key_aliases (const xcb_xkb_get_names_value_list_t *S); int -xcb_xkb_get_names_value_list_key_aliases_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_key_aliases_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_xkb_key_alias_iterator_t -xcb_xkb_get_names_value_list_key_aliases_iterator (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_key_aliases_iterator (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_atom_t * -xcb_xkb_get_names_value_list_radio_group_names (const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_radio_group_names (const xcb_xkb_get_names_value_list_t *S); int -xcb_xkb_get_names_value_list_radio_group_names_length (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_radio_group_names_length (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); xcb_generic_iterator_t -xcb_xkb_get_names_value_list_radio_group_names_end (const xcb_xkb_get_names_reply_t *R /**< */, - const xcb_xkb_get_names_value_list_t *S /**< */); +xcb_xkb_get_names_value_list_radio_group_names_end (const xcb_xkb_get_names_reply_t *R, + const xcb_xkb_get_names_value_list_t *S); int -xcb_xkb_get_names_value_list_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - const xcb_xkb_get_names_value_list_t *_aux /**< */); +xcb_xkb_get_names_value_list_serialize (void **_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + const xcb_xkb_get_names_value_list_t *_aux); int -xcb_xkb_get_names_value_list_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - xcb_xkb_get_names_value_list_t *_aux /**< */); +xcb_xkb_get_names_value_list_unpack (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + xcb_xkb_get_names_value_list_t *_aux); int -xcb_xkb_get_names_value_list_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */); +xcb_xkb_get_names_value_list_sizeof (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which); + +int +xcb_xkb_get_names_sizeof (const void *_buffer); /** * @@ -6045,9 +6079,9 @@ xcb_xkb_get_names_value_list_sizeof (const void *_buffer /**< */, * */ xcb_xkb_get_names_cookie_t -xcb_xkb_get_names (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */); +xcb_xkb_get_names (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which); /** * @@ -6061,12 +6095,12 @@ xcb_xkb_get_names (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_get_names_cookie_t -xcb_xkb_get_names_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t which /**< */); +xcb_xkb_get_names_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t which); void * -xcb_xkb_get_names_value_list (const xcb_xkb_get_names_reply_t *R /**< */); +xcb_xkb_get_names_value_list (const xcb_xkb_get_names_reply_t *R); /** * Return the reply @@ -6083,143 +6117,146 @@ xcb_xkb_get_names_value_list (const xcb_xkb_get_names_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_xkb_get_names_reply_t * -xcb_xkb_get_names_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_names_reply (xcb_connection_t *c, xcb_xkb_get_names_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); xcb_atom_t * -xcb_xkb_set_names_values_type_names (const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_type_names (const xcb_xkb_set_names_values_t *S); int -xcb_xkb_set_names_values_type_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_type_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_generic_iterator_t -xcb_xkb_set_names_values_type_names_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_type_names_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); uint8_t * -xcb_xkb_set_names_values_n_levels_per_type (const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_n_levels_per_type (const xcb_xkb_set_names_values_t *S); int -xcb_xkb_set_names_values_n_levels_per_type_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_n_levels_per_type_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_generic_iterator_t -xcb_xkb_set_names_values_n_levels_per_type_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_n_levels_per_type_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_atom_t * -xcb_xkb_set_names_values_kt_level_names (const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_kt_level_names (const xcb_xkb_set_names_values_t *S); int -xcb_xkb_set_names_values_kt_level_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_kt_level_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_generic_iterator_t -xcb_xkb_set_names_values_kt_level_names_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_kt_level_names_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_atom_t * -xcb_xkb_set_names_values_indicator_names (const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_indicator_names (const xcb_xkb_set_names_values_t *S); int -xcb_xkb_set_names_values_indicator_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_indicator_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_generic_iterator_t -xcb_xkb_set_names_values_indicator_names_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_indicator_names_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_atom_t * -xcb_xkb_set_names_values_virtual_mod_names (const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_virtual_mod_names (const xcb_xkb_set_names_values_t *S); int -xcb_xkb_set_names_values_virtual_mod_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_virtual_mod_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_generic_iterator_t -xcb_xkb_set_names_values_virtual_mod_names_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_virtual_mod_names_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_atom_t * -xcb_xkb_set_names_values_groups (const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_groups (const xcb_xkb_set_names_values_t *S); int -xcb_xkb_set_names_values_groups_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_groups_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_generic_iterator_t -xcb_xkb_set_names_values_groups_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_groups_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_xkb_key_name_t * -xcb_xkb_set_names_values_key_names (const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_key_names (const xcb_xkb_set_names_values_t *S); int -xcb_xkb_set_names_values_key_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_key_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_xkb_key_name_iterator_t -xcb_xkb_set_names_values_key_names_iterator (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_key_names_iterator (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_xkb_key_alias_t * -xcb_xkb_set_names_values_key_aliases (const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_key_aliases (const xcb_xkb_set_names_values_t *S); int -xcb_xkb_set_names_values_key_aliases_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_key_aliases_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_xkb_key_alias_iterator_t -xcb_xkb_set_names_values_key_aliases_iterator (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_key_aliases_iterator (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_atom_t * -xcb_xkb_set_names_values_radio_group_names (const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_radio_group_names (const xcb_xkb_set_names_values_t *S); int -xcb_xkb_set_names_values_radio_group_names_length (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_radio_group_names_length (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); xcb_generic_iterator_t -xcb_xkb_set_names_values_radio_group_names_end (const xcb_xkb_set_names_request_t *R /**< */, - const xcb_xkb_set_names_values_t *S /**< */); +xcb_xkb_set_names_values_radio_group_names_end (const xcb_xkb_set_names_request_t *R, + const xcb_xkb_set_names_values_t *S); int -xcb_xkb_set_names_values_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - const xcb_xkb_set_names_values_t *_aux /**< */); +xcb_xkb_set_names_values_serialize (void **_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + const xcb_xkb_set_names_values_t *_aux); int -xcb_xkb_set_names_values_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - xcb_xkb_set_names_values_t *_aux /**< */); +xcb_xkb_set_names_values_unpack (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + xcb_xkb_set_names_values_t *_aux); int -xcb_xkb_set_names_values_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */); +xcb_xkb_set_names_values_sizeof (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which); + +int +xcb_xkb_set_names_sizeof (const void *_buffer); /** * @@ -6233,22 +6270,22 @@ xcb_xkb_set_names_values_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_set_names_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t virtualMods /**< */, - uint32_t which /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - uint8_t firstKTLevelt /**< */, - uint8_t nKTLevels /**< */, - uint32_t indicators /**< */, - uint8_t groupNames /**< */, - uint8_t nRadioGroups /**< */, - xcb_keycode_t firstKey /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint16_t totalKTLevelNames /**< */, - const void *values /**< */); +xcb_xkb_set_names_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t virtualMods, + uint32_t which, + uint8_t firstType, + uint8_t nTypes, + uint8_t firstKTLevelt, + uint8_t nKTLevels, + uint32_t indicators, + uint8_t groupNames, + uint8_t nRadioGroups, + xcb_keycode_t firstKey, + uint8_t nKeys, + uint8_t nKeyAliases, + uint16_t totalKTLevelNames, + const void *values); /** * @@ -6259,22 +6296,22 @@ xcb_xkb_set_names_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_set_names (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t virtualMods /**< */, - uint32_t which /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - uint8_t firstKTLevelt /**< */, - uint8_t nKTLevels /**< */, - uint32_t indicators /**< */, - uint8_t groupNames /**< */, - uint8_t nRadioGroups /**< */, - xcb_keycode_t firstKey /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint16_t totalKTLevelNames /**< */, - const void *values /**< */); +xcb_xkb_set_names (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t virtualMods, + uint32_t which, + uint8_t firstType, + uint8_t nTypes, + uint8_t firstKTLevelt, + uint8_t nKTLevels, + uint32_t indicators, + uint8_t groupNames, + uint8_t nRadioGroups, + xcb_keycode_t firstKey, + uint8_t nKeys, + uint8_t nKeyAliases, + uint16_t totalKTLevelNames, + const void *values); /** * @@ -6288,22 +6325,22 @@ xcb_xkb_set_names (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_set_names_aux_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t virtualMods /**< */, - uint32_t which /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - uint8_t firstKTLevelt /**< */, - uint8_t nKTLevels /**< */, - uint32_t indicators /**< */, - uint8_t groupNames /**< */, - uint8_t nRadioGroups /**< */, - xcb_keycode_t firstKey /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint16_t totalKTLevelNames /**< */, - const xcb_xkb_set_names_values_t *values /**< */); +xcb_xkb_set_names_aux_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t virtualMods, + uint32_t which, + uint8_t firstType, + uint8_t nTypes, + uint8_t firstKTLevelt, + uint8_t nKTLevels, + uint32_t indicators, + uint8_t groupNames, + uint8_t nRadioGroups, + xcb_keycode_t firstKey, + uint8_t nKeys, + uint8_t nKeyAliases, + uint16_t totalKTLevelNames, + const xcb_xkb_set_names_values_t *values); /** * @@ -6314,22 +6351,25 @@ xcb_xkb_set_names_aux_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_set_names_aux (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t virtualMods /**< */, - uint32_t which /**< */, - uint8_t firstType /**< */, - uint8_t nTypes /**< */, - uint8_t firstKTLevelt /**< */, - uint8_t nKTLevels /**< */, - uint32_t indicators /**< */, - uint8_t groupNames /**< */, - uint8_t nRadioGroups /**< */, - xcb_keycode_t firstKey /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint16_t totalKTLevelNames /**< */, - const xcb_xkb_set_names_values_t *values /**< */); +xcb_xkb_set_names_aux (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t virtualMods, + uint32_t which, + uint8_t firstType, + uint8_t nTypes, + uint8_t firstKTLevelt, + uint8_t nKTLevels, + uint32_t indicators, + uint8_t groupNames, + uint8_t nRadioGroups, + xcb_keycode_t firstKey, + uint8_t nKeys, + uint8_t nKeyAliases, + uint16_t totalKTLevelNames, + const xcb_xkb_set_names_values_t *values); + +void * +xcb_xkb_set_names_values (const xcb_xkb_set_names_request_t *R); /** * @@ -6340,13 +6380,13 @@ xcb_xkb_set_names_aux (xcb_connection_t *c /**< */, * */ xcb_xkb_per_client_flags_cookie_t -xcb_xkb_per_client_flags (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t change /**< */, - uint32_t value /**< */, - uint32_t ctrlsToChange /**< */, - uint32_t autoCtrls /**< */, - uint32_t autoCtrlsValues /**< */); +xcb_xkb_per_client_flags (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t change, + uint32_t value, + uint32_t ctrlsToChange, + uint32_t autoCtrls, + uint32_t autoCtrlsValues); /** * @@ -6360,13 +6400,13 @@ xcb_xkb_per_client_flags (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_per_client_flags_cookie_t -xcb_xkb_per_client_flags_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint32_t change /**< */, - uint32_t value /**< */, - uint32_t ctrlsToChange /**< */, - uint32_t autoCtrls /**< */, - uint32_t autoCtrlsValues /**< */); +xcb_xkb_per_client_flags_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint32_t change, + uint32_t value, + uint32_t ctrlsToChange, + uint32_t autoCtrls, + uint32_t autoCtrlsValues); /** * Return the reply @@ -6383,12 +6423,12 @@ xcb_xkb_per_client_flags_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xkb_per_client_flags_reply_t * -xcb_xkb_per_client_flags_reply (xcb_connection_t *c /**< */, +xcb_xkb_per_client_flags_reply (xcb_connection_t *c, xcb_xkb_per_client_flags_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xkb_list_components_sizeof (const void *_buffer /**< */); +xcb_xkb_list_components_sizeof (const void *_buffer); /** * @@ -6399,9 +6439,9 @@ xcb_xkb_list_components_sizeof (const void *_buffer /**< */); * */ xcb_xkb_list_components_cookie_t -xcb_xkb_list_components (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t maxNames /**< */); +xcb_xkb_list_components (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t maxNames); /** * @@ -6415,45 +6455,45 @@ xcb_xkb_list_components (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_list_components_cookie_t -xcb_xkb_list_components_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t maxNames /**< */); +xcb_xkb_list_components_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t maxNames); int -xcb_xkb_list_components_keymaps_length (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_keymaps_length (const xcb_xkb_list_components_reply_t *R); xcb_xkb_listing_iterator_t -xcb_xkb_list_components_keymaps_iterator (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_keymaps_iterator (const xcb_xkb_list_components_reply_t *R); int -xcb_xkb_list_components_keycodes_length (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_keycodes_length (const xcb_xkb_list_components_reply_t *R); xcb_xkb_listing_iterator_t -xcb_xkb_list_components_keycodes_iterator (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_keycodes_iterator (const xcb_xkb_list_components_reply_t *R); int -xcb_xkb_list_components_types_length (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_types_length (const xcb_xkb_list_components_reply_t *R); xcb_xkb_listing_iterator_t -xcb_xkb_list_components_types_iterator (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_types_iterator (const xcb_xkb_list_components_reply_t *R); int -xcb_xkb_list_components_compat_maps_length (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_compat_maps_length (const xcb_xkb_list_components_reply_t *R); xcb_xkb_listing_iterator_t -xcb_xkb_list_components_compat_maps_iterator (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_compat_maps_iterator (const xcb_xkb_list_components_reply_t *R); int -xcb_xkb_list_components_symbols_length (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_symbols_length (const xcb_xkb_list_components_reply_t *R); xcb_xkb_listing_iterator_t -xcb_xkb_list_components_symbols_iterator (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_symbols_iterator (const xcb_xkb_list_components_reply_t *R); int -xcb_xkb_list_components_geometries_length (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_geometries_length (const xcb_xkb_list_components_reply_t *R); xcb_xkb_listing_iterator_t -xcb_xkb_list_components_geometries_iterator (const xcb_xkb_list_components_reply_t *R /**< */); +xcb_xkb_list_components_geometries_iterator (const xcb_xkb_list_components_reply_t *R); /** * Return the reply @@ -6470,330 +6510,333 @@ xcb_xkb_list_components_geometries_iterator (const xcb_xkb_list_components_reply * The returned value must be freed by the caller using free(). */ xcb_xkb_list_components_reply_t * -xcb_xkb_list_components_reply (xcb_connection_t *c /**< */, +xcb_xkb_list_components_reply (xcb_connection_t *c, xcb_xkb_list_components_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_key_type_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_key_sym_map_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); uint8_t * -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_action_t * -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_action_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_set_behavior_t * -xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_set_behavior_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); uint8_t * -xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_set_explicit_t * -xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_set_explicit_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_key_mod_map_t * -xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_key_mod_map_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_key_v_mod_map_t * -xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_key_v_mod_map_iterator_t -xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - const xcb_xkb_get_kbd_by_name_replies_types_map_t *_aux /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void **_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + const xcb_xkb_get_kbd_by_name_replies_types_map_t *_aux); int -xcb_xkb_get_kbd_by_name_replies_types_map_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */, - xcb_xkb_get_kbd_by_name_replies_types_map_t *_aux /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_unpack (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present, + xcb_xkb_get_kbd_by_name_replies_types_map_t *_aux); int -xcb_xkb_get_kbd_by_name_replies_types_map_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint8_t nKeySyms /**< */, - uint8_t nKeyActions /**< */, - uint16_t totalActions /**< */, - uint8_t totalKeyBehaviors /**< */, - uint16_t virtualMods /**< */, - uint8_t totalKeyExplicit /**< */, - uint8_t totalModMapKeys /**< */, - uint8_t totalVModMapKeys /**< */, - uint16_t present /**< */); +xcb_xkb_get_kbd_by_name_replies_types_map_sizeof (const void *_buffer, + uint8_t nTypes, + uint8_t nKeySyms, + uint8_t nKeyActions, + uint16_t totalActions, + uint8_t totalKeyBehaviors, + uint16_t virtualMods, + uint8_t totalKeyExplicit, + uint8_t totalModMapKeys, + uint8_t totalVModMapKeys, + uint16_t present); xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); uint8_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_key_name_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_key_name_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_key_alias_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_key_alias_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_atom_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_generic_iterator_t -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void **_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - const xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *_aux /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void **_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + const xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *_aux); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */, - xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *_aux /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which, + xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *_aux); int -xcb_xkb_get_kbd_by_name_replies_key_names_value_list_sizeof (const void *_buffer /**< */, - uint8_t nTypes /**< */, - uint32_t indicators /**< */, - uint16_t virtualMods /**< */, - uint8_t groupNames /**< */, - uint8_t nKeys /**< */, - uint8_t nKeyAliases /**< */, - uint8_t nRadioGroups /**< */, - uint32_t which /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list_sizeof (const void *_buffer, + uint8_t nTypes, + uint32_t indicators, + uint16_t virtualMods, + uint8_t groupNames, + uint8_t nKeys, + uint8_t nKeyAliases, + uint8_t nRadioGroups, + uint32_t which); xcb_xkb_sym_interpret_t * -xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_sym_interpret_iterator_t -xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_mod_def_t * -xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_mod_def_iterator_t -xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_indicator_map_t * -xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps (const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps (const xcb_xkb_get_kbd_by_name_replies_t *S); int -xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_length (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_length (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_indicator_map_iterator_t -xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *S /**< */); +xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R, + const xcb_xkb_get_kbd_by_name_replies_t *S); xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t * -xcb_xkb_get_kbd_by_name_replies_key_names_value_list (const xcb_xkb_get_kbd_by_name_replies_t *R /**< */); +xcb_xkb_get_kbd_by_name_replies_key_names_value_list (const xcb_xkb_get_kbd_by_name_replies_t *R); xcb_xkb_counted_string_16_t * -xcb_xkb_get_kbd_by_name_replies_geometry_label_font (const xcb_xkb_get_kbd_by_name_replies_t *R /**< */); +xcb_xkb_get_kbd_by_name_replies_geometry_label_font (const xcb_xkb_get_kbd_by_name_replies_t *R); int -xcb_xkb_get_kbd_by_name_replies_serialize (void **_buffer /**< */, - uint16_t reported /**< */, - const xcb_xkb_get_kbd_by_name_replies_t *_aux /**< */); +xcb_xkb_get_kbd_by_name_replies_serialize (void **_buffer, + uint16_t reported, + const xcb_xkb_get_kbd_by_name_replies_t *_aux); int -xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buffer /**< */, - uint16_t reported /**< */, - xcb_xkb_get_kbd_by_name_replies_t *_aux /**< */); +xcb_xkb_get_kbd_by_name_replies_unpack (const void *_buffer, + uint16_t reported, + xcb_xkb_get_kbd_by_name_replies_t *_aux); int -xcb_xkb_get_kbd_by_name_replies_sizeof (const void *_buffer /**< */, - uint16_t reported /**< */); +xcb_xkb_get_kbd_by_name_replies_sizeof (const void *_buffer, + uint16_t reported); + +int +xcb_xkb_get_kbd_by_name_sizeof (const void *_buffer); /** * @@ -6804,11 +6847,11 @@ xcb_xkb_get_kbd_by_name_replies_sizeof (const void *_buffer /**< */, * */ xcb_xkb_get_kbd_by_name_cookie_t -xcb_xkb_get_kbd_by_name (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t need /**< */, - uint16_t want /**< */, - uint8_t load /**< */); +xcb_xkb_get_kbd_by_name (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t need, + uint16_t want, + uint8_t load); /** * @@ -6822,14 +6865,14 @@ xcb_xkb_get_kbd_by_name (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_get_kbd_by_name_cookie_t -xcb_xkb_get_kbd_by_name_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t need /**< */, - uint16_t want /**< */, - uint8_t load /**< */); +xcb_xkb_get_kbd_by_name_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t need, + uint16_t want, + uint8_t load); void * -xcb_xkb_get_kbd_by_name_replies (const xcb_xkb_get_kbd_by_name_reply_t *R /**< */); +xcb_xkb_get_kbd_by_name_replies (const xcb_xkb_get_kbd_by_name_reply_t *R); /** * Return the reply @@ -6846,12 +6889,12 @@ xcb_xkb_get_kbd_by_name_replies (const xcb_xkb_get_kbd_by_name_reply_t *R /**< * The returned value must be freed by the caller using free(). */ xcb_xkb_get_kbd_by_name_reply_t * -xcb_xkb_get_kbd_by_name_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_kbd_by_name_reply (xcb_connection_t *c, xcb_xkb_get_kbd_by_name_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xkb_get_device_info_sizeof (const void *_buffer /**< */); +xcb_xkb_get_device_info_sizeof (const void *_buffer); /** * @@ -6862,14 +6905,14 @@ xcb_xkb_get_device_info_sizeof (const void *_buffer /**< */); * */ xcb_xkb_get_device_info_cookie_t -xcb_xkb_get_device_info (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t wanted /**< */, - uint8_t allButtons /**< */, - uint8_t firstButton /**< */, - uint8_t nButtons /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */); +xcb_xkb_get_device_info (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t wanted, + uint8_t allButtons, + uint8_t firstButton, + uint8_t nButtons, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID); /** * @@ -6883,38 +6926,38 @@ xcb_xkb_get_device_info (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_get_device_info_cookie_t -xcb_xkb_get_device_info_unchecked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint16_t wanted /**< */, - uint8_t allButtons /**< */, - uint8_t firstButton /**< */, - uint8_t nButtons /**< */, - xcb_xkb_led_class_spec_t ledClass /**< */, - xcb_xkb_id_spec_t ledID /**< */); +xcb_xkb_get_device_info_unchecked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint16_t wanted, + uint8_t allButtons, + uint8_t firstButton, + uint8_t nButtons, + xcb_xkb_led_class_spec_t ledClass, + xcb_xkb_id_spec_t ledID); xcb_xkb_string8_t * -xcb_xkb_get_device_info_name (const xcb_xkb_get_device_info_reply_t *R /**< */); +xcb_xkb_get_device_info_name (const xcb_xkb_get_device_info_reply_t *R); int -xcb_xkb_get_device_info_name_length (const xcb_xkb_get_device_info_reply_t *R /**< */); +xcb_xkb_get_device_info_name_length (const xcb_xkb_get_device_info_reply_t *R); xcb_generic_iterator_t -xcb_xkb_get_device_info_name_end (const xcb_xkb_get_device_info_reply_t *R /**< */); +xcb_xkb_get_device_info_name_end (const xcb_xkb_get_device_info_reply_t *R); xcb_xkb_action_t * -xcb_xkb_get_device_info_btn_actions (const xcb_xkb_get_device_info_reply_t *R /**< */); +xcb_xkb_get_device_info_btn_actions (const xcb_xkb_get_device_info_reply_t *R); int -xcb_xkb_get_device_info_btn_actions_length (const xcb_xkb_get_device_info_reply_t *R /**< */); +xcb_xkb_get_device_info_btn_actions_length (const xcb_xkb_get_device_info_reply_t *R); xcb_xkb_action_iterator_t -xcb_xkb_get_device_info_btn_actions_iterator (const xcb_xkb_get_device_info_reply_t *R /**< */); +xcb_xkb_get_device_info_btn_actions_iterator (const xcb_xkb_get_device_info_reply_t *R); int -xcb_xkb_get_device_info_leds_length (const xcb_xkb_get_device_info_reply_t *R /**< */); +xcb_xkb_get_device_info_leds_length (const xcb_xkb_get_device_info_reply_t *R); xcb_xkb_device_led_info_iterator_t -xcb_xkb_get_device_info_leds_iterator (const xcb_xkb_get_device_info_reply_t *R /**< */); +xcb_xkb_get_device_info_leds_iterator (const xcb_xkb_get_device_info_reply_t *R); /** * Return the reply @@ -6931,12 +6974,12 @@ xcb_xkb_get_device_info_leds_iterator (const xcb_xkb_get_device_info_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_xkb_get_device_info_reply_t * -xcb_xkb_get_device_info_reply (xcb_connection_t *c /**< */, +xcb_xkb_get_device_info_reply (xcb_connection_t *c, xcb_xkb_get_device_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xkb_set_device_info_sizeof (const void *_buffer /**< */); +xcb_xkb_set_device_info_sizeof (const void *_buffer); /** * @@ -6950,14 +6993,14 @@ xcb_xkb_set_device_info_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xkb_set_device_info_checked (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t firstBtn /**< */, - uint8_t nBtns /**< */, - uint16_t change /**< */, - uint16_t nDeviceLedFBs /**< */, - const xcb_xkb_action_t *btnActions /**< */, - const xcb_xkb_device_led_info_t *leds /**< */); +xcb_xkb_set_device_info_checked (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t firstBtn, + uint8_t nBtns, + uint16_t change, + uint16_t nDeviceLedFBs, + const xcb_xkb_action_t *btnActions, + const xcb_xkb_device_led_info_t *leds); /** * @@ -6968,17 +7011,32 @@ xcb_xkb_set_device_info_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xkb_set_device_info (xcb_connection_t *c /**< */, - xcb_xkb_device_spec_t deviceSpec /**< */, - uint8_t firstBtn /**< */, - uint8_t nBtns /**< */, - uint16_t change /**< */, - uint16_t nDeviceLedFBs /**< */, - const xcb_xkb_action_t *btnActions /**< */, - const xcb_xkb_device_led_info_t *leds /**< */); +xcb_xkb_set_device_info (xcb_connection_t *c, + xcb_xkb_device_spec_t deviceSpec, + uint8_t firstBtn, + uint8_t nBtns, + uint16_t change, + uint16_t nDeviceLedFBs, + const xcb_xkb_action_t *btnActions, + const xcb_xkb_device_led_info_t *leds); + +xcb_xkb_action_t * +xcb_xkb_set_device_info_btn_actions (const xcb_xkb_set_device_info_request_t *R); int -xcb_xkb_set_debugging_flags_sizeof (const void *_buffer /**< */); +xcb_xkb_set_device_info_btn_actions_length (const xcb_xkb_set_device_info_request_t *R); + +xcb_xkb_action_iterator_t +xcb_xkb_set_device_info_btn_actions_iterator (const xcb_xkb_set_device_info_request_t *R); + +int +xcb_xkb_set_device_info_leds_length (const xcb_xkb_set_device_info_request_t *R); + +xcb_xkb_device_led_info_iterator_t +xcb_xkb_set_device_info_leds_iterator (const xcb_xkb_set_device_info_request_t *R); + +int +xcb_xkb_set_debugging_flags_sizeof (const void *_buffer); /** * @@ -6989,13 +7047,13 @@ xcb_xkb_set_debugging_flags_sizeof (const void *_buffer /**< */); * */ xcb_xkb_set_debugging_flags_cookie_t -xcb_xkb_set_debugging_flags (xcb_connection_t *c /**< */, - uint16_t msgLength /**< */, - uint32_t affectFlags /**< */, - uint32_t flags /**< */, - uint32_t affectCtrls /**< */, - uint32_t ctrls /**< */, - const xcb_xkb_string8_t *message /**< */); +xcb_xkb_set_debugging_flags (xcb_connection_t *c, + uint16_t msgLength, + uint32_t affectFlags, + uint32_t flags, + uint32_t affectCtrls, + uint32_t ctrls, + const xcb_xkb_string8_t *message); /** * @@ -7009,13 +7067,13 @@ xcb_xkb_set_debugging_flags (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xkb_set_debugging_flags_cookie_t -xcb_xkb_set_debugging_flags_unchecked (xcb_connection_t *c /**< */, - uint16_t msgLength /**< */, - uint32_t affectFlags /**< */, - uint32_t flags /**< */, - uint32_t affectCtrls /**< */, - uint32_t ctrls /**< */, - const xcb_xkb_string8_t *message /**< */); +xcb_xkb_set_debugging_flags_unchecked (xcb_connection_t *c, + uint16_t msgLength, + uint32_t affectFlags, + uint32_t flags, + uint32_t affectCtrls, + uint32_t ctrls, + const xcb_xkb_string8_t *message); /** * Return the reply @@ -7032,9 +7090,9 @@ xcb_xkb_set_debugging_flags_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xkb_set_debugging_flags_reply_t * -xcb_xkb_set_debugging_flags_reply (xcb_connection_t *c /**< */, +xcb_xkb_set_debugging_flags_reply (xcb_connection_t *c, xcb_xkb_set_debugging_flags_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/xprint.c b/lib/libxcb/src/xprint.c index a20702045..1cfc9604d 100644 --- a/lib/libxcb/src/xprint.c +++ b/lib/libxcb/src/xprint.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_x_print_id = { "XpExtension", 0 }; void -xcb_x_print_string8_next (xcb_x_print_string8_iterator_t *i /**< */) +xcb_x_print_string8_next (xcb_x_print_string8_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_x_print_string8_next (xcb_x_print_string8_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_x_print_string8_end (xcb_x_print_string8_iterator_t i /**< */) +xcb_x_print_string8_end (xcb_x_print_string8_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,10 +37,10 @@ xcb_x_print_string8_end (xcb_x_print_string8_iterator_t i /**< */) } int -xcb_x_print_printer_serialize (void **_buffer /**< */, - const xcb_x_print_printer_t *_aux /**< */, - const xcb_x_print_string8_t *name /**< */, - const xcb_x_print_string8_t *description /**< */) +xcb_x_print_printer_serialize (void **_buffer, + const xcb_x_print_printer_t *_aux, + const xcb_x_print_string8_t *name, + const xcb_x_print_string8_t *description) { char *xcb_out = *_buffer; unsigned int xcb_buffer_len = 0; @@ -48,7 +48,7 @@ xcb_x_print_printer_serialize (void **_buffer /**< */, unsigned int xcb_pad = 0; char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[5]; + struct iovec xcb_parts[7]; unsigned int xcb_parts_idx = 0; unsigned int xcb_block_len = 0; unsigned int i; @@ -66,6 +66,11 @@ xcb_x_print_printer_serialize (void **_buffer /**< */, xcb_parts[xcb_parts_idx].iov_len = _aux->nameLen * sizeof(xcb_x_print_string8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_x_print_string8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + xcb_block_len = 0; /* xcb_x_print_printer_t.descLen */ xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->descLen; xcb_block_len += sizeof(uint32_t); @@ -78,6 +83,11 @@ xcb_x_print_printer_serialize (void **_buffer /**< */, xcb_parts[xcb_parts_idx].iov_len = _aux->descLen * sizeof(xcb_x_print_string8_t); xcb_parts_idx++; xcb_align_to = ALIGNOF(xcb_x_print_string8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + xcb_block_len = 0; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -107,8 +117,8 @@ xcb_x_print_printer_serialize (void **_buffer /**< */, } int -xcb_x_print_printer_unserialize (const void *_buffer /**< */, - xcb_x_print_printer_t **_aux /**< */) +xcb_x_print_printer_unserialize (const void *_buffer, + xcb_x_print_printer_t **_aux) { char *xcb_tmp = (char *)_buffer; xcb_x_print_printer_t xcb_out; @@ -133,6 +143,11 @@ xcb_x_print_printer_unserialize (const void *_buffer /**< */, xcb_block_len += name_len; xcb_tmp += name_len; xcb_align_to = ALIGNOF(xcb_x_print_string8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + xcb_block_len = 0; /* xcb_x_print_printer_t.descLen */ xcb_out.descLen = *(uint32_t *)xcb_tmp; xcb_block_len += sizeof(uint32_t); @@ -144,6 +159,11 @@ xcb_x_print_printer_unserialize (const void *_buffer /**< */, xcb_block_len += description_len; xcb_tmp += description_len; xcb_align_to = ALIGNOF(xcb_x_print_string8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + xcb_block_len = 0; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -172,25 +192,25 @@ xcb_x_print_printer_unserialize (const void *_buffer /**< */, } int -xcb_x_print_printer_sizeof (const void *_buffer /**< */) +xcb_x_print_printer_sizeof (const void *_buffer) { return xcb_x_print_printer_unserialize(_buffer, NULL); } xcb_x_print_string8_t * -xcb_x_print_printer_name (const xcb_x_print_printer_t *R /**< */) +xcb_x_print_printer_name (const xcb_x_print_printer_t *R) { return (xcb_x_print_string8_t *) (R + 1); } int -xcb_x_print_printer_name_length (const xcb_x_print_printer_t *R /**< */) +xcb_x_print_printer_name_length (const xcb_x_print_printer_t *R) { return R->nameLen; } xcb_generic_iterator_t -xcb_x_print_printer_name_end (const xcb_x_print_printer_t *R /**< */) +xcb_x_print_printer_name_end (const xcb_x_print_printer_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_x_print_string8_t *) (R + 1)) + (R->nameLen); @@ -200,31 +220,31 @@ xcb_x_print_printer_name_end (const xcb_x_print_printer_t *R /**< */) } xcb_x_print_string8_t * -xcb_x_print_printer_description (const xcb_x_print_printer_t *R /**< */) +xcb_x_print_printer_description (const xcb_x_print_printer_t *R) { xcb_generic_iterator_t prev = xcb_x_print_printer_name_end(R); - return (xcb_x_print_string8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 4); + return (xcb_x_print_string8_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 4); } int -xcb_x_print_printer_description_length (const xcb_x_print_printer_t *R /**< */) +xcb_x_print_printer_description_length (const xcb_x_print_printer_t *R) { return R->descLen; } xcb_generic_iterator_t -xcb_x_print_printer_description_end (const xcb_x_print_printer_t *R /**< */) +xcb_x_print_printer_description_end (const xcb_x_print_printer_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_x_print_printer_name_end(R); - i.data = ((xcb_x_print_string8_t *) child.data) + (R->descLen); + xcb_generic_iterator_t prev = xcb_x_print_printer_name_end(R); + i.data = ((xcb_x_print_string8_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->descLen); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } void -xcb_x_print_printer_next (xcb_x_print_printer_iterator_t *i /**< */) +xcb_x_print_printer_next (xcb_x_print_printer_iterator_t *i) { xcb_x_print_printer_t *R = i->data; xcb_generic_iterator_t child; @@ -235,7 +255,7 @@ xcb_x_print_printer_next (xcb_x_print_printer_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_x_print_printer_end (xcb_x_print_printer_iterator_t i /**< */) +xcb_x_print_printer_end (xcb_x_print_printer_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -247,7 +267,7 @@ xcb_x_print_printer_end (xcb_x_print_printer_iterator_t i /**< */) } void -xcb_x_print_pcontext_next (xcb_x_print_pcontext_iterator_t *i /**< */) +xcb_x_print_pcontext_next (xcb_x_print_pcontext_iterator_t *i) { --i->rem; ++i->data; @@ -255,7 +275,7 @@ xcb_x_print_pcontext_next (xcb_x_print_pcontext_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_x_print_pcontext_end (xcb_x_print_pcontext_iterator_t i /**< */) +xcb_x_print_pcontext_end (xcb_x_print_pcontext_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -265,13 +285,13 @@ xcb_x_print_pcontext_end (xcb_x_print_pcontext_iterator_t i /**< */) } xcb_x_print_print_query_version_cookie_t -xcb_x_print_print_query_version (xcb_connection_t *c /**< */) +xcb_x_print_print_query_version (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -289,13 +309,13 @@ xcb_x_print_print_query_version (xcb_connection_t *c /**< */) } xcb_x_print_print_query_version_cookie_t -xcb_x_print_print_query_version_unchecked (xcb_connection_t *c /**< */) +xcb_x_print_print_query_version_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -313,15 +333,15 @@ xcb_x_print_print_query_version_unchecked (xcb_connection_t *c /**< */) } xcb_x_print_print_query_version_reply_t * -xcb_x_print_print_query_version_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_query_version_reply (xcb_connection_t *c, xcb_x_print_print_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_x_print_print_get_printer_list_sizeof (const void *_buffer /**< */) +xcb_x_print_print_get_printer_list_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_x_print_print_get_printer_list_request_t *_aux = (xcb_x_print_print_get_printer_list_request_t *)_buffer; @@ -364,17 +384,17 @@ xcb_x_print_print_get_printer_list_sizeof (const void *_buffer /**< */) } xcb_x_print_print_get_printer_list_cookie_t -xcb_x_print_print_get_printer_list (xcb_connection_t *c /**< */, - uint32_t printerNameLen /**< */, - uint32_t localeLen /**< */, - const xcb_x_print_string8_t *printer_name /**< */, - const xcb_x_print_string8_t *locale /**< */) +xcb_x_print_print_get_printer_list (xcb_connection_t *c, + uint32_t printerNameLen, + uint32_t localeLen, + const xcb_x_print_string8_t *printer_name, + const xcb_x_print_string8_t *locale) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_PRINTER_LIST, - /* isvoid */ 0 + .count = 6, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_PRINTER_LIST, + .isvoid = 0 }; struct iovec xcb_parts[8]; @@ -404,17 +424,17 @@ xcb_x_print_print_get_printer_list (xcb_connection_t *c /**< */, } xcb_x_print_print_get_printer_list_cookie_t -xcb_x_print_print_get_printer_list_unchecked (xcb_connection_t *c /**< */, - uint32_t printerNameLen /**< */, - uint32_t localeLen /**< */, - const xcb_x_print_string8_t *printer_name /**< */, - const xcb_x_print_string8_t *locale /**< */) +xcb_x_print_print_get_printer_list_unchecked (xcb_connection_t *c, + uint32_t printerNameLen, + uint32_t localeLen, + const xcb_x_print_string8_t *printer_name, + const xcb_x_print_string8_t *locale) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_PRINTER_LIST, - /* isvoid */ 0 + .count = 6, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_PRINTER_LIST, + .isvoid = 0 }; struct iovec xcb_parts[8]; @@ -444,13 +464,13 @@ xcb_x_print_print_get_printer_list_unchecked (xcb_connection_t *c /* } int -xcb_x_print_print_get_printer_list_printers_length (const xcb_x_print_print_get_printer_list_reply_t *R /**< */) +xcb_x_print_print_get_printer_list_printers_length (const xcb_x_print_print_get_printer_list_reply_t *R) { return R->listCount; } xcb_x_print_printer_iterator_t -xcb_x_print_print_get_printer_list_printers_iterator (const xcb_x_print_print_get_printer_list_reply_t *R /**< */) +xcb_x_print_print_get_printer_list_printers_iterator (const xcb_x_print_print_get_printer_list_reply_t *R) { xcb_x_print_printer_iterator_t i; i.data = (xcb_x_print_printer_t *) (R + 1); @@ -460,9 +480,9 @@ xcb_x_print_print_get_printer_list_printers_iterator (const xcb_x_print_print_ge } xcb_x_print_print_get_printer_list_reply_t * -xcb_x_print_print_get_printer_list_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_printer_list_reply (xcb_connection_t *c, xcb_x_print_print_get_printer_list_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { xcb_x_print_print_get_printer_list_reply_t *reply = (xcb_x_print_print_get_printer_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); int i; @@ -479,13 +499,13 @@ xcb_x_print_print_get_printer_list_reply (xcb_connection_t } xcb_void_cookie_t -xcb_x_print_print_rehash_printer_list_checked (xcb_connection_t *c /**< */) +xcb_x_print_print_rehash_printer_list_checked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_REHASH_PRINTER_LIST, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_REHASH_PRINTER_LIST, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -503,13 +523,13 @@ xcb_x_print_print_rehash_printer_list_checked (xcb_connection_t *c /**< */) } xcb_void_cookie_t -xcb_x_print_print_rehash_printer_list (xcb_connection_t *c /**< */) +xcb_x_print_print_rehash_printer_list (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_REHASH_PRINTER_LIST, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_REHASH_PRINTER_LIST, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -527,7 +547,7 @@ xcb_x_print_print_rehash_printer_list (xcb_connection_t *c /**< */) } int -xcb_x_print_create_context_sizeof (const void *_buffer /**< */) +xcb_x_print_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_x_print_create_context_request_t *_aux = (xcb_x_print_create_context_request_t *)_buffer; @@ -570,18 +590,18 @@ xcb_x_print_create_context_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_x_print_create_context_checked (xcb_connection_t *c /**< */, - uint32_t context_id /**< */, - uint32_t printerNameLen /**< */, - uint32_t localeLen /**< */, - const xcb_x_print_string8_t *printerName /**< */, - const xcb_x_print_string8_t *locale /**< */) +xcb_x_print_create_context_checked (xcb_connection_t *c, + uint32_t context_id, + uint32_t printerNameLen, + uint32_t localeLen, + const xcb_x_print_string8_t *printerName, + const xcb_x_print_string8_t *locale) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -612,18 +632,18 @@ xcb_x_print_create_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_create_context (xcb_connection_t *c /**< */, - uint32_t context_id /**< */, - uint32_t printerNameLen /**< */, - uint32_t localeLen /**< */, - const xcb_x_print_string8_t *printerName /**< */, - const xcb_x_print_string8_t *locale /**< */) +xcb_x_print_create_context (xcb_connection_t *c, + uint32_t context_id, + uint32_t printerNameLen, + uint32_t localeLen, + const xcb_x_print_string8_t *printerName, + const xcb_x_print_string8_t *locale) { static const xcb_protocol_request_t xcb_req = { - /* count */ 6, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 6, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[8]; @@ -653,15 +673,61 @@ xcb_x_print_create_context (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_x_print_string8_t * +xcb_x_print_create_context_printer_name (const xcb_x_print_create_context_request_t *R) +{ + return (xcb_x_print_string8_t *) (R + 1); +} + +int +xcb_x_print_create_context_printer_name_length (const xcb_x_print_create_context_request_t *R) +{ + return R->printerNameLen; +} + +xcb_generic_iterator_t +xcb_x_print_create_context_printer_name_end (const xcb_x_print_create_context_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_x_print_string8_t *) (R + 1)) + (R->printerNameLen); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_x_print_string8_t * +xcb_x_print_create_context_locale (const xcb_x_print_create_context_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_x_print_create_context_printer_name_end(R); + return (xcb_x_print_string8_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_x_print_string8_t, prev.index) + 0); +} + +int +xcb_x_print_create_context_locale_length (const xcb_x_print_create_context_request_t *R) +{ + return R->localeLen; +} + +xcb_generic_iterator_t +xcb_x_print_create_context_locale_end (const xcb_x_print_create_context_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_x_print_create_context_printer_name_end(R); + i.data = ((xcb_x_print_string8_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_x_print_string8_t, prev.index))) + (R->localeLen); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_x_print_print_set_context_checked (xcb_connection_t *c /**< */, - uint32_t context /**< */) +xcb_x_print_print_set_context_checked (xcb_connection_t *c, + uint32_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_SET_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_SET_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -680,14 +746,14 @@ xcb_x_print_print_set_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_set_context (xcb_connection_t *c /**< */, - uint32_t context /**< */) +xcb_x_print_print_set_context (xcb_connection_t *c, + uint32_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_SET_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_SET_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -706,13 +772,13 @@ xcb_x_print_print_set_context (xcb_connection_t *c /**< */, } xcb_x_print_print_get_context_cookie_t -xcb_x_print_print_get_context (xcb_connection_t *c /**< */) +xcb_x_print_print_get_context (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -730,13 +796,13 @@ xcb_x_print_print_get_context (xcb_connection_t *c /**< */) } xcb_x_print_print_get_context_cookie_t -xcb_x_print_print_get_context_unchecked (xcb_connection_t *c /**< */) +xcb_x_print_print_get_context_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -754,22 +820,22 @@ xcb_x_print_print_get_context_unchecked (xcb_connection_t *c /**< */) } xcb_x_print_print_get_context_reply_t * -xcb_x_print_print_get_context_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_context_reply (xcb_connection_t *c, xcb_x_print_print_get_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_get_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_x_print_print_destroy_context_checked (xcb_connection_t *c /**< */, - uint32_t context /**< */) +xcb_x_print_print_destroy_context_checked (xcb_connection_t *c, + uint32_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_DESTROY_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_DESTROY_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -788,14 +854,14 @@ xcb_x_print_print_destroy_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_destroy_context (xcb_connection_t *c /**< */, - uint32_t context /**< */) +xcb_x_print_print_destroy_context (xcb_connection_t *c, + uint32_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_DESTROY_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_DESTROY_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -814,13 +880,13 @@ xcb_x_print_print_destroy_context (xcb_connection_t *c /**< */, } xcb_x_print_print_get_screen_of_context_cookie_t -xcb_x_print_print_get_screen_of_context (xcb_connection_t *c /**< */) +xcb_x_print_print_get_screen_of_context (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_SCREEN_OF_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_SCREEN_OF_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -838,13 +904,13 @@ xcb_x_print_print_get_screen_of_context (xcb_connection_t *c /**< */) } xcb_x_print_print_get_screen_of_context_cookie_t -xcb_x_print_print_get_screen_of_context_unchecked (xcb_connection_t *c /**< */) +xcb_x_print_print_get_screen_of_context_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_SCREEN_OF_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_SCREEN_OF_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -862,22 +928,22 @@ xcb_x_print_print_get_screen_of_context_unchecked (xcb_connection_t *c /**< */) } xcb_x_print_print_get_screen_of_context_reply_t * -xcb_x_print_print_get_screen_of_context_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_screen_of_context_reply (xcb_connection_t *c, xcb_x_print_print_get_screen_of_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_get_screen_of_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_x_print_print_start_job_checked (xcb_connection_t *c /**< */, - uint8_t output_mode /**< */) +xcb_x_print_print_start_job_checked (xcb_connection_t *c, + uint8_t output_mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_START_JOB, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_START_JOB, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -896,14 +962,14 @@ xcb_x_print_print_start_job_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_start_job (xcb_connection_t *c /**< */, - uint8_t output_mode /**< */) +xcb_x_print_print_start_job (xcb_connection_t *c, + uint8_t output_mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_START_JOB, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_START_JOB, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -922,14 +988,14 @@ xcb_x_print_print_start_job (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_end_job_checked (xcb_connection_t *c /**< */, - uint8_t cancel /**< */) +xcb_x_print_print_end_job_checked (xcb_connection_t *c, + uint8_t cancel) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_END_JOB, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_END_JOB, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -948,14 +1014,14 @@ xcb_x_print_print_end_job_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_end_job (xcb_connection_t *c /**< */, - uint8_t cancel /**< */) +xcb_x_print_print_end_job (xcb_connection_t *c, + uint8_t cancel) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_END_JOB, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_END_JOB, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -974,14 +1040,14 @@ xcb_x_print_print_end_job (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_start_doc_checked (xcb_connection_t *c /**< */, - uint8_t driver_mode /**< */) +xcb_x_print_print_start_doc_checked (xcb_connection_t *c, + uint8_t driver_mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_START_DOC, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_START_DOC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1000,14 +1066,14 @@ xcb_x_print_print_start_doc_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_start_doc (xcb_connection_t *c /**< */, - uint8_t driver_mode /**< */) +xcb_x_print_print_start_doc (xcb_connection_t *c, + uint8_t driver_mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_START_DOC, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_START_DOC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1026,14 +1092,14 @@ xcb_x_print_print_start_doc (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_end_doc_checked (xcb_connection_t *c /**< */, - uint8_t cancel /**< */) +xcb_x_print_print_end_doc_checked (xcb_connection_t *c, + uint8_t cancel) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_END_DOC, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_END_DOC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1052,14 +1118,14 @@ xcb_x_print_print_end_doc_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_end_doc (xcb_connection_t *c /**< */, - uint8_t cancel /**< */) +xcb_x_print_print_end_doc (xcb_connection_t *c, + uint8_t cancel) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_END_DOC, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_END_DOC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1078,9 +1144,7 @@ xcb_x_print_print_end_doc (xcb_connection_t *c /**< */, } int -xcb_x_print_print_put_document_data_sizeof (const void *_buffer /**< */, - uint32_t doc_format_len /**< */, - uint32_t options_len /**< */) +xcb_x_print_print_put_document_data_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_x_print_print_put_document_data_request_t *_aux = (xcb_x_print_print_put_document_data_request_t *)_buffer; @@ -1107,7 +1171,7 @@ xcb_x_print_print_put_document_data_sizeof (const void *_buffer /**< */, } xcb_block_len = 0; /* doc_format */ - xcb_block_len += doc_format_len * sizeof(xcb_x_print_string8_t); + xcb_block_len += _aux->len_fmt * sizeof(xcb_x_print_string8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_x_print_string8_t); /* insert padding */ @@ -1119,7 +1183,7 @@ xcb_x_print_print_put_document_data_sizeof (const void *_buffer /**< */, } xcb_block_len = 0; /* options */ - xcb_block_len += options_len * sizeof(xcb_x_print_string8_t); + xcb_block_len += _aux->len_options * sizeof(xcb_x_print_string8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(xcb_x_print_string8_t); /* insert padding */ @@ -1135,22 +1199,20 @@ xcb_x_print_print_put_document_data_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_x_print_print_put_document_data_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t len_data /**< */, - uint16_t len_fmt /**< */, - uint16_t len_options /**< */, - const uint8_t *data /**< */, - uint32_t doc_format_len /**< */, - const xcb_x_print_string8_t *doc_format /**< */, - uint32_t options_len /**< */, - const xcb_x_print_string8_t *options /**< */) +xcb_x_print_print_put_document_data_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t len_data, + uint16_t len_fmt, + uint16_t len_options, + const uint8_t *data, + const xcb_x_print_string8_t *doc_format, + const xcb_x_print_string8_t *options) { static const xcb_protocol_request_t xcb_req = { - /* count */ 8, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_PUT_DOCUMENT_DATA, - /* isvoid */ 1 + .count = 8, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_PUT_DOCUMENT_DATA, + .isvoid = 1 }; struct iovec xcb_parts[10]; @@ -1173,12 +1235,12 @@ xcb_x_print_print_put_document_data_checked (xcb_connection_t *c /** xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; /* xcb_x_print_string8_t doc_format */ xcb_parts[6].iov_base = (char *) doc_format; - xcb_parts[6].iov_len = doc_format_len * sizeof(xcb_x_print_string8_t); + xcb_parts[6].iov_len = len_fmt * sizeof(xcb_x_print_string8_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; /* xcb_x_print_string8_t options */ xcb_parts[8].iov_base = (char *) options; - xcb_parts[8].iov_len = options_len * sizeof(xcb_x_print_string8_t); + xcb_parts[8].iov_len = len_options * sizeof(xcb_x_print_string8_t); xcb_parts[9].iov_base = 0; xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; @@ -1187,22 +1249,20 @@ xcb_x_print_print_put_document_data_checked (xcb_connection_t *c /** } xcb_void_cookie_t -xcb_x_print_print_put_document_data (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t len_data /**< */, - uint16_t len_fmt /**< */, - uint16_t len_options /**< */, - const uint8_t *data /**< */, - uint32_t doc_format_len /**< */, - const xcb_x_print_string8_t *doc_format /**< */, - uint32_t options_len /**< */, - const xcb_x_print_string8_t *options /**< */) +xcb_x_print_print_put_document_data (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t len_data, + uint16_t len_fmt, + uint16_t len_options, + const uint8_t *data, + const xcb_x_print_string8_t *doc_format, + const xcb_x_print_string8_t *options) { static const xcb_protocol_request_t xcb_req = { - /* count */ 8, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_PUT_DOCUMENT_DATA, - /* isvoid */ 1 + .count = 8, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_PUT_DOCUMENT_DATA, + .isvoid = 1 }; struct iovec xcb_parts[10]; @@ -1225,12 +1285,12 @@ xcb_x_print_print_put_document_data (xcb_connection_t *c /**< */, xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; /* xcb_x_print_string8_t doc_format */ xcb_parts[6].iov_base = (char *) doc_format; - xcb_parts[6].iov_len = doc_format_len * sizeof(xcb_x_print_string8_t); + xcb_parts[6].iov_len = len_fmt * sizeof(xcb_x_print_string8_t); xcb_parts[7].iov_base = 0; xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; /* xcb_x_print_string8_t options */ xcb_parts[8].iov_base = (char *) options; - xcb_parts[8].iov_len = options_len * sizeof(xcb_x_print_string8_t); + xcb_parts[8].iov_len = len_options * sizeof(xcb_x_print_string8_t); xcb_parts[9].iov_base = 0; xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; @@ -1238,8 +1298,78 @@ xcb_x_print_print_put_document_data (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_x_print_print_put_document_data_data (const xcb_x_print_print_put_document_data_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_x_print_print_get_document_data_sizeof (const void *_buffer /**< */) +xcb_x_print_print_put_document_data_data_length (const xcb_x_print_print_put_document_data_request_t *R) +{ + return R->len_data; +} + +xcb_generic_iterator_t +xcb_x_print_print_put_document_data_data_end (const xcb_x_print_print_put_document_data_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + (R->len_data); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_x_print_string8_t * +xcb_x_print_print_put_document_data_doc_format (const xcb_x_print_print_put_document_data_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_x_print_print_put_document_data_data_end(R); + return (xcb_x_print_string8_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_x_print_string8_t, prev.index) + 0); +} + +int +xcb_x_print_print_put_document_data_doc_format_length (const xcb_x_print_print_put_document_data_request_t *R) +{ + return R->len_fmt; +} + +xcb_generic_iterator_t +xcb_x_print_print_put_document_data_doc_format_end (const xcb_x_print_print_put_document_data_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_x_print_print_put_document_data_data_end(R); + i.data = ((xcb_x_print_string8_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_x_print_string8_t, prev.index))) + (R->len_fmt); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_x_print_string8_t * +xcb_x_print_print_put_document_data_options (const xcb_x_print_print_put_document_data_request_t *R) +{ + xcb_generic_iterator_t prev = xcb_x_print_print_put_document_data_doc_format_end(R); + return (xcb_x_print_string8_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_x_print_string8_t, prev.index) + 0); +} + +int +xcb_x_print_print_put_document_data_options_length (const xcb_x_print_print_put_document_data_request_t *R) +{ + return R->len_options; +} + +xcb_generic_iterator_t +xcb_x_print_print_put_document_data_options_end (const xcb_x_print_print_put_document_data_request_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_x_print_print_put_document_data_doc_format_end(R); + i.data = ((xcb_x_print_string8_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_x_print_string8_t, prev.index))) + (R->len_options); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_x_print_print_get_document_data_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_x_print_print_get_document_data_reply_t *_aux = (xcb_x_print_print_get_document_data_reply_t *)_buffer; @@ -1270,15 +1400,15 @@ xcb_x_print_print_get_document_data_sizeof (const void *_buffer /**< */) } xcb_x_print_print_get_document_data_cookie_t -xcb_x_print_print_get_document_data (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t max_bytes /**< */) +xcb_x_print_print_get_document_data (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t max_bytes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_DOCUMENT_DATA, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_DOCUMENT_DATA, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1298,15 +1428,15 @@ xcb_x_print_print_get_document_data (xcb_connection_t *c /**< */, } xcb_x_print_print_get_document_data_cookie_t -xcb_x_print_print_get_document_data_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t max_bytes /**< */) +xcb_x_print_print_get_document_data_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t max_bytes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_DOCUMENT_DATA, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_DOCUMENT_DATA, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1326,19 +1456,19 @@ xcb_x_print_print_get_document_data_unchecked (xcb_connection_t *c /**< * } uint8_t * -xcb_x_print_print_get_document_data_data (const xcb_x_print_print_get_document_data_reply_t *R /**< */) +xcb_x_print_print_get_document_data_data (const xcb_x_print_print_get_document_data_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_x_print_print_get_document_data_data_length (const xcb_x_print_print_get_document_data_reply_t *R /**< */) +xcb_x_print_print_get_document_data_data_length (const xcb_x_print_print_get_document_data_reply_t *R) { return R->dataLen; } xcb_generic_iterator_t -xcb_x_print_print_get_document_data_data_end (const xcb_x_print_print_get_document_data_reply_t *R /**< */) +xcb_x_print_print_get_document_data_data_end (const xcb_x_print_print_get_document_data_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + (R->dataLen); @@ -1348,22 +1478,22 @@ xcb_x_print_print_get_document_data_data_end (const xcb_x_print_print_get_docume } xcb_x_print_print_get_document_data_reply_t * -xcb_x_print_print_get_document_data_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_document_data_reply (xcb_connection_t *c, xcb_x_print_print_get_document_data_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_get_document_data_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_x_print_print_start_page_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_x_print_print_start_page_checked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_START_PAGE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_START_PAGE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1382,14 +1512,14 @@ xcb_x_print_print_start_page_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_start_page (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_x_print_print_start_page (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_START_PAGE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_START_PAGE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1408,14 +1538,14 @@ xcb_x_print_print_start_page (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_end_page_checked (xcb_connection_t *c /**< */, - uint8_t cancel /**< */) +xcb_x_print_print_end_page_checked (xcb_connection_t *c, + uint8_t cancel) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_END_PAGE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_END_PAGE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1435,14 +1565,14 @@ xcb_x_print_print_end_page_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_x_print_print_end_page (xcb_connection_t *c /**< */, - uint8_t cancel /**< */) +xcb_x_print_print_end_page (xcb_connection_t *c, + uint8_t cancel) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_END_PAGE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_END_PAGE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1461,51 +1591,19 @@ xcb_x_print_print_end_page (xcb_connection_t *c /**< */, return xcb_ret; } -int -xcb_x_print_print_select_input_sizeof (const void *_buffer /**< */) -{ - char *xcb_tmp = (char *)_buffer; - const xcb_x_print_print_select_input_request_t *_aux = (xcb_x_print_print_select_input_request_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; - - - xcb_block_len += sizeof(xcb_x_print_print_select_input_request_t); - xcb_tmp += xcb_block_len; - xcb_buffer_len += xcb_block_len; - xcb_block_len = 0; - /* event_list */ - xcb_block_len += xcb_popcount(_aux->event_mask) * sizeof(uint32_t); - xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (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; - - return xcb_buffer_len; -} - xcb_void_cookie_t -xcb_x_print_print_select_input_checked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t event_mask /**< */, - const uint32_t *event_list /**< */) +xcb_x_print_print_select_input_checked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_SELECT_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_SELECT_INPUT, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[4]; xcb_void_cookie_t xcb_ret; xcb_x_print_print_select_input_request_t xcb_out; @@ -1516,30 +1614,24 @@ xcb_x_print_print_select_input_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t event_list */ - xcb_parts[4].iov_base = (char *) event_list; - xcb_parts[4].iov_len = xcb_popcount(event_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_x_print_print_select_input (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t event_mask /**< */, - const uint32_t *event_list /**< */) +xcb_x_print_print_select_input (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_SELECT_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_SELECT_INPUT, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[4]; xcb_void_cookie_t xcb_ret; xcb_x_print_print_select_input_request_t xcb_out; @@ -1550,192 +1642,20 @@ xcb_x_print_print_select_input (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t event_list */ - xcb_parts[4].iov_base = (char *) event_list; - xcb_parts[4].iov_len = xcb_popcount(event_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } -int -xcb_x_print_print_input_selected_serialize (void **_buffer /**< */, - const xcb_x_print_print_input_selected_reply_t *_aux /**< */, - const uint32_t *event_list /**< */, - const uint32_t *all_events_list /**< */) -{ - char *xcb_out = *_buffer; - unsigned int xcb_buffer_len = 0; - unsigned int xcb_align_to = 0; - - unsigned int xcb_pad = 0; - char xcb_pad0[3] = {0, 0, 0}; - struct iovec xcb_parts[6]; - unsigned int xcb_parts_idx = 0; - unsigned int xcb_block_len = 0; - unsigned int i; - char *xcb_tmp; - - /* xcb_x_print_print_input_selected_reply_t.pad0 */ - xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; - xcb_block_len += sizeof(uint8_t); - xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); - xcb_parts_idx++; - xcb_align_to = ALIGNOF(uint8_t); - /* xcb_x_print_print_input_selected_reply_t.event_mask */ - xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask; - xcb_block_len += sizeof(uint32_t); - xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); - xcb_parts_idx++; - xcb_align_to = ALIGNOF(uint32_t); - /* event_list */ - xcb_parts[xcb_parts_idx].iov_base = (char *) event_list; - xcb_block_len += xcb_popcount(_aux->event_mask) * sizeof(uint32_t); - xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(_aux->event_mask) * sizeof(uint32_t); - xcb_parts_idx++; - xcb_align_to = ALIGNOF(uint32_t); - /* xcb_x_print_print_input_selected_reply_t.all_events_mask */ - xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->all_events_mask; - xcb_block_len += sizeof(uint32_t); - xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); - xcb_parts_idx++; - xcb_align_to = ALIGNOF(uint32_t); - /* all_events_list */ - xcb_parts[xcb_parts_idx].iov_base = (char *) all_events_list; - xcb_block_len += xcb_popcount(_aux->all_events_mask) * sizeof(uint32_t); - xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(_aux->all_events_mask) * sizeof(uint32_t); - xcb_parts_idx++; - xcb_align_to = ALIGNOF(uint32_t); - /* insert padding */ - xcb_pad = -xcb_block_len & (xcb_align_to - 1); - xcb_buffer_len += xcb_block_len + xcb_pad; - if (0 != xcb_pad) { - xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; - xcb_parts[xcb_parts_idx].iov_len = xcb_pad; - xcb_parts_idx++; - xcb_pad = 0; - } - xcb_block_len = 0; - - if (NULL == xcb_out) { - /* allocate memory */ - xcb_out = malloc(xcb_buffer_len); - *_buffer = xcb_out; - } - - xcb_tmp = xcb_out; - for(i=0; ievent_mask); -} - -xcb_generic_iterator_t -xcb_x_print_print_input_selected_event_list_end (const xcb_x_print_print_input_selected_reply_t *R /**< */) -{ - xcb_generic_iterator_t i; - i.data = ((uint32_t *) (R + 1)) + (xcb_popcount(R->event_mask)); - i.rem = 0; - i.index = (char *) i.data - (char *) R; - return i; -} - -uint32_t * -xcb_x_print_print_input_selected_all_events_list (const xcb_x_print_print_input_selected_reply_t *R /**< */) -{ - xcb_generic_iterator_t prev = xcb_x_print_print_input_selected_event_list_end(R); - return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 4); -} - -int -xcb_x_print_print_input_selected_all_events_list_length (const xcb_x_print_print_input_selected_reply_t *R /**< */) -{ - return xcb_popcount(R->all_events_mask); -} - -xcb_generic_iterator_t -xcb_x_print_print_input_selected_all_events_list_end (const xcb_x_print_print_input_selected_reply_t *R /**< */) -{ - xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_x_print_print_input_selected_event_list_end(R); - i.data = ((uint32_t *) child.data) + (xcb_popcount(R->all_events_mask)); - i.rem = 0; - i.index = (char *) i.data - (char *) R; - return i; -} - xcb_x_print_print_input_selected_reply_t * -xcb_x_print_print_input_selected_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_input_selected_reply (xcb_connection_t *c, xcb_x_print_print_input_selected_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_input_selected_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_x_print_print_get_attributes_sizeof (const void *_buffer /**< */) +xcb_x_print_print_get_attributes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_x_print_print_get_attributes_reply_t *_aux = (xcb_x_print_print_get_attributes_reply_t *)_buffer; @@ -1865,15 +1739,15 @@ xcb_x_print_print_get_attributes_sizeof (const void *_buffer /**< */) } xcb_x_print_print_get_attributes_cookie_t -xcb_x_print_print_get_attributes (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint8_t pool /**< */) +xcb_x_print_print_get_attributes (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint8_t pool) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_ATTRIBUTES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1894,15 +1768,15 @@ xcb_x_print_print_get_attributes (xcb_connection_t *c /**< */, } xcb_x_print_print_get_attributes_cookie_t -xcb_x_print_print_get_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint8_t pool /**< */) +xcb_x_print_print_get_attributes_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint8_t pool) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_ATTRIBUTES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1923,19 +1797,19 @@ xcb_x_print_print_get_attributes_unchecked (xcb_connection_t *c /**< */, } xcb_x_print_string8_t * -xcb_x_print_print_get_attributes_attributes (const xcb_x_print_print_get_attributes_reply_t *R /**< */) +xcb_x_print_print_get_attributes_attributes (const xcb_x_print_print_get_attributes_reply_t *R) { return (xcb_x_print_string8_t *) (R + 1); } int -xcb_x_print_print_get_attributes_attributes_length (const xcb_x_print_print_get_attributes_reply_t *R /**< */) +xcb_x_print_print_get_attributes_attributes_length (const xcb_x_print_print_get_attributes_reply_t *R) { return R->stringLen; } xcb_generic_iterator_t -xcb_x_print_print_get_attributes_attributes_end (const xcb_x_print_print_get_attributes_reply_t *R /**< */) +xcb_x_print_print_get_attributes_attributes_end (const xcb_x_print_print_get_attributes_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_x_print_string8_t *) (R + 1)) + (R->stringLen); @@ -1945,15 +1819,15 @@ xcb_x_print_print_get_attributes_attributes_end (const xcb_x_print_print_get_att } xcb_x_print_print_get_attributes_reply_t * -xcb_x_print_print_get_attributes_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_attributes_reply (xcb_connection_t *c, xcb_x_print_print_get_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_get_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_x_print_print_get_one_attributes_sizeof (const void *_buffer /**< */) +xcb_x_print_print_get_one_attributes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_x_print_print_get_one_attributes_request_t *_aux = (xcb_x_print_print_get_one_attributes_request_t *)_buffer; @@ -1984,17 +1858,17 @@ xcb_x_print_print_get_one_attributes_sizeof (const void *_buffer /**< */) } xcb_x_print_print_get_one_attributes_cookie_t -xcb_x_print_print_get_one_attributes (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t nameLen /**< */, - uint8_t pool /**< */, - const xcb_x_print_string8_t *name /**< */) +xcb_x_print_print_get_one_attributes (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t nameLen, + uint8_t pool, + const xcb_x_print_string8_t *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_ONE_ATTRIBUTES, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_ONE_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -2021,17 +1895,17 @@ xcb_x_print_print_get_one_attributes (xcb_connection_t *c /**< */, } xcb_x_print_print_get_one_attributes_cookie_t -xcb_x_print_print_get_one_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t nameLen /**< */, - uint8_t pool /**< */, - const xcb_x_print_string8_t *name /**< */) +xcb_x_print_print_get_one_attributes_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t nameLen, + uint8_t pool, + const xcb_x_print_string8_t *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_ONE_ATTRIBUTES, - /* isvoid */ 0 + .count = 4, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_ONE_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -2058,19 +1932,19 @@ xcb_x_print_print_get_one_attributes_unchecked (xcb_connection_t *c } xcb_x_print_string8_t * -xcb_x_print_print_get_one_attributes_value (const xcb_x_print_print_get_one_attributes_reply_t *R /**< */) +xcb_x_print_print_get_one_attributes_value (const xcb_x_print_print_get_one_attributes_reply_t *R) { return (xcb_x_print_string8_t *) (R + 1); } int -xcb_x_print_print_get_one_attributes_value_length (const xcb_x_print_print_get_one_attributes_reply_t *R /**< */) +xcb_x_print_print_get_one_attributes_value_length (const xcb_x_print_print_get_one_attributes_reply_t *R) { return R->valueLen; } xcb_generic_iterator_t -xcb_x_print_print_get_one_attributes_value_end (const xcb_x_print_print_get_one_attributes_reply_t *R /**< */) +xcb_x_print_print_get_one_attributes_value_end (const xcb_x_print_print_get_one_attributes_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_x_print_string8_t *) (R + 1)) + (R->valueLen); @@ -2080,16 +1954,16 @@ xcb_x_print_print_get_one_attributes_value_end (const xcb_x_print_print_get_one_ } xcb_x_print_print_get_one_attributes_reply_t * -xcb_x_print_print_get_one_attributes_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_one_attributes_reply (xcb_connection_t *c, xcb_x_print_print_get_one_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_get_one_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_x_print_print_set_attributes_sizeof (const void *_buffer /**< */, - uint32_t attributes_len /**< */) +xcb_x_print_print_set_attributes_sizeof (const void *_buffer, + uint32_t attributes_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -2119,19 +1993,19 @@ xcb_x_print_print_set_attributes_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_x_print_print_set_attributes_checked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t stringLen /**< */, - uint8_t pool /**< */, - uint8_t rule /**< */, - uint32_t attributes_len /**< */, - const xcb_x_print_string8_t *attributes /**< */) +xcb_x_print_print_set_attributes_checked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t stringLen, + uint8_t pool, + uint8_t rule, + uint32_t attributes_len, + const xcb_x_print_string8_t *attributes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_SET_ATTRIBUTES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_SET_ATTRIBUTES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2159,19 +2033,19 @@ xcb_x_print_print_set_attributes_checked (xcb_connection_t *c /**< * } xcb_void_cookie_t -xcb_x_print_print_set_attributes (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t stringLen /**< */, - uint8_t pool /**< */, - uint8_t rule /**< */, - uint32_t attributes_len /**< */, - const xcb_x_print_string8_t *attributes /**< */) +xcb_x_print_print_set_attributes (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t stringLen, + uint8_t pool, + uint8_t rule, + uint32_t attributes_len, + const xcb_x_print_string8_t *attributes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_SET_ATTRIBUTES, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_SET_ATTRIBUTES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2198,15 +2072,37 @@ xcb_x_print_print_set_attributes (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_x_print_string8_t * +xcb_x_print_print_set_attributes_attributes (const xcb_x_print_print_set_attributes_request_t *R) +{ + return (xcb_x_print_string8_t *) (R + 1); +} + +int +xcb_x_print_print_set_attributes_attributes_length (const xcb_x_print_print_set_attributes_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_x_print_print_set_attributes_request_t))/sizeof(xcb_x_print_string8_t)); +} + +xcb_generic_iterator_t +xcb_x_print_print_set_attributes_attributes_end (const xcb_x_print_print_set_attributes_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_x_print_string8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_x_print_print_set_attributes_request_t))/sizeof(xcb_x_print_string8_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_x_print_print_get_page_dimensions_cookie_t -xcb_x_print_print_get_page_dimensions (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */) +xcb_x_print_print_get_page_dimensions (xcb_connection_t *c, + xcb_x_print_pcontext_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_PAGE_DIMENSIONS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_PAGE_DIMENSIONS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2225,14 +2121,14 @@ xcb_x_print_print_get_page_dimensions (xcb_connection_t *c /**< */, } xcb_x_print_print_get_page_dimensions_cookie_t -xcb_x_print_print_get_page_dimensions_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */) +xcb_x_print_print_get_page_dimensions_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_PAGE_DIMENSIONS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_PAGE_DIMENSIONS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2251,15 +2147,15 @@ xcb_x_print_print_get_page_dimensions_unchecked (xcb_connection_t *c /**< } xcb_x_print_print_get_page_dimensions_reply_t * -xcb_x_print_print_get_page_dimensions_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_page_dimensions_reply (xcb_connection_t *c, xcb_x_print_print_get_page_dimensions_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_get_page_dimensions_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_x_print_print_query_screens_sizeof (const void *_buffer /**< */) +xcb_x_print_print_query_screens_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_x_print_print_query_screens_reply_t *_aux = (xcb_x_print_print_query_screens_reply_t *)_buffer; @@ -2290,13 +2186,13 @@ xcb_x_print_print_query_screens_sizeof (const void *_buffer /**< */) } xcb_x_print_print_query_screens_cookie_t -xcb_x_print_print_query_screens (xcb_connection_t *c /**< */) +xcb_x_print_print_query_screens (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_QUERY_SCREENS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_QUERY_SCREENS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2314,13 +2210,13 @@ xcb_x_print_print_query_screens (xcb_connection_t *c /**< */) } xcb_x_print_print_query_screens_cookie_t -xcb_x_print_print_query_screens_unchecked (xcb_connection_t *c /**< */) +xcb_x_print_print_query_screens_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_QUERY_SCREENS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_QUERY_SCREENS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2338,19 +2234,19 @@ xcb_x_print_print_query_screens_unchecked (xcb_connection_t *c /**< */) } xcb_window_t * -xcb_x_print_print_query_screens_roots (const xcb_x_print_print_query_screens_reply_t *R /**< */) +xcb_x_print_print_query_screens_roots (const xcb_x_print_print_query_screens_reply_t *R) { return (xcb_window_t *) (R + 1); } int -xcb_x_print_print_query_screens_roots_length (const xcb_x_print_print_query_screens_reply_t *R /**< */) +xcb_x_print_print_query_screens_roots_length (const xcb_x_print_print_query_screens_reply_t *R) { return R->listCount; } xcb_generic_iterator_t -xcb_x_print_print_query_screens_roots_end (const xcb_x_print_print_query_screens_reply_t *R /**< */) +xcb_x_print_print_query_screens_roots_end (const xcb_x_print_print_query_screens_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_window_t *) (R + 1)) + (R->listCount); @@ -2360,23 +2256,23 @@ xcb_x_print_print_query_screens_roots_end (const xcb_x_print_print_query_screens } xcb_x_print_print_query_screens_reply_t * -xcb_x_print_print_query_screens_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_query_screens_reply (xcb_connection_t *c, xcb_x_print_print_query_screens_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_query_screens_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_x_print_print_set_image_resolution_cookie_t -xcb_x_print_print_set_image_resolution (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint16_t image_resolution /**< */) +xcb_x_print_print_set_image_resolution (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint16_t image_resolution) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_SET_IMAGE_RESOLUTION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_SET_IMAGE_RESOLUTION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2396,15 +2292,15 @@ xcb_x_print_print_set_image_resolution (xcb_connection_t *c /**< */, } xcb_x_print_print_set_image_resolution_cookie_t -xcb_x_print_print_set_image_resolution_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint16_t image_resolution /**< */) +xcb_x_print_print_set_image_resolution_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint16_t image_resolution) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_SET_IMAGE_RESOLUTION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_SET_IMAGE_RESOLUTION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2424,22 +2320,22 @@ xcb_x_print_print_set_image_resolution_unchecked (xcb_connection_t *c /** } xcb_x_print_print_set_image_resolution_reply_t * -xcb_x_print_print_set_image_resolution_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_set_image_resolution_reply (xcb_connection_t *c, xcb_x_print_print_set_image_resolution_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_set_image_resolution_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_x_print_print_get_image_resolution_cookie_t -xcb_x_print_print_get_image_resolution (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */) +xcb_x_print_print_get_image_resolution (xcb_connection_t *c, + xcb_x_print_pcontext_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_IMAGE_RESOLUTION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_IMAGE_RESOLUTION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2458,14 +2354,14 @@ xcb_x_print_print_get_image_resolution (xcb_connection_t *c /**< */, } xcb_x_print_print_get_image_resolution_cookie_t -xcb_x_print_print_get_image_resolution_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */) +xcb_x_print_print_get_image_resolution_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_x_print_id, - /* opcode */ XCB_X_PRINT_PRINT_GET_IMAGE_RESOLUTION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_x_print_id, + .opcode = XCB_X_PRINT_PRINT_GET_IMAGE_RESOLUTION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2484,9 +2380,9 @@ xcb_x_print_print_get_image_resolution_unchecked (xcb_connection_t *c /** } xcb_x_print_print_get_image_resolution_reply_t * -xcb_x_print_print_get_image_resolution_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_image_resolution_reply (xcb_connection_t *c, xcb_x_print_print_get_image_resolution_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_x_print_print_get_image_resolution_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/xprint.h b/lib/libxcb/src/xprint.h index 9bead9660..2763dd04c 100644 --- a/lib/libxcb/src/xprint.h +++ b/lib/libxcb/src/xprint.h @@ -30,26 +30,26 @@ typedef char xcb_x_print_string8_t; * @brief xcb_x_print_string8_iterator_t **/ typedef struct xcb_x_print_string8_iterator_t { - xcb_x_print_string8_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_x_print_string8_t *data; + int rem; + int index; } xcb_x_print_string8_iterator_t; /** * @brief xcb_x_print_printer_t **/ typedef struct xcb_x_print_printer_t { - uint32_t nameLen; /**< */ - uint32_t descLen; /**< */ + uint32_t nameLen; + uint32_t descLen; } xcb_x_print_printer_t; /** * @brief xcb_x_print_printer_iterator_t **/ typedef struct xcb_x_print_printer_iterator_t { - xcb_x_print_printer_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_x_print_printer_t *data; + int rem; + int index; } xcb_x_print_printer_iterator_t; typedef uint32_t xcb_x_print_pcontext_t; @@ -58,9 +58,9 @@ typedef uint32_t xcb_x_print_pcontext_t; * @brief xcb_x_print_pcontext_iterator_t **/ typedef struct xcb_x_print_pcontext_iterator_t { - xcb_x_print_pcontext_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_x_print_pcontext_t *data; + int rem; + int index; } xcb_x_print_pcontext_iterator_t; typedef enum xcb_x_print_get_doc_t { @@ -97,7 +97,7 @@ typedef enum xcb_x_print_attr_t { * @brief xcb_x_print_print_query_version_cookie_t **/ typedef struct xcb_x_print_print_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_query_version_cookie_t; /** Opcode for xcb_x_print_print_query_version. */ @@ -107,28 +107,28 @@ typedef struct xcb_x_print_print_query_version_cookie_t { * @brief xcb_x_print_print_query_version_request_t **/ typedef struct xcb_x_print_print_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_x_print_print_query_version_request_t; /** * @brief xcb_x_print_print_query_version_reply_t **/ typedef struct xcb_x_print_print_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t major_version; /**< */ - uint16_t minor_version; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t major_version; + uint16_t minor_version; } xcb_x_print_print_query_version_reply_t; /** * @brief xcb_x_print_print_get_printer_list_cookie_t **/ typedef struct xcb_x_print_print_get_printer_list_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_get_printer_list_cookie_t; /** Opcode for xcb_x_print_print_get_printer_list. */ @@ -138,23 +138,23 @@ typedef struct xcb_x_print_print_get_printer_list_cookie_t { * @brief xcb_x_print_print_get_printer_list_request_t **/ typedef struct xcb_x_print_print_get_printer_list_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t printerNameLen; /**< */ - uint32_t localeLen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t printerNameLen; + uint32_t localeLen; } xcb_x_print_print_get_printer_list_request_t; /** * @brief xcb_x_print_print_get_printer_list_reply_t **/ typedef struct xcb_x_print_print_get_printer_list_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t listCount; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t listCount; + uint8_t pad1[20]; } xcb_x_print_print_get_printer_list_reply_t; /** Opcode for xcb_x_print_print_rehash_printer_list. */ @@ -164,9 +164,9 @@ typedef struct xcb_x_print_print_get_printer_list_reply_t { * @brief xcb_x_print_print_rehash_printer_list_request_t **/ typedef struct xcb_x_print_print_rehash_printer_list_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_x_print_print_rehash_printer_list_request_t; /** Opcode for xcb_x_print_create_context. */ @@ -176,12 +176,12 @@ typedef struct xcb_x_print_print_rehash_printer_list_request_t { * @brief xcb_x_print_create_context_request_t **/ typedef struct xcb_x_print_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t context_id; /**< */ - uint32_t printerNameLen; /**< */ - uint32_t localeLen; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t context_id; + uint32_t printerNameLen; + uint32_t localeLen; } xcb_x_print_create_context_request_t; /** Opcode for xcb_x_print_print_set_context. */ @@ -191,17 +191,17 @@ typedef struct xcb_x_print_create_context_request_t { * @brief xcb_x_print_print_set_context_request_t **/ typedef struct xcb_x_print_print_set_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t context; } xcb_x_print_print_set_context_request_t; /** * @brief xcb_x_print_print_get_context_cookie_t **/ typedef struct xcb_x_print_print_get_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_get_context_cookie_t; /** Opcode for xcb_x_print_print_get_context. */ @@ -211,20 +211,20 @@ typedef struct xcb_x_print_print_get_context_cookie_t { * @brief xcb_x_print_print_get_context_request_t **/ typedef struct xcb_x_print_print_get_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_x_print_print_get_context_request_t; /** * @brief xcb_x_print_print_get_context_reply_t **/ typedef struct xcb_x_print_print_get_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context; } xcb_x_print_print_get_context_reply_t; /** Opcode for xcb_x_print_print_destroy_context. */ @@ -234,17 +234,17 @@ typedef struct xcb_x_print_print_get_context_reply_t { * @brief xcb_x_print_print_destroy_context_request_t **/ typedef struct xcb_x_print_print_destroy_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t context; } xcb_x_print_print_destroy_context_request_t; /** * @brief xcb_x_print_print_get_screen_of_context_cookie_t **/ typedef struct xcb_x_print_print_get_screen_of_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_get_screen_of_context_cookie_t; /** Opcode for xcb_x_print_print_get_screen_of_context. */ @@ -254,20 +254,20 @@ typedef struct xcb_x_print_print_get_screen_of_context_cookie_t { * @brief xcb_x_print_print_get_screen_of_context_request_t **/ typedef struct xcb_x_print_print_get_screen_of_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_x_print_print_get_screen_of_context_request_t; /** * @brief xcb_x_print_print_get_screen_of_context_reply_t **/ typedef struct xcb_x_print_print_get_screen_of_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t root; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_window_t root; } xcb_x_print_print_get_screen_of_context_reply_t; /** Opcode for xcb_x_print_print_start_job. */ @@ -277,10 +277,10 @@ typedef struct xcb_x_print_print_get_screen_of_context_reply_t { * @brief xcb_x_print_print_start_job_request_t **/ typedef struct xcb_x_print_print_start_job_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t output_mode; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t output_mode; } xcb_x_print_print_start_job_request_t; /** Opcode for xcb_x_print_print_end_job. */ @@ -290,10 +290,10 @@ typedef struct xcb_x_print_print_start_job_request_t { * @brief xcb_x_print_print_end_job_request_t **/ typedef struct xcb_x_print_print_end_job_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t cancel; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t cancel; } xcb_x_print_print_end_job_request_t; /** Opcode for xcb_x_print_print_start_doc. */ @@ -303,10 +303,10 @@ typedef struct xcb_x_print_print_end_job_request_t { * @brief xcb_x_print_print_start_doc_request_t **/ typedef struct xcb_x_print_print_start_doc_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t driver_mode; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t driver_mode; } xcb_x_print_print_start_doc_request_t; /** Opcode for xcb_x_print_print_end_doc. */ @@ -316,10 +316,10 @@ typedef struct xcb_x_print_print_start_doc_request_t { * @brief xcb_x_print_print_end_doc_request_t **/ typedef struct xcb_x_print_print_end_doc_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t cancel; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t cancel; } xcb_x_print_print_end_doc_request_t; /** Opcode for xcb_x_print_print_put_document_data. */ @@ -329,20 +329,20 @@ typedef struct xcb_x_print_print_end_doc_request_t { * @brief xcb_x_print_print_put_document_data_request_t **/ typedef struct xcb_x_print_print_put_document_data_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t len_data; /**< */ - uint16_t len_fmt; /**< */ - uint16_t len_options; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint32_t len_data; + uint16_t len_fmt; + uint16_t len_options; } xcb_x_print_print_put_document_data_request_t; /** * @brief xcb_x_print_print_get_document_data_cookie_t **/ typedef struct xcb_x_print_print_get_document_data_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_get_document_data_cookie_t; /** Opcode for xcb_x_print_print_get_document_data. */ @@ -352,25 +352,25 @@ typedef struct xcb_x_print_print_get_document_data_cookie_t { * @brief xcb_x_print_print_get_document_data_request_t **/ typedef struct xcb_x_print_print_get_document_data_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_x_print_pcontext_t context; /**< */ - uint32_t max_bytes; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_x_print_pcontext_t context; + uint32_t max_bytes; } xcb_x_print_print_get_document_data_request_t; /** * @brief xcb_x_print_print_get_document_data_reply_t **/ typedef struct xcb_x_print_print_get_document_data_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t status_code; /**< */ - uint32_t finished_flag; /**< */ - uint32_t dataLen; /**< */ - uint8_t pad1[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t status_code; + uint32_t finished_flag; + uint32_t dataLen; + uint8_t pad1[12]; } xcb_x_print_print_get_document_data_reply_t; /** Opcode for xcb_x_print_print_start_page. */ @@ -380,10 +380,10 @@ typedef struct xcb_x_print_print_get_document_data_reply_t { * @brief xcb_x_print_print_start_page_request_t **/ typedef struct xcb_x_print_print_start_page_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_x_print_print_start_page_request_t; /** Opcode for xcb_x_print_print_end_page. */ @@ -393,11 +393,11 @@ typedef struct xcb_x_print_print_start_page_request_t { * @brief xcb_x_print_print_end_page_request_t **/ typedef struct xcb_x_print_print_end_page_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t cancel; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t cancel; + uint8_t pad0[3]; } xcb_x_print_print_end_page_request_t; /** Opcode for xcb_x_print_print_select_input. */ @@ -407,18 +407,18 @@ typedef struct xcb_x_print_print_end_page_request_t { * @brief xcb_x_print_print_select_input_request_t **/ typedef struct xcb_x_print_print_select_input_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_x_print_pcontext_t context; /**< */ - uint32_t event_mask; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_x_print_pcontext_t context; + uint32_t event_mask; } xcb_x_print_print_select_input_request_t; /** * @brief xcb_x_print_print_input_selected_cookie_t **/ typedef struct xcb_x_print_print_input_selected_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_input_selected_cookie_t; /** Opcode for xcb_x_print_print_input_selected. */ @@ -428,29 +428,29 @@ typedef struct xcb_x_print_print_input_selected_cookie_t { * @brief xcb_x_print_print_input_selected_request_t **/ typedef struct xcb_x_print_print_input_selected_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_x_print_pcontext_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_x_print_pcontext_t context; } xcb_x_print_print_input_selected_request_t; /** * @brief xcb_x_print_print_input_selected_reply_t **/ typedef struct xcb_x_print_print_input_selected_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t event_mask; /**< */ - uint32_t all_events_mask; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t event_mask; + uint32_t all_events_mask; } xcb_x_print_print_input_selected_reply_t; /** * @brief xcb_x_print_print_get_attributes_cookie_t **/ typedef struct xcb_x_print_print_get_attributes_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_get_attributes_cookie_t; /** Opcode for xcb_x_print_print_get_attributes. */ @@ -460,31 +460,31 @@ typedef struct xcb_x_print_print_get_attributes_cookie_t { * @brief xcb_x_print_print_get_attributes_request_t **/ typedef struct xcb_x_print_print_get_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_x_print_pcontext_t context; /**< */ - uint8_t pool; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_x_print_pcontext_t context; + uint8_t pool; + uint8_t pad0[3]; } xcb_x_print_print_get_attributes_request_t; /** * @brief xcb_x_print_print_get_attributes_reply_t **/ typedef struct xcb_x_print_print_get_attributes_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t stringLen; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t stringLen; + uint8_t pad1[20]; } xcb_x_print_print_get_attributes_reply_t; /** * @brief xcb_x_print_print_get_one_attributes_cookie_t **/ typedef struct xcb_x_print_print_get_one_attributes_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_get_one_attributes_cookie_t; /** Opcode for xcb_x_print_print_get_one_attributes. */ @@ -494,25 +494,25 @@ typedef struct xcb_x_print_print_get_one_attributes_cookie_t { * @brief xcb_x_print_print_get_one_attributes_request_t **/ typedef struct xcb_x_print_print_get_one_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_x_print_pcontext_t context; /**< */ - uint32_t nameLen; /**< */ - uint8_t pool; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_x_print_pcontext_t context; + uint32_t nameLen; + uint8_t pool; + uint8_t pad0[3]; } xcb_x_print_print_get_one_attributes_request_t; /** * @brief xcb_x_print_print_get_one_attributes_reply_t **/ typedef struct xcb_x_print_print_get_one_attributes_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t valueLen; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t valueLen; + uint8_t pad1[20]; } xcb_x_print_print_get_one_attributes_reply_t; /** Opcode for xcb_x_print_print_set_attributes. */ @@ -522,21 +522,21 @@ typedef struct xcb_x_print_print_get_one_attributes_reply_t { * @brief xcb_x_print_print_set_attributes_request_t **/ typedef struct xcb_x_print_print_set_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_x_print_pcontext_t context; /**< */ - uint32_t stringLen; /**< */ - uint8_t pool; /**< */ - uint8_t rule; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_x_print_pcontext_t context; + uint32_t stringLen; + uint8_t pool; + uint8_t rule; + uint8_t pad0[2]; } xcb_x_print_print_set_attributes_request_t; /** * @brief xcb_x_print_print_get_page_dimensions_cookie_t **/ typedef struct xcb_x_print_print_get_page_dimensions_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_get_page_dimensions_cookie_t; /** Opcode for xcb_x_print_print_get_page_dimensions. */ @@ -546,33 +546,33 @@ typedef struct xcb_x_print_print_get_page_dimensions_cookie_t { * @brief xcb_x_print_print_get_page_dimensions_request_t **/ typedef struct xcb_x_print_print_get_page_dimensions_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_x_print_pcontext_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_x_print_pcontext_t context; } xcb_x_print_print_get_page_dimensions_request_t; /** * @brief xcb_x_print_print_get_page_dimensions_reply_t **/ typedef struct xcb_x_print_print_get_page_dimensions_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t offset_x; /**< */ - uint16_t offset_y; /**< */ - uint16_t reproducible_width; /**< */ - uint16_t reproducible_height; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t width; + uint16_t height; + uint16_t offset_x; + uint16_t offset_y; + uint16_t reproducible_width; + uint16_t reproducible_height; } xcb_x_print_print_get_page_dimensions_reply_t; /** * @brief xcb_x_print_print_query_screens_cookie_t **/ typedef struct xcb_x_print_print_query_screens_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_query_screens_cookie_t; /** Opcode for xcb_x_print_print_query_screens. */ @@ -582,28 +582,28 @@ typedef struct xcb_x_print_print_query_screens_cookie_t { * @brief xcb_x_print_print_query_screens_request_t **/ typedef struct xcb_x_print_print_query_screens_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_x_print_print_query_screens_request_t; /** * @brief xcb_x_print_print_query_screens_reply_t **/ typedef struct xcb_x_print_print_query_screens_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t listCount; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t listCount; + uint8_t pad1[20]; } xcb_x_print_print_query_screens_reply_t; /** * @brief xcb_x_print_print_set_image_resolution_cookie_t **/ typedef struct xcb_x_print_print_set_image_resolution_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_set_image_resolution_cookie_t; /** Opcode for xcb_x_print_print_set_image_resolution. */ @@ -613,29 +613,29 @@ typedef struct xcb_x_print_print_set_image_resolution_cookie_t { * @brief xcb_x_print_print_set_image_resolution_request_t **/ typedef struct xcb_x_print_print_set_image_resolution_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_x_print_pcontext_t context; /**< */ - uint16_t image_resolution; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_x_print_pcontext_t context; + uint16_t image_resolution; } xcb_x_print_print_set_image_resolution_request_t; /** * @brief xcb_x_print_print_set_image_resolution_reply_t **/ typedef struct xcb_x_print_print_set_image_resolution_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t previous_resolutions; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; + uint16_t previous_resolutions; } xcb_x_print_print_set_image_resolution_reply_t; /** * @brief xcb_x_print_print_get_image_resolution_cookie_t **/ typedef struct xcb_x_print_print_get_image_resolution_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_x_print_print_get_image_resolution_cookie_t; /** Opcode for xcb_x_print_print_get_image_resolution. */ @@ -645,21 +645,21 @@ typedef struct xcb_x_print_print_get_image_resolution_cookie_t { * @brief xcb_x_print_print_get_image_resolution_request_t **/ typedef struct xcb_x_print_print_get_image_resolution_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_x_print_pcontext_t context; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_x_print_pcontext_t context; } xcb_x_print_print_get_image_resolution_request_t; /** * @brief xcb_x_print_print_get_image_resolution_reply_t **/ typedef struct xcb_x_print_print_get_image_resolution_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t image_resolution; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t image_resolution; } xcb_x_print_print_get_image_resolution_reply_t; /** Opcode for xcb_x_print_notify. */ @@ -669,11 +669,11 @@ typedef struct xcb_x_print_print_get_image_resolution_reply_t { * @brief xcb_x_print_notify_event_t **/ typedef struct xcb_x_print_notify_event_t { - uint8_t response_type; /**< */ - uint8_t detail; /**< */ - uint16_t sequence; /**< */ - xcb_x_print_pcontext_t context; /**< */ - uint8_t cancel; /**< */ + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_x_print_pcontext_t context; + uint8_t cancel; } xcb_x_print_notify_event_t; /** Opcode for xcb_x_print_attribut_notify. */ @@ -683,10 +683,10 @@ typedef struct xcb_x_print_notify_event_t { * @brief xcb_x_print_attribut_notify_event_t **/ typedef struct xcb_x_print_attribut_notify_event_t { - uint8_t response_type; /**< */ - uint8_t detail; /**< */ - uint16_t sequence; /**< */ - xcb_x_print_pcontext_t context; /**< */ + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_x_print_pcontext_t context; } xcb_x_print_attribut_notify_event_t; /** Opcode for xcb_x_print_bad_context. */ @@ -696,9 +696,9 @@ typedef struct xcb_x_print_attribut_notify_event_t { * @brief xcb_x_print_bad_context_error_t **/ typedef struct xcb_x_print_bad_context_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_x_print_bad_context_error_t; /** Opcode for xcb_x_print_bad_sequence. */ @@ -708,9 +708,9 @@ typedef struct xcb_x_print_bad_context_error_t { * @brief xcb_x_print_bad_sequence_error_t **/ typedef struct xcb_x_print_bad_sequence_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_x_print_bad_sequence_error_t; /** @@ -722,7 +722,7 @@ typedef struct xcb_x_print_bad_sequence_error_t { * element. The member index is increased by sizeof(xcb_x_print_string8_t) */ void -xcb_x_print_string8_next (xcb_x_print_string8_iterator_t *i /**< */); +xcb_x_print_string8_next (xcb_x_print_string8_iterator_t *i); /** * Return the iterator pointing to the last element @@ -734,38 +734,38 @@ xcb_x_print_string8_next (xcb_x_print_string8_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_x_print_string8_end (xcb_x_print_string8_iterator_t i /**< */); +xcb_x_print_string8_end (xcb_x_print_string8_iterator_t i); int -xcb_x_print_printer_serialize (void **_buffer /**< */, - const xcb_x_print_printer_t *_aux /**< */, - const xcb_x_print_string8_t *name /**< */, - const xcb_x_print_string8_t *description /**< */); +xcb_x_print_printer_serialize (void **_buffer, + const xcb_x_print_printer_t *_aux, + const xcb_x_print_string8_t *name, + const xcb_x_print_string8_t *description); int -xcb_x_print_printer_unserialize (const void *_buffer /**< */, - xcb_x_print_printer_t **_aux /**< */); +xcb_x_print_printer_unserialize (const void *_buffer, + xcb_x_print_printer_t **_aux); int -xcb_x_print_printer_sizeof (const void *_buffer /**< */); +xcb_x_print_printer_sizeof (const void *_buffer); xcb_x_print_string8_t * -xcb_x_print_printer_name (const xcb_x_print_printer_t *R /**< */); +xcb_x_print_printer_name (const xcb_x_print_printer_t *R); int -xcb_x_print_printer_name_length (const xcb_x_print_printer_t *R /**< */); +xcb_x_print_printer_name_length (const xcb_x_print_printer_t *R); xcb_generic_iterator_t -xcb_x_print_printer_name_end (const xcb_x_print_printer_t *R /**< */); +xcb_x_print_printer_name_end (const xcb_x_print_printer_t *R); xcb_x_print_string8_t * -xcb_x_print_printer_description (const xcb_x_print_printer_t *R /**< */); +xcb_x_print_printer_description (const xcb_x_print_printer_t *R); int -xcb_x_print_printer_description_length (const xcb_x_print_printer_t *R /**< */); +xcb_x_print_printer_description_length (const xcb_x_print_printer_t *R); xcb_generic_iterator_t -xcb_x_print_printer_description_end (const xcb_x_print_printer_t *R /**< */); +xcb_x_print_printer_description_end (const xcb_x_print_printer_t *R); /** * Get the next element of the iterator @@ -776,7 +776,7 @@ xcb_x_print_printer_description_end (const xcb_x_print_printer_t *R /**< */); * element. The member index is increased by sizeof(xcb_x_print_printer_t) */ void -xcb_x_print_printer_next (xcb_x_print_printer_iterator_t *i /**< */); +xcb_x_print_printer_next (xcb_x_print_printer_iterator_t *i); /** * Return the iterator pointing to the last element @@ -788,7 +788,7 @@ xcb_x_print_printer_next (xcb_x_print_printer_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_x_print_printer_end (xcb_x_print_printer_iterator_t i /**< */); +xcb_x_print_printer_end (xcb_x_print_printer_iterator_t i); /** * Get the next element of the iterator @@ -799,7 +799,7 @@ xcb_x_print_printer_end (xcb_x_print_printer_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_x_print_pcontext_t) */ void -xcb_x_print_pcontext_next (xcb_x_print_pcontext_iterator_t *i /**< */); +xcb_x_print_pcontext_next (xcb_x_print_pcontext_iterator_t *i); /** * Return the iterator pointing to the last element @@ -811,7 +811,7 @@ xcb_x_print_pcontext_next (xcb_x_print_pcontext_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_x_print_pcontext_end (xcb_x_print_pcontext_iterator_t i /**< */); +xcb_x_print_pcontext_end (xcb_x_print_pcontext_iterator_t i); /** * @@ -822,7 +822,7 @@ xcb_x_print_pcontext_end (xcb_x_print_pcontext_iterator_t i /**< */); * */ xcb_x_print_print_query_version_cookie_t -xcb_x_print_print_query_version (xcb_connection_t *c /**< */); +xcb_x_print_print_query_version (xcb_connection_t *c); /** * @@ -836,7 +836,7 @@ xcb_x_print_print_query_version (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_x_print_print_query_version_cookie_t -xcb_x_print_print_query_version_unchecked (xcb_connection_t *c /**< */); +xcb_x_print_print_query_version_unchecked (xcb_connection_t *c); /** * Return the reply @@ -853,12 +853,12 @@ xcb_x_print_print_query_version_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_x_print_print_query_version_reply_t * -xcb_x_print_print_query_version_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_query_version_reply (xcb_connection_t *c, xcb_x_print_print_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_x_print_print_get_printer_list_sizeof (const void *_buffer /**< */); +xcb_x_print_print_get_printer_list_sizeof (const void *_buffer); /** * @@ -869,11 +869,11 @@ xcb_x_print_print_get_printer_list_sizeof (const void *_buffer /**< */); * */ xcb_x_print_print_get_printer_list_cookie_t -xcb_x_print_print_get_printer_list (xcb_connection_t *c /**< */, - uint32_t printerNameLen /**< */, - uint32_t localeLen /**< */, - const xcb_x_print_string8_t *printer_name /**< */, - const xcb_x_print_string8_t *locale /**< */); +xcb_x_print_print_get_printer_list (xcb_connection_t *c, + uint32_t printerNameLen, + uint32_t localeLen, + const xcb_x_print_string8_t *printer_name, + const xcb_x_print_string8_t *locale); /** * @@ -887,17 +887,17 @@ xcb_x_print_print_get_printer_list (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_x_print_print_get_printer_list_cookie_t -xcb_x_print_print_get_printer_list_unchecked (xcb_connection_t *c /**< */, - uint32_t printerNameLen /**< */, - uint32_t localeLen /**< */, - const xcb_x_print_string8_t *printer_name /**< */, - const xcb_x_print_string8_t *locale /**< */); +xcb_x_print_print_get_printer_list_unchecked (xcb_connection_t *c, + uint32_t printerNameLen, + uint32_t localeLen, + const xcb_x_print_string8_t *printer_name, + const xcb_x_print_string8_t *locale); int -xcb_x_print_print_get_printer_list_printers_length (const xcb_x_print_print_get_printer_list_reply_t *R /**< */); +xcb_x_print_print_get_printer_list_printers_length (const xcb_x_print_print_get_printer_list_reply_t *R); xcb_x_print_printer_iterator_t -xcb_x_print_print_get_printer_list_printers_iterator (const xcb_x_print_print_get_printer_list_reply_t *R /**< */); +xcb_x_print_print_get_printer_list_printers_iterator (const xcb_x_print_print_get_printer_list_reply_t *R); /** * Return the reply @@ -914,9 +914,9 @@ xcb_x_print_print_get_printer_list_printers_iterator (const xcb_x_print_print_ge * The returned value must be freed by the caller using free(). */ xcb_x_print_print_get_printer_list_reply_t * -xcb_x_print_print_get_printer_list_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_printer_list_reply (xcb_connection_t *c, xcb_x_print_print_get_printer_list_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -930,7 +930,7 @@ xcb_x_print_print_get_printer_list_reply (xcb_connection_t * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_rehash_printer_list_checked (xcb_connection_t *c /**< */); +xcb_x_print_print_rehash_printer_list_checked (xcb_connection_t *c); /** * @@ -941,10 +941,10 @@ xcb_x_print_print_rehash_printer_list_checked (xcb_connection_t *c /**< */); * */ xcb_void_cookie_t -xcb_x_print_print_rehash_printer_list (xcb_connection_t *c /**< */); +xcb_x_print_print_rehash_printer_list (xcb_connection_t *c); int -xcb_x_print_create_context_sizeof (const void *_buffer /**< */); +xcb_x_print_create_context_sizeof (const void *_buffer); /** * @@ -958,12 +958,12 @@ xcb_x_print_create_context_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_create_context_checked (xcb_connection_t *c /**< */, - uint32_t context_id /**< */, - uint32_t printerNameLen /**< */, - uint32_t localeLen /**< */, - const xcb_x_print_string8_t *printerName /**< */, - const xcb_x_print_string8_t *locale /**< */); +xcb_x_print_create_context_checked (xcb_connection_t *c, + uint32_t context_id, + uint32_t printerNameLen, + uint32_t localeLen, + const xcb_x_print_string8_t *printerName, + const xcb_x_print_string8_t *locale); /** * @@ -974,12 +974,30 @@ xcb_x_print_create_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_x_print_create_context (xcb_connection_t *c /**< */, - uint32_t context_id /**< */, - uint32_t printerNameLen /**< */, - uint32_t localeLen /**< */, - const xcb_x_print_string8_t *printerName /**< */, - const xcb_x_print_string8_t *locale /**< */); +xcb_x_print_create_context (xcb_connection_t *c, + uint32_t context_id, + uint32_t printerNameLen, + uint32_t localeLen, + const xcb_x_print_string8_t *printerName, + const xcb_x_print_string8_t *locale); + +xcb_x_print_string8_t * +xcb_x_print_create_context_printer_name (const xcb_x_print_create_context_request_t *R); + +int +xcb_x_print_create_context_printer_name_length (const xcb_x_print_create_context_request_t *R); + +xcb_generic_iterator_t +xcb_x_print_create_context_printer_name_end (const xcb_x_print_create_context_request_t *R); + +xcb_x_print_string8_t * +xcb_x_print_create_context_locale (const xcb_x_print_create_context_request_t *R); + +int +xcb_x_print_create_context_locale_length (const xcb_x_print_create_context_request_t *R); + +xcb_generic_iterator_t +xcb_x_print_create_context_locale_end (const xcb_x_print_create_context_request_t *R); /** * @@ -993,8 +1011,8 @@ xcb_x_print_create_context (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_set_context_checked (xcb_connection_t *c /**< */, - uint32_t context /**< */); +xcb_x_print_print_set_context_checked (xcb_connection_t *c, + uint32_t context); /** * @@ -1005,8 +1023,8 @@ xcb_x_print_print_set_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_x_print_print_set_context (xcb_connection_t *c /**< */, - uint32_t context /**< */); +xcb_x_print_print_set_context (xcb_connection_t *c, + uint32_t context); /** * @@ -1017,7 +1035,7 @@ xcb_x_print_print_set_context (xcb_connection_t *c /**< */, * */ xcb_x_print_print_get_context_cookie_t -xcb_x_print_print_get_context (xcb_connection_t *c /**< */); +xcb_x_print_print_get_context (xcb_connection_t *c); /** * @@ -1031,7 +1049,7 @@ xcb_x_print_print_get_context (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_x_print_print_get_context_cookie_t -xcb_x_print_print_get_context_unchecked (xcb_connection_t *c /**< */); +xcb_x_print_print_get_context_unchecked (xcb_connection_t *c); /** * Return the reply @@ -1048,9 +1066,9 @@ xcb_x_print_print_get_context_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_x_print_print_get_context_reply_t * -xcb_x_print_print_get_context_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_context_reply (xcb_connection_t *c, xcb_x_print_print_get_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1064,8 +1082,8 @@ xcb_x_print_print_get_context_reply (xcb_connection_t *c * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_destroy_context_checked (xcb_connection_t *c /**< */, - uint32_t context /**< */); +xcb_x_print_print_destroy_context_checked (xcb_connection_t *c, + uint32_t context); /** * @@ -1076,8 +1094,8 @@ xcb_x_print_print_destroy_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_x_print_print_destroy_context (xcb_connection_t *c /**< */, - uint32_t context /**< */); +xcb_x_print_print_destroy_context (xcb_connection_t *c, + uint32_t context); /** * @@ -1088,7 +1106,7 @@ xcb_x_print_print_destroy_context (xcb_connection_t *c /**< */, * */ xcb_x_print_print_get_screen_of_context_cookie_t -xcb_x_print_print_get_screen_of_context (xcb_connection_t *c /**< */); +xcb_x_print_print_get_screen_of_context (xcb_connection_t *c); /** * @@ -1102,7 +1120,7 @@ xcb_x_print_print_get_screen_of_context (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_x_print_print_get_screen_of_context_cookie_t -xcb_x_print_print_get_screen_of_context_unchecked (xcb_connection_t *c /**< */); +xcb_x_print_print_get_screen_of_context_unchecked (xcb_connection_t *c); /** * Return the reply @@ -1119,9 +1137,9 @@ xcb_x_print_print_get_screen_of_context_unchecked (xcb_connection_t *c /**< */) * The returned value must be freed by the caller using free(). */ xcb_x_print_print_get_screen_of_context_reply_t * -xcb_x_print_print_get_screen_of_context_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_screen_of_context_reply (xcb_connection_t *c, xcb_x_print_print_get_screen_of_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1135,8 +1153,8 @@ xcb_x_print_print_get_screen_of_context_reply (xcb_connection_t * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_start_job_checked (xcb_connection_t *c /**< */, - uint8_t output_mode /**< */); +xcb_x_print_print_start_job_checked (xcb_connection_t *c, + uint8_t output_mode); /** * @@ -1147,8 +1165,8 @@ xcb_x_print_print_start_job_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_x_print_print_start_job (xcb_connection_t *c /**< */, - uint8_t output_mode /**< */); +xcb_x_print_print_start_job (xcb_connection_t *c, + uint8_t output_mode); /** * @@ -1162,8 +1180,8 @@ xcb_x_print_print_start_job (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_end_job_checked (xcb_connection_t *c /**< */, - uint8_t cancel /**< */); +xcb_x_print_print_end_job_checked (xcb_connection_t *c, + uint8_t cancel); /** * @@ -1174,8 +1192,8 @@ xcb_x_print_print_end_job_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_x_print_print_end_job (xcb_connection_t *c /**< */, - uint8_t cancel /**< */); +xcb_x_print_print_end_job (xcb_connection_t *c, + uint8_t cancel); /** * @@ -1189,8 +1207,8 @@ xcb_x_print_print_end_job (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_start_doc_checked (xcb_connection_t *c /**< */, - uint8_t driver_mode /**< */); +xcb_x_print_print_start_doc_checked (xcb_connection_t *c, + uint8_t driver_mode); /** * @@ -1201,8 +1219,8 @@ xcb_x_print_print_start_doc_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_x_print_print_start_doc (xcb_connection_t *c /**< */, - uint8_t driver_mode /**< */); +xcb_x_print_print_start_doc (xcb_connection_t *c, + uint8_t driver_mode); /** * @@ -1216,8 +1234,8 @@ xcb_x_print_print_start_doc (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_end_doc_checked (xcb_connection_t *c /**< */, - uint8_t cancel /**< */); +xcb_x_print_print_end_doc_checked (xcb_connection_t *c, + uint8_t cancel); /** * @@ -1228,13 +1246,11 @@ xcb_x_print_print_end_doc_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_x_print_print_end_doc (xcb_connection_t *c /**< */, - uint8_t cancel /**< */); +xcb_x_print_print_end_doc (xcb_connection_t *c, + uint8_t cancel); int -xcb_x_print_print_put_document_data_sizeof (const void *_buffer /**< */, - uint32_t doc_format_len /**< */, - uint32_t options_len /**< */); +xcb_x_print_print_put_document_data_sizeof (const void *_buffer); /** * @@ -1248,16 +1264,14 @@ xcb_x_print_print_put_document_data_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_put_document_data_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t len_data /**< */, - uint16_t len_fmt /**< */, - uint16_t len_options /**< */, - const uint8_t *data /**< */, - uint32_t doc_format_len /**< */, - const xcb_x_print_string8_t *doc_format /**< */, - uint32_t options_len /**< */, - const xcb_x_print_string8_t *options /**< */); +xcb_x_print_print_put_document_data_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t len_data, + uint16_t len_fmt, + uint16_t len_options, + const uint8_t *data, + const xcb_x_print_string8_t *doc_format, + const xcb_x_print_string8_t *options); /** * @@ -1268,19 +1282,44 @@ xcb_x_print_print_put_document_data_checked (xcb_connection_t *c /** * */ xcb_void_cookie_t -xcb_x_print_print_put_document_data (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint32_t len_data /**< */, - uint16_t len_fmt /**< */, - uint16_t len_options /**< */, - const uint8_t *data /**< */, - uint32_t doc_format_len /**< */, - const xcb_x_print_string8_t *doc_format /**< */, - uint32_t options_len /**< */, - const xcb_x_print_string8_t *options /**< */); +xcb_x_print_print_put_document_data (xcb_connection_t *c, + xcb_drawable_t drawable, + uint32_t len_data, + uint16_t len_fmt, + uint16_t len_options, + const uint8_t *data, + const xcb_x_print_string8_t *doc_format, + const xcb_x_print_string8_t *options); + +uint8_t * +xcb_x_print_print_put_document_data_data (const xcb_x_print_print_put_document_data_request_t *R); int -xcb_x_print_print_get_document_data_sizeof (const void *_buffer /**< */); +xcb_x_print_print_put_document_data_data_length (const xcb_x_print_print_put_document_data_request_t *R); + +xcb_generic_iterator_t +xcb_x_print_print_put_document_data_data_end (const xcb_x_print_print_put_document_data_request_t *R); + +xcb_x_print_string8_t * +xcb_x_print_print_put_document_data_doc_format (const xcb_x_print_print_put_document_data_request_t *R); + +int +xcb_x_print_print_put_document_data_doc_format_length (const xcb_x_print_print_put_document_data_request_t *R); + +xcb_generic_iterator_t +xcb_x_print_print_put_document_data_doc_format_end (const xcb_x_print_print_put_document_data_request_t *R); + +xcb_x_print_string8_t * +xcb_x_print_print_put_document_data_options (const xcb_x_print_print_put_document_data_request_t *R); + +int +xcb_x_print_print_put_document_data_options_length (const xcb_x_print_print_put_document_data_request_t *R); + +xcb_generic_iterator_t +xcb_x_print_print_put_document_data_options_end (const xcb_x_print_print_put_document_data_request_t *R); + +int +xcb_x_print_print_get_document_data_sizeof (const void *_buffer); /** * @@ -1291,9 +1330,9 @@ xcb_x_print_print_get_document_data_sizeof (const void *_buffer /**< */); * */ xcb_x_print_print_get_document_data_cookie_t -xcb_x_print_print_get_document_data (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t max_bytes /**< */); +xcb_x_print_print_get_document_data (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t max_bytes); /** * @@ -1307,18 +1346,18 @@ xcb_x_print_print_get_document_data (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_x_print_print_get_document_data_cookie_t -xcb_x_print_print_get_document_data_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t max_bytes /**< */); +xcb_x_print_print_get_document_data_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t max_bytes); uint8_t * -xcb_x_print_print_get_document_data_data (const xcb_x_print_print_get_document_data_reply_t *R /**< */); +xcb_x_print_print_get_document_data_data (const xcb_x_print_print_get_document_data_reply_t *R); int -xcb_x_print_print_get_document_data_data_length (const xcb_x_print_print_get_document_data_reply_t *R /**< */); +xcb_x_print_print_get_document_data_data_length (const xcb_x_print_print_get_document_data_reply_t *R); xcb_generic_iterator_t -xcb_x_print_print_get_document_data_data_end (const xcb_x_print_print_get_document_data_reply_t *R /**< */); +xcb_x_print_print_get_document_data_data_end (const xcb_x_print_print_get_document_data_reply_t *R); /** * Return the reply @@ -1335,9 +1374,9 @@ xcb_x_print_print_get_document_data_data_end (const xcb_x_print_print_get_docume * The returned value must be freed by the caller using free(). */ xcb_x_print_print_get_document_data_reply_t * -xcb_x_print_print_get_document_data_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_document_data_reply (xcb_connection_t *c, xcb_x_print_print_get_document_data_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1351,8 +1390,8 @@ xcb_x_print_print_get_document_data_reply (xcb_connection_t * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_start_page_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_x_print_print_start_page_checked (xcb_connection_t *c, + xcb_window_t window); /** * @@ -1363,8 +1402,8 @@ xcb_x_print_print_start_page_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_x_print_print_start_page (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_x_print_print_start_page (xcb_connection_t *c, + xcb_window_t window); /** * @@ -1378,8 +1417,8 @@ xcb_x_print_print_start_page (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_end_page_checked (xcb_connection_t *c /**< */, - uint8_t cancel /**< */); +xcb_x_print_print_end_page_checked (xcb_connection_t *c, + uint8_t cancel); /** * @@ -1390,11 +1429,8 @@ xcb_x_print_print_end_page_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_x_print_print_end_page (xcb_connection_t *c /**< */, - uint8_t cancel /**< */); - -int -xcb_x_print_print_select_input_sizeof (const void *_buffer /**< */); +xcb_x_print_print_end_page (xcb_connection_t *c, + uint8_t cancel); /** * @@ -1408,10 +1444,9 @@ xcb_x_print_print_select_input_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_select_input_checked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t event_mask /**< */, - const uint32_t *event_list /**< */); +xcb_x_print_print_select_input_checked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t event_mask); /** * @@ -1422,23 +1457,9 @@ xcb_x_print_print_select_input_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_x_print_print_select_input (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t event_mask /**< */, - const uint32_t *event_list /**< */); - -int -xcb_x_print_print_input_selected_serialize (void **_buffer /**< */, - const xcb_x_print_print_input_selected_reply_t *_aux /**< */, - const uint32_t *event_list /**< */, - const uint32_t *all_events_list /**< */); - -int -xcb_x_print_print_input_selected_unserialize (const void *_buffer /**< */, - xcb_x_print_print_input_selected_reply_t **_aux /**< */); - -int -xcb_x_print_print_input_selected_sizeof (const void *_buffer /**< */); +xcb_x_print_print_select_input (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t event_mask); /** * @@ -1449,8 +1470,8 @@ xcb_x_print_print_input_selected_sizeof (const void *_buffer /**< */); * */ xcb_x_print_print_input_selected_cookie_t -xcb_x_print_print_input_selected (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */); +xcb_x_print_print_input_selected (xcb_connection_t *c, + xcb_x_print_pcontext_t context); /** * @@ -1464,26 +1485,8 @@ xcb_x_print_print_input_selected (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_x_print_print_input_selected_cookie_t -xcb_x_print_print_input_selected_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */); - -uint32_t * -xcb_x_print_print_input_selected_event_list (const xcb_x_print_print_input_selected_reply_t *R /**< */); - -int -xcb_x_print_print_input_selected_event_list_length (const xcb_x_print_print_input_selected_reply_t *R /**< */); - -xcb_generic_iterator_t -xcb_x_print_print_input_selected_event_list_end (const xcb_x_print_print_input_selected_reply_t *R /**< */); - -uint32_t * -xcb_x_print_print_input_selected_all_events_list (const xcb_x_print_print_input_selected_reply_t *R /**< */); - -int -xcb_x_print_print_input_selected_all_events_list_length (const xcb_x_print_print_input_selected_reply_t *R /**< */); - -xcb_generic_iterator_t -xcb_x_print_print_input_selected_all_events_list_end (const xcb_x_print_print_input_selected_reply_t *R /**< */); +xcb_x_print_print_input_selected_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context); /** * Return the reply @@ -1500,12 +1503,12 @@ xcb_x_print_print_input_selected_all_events_list_end (const xcb_x_print_print_in * The returned value must be freed by the caller using free(). */ xcb_x_print_print_input_selected_reply_t * -xcb_x_print_print_input_selected_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_input_selected_reply (xcb_connection_t *c, xcb_x_print_print_input_selected_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_x_print_print_get_attributes_sizeof (const void *_buffer /**< */); +xcb_x_print_print_get_attributes_sizeof (const void *_buffer); /** * @@ -1516,9 +1519,9 @@ xcb_x_print_print_get_attributes_sizeof (const void *_buffer /**< */); * */ xcb_x_print_print_get_attributes_cookie_t -xcb_x_print_print_get_attributes (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint8_t pool /**< */); +xcb_x_print_print_get_attributes (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint8_t pool); /** * @@ -1532,18 +1535,18 @@ xcb_x_print_print_get_attributes (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_x_print_print_get_attributes_cookie_t -xcb_x_print_print_get_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint8_t pool /**< */); +xcb_x_print_print_get_attributes_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint8_t pool); xcb_x_print_string8_t * -xcb_x_print_print_get_attributes_attributes (const xcb_x_print_print_get_attributes_reply_t *R /**< */); +xcb_x_print_print_get_attributes_attributes (const xcb_x_print_print_get_attributes_reply_t *R); int -xcb_x_print_print_get_attributes_attributes_length (const xcb_x_print_print_get_attributes_reply_t *R /**< */); +xcb_x_print_print_get_attributes_attributes_length (const xcb_x_print_print_get_attributes_reply_t *R); xcb_generic_iterator_t -xcb_x_print_print_get_attributes_attributes_end (const xcb_x_print_print_get_attributes_reply_t *R /**< */); +xcb_x_print_print_get_attributes_attributes_end (const xcb_x_print_print_get_attributes_reply_t *R); /** * Return the reply @@ -1560,12 +1563,12 @@ xcb_x_print_print_get_attributes_attributes_end (const xcb_x_print_print_get_att * The returned value must be freed by the caller using free(). */ xcb_x_print_print_get_attributes_reply_t * -xcb_x_print_print_get_attributes_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_attributes_reply (xcb_connection_t *c, xcb_x_print_print_get_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_x_print_print_get_one_attributes_sizeof (const void *_buffer /**< */); +xcb_x_print_print_get_one_attributes_sizeof (const void *_buffer); /** * @@ -1576,11 +1579,11 @@ xcb_x_print_print_get_one_attributes_sizeof (const void *_buffer /**< */); * */ xcb_x_print_print_get_one_attributes_cookie_t -xcb_x_print_print_get_one_attributes (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t nameLen /**< */, - uint8_t pool /**< */, - const xcb_x_print_string8_t *name /**< */); +xcb_x_print_print_get_one_attributes (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t nameLen, + uint8_t pool, + const xcb_x_print_string8_t *name); /** * @@ -1594,20 +1597,20 @@ xcb_x_print_print_get_one_attributes (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_x_print_print_get_one_attributes_cookie_t -xcb_x_print_print_get_one_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t nameLen /**< */, - uint8_t pool /**< */, - const xcb_x_print_string8_t *name /**< */); +xcb_x_print_print_get_one_attributes_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t nameLen, + uint8_t pool, + const xcb_x_print_string8_t *name); xcb_x_print_string8_t * -xcb_x_print_print_get_one_attributes_value (const xcb_x_print_print_get_one_attributes_reply_t *R /**< */); +xcb_x_print_print_get_one_attributes_value (const xcb_x_print_print_get_one_attributes_reply_t *R); int -xcb_x_print_print_get_one_attributes_value_length (const xcb_x_print_print_get_one_attributes_reply_t *R /**< */); +xcb_x_print_print_get_one_attributes_value_length (const xcb_x_print_print_get_one_attributes_reply_t *R); xcb_generic_iterator_t -xcb_x_print_print_get_one_attributes_value_end (const xcb_x_print_print_get_one_attributes_reply_t *R /**< */); +xcb_x_print_print_get_one_attributes_value_end (const xcb_x_print_print_get_one_attributes_reply_t *R); /** * Return the reply @@ -1624,13 +1627,13 @@ xcb_x_print_print_get_one_attributes_value_end (const xcb_x_print_print_get_one_ * The returned value must be freed by the caller using free(). */ xcb_x_print_print_get_one_attributes_reply_t * -xcb_x_print_print_get_one_attributes_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_one_attributes_reply (xcb_connection_t *c, xcb_x_print_print_get_one_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_x_print_print_set_attributes_sizeof (const void *_buffer /**< */, - uint32_t attributes_len /**< */); +xcb_x_print_print_set_attributes_sizeof (const void *_buffer, + uint32_t attributes_len); /** * @@ -1644,13 +1647,13 @@ xcb_x_print_print_set_attributes_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_x_print_print_set_attributes_checked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t stringLen /**< */, - uint8_t pool /**< */, - uint8_t rule /**< */, - uint32_t attributes_len /**< */, - const xcb_x_print_string8_t *attributes /**< */); +xcb_x_print_print_set_attributes_checked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t stringLen, + uint8_t pool, + uint8_t rule, + uint32_t attributes_len, + const xcb_x_print_string8_t *attributes); /** * @@ -1661,13 +1664,22 @@ xcb_x_print_print_set_attributes_checked (xcb_connection_t *c /**< * * */ xcb_void_cookie_t -xcb_x_print_print_set_attributes (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint32_t stringLen /**< */, - uint8_t pool /**< */, - uint8_t rule /**< */, - uint32_t attributes_len /**< */, - const xcb_x_print_string8_t *attributes /**< */); +xcb_x_print_print_set_attributes (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint32_t stringLen, + uint8_t pool, + uint8_t rule, + uint32_t attributes_len, + const xcb_x_print_string8_t *attributes); + +xcb_x_print_string8_t * +xcb_x_print_print_set_attributes_attributes (const xcb_x_print_print_set_attributes_request_t *R); + +int +xcb_x_print_print_set_attributes_attributes_length (const xcb_x_print_print_set_attributes_request_t *R); + +xcb_generic_iterator_t +xcb_x_print_print_set_attributes_attributes_end (const xcb_x_print_print_set_attributes_request_t *R); /** * @@ -1678,8 +1690,8 @@ xcb_x_print_print_set_attributes (xcb_connection_t *c /**< */, * */ xcb_x_print_print_get_page_dimensions_cookie_t -xcb_x_print_print_get_page_dimensions (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */); +xcb_x_print_print_get_page_dimensions (xcb_connection_t *c, + xcb_x_print_pcontext_t context); /** * @@ -1693,8 +1705,8 @@ xcb_x_print_print_get_page_dimensions (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_x_print_print_get_page_dimensions_cookie_t -xcb_x_print_print_get_page_dimensions_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */); +xcb_x_print_print_get_page_dimensions_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context); /** * Return the reply @@ -1711,12 +1723,12 @@ xcb_x_print_print_get_page_dimensions_unchecked (xcb_connection_t *c /**< * The returned value must be freed by the caller using free(). */ xcb_x_print_print_get_page_dimensions_reply_t * -xcb_x_print_print_get_page_dimensions_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_page_dimensions_reply (xcb_connection_t *c, xcb_x_print_print_get_page_dimensions_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_x_print_print_query_screens_sizeof (const void *_buffer /**< */); +xcb_x_print_print_query_screens_sizeof (const void *_buffer); /** * @@ -1727,7 +1739,7 @@ xcb_x_print_print_query_screens_sizeof (const void *_buffer /**< */); * */ xcb_x_print_print_query_screens_cookie_t -xcb_x_print_print_query_screens (xcb_connection_t *c /**< */); +xcb_x_print_print_query_screens (xcb_connection_t *c); /** * @@ -1741,16 +1753,16 @@ xcb_x_print_print_query_screens (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_x_print_print_query_screens_cookie_t -xcb_x_print_print_query_screens_unchecked (xcb_connection_t *c /**< */); +xcb_x_print_print_query_screens_unchecked (xcb_connection_t *c); xcb_window_t * -xcb_x_print_print_query_screens_roots (const xcb_x_print_print_query_screens_reply_t *R /**< */); +xcb_x_print_print_query_screens_roots (const xcb_x_print_print_query_screens_reply_t *R); int -xcb_x_print_print_query_screens_roots_length (const xcb_x_print_print_query_screens_reply_t *R /**< */); +xcb_x_print_print_query_screens_roots_length (const xcb_x_print_print_query_screens_reply_t *R); xcb_generic_iterator_t -xcb_x_print_print_query_screens_roots_end (const xcb_x_print_print_query_screens_reply_t *R /**< */); +xcb_x_print_print_query_screens_roots_end (const xcb_x_print_print_query_screens_reply_t *R); /** * Return the reply @@ -1767,9 +1779,9 @@ xcb_x_print_print_query_screens_roots_end (const xcb_x_print_print_query_screens * The returned value must be freed by the caller using free(). */ xcb_x_print_print_query_screens_reply_t * -xcb_x_print_print_query_screens_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_query_screens_reply (xcb_connection_t *c, xcb_x_print_print_query_screens_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1780,9 +1792,9 @@ xcb_x_print_print_query_screens_reply (xcb_connection_t * */ xcb_x_print_print_set_image_resolution_cookie_t -xcb_x_print_print_set_image_resolution (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint16_t image_resolution /**< */); +xcb_x_print_print_set_image_resolution (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint16_t image_resolution); /** * @@ -1796,9 +1808,9 @@ xcb_x_print_print_set_image_resolution (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_x_print_print_set_image_resolution_cookie_t -xcb_x_print_print_set_image_resolution_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */, - uint16_t image_resolution /**< */); +xcb_x_print_print_set_image_resolution_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context, + uint16_t image_resolution); /** * Return the reply @@ -1815,9 +1827,9 @@ xcb_x_print_print_set_image_resolution_unchecked (xcb_connection_t *c /** * The returned value must be freed by the caller using free(). */ xcb_x_print_print_set_image_resolution_reply_t * -xcb_x_print_print_set_image_resolution_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_set_image_resolution_reply (xcb_connection_t *c, xcb_x_print_print_set_image_resolution_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1828,8 +1840,8 @@ xcb_x_print_print_set_image_resolution_reply (xcb_connection_t * */ xcb_x_print_print_get_image_resolution_cookie_t -xcb_x_print_print_get_image_resolution (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */); +xcb_x_print_print_get_image_resolution (xcb_connection_t *c, + xcb_x_print_pcontext_t context); /** * @@ -1843,8 +1855,8 @@ xcb_x_print_print_get_image_resolution (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_x_print_print_get_image_resolution_cookie_t -xcb_x_print_print_get_image_resolution_unchecked (xcb_connection_t *c /**< */, - xcb_x_print_pcontext_t context /**< */); +xcb_x_print_print_get_image_resolution_unchecked (xcb_connection_t *c, + xcb_x_print_pcontext_t context); /** * Return the reply @@ -1861,9 +1873,9 @@ xcb_x_print_print_get_image_resolution_unchecked (xcb_connection_t *c /** * The returned value must be freed by the caller using free(). */ xcb_x_print_print_get_image_resolution_reply_t * -xcb_x_print_print_get_image_resolution_reply (xcb_connection_t *c /**< */, +xcb_x_print_print_get_image_resolution_reply (xcb_connection_t *c, xcb_x_print_print_get_image_resolution_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/xproto.c b/lib/libxcb/src/xproto.c index 4feb89d95..fcb0d2679 100644 --- a/lib/libxcb/src/xproto.c +++ b/lib/libxcb/src/xproto.c @@ -16,7 +16,7 @@ #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) void -xcb_char2b_next (xcb_char2b_iterator_t *i /**< */) +xcb_char2b_next (xcb_char2b_iterator_t *i) { --i->rem; ++i->data; @@ -24,7 +24,7 @@ xcb_char2b_next (xcb_char2b_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_char2b_end (xcb_char2b_iterator_t i /**< */) +xcb_char2b_end (xcb_char2b_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -34,7 +34,7 @@ xcb_char2b_end (xcb_char2b_iterator_t i /**< */) } void -xcb_window_next (xcb_window_iterator_t *i /**< */) +xcb_window_next (xcb_window_iterator_t *i) { --i->rem; ++i->data; @@ -42,7 +42,7 @@ xcb_window_next (xcb_window_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_window_end (xcb_window_iterator_t i /**< */) +xcb_window_end (xcb_window_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -52,7 +52,7 @@ xcb_window_end (xcb_window_iterator_t i /**< */) } void -xcb_pixmap_next (xcb_pixmap_iterator_t *i /**< */) +xcb_pixmap_next (xcb_pixmap_iterator_t *i) { --i->rem; ++i->data; @@ -60,7 +60,7 @@ xcb_pixmap_next (xcb_pixmap_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_pixmap_end (xcb_pixmap_iterator_t i /**< */) +xcb_pixmap_end (xcb_pixmap_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -70,7 +70,7 @@ xcb_pixmap_end (xcb_pixmap_iterator_t i /**< */) } void -xcb_cursor_next (xcb_cursor_iterator_t *i /**< */) +xcb_cursor_next (xcb_cursor_iterator_t *i) { --i->rem; ++i->data; @@ -78,7 +78,7 @@ xcb_cursor_next (xcb_cursor_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_cursor_end (xcb_cursor_iterator_t i /**< */) +xcb_cursor_end (xcb_cursor_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -88,7 +88,7 @@ xcb_cursor_end (xcb_cursor_iterator_t i /**< */) } void -xcb_font_next (xcb_font_iterator_t *i /**< */) +xcb_font_next (xcb_font_iterator_t *i) { --i->rem; ++i->data; @@ -96,7 +96,7 @@ xcb_font_next (xcb_font_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_font_end (xcb_font_iterator_t i /**< */) +xcb_font_end (xcb_font_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -106,7 +106,7 @@ xcb_font_end (xcb_font_iterator_t i /**< */) } void -xcb_gcontext_next (xcb_gcontext_iterator_t *i /**< */) +xcb_gcontext_next (xcb_gcontext_iterator_t *i) { --i->rem; ++i->data; @@ -114,7 +114,7 @@ xcb_gcontext_next (xcb_gcontext_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_gcontext_end (xcb_gcontext_iterator_t i /**< */) +xcb_gcontext_end (xcb_gcontext_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -124,7 +124,7 @@ xcb_gcontext_end (xcb_gcontext_iterator_t i /**< */) } void -xcb_colormap_next (xcb_colormap_iterator_t *i /**< */) +xcb_colormap_next (xcb_colormap_iterator_t *i) { --i->rem; ++i->data; @@ -132,7 +132,7 @@ xcb_colormap_next (xcb_colormap_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_colormap_end (xcb_colormap_iterator_t i /**< */) +xcb_colormap_end (xcb_colormap_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -142,7 +142,7 @@ xcb_colormap_end (xcb_colormap_iterator_t i /**< */) } void -xcb_atom_next (xcb_atom_iterator_t *i /**< */) +xcb_atom_next (xcb_atom_iterator_t *i) { --i->rem; ++i->data; @@ -150,7 +150,7 @@ xcb_atom_next (xcb_atom_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_atom_end (xcb_atom_iterator_t i /**< */) +xcb_atom_end (xcb_atom_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -160,7 +160,7 @@ xcb_atom_end (xcb_atom_iterator_t i /**< */) } void -xcb_drawable_next (xcb_drawable_iterator_t *i /**< */) +xcb_drawable_next (xcb_drawable_iterator_t *i) { --i->rem; ++i->data; @@ -168,7 +168,7 @@ xcb_drawable_next (xcb_drawable_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_drawable_end (xcb_drawable_iterator_t i /**< */) +xcb_drawable_end (xcb_drawable_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -178,7 +178,7 @@ xcb_drawable_end (xcb_drawable_iterator_t i /**< */) } void -xcb_fontable_next (xcb_fontable_iterator_t *i /**< */) +xcb_fontable_next (xcb_fontable_iterator_t *i) { --i->rem; ++i->data; @@ -186,7 +186,7 @@ xcb_fontable_next (xcb_fontable_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_fontable_end (xcb_fontable_iterator_t i /**< */) +xcb_fontable_end (xcb_fontable_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -196,7 +196,25 @@ xcb_fontable_end (xcb_fontable_iterator_t i /**< */) } void -xcb_visualid_next (xcb_visualid_iterator_t *i /**< */) +xcb_bool32_next (xcb_bool32_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_bool32_t); +} + +xcb_generic_iterator_t +xcb_bool32_end (xcb_bool32_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; + return ret; +} + +void +xcb_visualid_next (xcb_visualid_iterator_t *i) { --i->rem; ++i->data; @@ -204,7 +222,7 @@ xcb_visualid_next (xcb_visualid_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_visualid_end (xcb_visualid_iterator_t i /**< */) +xcb_visualid_end (xcb_visualid_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -214,7 +232,7 @@ xcb_visualid_end (xcb_visualid_iterator_t i /**< */) } void -xcb_timestamp_next (xcb_timestamp_iterator_t *i /**< */) +xcb_timestamp_next (xcb_timestamp_iterator_t *i) { --i->rem; ++i->data; @@ -222,7 +240,7 @@ xcb_timestamp_next (xcb_timestamp_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_timestamp_end (xcb_timestamp_iterator_t i /**< */) +xcb_timestamp_end (xcb_timestamp_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -232,7 +250,7 @@ xcb_timestamp_end (xcb_timestamp_iterator_t i /**< */) } void -xcb_keysym_next (xcb_keysym_iterator_t *i /**< */) +xcb_keysym_next (xcb_keysym_iterator_t *i) { --i->rem; ++i->data; @@ -240,7 +258,7 @@ xcb_keysym_next (xcb_keysym_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_keysym_end (xcb_keysym_iterator_t i /**< */) +xcb_keysym_end (xcb_keysym_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -250,7 +268,7 @@ xcb_keysym_end (xcb_keysym_iterator_t i /**< */) } void -xcb_keycode_next (xcb_keycode_iterator_t *i /**< */) +xcb_keycode_next (xcb_keycode_iterator_t *i) { --i->rem; ++i->data; @@ -258,7 +276,7 @@ xcb_keycode_next (xcb_keycode_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_keycode_end (xcb_keycode_iterator_t i /**< */) +xcb_keycode_end (xcb_keycode_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -268,7 +286,25 @@ xcb_keycode_end (xcb_keycode_iterator_t i /**< */) } void -xcb_button_next (xcb_button_iterator_t *i /**< */) +xcb_keycode32_next (xcb_keycode32_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_keycode32_t); +} + +xcb_generic_iterator_t +xcb_keycode32_end (xcb_keycode32_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; + return ret; +} + +void +xcb_button_next (xcb_button_iterator_t *i) { --i->rem; ++i->data; @@ -276,7 +312,7 @@ xcb_button_next (xcb_button_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_button_end (xcb_button_iterator_t i /**< */) +xcb_button_end (xcb_button_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -286,7 +322,7 @@ xcb_button_end (xcb_button_iterator_t i /**< */) } void -xcb_point_next (xcb_point_iterator_t *i /**< */) +xcb_point_next (xcb_point_iterator_t *i) { --i->rem; ++i->data; @@ -294,7 +330,7 @@ xcb_point_next (xcb_point_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_point_end (xcb_point_iterator_t i /**< */) +xcb_point_end (xcb_point_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -304,7 +340,7 @@ xcb_point_end (xcb_point_iterator_t i /**< */) } void -xcb_rectangle_next (xcb_rectangle_iterator_t *i /**< */) +xcb_rectangle_next (xcb_rectangle_iterator_t *i) { --i->rem; ++i->data; @@ -312,7 +348,7 @@ xcb_rectangle_next (xcb_rectangle_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_rectangle_end (xcb_rectangle_iterator_t i /**< */) +xcb_rectangle_end (xcb_rectangle_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -322,7 +358,7 @@ xcb_rectangle_end (xcb_rectangle_iterator_t i /**< */) } void -xcb_arc_next (xcb_arc_iterator_t *i /**< */) +xcb_arc_next (xcb_arc_iterator_t *i) { --i->rem; ++i->data; @@ -330,7 +366,7 @@ xcb_arc_next (xcb_arc_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_arc_end (xcb_arc_iterator_t i /**< */) +xcb_arc_end (xcb_arc_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -340,7 +376,7 @@ xcb_arc_end (xcb_arc_iterator_t i /**< */) } void -xcb_format_next (xcb_format_iterator_t *i /**< */) +xcb_format_next (xcb_format_iterator_t *i) { --i->rem; ++i->data; @@ -348,7 +384,7 @@ xcb_format_next (xcb_format_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_format_end (xcb_format_iterator_t i /**< */) +xcb_format_end (xcb_format_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -358,7 +394,7 @@ xcb_format_end (xcb_format_iterator_t i /**< */) } void -xcb_visualtype_next (xcb_visualtype_iterator_t *i /**< */) +xcb_visualtype_next (xcb_visualtype_iterator_t *i) { --i->rem; ++i->data; @@ -366,7 +402,7 @@ xcb_visualtype_next (xcb_visualtype_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_visualtype_end (xcb_visualtype_iterator_t i /**< */) +xcb_visualtype_end (xcb_visualtype_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -376,7 +412,7 @@ xcb_visualtype_end (xcb_visualtype_iterator_t i /**< */) } int -xcb_depth_sizeof (const void *_buffer /**< */) +xcb_depth_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_depth_t *_aux = (xcb_depth_t *)_buffer; @@ -407,19 +443,19 @@ xcb_depth_sizeof (const void *_buffer /**< */) } xcb_visualtype_t * -xcb_depth_visuals (const xcb_depth_t *R /**< */) +xcb_depth_visuals (const xcb_depth_t *R) { return (xcb_visualtype_t *) (R + 1); } int -xcb_depth_visuals_length (const xcb_depth_t *R /**< */) +xcb_depth_visuals_length (const xcb_depth_t *R) { return R->visuals_len; } xcb_visualtype_iterator_t -xcb_depth_visuals_iterator (const xcb_depth_t *R /**< */) +xcb_depth_visuals_iterator (const xcb_depth_t *R) { xcb_visualtype_iterator_t i; i.data = (xcb_visualtype_t *) (R + 1); @@ -429,7 +465,7 @@ xcb_depth_visuals_iterator (const xcb_depth_t *R /**< */) } void -xcb_depth_next (xcb_depth_iterator_t *i /**< */) +xcb_depth_next (xcb_depth_iterator_t *i) { xcb_depth_t *R = i->data; xcb_generic_iterator_t child; @@ -440,7 +476,7 @@ xcb_depth_next (xcb_depth_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_depth_end (xcb_depth_iterator_t i /**< */) +xcb_depth_end (xcb_depth_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -452,7 +488,7 @@ xcb_depth_end (xcb_depth_iterator_t i /**< */) } int -xcb_screen_sizeof (const void *_buffer /**< */) +xcb_screen_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_screen_t *_aux = (xcb_screen_t *)_buffer; @@ -488,13 +524,13 @@ xcb_screen_sizeof (const void *_buffer /**< */) } int -xcb_screen_allowed_depths_length (const xcb_screen_t *R /**< */) +xcb_screen_allowed_depths_length (const xcb_screen_t *R) { return R->allowed_depths_len; } xcb_depth_iterator_t -xcb_screen_allowed_depths_iterator (const xcb_screen_t *R /**< */) +xcb_screen_allowed_depths_iterator (const xcb_screen_t *R) { xcb_depth_iterator_t i; i.data = (xcb_depth_t *) (R + 1); @@ -504,7 +540,7 @@ xcb_screen_allowed_depths_iterator (const xcb_screen_t *R /**< */) } void -xcb_screen_next (xcb_screen_iterator_t *i /**< */) +xcb_screen_next (xcb_screen_iterator_t *i) { xcb_screen_t *R = i->data; xcb_generic_iterator_t child; @@ -515,7 +551,7 @@ xcb_screen_next (xcb_screen_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_screen_end (xcb_screen_iterator_t i /**< */) +xcb_screen_end (xcb_screen_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -527,7 +563,7 @@ xcb_screen_end (xcb_screen_iterator_t i /**< */) } int -xcb_setup_request_sizeof (const void *_buffer /**< */) +xcb_setup_request_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_setup_request_t *_aux = (xcb_setup_request_t *)_buffer; @@ -570,19 +606,19 @@ xcb_setup_request_sizeof (const void *_buffer /**< */) } char * -xcb_setup_request_authorization_protocol_name (const xcb_setup_request_t *R /**< */) +xcb_setup_request_authorization_protocol_name (const xcb_setup_request_t *R) { return (char *) (R + 1); } int -xcb_setup_request_authorization_protocol_name_length (const xcb_setup_request_t *R /**< */) +xcb_setup_request_authorization_protocol_name_length (const xcb_setup_request_t *R) { return R->authorization_protocol_name_len; } xcb_generic_iterator_t -xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R /**< */) +xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->authorization_protocol_name_len); @@ -592,31 +628,31 @@ xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R } char * -xcb_setup_request_authorization_protocol_data (const xcb_setup_request_t *R /**< */) +xcb_setup_request_authorization_protocol_data (const xcb_setup_request_t *R) { xcb_generic_iterator_t prev = xcb_setup_request_authorization_protocol_name_end(R); return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); } int -xcb_setup_request_authorization_protocol_data_length (const xcb_setup_request_t *R /**< */) +xcb_setup_request_authorization_protocol_data_length (const xcb_setup_request_t *R) { return R->authorization_protocol_data_len; } xcb_generic_iterator_t -xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R /**< */) +xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_setup_request_authorization_protocol_name_end(R); - i.data = ((char *) child.data) + (R->authorization_protocol_data_len); + xcb_generic_iterator_t prev = xcb_setup_request_authorization_protocol_name_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->authorization_protocol_data_len); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } void -xcb_setup_request_next (xcb_setup_request_iterator_t *i /**< */) +xcb_setup_request_next (xcb_setup_request_iterator_t *i) { xcb_setup_request_t *R = i->data; xcb_generic_iterator_t child; @@ -627,7 +663,7 @@ xcb_setup_request_next (xcb_setup_request_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_setup_request_end (xcb_setup_request_iterator_t i /**< */) +xcb_setup_request_end (xcb_setup_request_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -639,7 +675,7 @@ xcb_setup_request_end (xcb_setup_request_iterator_t i /**< */) } int -xcb_setup_failed_sizeof (const void *_buffer /**< */) +xcb_setup_failed_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_setup_failed_t *_aux = (xcb_setup_failed_t *)_buffer; @@ -670,19 +706,19 @@ xcb_setup_failed_sizeof (const void *_buffer /**< */) } char * -xcb_setup_failed_reason (const xcb_setup_failed_t *R /**< */) +xcb_setup_failed_reason (const xcb_setup_failed_t *R) { return (char *) (R + 1); } int -xcb_setup_failed_reason_length (const xcb_setup_failed_t *R /**< */) +xcb_setup_failed_reason_length (const xcb_setup_failed_t *R) { return R->reason_len; } xcb_generic_iterator_t -xcb_setup_failed_reason_end (const xcb_setup_failed_t *R /**< */) +xcb_setup_failed_reason_end (const xcb_setup_failed_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->reason_len); @@ -692,7 +728,7 @@ xcb_setup_failed_reason_end (const xcb_setup_failed_t *R /**< */) } void -xcb_setup_failed_next (xcb_setup_failed_iterator_t *i /**< */) +xcb_setup_failed_next (xcb_setup_failed_iterator_t *i) { xcb_setup_failed_t *R = i->data; xcb_generic_iterator_t child; @@ -703,7 +739,7 @@ xcb_setup_failed_next (xcb_setup_failed_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_setup_failed_end (xcb_setup_failed_iterator_t i /**< */) +xcb_setup_failed_end (xcb_setup_failed_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -715,7 +751,7 @@ xcb_setup_failed_end (xcb_setup_failed_iterator_t i /**< */) } int -xcb_setup_authenticate_sizeof (const void *_buffer /**< */) +xcb_setup_authenticate_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_setup_authenticate_t *_aux = (xcb_setup_authenticate_t *)_buffer; @@ -746,19 +782,19 @@ xcb_setup_authenticate_sizeof (const void *_buffer /**< */) } char * -xcb_setup_authenticate_reason (const xcb_setup_authenticate_t *R /**< */) +xcb_setup_authenticate_reason (const xcb_setup_authenticate_t *R) { return (char *) (R + 1); } int -xcb_setup_authenticate_reason_length (const xcb_setup_authenticate_t *R /**< */) +xcb_setup_authenticate_reason_length (const xcb_setup_authenticate_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R /**< */) +xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + ((R->length * 4)); @@ -768,7 +804,7 @@ xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R /**< */) } void -xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i /**< */) +xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i) { xcb_setup_authenticate_t *R = i->data; xcb_generic_iterator_t child; @@ -779,7 +815,7 @@ xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i /**< */) +xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -791,7 +827,7 @@ xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i /**< */) } int -xcb_setup_sizeof (const void *_buffer /**< */) +xcb_setup_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_setup_t *_aux = (xcb_setup_t *)_buffer; @@ -811,6 +847,15 @@ xcb_setup_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->vendor_len * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -851,19 +896,19 @@ xcb_setup_sizeof (const void *_buffer /**< */) } char * -xcb_setup_vendor (const xcb_setup_t *R /**< */) +xcb_setup_vendor (const xcb_setup_t *R) { return (char *) (R + 1); } int -xcb_setup_vendor_length (const xcb_setup_t *R /**< */) +xcb_setup_vendor_length (const xcb_setup_t *R) { return R->vendor_len; } xcb_generic_iterator_t -xcb_setup_vendor_end (const xcb_setup_t *R /**< */) +xcb_setup_vendor_end (const xcb_setup_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->vendor_len); @@ -873,37 +918,37 @@ xcb_setup_vendor_end (const xcb_setup_t *R /**< */) } xcb_format_t * -xcb_setup_pixmap_formats (const xcb_setup_t *R /**< */) +xcb_setup_pixmap_formats (const xcb_setup_t *R) { xcb_generic_iterator_t prev = xcb_setup_vendor_end(R); - return (xcb_format_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_format_t, prev.index) + 0); + return (xcb_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); } int -xcb_setup_pixmap_formats_length (const xcb_setup_t *R /**< */) +xcb_setup_pixmap_formats_length (const xcb_setup_t *R) { return R->pixmap_formats_len; } xcb_format_iterator_t -xcb_setup_pixmap_formats_iterator (const xcb_setup_t *R /**< */) +xcb_setup_pixmap_formats_iterator (const xcb_setup_t *R) { xcb_format_iterator_t i; xcb_generic_iterator_t prev = xcb_setup_vendor_end(R); - i.data = (xcb_format_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_format_t, prev.index)); + i.data = (xcb_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1))); i.rem = R->pixmap_formats_len; i.index = (char *) i.data - (char *) R; return i; } int -xcb_setup_roots_length (const xcb_setup_t *R /**< */) +xcb_setup_roots_length (const xcb_setup_t *R) { return R->roots_len; } xcb_screen_iterator_t -xcb_setup_roots_iterator (const xcb_setup_t *R /**< */) +xcb_setup_roots_iterator (const xcb_setup_t *R) { xcb_screen_iterator_t i; xcb_generic_iterator_t prev = xcb_format_end(xcb_setup_pixmap_formats_iterator(R)); @@ -914,7 +959,7 @@ xcb_setup_roots_iterator (const xcb_setup_t *R /**< */) } void -xcb_setup_next (xcb_setup_iterator_t *i /**< */) +xcb_setup_next (xcb_setup_iterator_t *i) { xcb_setup_t *R = i->data; xcb_generic_iterator_t child; @@ -925,7 +970,7 @@ xcb_setup_next (xcb_setup_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_setup_end (xcb_setup_iterator_t i /**< */) +xcb_setup_end (xcb_setup_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -937,7 +982,7 @@ xcb_setup_end (xcb_setup_iterator_t i /**< */) } void -xcb_client_message_data_next (xcb_client_message_data_iterator_t *i /**< */) +xcb_client_message_data_next (xcb_client_message_data_iterator_t *i) { --i->rem; ++i->data; @@ -945,7 +990,7 @@ xcb_client_message_data_next (xcb_client_message_data_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_client_message_data_end (xcb_client_message_data_iterator_t i /**< */) +xcb_client_message_data_end (xcb_client_message_data_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -955,7 +1000,313 @@ xcb_client_message_data_end (xcb_client_message_data_iterator_t i /**< */) } int -xcb_create_window_sizeof (const void *_buffer /**< */) +xcb_create_window_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_create_window_value_list_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[16]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(value_mask & XCB_CW_BACK_PIXMAP) { + /* xcb_create_window_value_list_t.background_pixmap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixmap; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BACK_PIXEL) { + /* xcb_create_window_value_list_t.background_pixel */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixel; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BORDER_PIXMAP) { + /* xcb_create_window_value_list_t.border_pixmap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixmap; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BORDER_PIXEL) { + /* xcb_create_window_value_list_t.border_pixel */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixel; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BIT_GRAVITY) { + /* xcb_create_window_value_list_t.bit_gravity */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bit_gravity; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_WIN_GRAVITY) { + /* xcb_create_window_value_list_t.win_gravity */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->win_gravity; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_STORE) { + /* xcb_create_window_value_list_t.backing_store */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_store; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PLANES) { + /* xcb_create_window_value_list_t.backing_planes */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_planes; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PIXEL) { + /* xcb_create_window_value_list_t.backing_pixel */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_pixel; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_OVERRIDE_REDIRECT) { + /* xcb_create_window_value_list_t.override_redirect */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->override_redirect; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_SAVE_UNDER) { + /* xcb_create_window_value_list_t.save_under */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->save_under; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_EVENT_MASK) { + /* xcb_create_window_value_list_t.event_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_DONT_PROPAGATE) { + /* xcb_create_window_value_list_t.do_not_propogate_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->do_not_propogate_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_COLORMAP) { + /* xcb_create_window_value_list_t.colormap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->colormap; + xcb_block_len += sizeof(xcb_colormap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_colormap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_colormap_t); + } + if(value_mask & XCB_CW_CURSOR) { + /* xcb_create_window_value_list_t.cursor */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cursor; + xcb_block_len += sizeof(xcb_cursor_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_cursor_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_cursor_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ibackground_pixmap = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BACK_PIXEL) { + /* xcb_create_window_value_list_t.background_pixel */ + _aux->background_pixel = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BORDER_PIXMAP) { + /* xcb_create_window_value_list_t.border_pixmap */ + _aux->border_pixmap = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BORDER_PIXEL) { + /* xcb_create_window_value_list_t.border_pixel */ + _aux->border_pixel = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BIT_GRAVITY) { + /* xcb_create_window_value_list_t.bit_gravity */ + _aux->bit_gravity = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_WIN_GRAVITY) { + /* xcb_create_window_value_list_t.win_gravity */ + _aux->win_gravity = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_STORE) { + /* xcb_create_window_value_list_t.backing_store */ + _aux->backing_store = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PLANES) { + /* xcb_create_window_value_list_t.backing_planes */ + _aux->backing_planes = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PIXEL) { + /* xcb_create_window_value_list_t.backing_pixel */ + _aux->backing_pixel = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_OVERRIDE_REDIRECT) { + /* xcb_create_window_value_list_t.override_redirect */ + _aux->override_redirect = *(xcb_bool32_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_tmp += sizeof(xcb_bool32_t); + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_SAVE_UNDER) { + /* xcb_create_window_value_list_t.save_under */ + _aux->save_under = *(xcb_bool32_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_tmp += sizeof(xcb_bool32_t); + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_EVENT_MASK) { + /* xcb_create_window_value_list_t.event_mask */ + _aux->event_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_DONT_PROPAGATE) { + /* xcb_create_window_value_list_t.do_not_propogate_mask */ + _aux->do_not_propogate_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_COLORMAP) { + /* xcb_create_window_value_list_t.colormap */ + _aux->colormap = *(xcb_colormap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_colormap_t); + xcb_tmp += sizeof(xcb_colormap_t); + xcb_align_to = ALIGNOF(xcb_colormap_t); + } + if(value_mask & XCB_CW_CURSOR) { + /* xcb_create_window_value_list_t.cursor */ + _aux->cursor = *(xcb_cursor_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_cursor_t); + xcb_tmp += sizeof(xcb_cursor_t); + xcb_align_to = ALIGNOF(xcb_cursor_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; +} + +int +xcb_create_window_value_list_sizeof (const void *_buffer, + uint32_t value_mask) +{ + xcb_create_window_value_list_t _aux; + return xcb_create_window_value_list_unpack(_buffer, value_mask, &_aux); +} + +int +xcb_create_window_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_create_window_request_t *_aux = (xcb_create_window_request_t *)_buffer; @@ -970,9 +1321,9 @@ xcb_create_window_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* value_list */ - xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_block_len += xcb_create_window_value_list_sizeof(xcb_tmp, _aux->value_mask); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -986,28 +1337,28 @@ xcb_create_window_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_create_window_checked (xcb_connection_t *c /**< */, - uint8_t depth /**< */, - xcb_window_t wid /**< */, - xcb_window_t parent /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t border_width /**< */, - uint16_t _class /**< */, - xcb_visualid_t visual /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_create_window_checked (xcb_connection_t *c, + uint8_t depth, + xcb_window_t wid, + xcb_window_t parent, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint16_t _class, + xcb_visualid_t visual, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CREATE_WINDOW, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CREATE_WINDOW, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_create_window_request_t xcb_out; @@ -1027,39 +1378,38 @@ xcb_create_window_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_create_window_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_create_window_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_create_window (xcb_connection_t *c /**< */, - uint8_t depth /**< */, - xcb_window_t wid /**< */, - xcb_window_t parent /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t border_width /**< */, - uint16_t _class /**< */, - xcb_visualid_t visual /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_create_window (xcb_connection_t *c, + uint8_t depth, + xcb_window_t wid, + xcb_window_t parent, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint16_t _class, + xcb_visualid_t visual, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CREATE_WINDOW, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CREATE_WINDOW, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_create_window_request_t xcb_out; @@ -1079,18 +1429,435 @@ xcb_create_window (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_create_window_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_create_window_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +xcb_void_cookie_t +xcb_create_window_aux_checked (xcb_connection_t *c, + uint8_t depth, + xcb_window_t wid, + xcb_window_t parent, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint16_t _class, + xcb_visualid_t visual, + uint32_t value_mask, + const xcb_create_window_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = 0, + .opcode = XCB_CREATE_WINDOW, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_create_window_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.depth = depth; + xcb_out.wid = wid; + xcb_out.parent = parent; + xcb_out.x = x; + xcb_out.y = y; + xcb_out.width = width; + xcb_out.height = height; + xcb_out.border_width = border_width; + xcb_out._class = _class; + xcb_out.visual = visual; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_create_window_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_create_window_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_create_window_aux (xcb_connection_t *c, + uint8_t depth, + xcb_window_t wid, + xcb_window_t parent, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint16_t _class, + xcb_visualid_t visual, + uint32_t value_mask, + const xcb_create_window_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = 0, + .opcode = XCB_CREATE_WINDOW, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_create_window_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.depth = depth; + xcb_out.wid = wid; + xcb_out.parent = parent; + xcb_out.x = x; + xcb_out.y = y; + xcb_out.width = width; + xcb_out.height = height; + xcb_out.border_width = border_width; + xcb_out._class = _class; + xcb_out.visual = visual; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_create_window_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_create_window_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_create_window_value_list (const xcb_create_window_request_t *R) +{ + return (void *) (R + 1); +} + int -xcb_change_window_attributes_sizeof (const void *_buffer /**< */) +xcb_change_window_attributes_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_change_window_attributes_value_list_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[16]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(value_mask & XCB_CW_BACK_PIXMAP) { + /* xcb_change_window_attributes_value_list_t.background_pixmap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixmap; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BACK_PIXEL) { + /* xcb_change_window_attributes_value_list_t.background_pixel */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixel; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BORDER_PIXMAP) { + /* xcb_change_window_attributes_value_list_t.border_pixmap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixmap; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BORDER_PIXEL) { + /* xcb_change_window_attributes_value_list_t.border_pixel */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixel; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BIT_GRAVITY) { + /* xcb_change_window_attributes_value_list_t.bit_gravity */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bit_gravity; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_WIN_GRAVITY) { + /* xcb_change_window_attributes_value_list_t.win_gravity */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->win_gravity; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_STORE) { + /* xcb_change_window_attributes_value_list_t.backing_store */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_store; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PLANES) { + /* xcb_change_window_attributes_value_list_t.backing_planes */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_planes; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PIXEL) { + /* xcb_change_window_attributes_value_list_t.backing_pixel */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_pixel; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_OVERRIDE_REDIRECT) { + /* xcb_change_window_attributes_value_list_t.override_redirect */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->override_redirect; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_SAVE_UNDER) { + /* xcb_change_window_attributes_value_list_t.save_under */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->save_under; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_EVENT_MASK) { + /* xcb_change_window_attributes_value_list_t.event_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_DONT_PROPAGATE) { + /* xcb_change_window_attributes_value_list_t.do_not_propogate_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->do_not_propogate_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_COLORMAP) { + /* xcb_change_window_attributes_value_list_t.colormap */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->colormap; + xcb_block_len += sizeof(xcb_colormap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_colormap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_colormap_t); + } + if(value_mask & XCB_CW_CURSOR) { + /* xcb_change_window_attributes_value_list_t.cursor */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cursor; + xcb_block_len += sizeof(xcb_cursor_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_cursor_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_cursor_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ibackground_pixmap = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BACK_PIXEL) { + /* xcb_change_window_attributes_value_list_t.background_pixel */ + _aux->background_pixel = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BORDER_PIXMAP) { + /* xcb_change_window_attributes_value_list_t.border_pixmap */ + _aux->border_pixmap = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_CW_BORDER_PIXEL) { + /* xcb_change_window_attributes_value_list_t.border_pixel */ + _aux->border_pixel = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BIT_GRAVITY) { + /* xcb_change_window_attributes_value_list_t.bit_gravity */ + _aux->bit_gravity = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_WIN_GRAVITY) { + /* xcb_change_window_attributes_value_list_t.win_gravity */ + _aux->win_gravity = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_STORE) { + /* xcb_change_window_attributes_value_list_t.backing_store */ + _aux->backing_store = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PLANES) { + /* xcb_change_window_attributes_value_list_t.backing_planes */ + _aux->backing_planes = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_BACKING_PIXEL) { + /* xcb_change_window_attributes_value_list_t.backing_pixel */ + _aux->backing_pixel = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_OVERRIDE_REDIRECT) { + /* xcb_change_window_attributes_value_list_t.override_redirect */ + _aux->override_redirect = *(xcb_bool32_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_tmp += sizeof(xcb_bool32_t); + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_SAVE_UNDER) { + /* xcb_change_window_attributes_value_list_t.save_under */ + _aux->save_under = *(xcb_bool32_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_tmp += sizeof(xcb_bool32_t); + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_CW_EVENT_MASK) { + /* xcb_change_window_attributes_value_list_t.event_mask */ + _aux->event_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_DONT_PROPAGATE) { + /* xcb_change_window_attributes_value_list_t.do_not_propogate_mask */ + _aux->do_not_propogate_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CW_COLORMAP) { + /* xcb_change_window_attributes_value_list_t.colormap */ + _aux->colormap = *(xcb_colormap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_colormap_t); + xcb_tmp += sizeof(xcb_colormap_t); + xcb_align_to = ALIGNOF(xcb_colormap_t); + } + if(value_mask & XCB_CW_CURSOR) { + /* xcb_change_window_attributes_value_list_t.cursor */ + _aux->cursor = *(xcb_cursor_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_cursor_t); + xcb_tmp += sizeof(xcb_cursor_t); + xcb_align_to = ALIGNOF(xcb_cursor_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; +} + +int +xcb_change_window_attributes_value_list_sizeof (const void *_buffer, + uint32_t value_mask) +{ + xcb_change_window_attributes_value_list_t _aux; + return xcb_change_window_attributes_value_list_unpack(_buffer, value_mask, &_aux); +} + +int +xcb_change_window_attributes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_change_window_attributes_request_t *_aux = (xcb_change_window_attributes_request_t *)_buffer; @@ -1105,9 +1872,9 @@ xcb_change_window_attributes_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* value_list */ - xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_block_len += xcb_change_window_attributes_value_list_sizeof(xcb_tmp, _aux->value_mask); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -1121,19 +1888,19 @@ xcb_change_window_attributes_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_change_window_attributes_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_change_window_attributes_checked (xcb_connection_t *c, + xcb_window_t window, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_WINDOW_ATTRIBUTES, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_change_window_attributes_request_t xcb_out; @@ -1145,30 +1912,29 @@ xcb_change_window_attributes_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_change_window_attributes_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_change_window_attributes_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_change_window_attributes (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_change_window_attributes (xcb_connection_t *c, + xcb_window_t window, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_WINDOW_ATTRIBUTES, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_change_window_attributes_request_t xcb_out; @@ -1180,25 +1946,102 @@ xcb_change_window_attributes (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_change_window_attributes_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_change_window_attributes_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } -xcb_get_window_attributes_cookie_t -xcb_get_window_attributes (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_void_cookie_t +xcb_change_window_attributes_aux_checked (xcb_connection_t *c, + xcb_window_t window, + uint32_t value_mask, + const xcb_change_window_attributes_value_list_t *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_WINDOW_ATTRIBUTES, - /* isvoid */ 0 + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_change_window_attributes_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pad0 = 0; + xcb_out.window = window; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_change_window_attributes_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_change_window_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_change_window_attributes_aux (xcb_connection_t *c, + xcb_window_t window, + uint32_t value_mask, + const xcb_change_window_attributes_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_change_window_attributes_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pad0 = 0; + xcb_out.window = window; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_change_window_attributes_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_change_window_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_change_window_attributes_value_list (const xcb_change_window_attributes_request_t *R) +{ + return (void *) (R + 1); +} + +xcb_get_window_attributes_cookie_t +xcb_get_window_attributes (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = 0, + .opcode = XCB_GET_WINDOW_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1218,14 +2061,14 @@ xcb_get_window_attributes (xcb_connection_t *c /**< */, } xcb_get_window_attributes_cookie_t -xcb_get_window_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_get_window_attributes_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_WINDOW_ATTRIBUTES, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_WINDOW_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1245,22 +2088,22 @@ xcb_get_window_attributes_unchecked (xcb_connection_t *c /**< */, } xcb_get_window_attributes_reply_t * -xcb_get_window_attributes_reply (xcb_connection_t *c /**< */, +xcb_get_window_attributes_reply (xcb_connection_t *c, xcb_get_window_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_window_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_destroy_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_destroy_window_checked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_DESTROY_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_DESTROY_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1280,14 +2123,14 @@ xcb_destroy_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_destroy_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_destroy_window (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_DESTROY_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_DESTROY_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1307,14 +2150,14 @@ xcb_destroy_window (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_destroy_subwindows_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_destroy_subwindows_checked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_DESTROY_SUBWINDOWS, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_DESTROY_SUBWINDOWS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1334,14 +2177,14 @@ xcb_destroy_subwindows_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_destroy_subwindows (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_destroy_subwindows (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_DESTROY_SUBWINDOWS, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_DESTROY_SUBWINDOWS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1361,15 +2204,15 @@ xcb_destroy_subwindows (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_change_save_set_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_window_t window /**< */) +xcb_change_save_set_checked (xcb_connection_t *c, + uint8_t mode, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CHANGE_SAVE_SET, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CHANGE_SAVE_SET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1389,15 +2232,15 @@ xcb_change_save_set_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_change_save_set (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_window_t window /**< */) +xcb_change_save_set (xcb_connection_t *c, + uint8_t mode, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CHANGE_SAVE_SET, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CHANGE_SAVE_SET, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1417,17 +2260,17 @@ xcb_change_save_set (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_reparent_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_window_t parent /**< */, - int16_t x /**< */, - int16_t y /**< */) +xcb_reparent_window_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_window_t parent, + int16_t x, + int16_t y) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_REPARENT_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_REPARENT_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1450,17 +2293,17 @@ xcb_reparent_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_reparent_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_window_t parent /**< */, - int16_t x /**< */, - int16_t y /**< */) +xcb_reparent_window (xcb_connection_t *c, + xcb_window_t window, + xcb_window_t parent, + int16_t x, + int16_t y) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_REPARENT_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_REPARENT_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1483,14 +2326,14 @@ xcb_reparent_window (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_map_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_map_window_checked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_MAP_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_MAP_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1510,14 +2353,14 @@ xcb_map_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_map_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_map_window (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_MAP_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_MAP_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1537,14 +2380,14 @@ xcb_map_window (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_map_subwindows_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_map_subwindows_checked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_MAP_SUBWINDOWS, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_MAP_SUBWINDOWS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1564,14 +2407,14 @@ xcb_map_subwindows_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_map_subwindows (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_map_subwindows (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_MAP_SUBWINDOWS, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_MAP_SUBWINDOWS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1591,14 +2434,14 @@ xcb_map_subwindows (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_unmap_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_unmap_window_checked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNMAP_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNMAP_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1618,14 +2461,14 @@ xcb_unmap_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_unmap_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_unmap_window (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNMAP_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNMAP_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1645,14 +2488,14 @@ xcb_unmap_window (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_unmap_subwindows_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_unmap_subwindows_checked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNMAP_SUBWINDOWS, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNMAP_SUBWINDOWS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1672,14 +2515,14 @@ xcb_unmap_subwindows_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_unmap_subwindows (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_unmap_subwindows (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNMAP_SUBWINDOWS, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNMAP_SUBWINDOWS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1699,7 +2542,193 @@ xcb_unmap_subwindows (xcb_connection_t *c /**< */, } int -xcb_configure_window_sizeof (const void *_buffer /**< */) +xcb_configure_window_value_list_serialize (void **_buffer, + uint16_t value_mask, + const xcb_configure_window_value_list_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[8]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(value_mask & XCB_CONFIG_WINDOW_X) { + /* xcb_configure_window_value_list_t.x */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->x; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_CONFIG_WINDOW_Y) { + /* xcb_configure_window_value_list_t.y */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->y; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_CONFIG_WINDOW_WIDTH) { + /* xcb_configure_window_value_list_t.width */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->width; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CONFIG_WINDOW_HEIGHT) { + /* xcb_configure_window_value_list_t.height */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->height; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) { + /* xcb_configure_window_value_list_t.border_width */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_width; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CONFIG_WINDOW_SIBLING) { + /* xcb_configure_window_value_list_t.sibling */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->sibling; + xcb_block_len += sizeof(xcb_window_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_window_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_window_t); + } + if(value_mask & XCB_CONFIG_WINDOW_STACK_MODE) { + /* xcb_configure_window_value_list_t.stack_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stack_mode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ix = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_CONFIG_WINDOW_Y) { + /* xcb_configure_window_value_list_t.y */ + _aux->y = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_CONFIG_WINDOW_WIDTH) { + /* xcb_configure_window_value_list_t.width */ + _aux->width = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CONFIG_WINDOW_HEIGHT) { + /* xcb_configure_window_value_list_t.height */ + _aux->height = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) { + /* xcb_configure_window_value_list_t.border_width */ + _aux->border_width = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_CONFIG_WINDOW_SIBLING) { + /* xcb_configure_window_value_list_t.sibling */ + _aux->sibling = *(xcb_window_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_window_t); + xcb_tmp += sizeof(xcb_window_t); + xcb_align_to = ALIGNOF(xcb_window_t); + } + if(value_mask & XCB_CONFIG_WINDOW_STACK_MODE) { + /* xcb_configure_window_value_list_t.stack_mode */ + _aux->stack_mode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_configure_window_value_list_sizeof (const void *_buffer, + uint16_t value_mask) +{ + xcb_configure_window_value_list_t _aux; + return xcb_configure_window_value_list_unpack(_buffer, value_mask, &_aux); +} + +int +xcb_configure_window_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_configure_window_request_t *_aux = (xcb_configure_window_request_t *)_buffer; @@ -1714,9 +2743,9 @@ xcb_configure_window_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* value_list */ - xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_block_len += xcb_configure_window_value_list_sizeof(xcb_tmp, _aux->value_mask); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -1730,19 +2759,19 @@ xcb_configure_window_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_configure_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_configure_window_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CONFIGURE_WINDOW, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CONFIGURE_WINDOW, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_configure_window_request_t xcb_out; @@ -1755,30 +2784,29 @@ xcb_configure_window_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_configure_window_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_configure_window_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_configure_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_configure_window (xcb_connection_t *c, + xcb_window_t window, + uint16_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CONFIGURE_WINDOW, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CONFIGURE_WINDOW, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_configure_window_request_t xcb_out; @@ -1791,26 +2819,105 @@ xcb_configure_window (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_configure_window_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_configure_window_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_circulate_window_checked (xcb_connection_t *c /**< */, - uint8_t direction /**< */, - xcb_window_t window /**< */) +xcb_configure_window_aux_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t value_mask, + const xcb_configure_window_value_list_t *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CIRCULATE_WINDOW, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CONFIGURE_WINDOW, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_configure_window_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pad0 = 0; + xcb_out.window = window; + xcb_out.value_mask = value_mask; + memset(xcb_out.pad1, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_configure_window_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_configure_window_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_configure_window_aux (xcb_connection_t *c, + xcb_window_t window, + uint16_t value_mask, + const xcb_configure_window_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = 0, + .opcode = XCB_CONFIGURE_WINDOW, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_configure_window_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pad0 = 0; + xcb_out.window = window; + xcb_out.value_mask = value_mask; + memset(xcb_out.pad1, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_configure_window_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_configure_window_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_configure_window_value_list (const xcb_configure_window_request_t *R) +{ + return (void *) (R + 1); +} + +xcb_void_cookie_t +xcb_circulate_window_checked (xcb_connection_t *c, + uint8_t direction, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = 0, + .opcode = XCB_CIRCULATE_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1830,15 +2937,15 @@ xcb_circulate_window_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_circulate_window (xcb_connection_t *c /**< */, - uint8_t direction /**< */, - xcb_window_t window /**< */) +xcb_circulate_window (xcb_connection_t *c, + uint8_t direction, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CIRCULATE_WINDOW, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CIRCULATE_WINDOW, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1858,14 +2965,14 @@ xcb_circulate_window (xcb_connection_t *c /**< */, } xcb_get_geometry_cookie_t -xcb_get_geometry (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_get_geometry (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_GEOMETRY, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_GEOMETRY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1885,14 +2992,14 @@ xcb_get_geometry (xcb_connection_t *c /**< */, } xcb_get_geometry_cookie_t -xcb_get_geometry_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */) +xcb_get_geometry_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_GEOMETRY, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_GEOMETRY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1912,15 +3019,15 @@ xcb_get_geometry_unchecked (xcb_connection_t *c /**< */, } xcb_get_geometry_reply_t * -xcb_get_geometry_reply (xcb_connection_t *c /**< */, +xcb_get_geometry_reply (xcb_connection_t *c, xcb_get_geometry_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_geometry_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_query_tree_sizeof (const void *_buffer /**< */) +xcb_query_tree_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_query_tree_reply_t *_aux = (xcb_query_tree_reply_t *)_buffer; @@ -1951,14 +3058,14 @@ xcb_query_tree_sizeof (const void *_buffer /**< */) } xcb_query_tree_cookie_t -xcb_query_tree (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_query_tree (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_QUERY_TREE, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_QUERY_TREE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1978,14 +3085,14 @@ xcb_query_tree (xcb_connection_t *c /**< */, } xcb_query_tree_cookie_t -xcb_query_tree_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_query_tree_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_QUERY_TREE, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_QUERY_TREE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2005,19 +3112,19 @@ xcb_query_tree_unchecked (xcb_connection_t *c /**< */, } xcb_window_t * -xcb_query_tree_children (const xcb_query_tree_reply_t *R /**< */) +xcb_query_tree_children (const xcb_query_tree_reply_t *R) { return (xcb_window_t *) (R + 1); } int -xcb_query_tree_children_length (const xcb_query_tree_reply_t *R /**< */) +xcb_query_tree_children_length (const xcb_query_tree_reply_t *R) { return R->children_len; } xcb_generic_iterator_t -xcb_query_tree_children_end (const xcb_query_tree_reply_t *R /**< */) +xcb_query_tree_children_end (const xcb_query_tree_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_window_t *) (R + 1)) + (R->children_len); @@ -2027,15 +3134,15 @@ xcb_query_tree_children_end (const xcb_query_tree_reply_t *R /**< */) } xcb_query_tree_reply_t * -xcb_query_tree_reply (xcb_connection_t *c /**< */, +xcb_query_tree_reply (xcb_connection_t *c, xcb_query_tree_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_query_tree_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_intern_atom_sizeof (const void *_buffer /**< */) +xcb_intern_atom_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_intern_atom_request_t *_aux = (xcb_intern_atom_request_t *)_buffer; @@ -2066,16 +3173,16 @@ xcb_intern_atom_sizeof (const void *_buffer /**< */) } xcb_intern_atom_cookie_t -xcb_intern_atom (xcb_connection_t *c /**< */, - uint8_t only_if_exists /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_intern_atom (xcb_connection_t *c, + uint8_t only_if_exists, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_INTERN_ATOM, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_INTERN_ATOM, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -2101,16 +3208,16 @@ xcb_intern_atom (xcb_connection_t *c /**< */, } xcb_intern_atom_cookie_t -xcb_intern_atom_unchecked (xcb_connection_t *c /**< */, - uint8_t only_if_exists /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_intern_atom_unchecked (xcb_connection_t *c, + uint8_t only_if_exists, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_INTERN_ATOM, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_INTERN_ATOM, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -2136,15 +3243,15 @@ xcb_intern_atom_unchecked (xcb_connection_t *c /**< */, } xcb_intern_atom_reply_t * -xcb_intern_atom_reply (xcb_connection_t *c /**< */, +xcb_intern_atom_reply (xcb_connection_t *c, xcb_intern_atom_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_intern_atom_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_get_atom_name_sizeof (const void *_buffer /**< */) +xcb_get_atom_name_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_get_atom_name_reply_t *_aux = (xcb_get_atom_name_reply_t *)_buffer; @@ -2175,14 +3282,14 @@ xcb_get_atom_name_sizeof (const void *_buffer /**< */) } xcb_get_atom_name_cookie_t -xcb_get_atom_name (xcb_connection_t *c /**< */, - xcb_atom_t atom /**< */) +xcb_get_atom_name (xcb_connection_t *c, + xcb_atom_t atom) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_ATOM_NAME, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_ATOM_NAME, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2202,14 +3309,14 @@ xcb_get_atom_name (xcb_connection_t *c /**< */, } xcb_get_atom_name_cookie_t -xcb_get_atom_name_unchecked (xcb_connection_t *c /**< */, - xcb_atom_t atom /**< */) +xcb_get_atom_name_unchecked (xcb_connection_t *c, + xcb_atom_t atom) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_ATOM_NAME, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_ATOM_NAME, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2229,19 +3336,19 @@ xcb_get_atom_name_unchecked (xcb_connection_t *c /**< */, } char * -xcb_get_atom_name_name (const xcb_get_atom_name_reply_t *R /**< */) +xcb_get_atom_name_name (const xcb_get_atom_name_reply_t *R) { return (char *) (R + 1); } int -xcb_get_atom_name_name_length (const xcb_get_atom_name_reply_t *R /**< */) +xcb_get_atom_name_name_length (const xcb_get_atom_name_reply_t *R) { return R->name_len; } xcb_generic_iterator_t -xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R /**< */) +xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->name_len); @@ -2251,15 +3358,15 @@ xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R /**< */) } xcb_get_atom_name_reply_t * -xcb_get_atom_name_reply (xcb_connection_t *c /**< */, +xcb_get_atom_name_reply (xcb_connection_t *c, xcb_get_atom_name_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_atom_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_change_property_sizeof (const void *_buffer /**< */) +xcb_change_property_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_change_property_request_t *_aux = (xcb_change_property_request_t *)_buffer; @@ -2290,20 +3397,20 @@ xcb_change_property_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_change_property_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint32_t data_len /**< */, - const void *data /**< */) +xcb_change_property_checked (xcb_connection_t *c, + uint8_t mode, + xcb_window_t window, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint32_t data_len, + const void *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_PROPERTY, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_CHANGE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2333,20 +3440,20 @@ xcb_change_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_change_property (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint32_t data_len /**< */, - const void *data /**< */) +xcb_change_property (xcb_connection_t *c, + uint8_t mode, + xcb_window_t window, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint32_t data_len, + const void *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_PROPERTY, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_CHANGE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2375,16 +3482,38 @@ xcb_change_property (xcb_connection_t *c /**< */, return xcb_ret; } +void * +xcb_change_property_data (const xcb_change_property_request_t *R) +{ + return (void *) (R + 1); +} + +int +xcb_change_property_data_length (const xcb_change_property_request_t *R) +{ + return ((R->data_len * R->format) / 8); +} + +xcb_generic_iterator_t +xcb_change_property_data_end (const xcb_change_property_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (((R->data_len * R->format) / 8)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_delete_property_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */) +xcb_delete_property_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_DELETE_PROPERTY, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_DELETE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2405,15 +3534,15 @@ xcb_delete_property_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_delete_property (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */) +xcb_delete_property (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_DELETE_PROPERTY, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_DELETE_PROPERTY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2434,7 +3563,7 @@ xcb_delete_property (xcb_connection_t *c /**< */, } int -xcb_get_property_sizeof (const void *_buffer /**< */) +xcb_get_property_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_get_property_reply_t *_aux = (xcb_get_property_reply_t *)_buffer; @@ -2465,19 +3594,19 @@ xcb_get_property_sizeof (const void *_buffer /**< */) } xcb_get_property_cookie_t -xcb_get_property (xcb_connection_t *c /**< */, - uint8_t _delete /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */) +xcb_get_property (xcb_connection_t *c, + uint8_t _delete, + xcb_window_t window, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2501,19 +3630,19 @@ xcb_get_property (xcb_connection_t *c /**< */, } xcb_get_property_cookie_t -xcb_get_property_unchecked (xcb_connection_t *c /**< */, - uint8_t _delete /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */) +xcb_get_property_unchecked (xcb_connection_t *c, + uint8_t _delete, + xcb_window_t window, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_PROPERTY, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_PROPERTY, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2537,19 +3666,19 @@ xcb_get_property_unchecked (xcb_connection_t *c /**< */, } void * -xcb_get_property_value (const xcb_get_property_reply_t *R /**< */) +xcb_get_property_value (const xcb_get_property_reply_t *R) { return (void *) (R + 1); } int -xcb_get_property_value_length (const xcb_get_property_reply_t *R /**< */) +xcb_get_property_value_length (const xcb_get_property_reply_t *R) { return (R->value_len * (R->format / 8)); } xcb_generic_iterator_t -xcb_get_property_value_end (const xcb_get_property_reply_t *R /**< */) +xcb_get_property_value_end (const xcb_get_property_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + ((R->value_len * (R->format / 8))); @@ -2559,15 +3688,15 @@ xcb_get_property_value_end (const xcb_get_property_reply_t *R /**< */) } xcb_get_property_reply_t * -xcb_get_property_reply (xcb_connection_t *c /**< */, +xcb_get_property_reply (xcb_connection_t *c, xcb_get_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_list_properties_sizeof (const void *_buffer /**< */) +xcb_list_properties_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_list_properties_reply_t *_aux = (xcb_list_properties_reply_t *)_buffer; @@ -2598,14 +3727,14 @@ xcb_list_properties_sizeof (const void *_buffer /**< */) } xcb_list_properties_cookie_t -xcb_list_properties (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_list_properties (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_LIST_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_LIST_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2625,14 +3754,14 @@ xcb_list_properties (xcb_connection_t *c /**< */, } xcb_list_properties_cookie_t -xcb_list_properties_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_list_properties_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_LIST_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_LIST_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2652,19 +3781,19 @@ xcb_list_properties_unchecked (xcb_connection_t *c /**< */, } xcb_atom_t * -xcb_list_properties_atoms (const xcb_list_properties_reply_t *R /**< */) +xcb_list_properties_atoms (const xcb_list_properties_reply_t *R) { return (xcb_atom_t *) (R + 1); } int -xcb_list_properties_atoms_length (const xcb_list_properties_reply_t *R /**< */) +xcb_list_properties_atoms_length (const xcb_list_properties_reply_t *R) { return R->atoms_len; } xcb_generic_iterator_t -xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R /**< */) +xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_atom_t *) (R + 1)) + (R->atoms_len); @@ -2674,24 +3803,24 @@ xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R /**< */) } xcb_list_properties_reply_t * -xcb_list_properties_reply (xcb_connection_t *c /**< */, +xcb_list_properties_reply (xcb_connection_t *c, xcb_list_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_set_selection_owner_checked (xcb_connection_t *c /**< */, - xcb_window_t owner /**< */, - xcb_atom_t selection /**< */, - xcb_timestamp_t time /**< */) +xcb_set_selection_owner_checked (xcb_connection_t *c, + xcb_window_t owner, + xcb_atom_t selection, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SET_SELECTION_OWNER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SET_SELECTION_OWNER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2713,16 +3842,16 @@ xcb_set_selection_owner_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_set_selection_owner (xcb_connection_t *c /**< */, - xcb_window_t owner /**< */, - xcb_atom_t selection /**< */, - xcb_timestamp_t time /**< */) +xcb_set_selection_owner (xcb_connection_t *c, + xcb_window_t owner, + xcb_atom_t selection, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SET_SELECTION_OWNER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SET_SELECTION_OWNER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2744,14 +3873,14 @@ xcb_set_selection_owner (xcb_connection_t *c /**< */, } xcb_get_selection_owner_cookie_t -xcb_get_selection_owner (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */) +xcb_get_selection_owner (xcb_connection_t *c, + xcb_atom_t selection) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_SELECTION_OWNER, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_SELECTION_OWNER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2771,14 +3900,14 @@ xcb_get_selection_owner (xcb_connection_t *c /**< */, } xcb_get_selection_owner_cookie_t -xcb_get_selection_owner_unchecked (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */) +xcb_get_selection_owner_unchecked (xcb_connection_t *c, + xcb_atom_t selection) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_SELECTION_OWNER, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_SELECTION_OWNER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2798,26 +3927,26 @@ xcb_get_selection_owner_unchecked (xcb_connection_t *c /**< */, } xcb_get_selection_owner_reply_t * -xcb_get_selection_owner_reply (xcb_connection_t *c /**< */, +xcb_get_selection_owner_reply (xcb_connection_t *c, xcb_get_selection_owner_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_selection_owner_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_convert_selection_checked (xcb_connection_t *c /**< */, - xcb_window_t requestor /**< */, - xcb_atom_t selection /**< */, - xcb_atom_t target /**< */, - xcb_atom_t property /**< */, - xcb_timestamp_t time /**< */) +xcb_convert_selection_checked (xcb_connection_t *c, + xcb_window_t requestor, + xcb_atom_t selection, + xcb_atom_t target, + xcb_atom_t property, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CONVERT_SELECTION, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CONVERT_SELECTION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2841,18 +3970,18 @@ xcb_convert_selection_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_convert_selection (xcb_connection_t *c /**< */, - xcb_window_t requestor /**< */, - xcb_atom_t selection /**< */, - xcb_atom_t target /**< */, - xcb_atom_t property /**< */, - xcb_timestamp_t time /**< */) +xcb_convert_selection (xcb_connection_t *c, + xcb_window_t requestor, + xcb_atom_t selection, + xcb_atom_t target, + xcb_atom_t property, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CONVERT_SELECTION, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CONVERT_SELECTION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2876,17 +4005,17 @@ xcb_convert_selection (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_send_event_checked (xcb_connection_t *c /**< */, - uint8_t propagate /**< */, - xcb_window_t destination /**< */, - uint32_t event_mask /**< */, - const char *event /**< */) +xcb_send_event_checked (xcb_connection_t *c, + uint8_t propagate, + xcb_window_t destination, + uint32_t event_mask, + const char *event) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SEND_EVENT, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SEND_EVENT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2908,17 +4037,17 @@ xcb_send_event_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_send_event (xcb_connection_t *c /**< */, - uint8_t propagate /**< */, - xcb_window_t destination /**< */, - uint32_t event_mask /**< */, - const char *event /**< */) +xcb_send_event (xcb_connection_t *c, + uint8_t propagate, + xcb_window_t destination, + uint32_t event_mask, + const char *event) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SEND_EVENT, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SEND_EVENT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2940,21 +4069,21 @@ xcb_send_event (xcb_connection_t *c /**< */, } xcb_grab_pointer_cookie_t -xcb_grab_pointer (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t event_mask /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */, - xcb_window_t confine_to /**< */, - xcb_cursor_t cursor /**< */, - xcb_timestamp_t time /**< */) +xcb_grab_pointer (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t event_mask, + uint8_t pointer_mode, + uint8_t keyboard_mode, + xcb_window_t confine_to, + xcb_cursor_t cursor, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GRAB_POINTER, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GRAB_POINTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2980,21 +4109,21 @@ xcb_grab_pointer (xcb_connection_t *c /**< */, } xcb_grab_pointer_cookie_t -xcb_grab_pointer_unchecked (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t event_mask /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */, - xcb_window_t confine_to /**< */, - xcb_cursor_t cursor /**< */, - xcb_timestamp_t time /**< */) +xcb_grab_pointer_unchecked (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t event_mask, + uint8_t pointer_mode, + uint8_t keyboard_mode, + xcb_window_t confine_to, + xcb_cursor_t cursor, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GRAB_POINTER, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GRAB_POINTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3020,22 +4149,22 @@ xcb_grab_pointer_unchecked (xcb_connection_t *c /**< */, } xcb_grab_pointer_reply_t * -xcb_grab_pointer_reply (xcb_connection_t *c /**< */, +xcb_grab_pointer_reply (xcb_connection_t *c, xcb_grab_pointer_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_grab_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_ungrab_pointer_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */) +xcb_ungrab_pointer_checked (xcb_connection_t *c, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNGRAB_POINTER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNGRAB_POINTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3055,14 +4184,14 @@ xcb_ungrab_pointer_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_ungrab_pointer (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */) +xcb_ungrab_pointer (xcb_connection_t *c, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNGRAB_POINTER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNGRAB_POINTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3082,22 +4211,22 @@ xcb_ungrab_pointer (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_grab_button_checked (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t event_mask /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */, - xcb_window_t confine_to /**< */, - xcb_cursor_t cursor /**< */, - uint8_t button /**< */, - uint16_t modifiers /**< */) +xcb_grab_button_checked (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t event_mask, + uint8_t pointer_mode, + uint8_t keyboard_mode, + xcb_window_t confine_to, + xcb_cursor_t cursor, + uint8_t button, + uint16_t modifiers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GRAB_BUTTON, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_GRAB_BUTTON, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3125,22 +4254,22 @@ xcb_grab_button_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_grab_button (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t event_mask /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */, - xcb_window_t confine_to /**< */, - xcb_cursor_t cursor /**< */, - uint8_t button /**< */, - uint16_t modifiers /**< */) +xcb_grab_button (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t event_mask, + uint8_t pointer_mode, + uint8_t keyboard_mode, + xcb_window_t confine_to, + xcb_cursor_t cursor, + uint8_t button, + uint16_t modifiers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GRAB_BUTTON, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_GRAB_BUTTON, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3168,16 +4297,16 @@ xcb_grab_button (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_ungrab_button_checked (xcb_connection_t *c /**< */, - uint8_t button /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */) +xcb_ungrab_button_checked (xcb_connection_t *c, + uint8_t button, + xcb_window_t grab_window, + uint16_t modifiers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNGRAB_BUTTON, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNGRAB_BUTTON, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3199,16 +4328,16 @@ xcb_ungrab_button_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_ungrab_button (xcb_connection_t *c /**< */, - uint8_t button /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */) +xcb_ungrab_button (xcb_connection_t *c, + uint8_t button, + xcb_window_t grab_window, + uint16_t modifiers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNGRAB_BUTTON, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNGRAB_BUTTON, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3230,16 +4359,16 @@ xcb_ungrab_button (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_change_active_pointer_grab_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - xcb_timestamp_t time /**< */, - uint16_t event_mask /**< */) +xcb_change_active_pointer_grab_checked (xcb_connection_t *c, + xcb_cursor_t cursor, + xcb_timestamp_t time, + uint16_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CHANGE_ACTIVE_POINTER_GRAB, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CHANGE_ACTIVE_POINTER_GRAB, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3262,16 +4391,16 @@ xcb_change_active_pointer_grab_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_change_active_pointer_grab (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - xcb_timestamp_t time /**< */, - uint16_t event_mask /**< */) +xcb_change_active_pointer_grab (xcb_connection_t *c, + xcb_cursor_t cursor, + xcb_timestamp_t time, + uint16_t event_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CHANGE_ACTIVE_POINTER_GRAB, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CHANGE_ACTIVE_POINTER_GRAB, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3294,18 +4423,18 @@ xcb_change_active_pointer_grab (xcb_connection_t *c /**< */, } xcb_grab_keyboard_cookie_t -xcb_grab_keyboard (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - xcb_timestamp_t time /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */) +xcb_grab_keyboard (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint8_t pointer_mode, + uint8_t keyboard_mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GRAB_KEYBOARD, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GRAB_KEYBOARD, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3329,18 +4458,18 @@ xcb_grab_keyboard (xcb_connection_t *c /**< */, } xcb_grab_keyboard_cookie_t -xcb_grab_keyboard_unchecked (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - xcb_timestamp_t time /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */) +xcb_grab_keyboard_unchecked (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint8_t pointer_mode, + uint8_t keyboard_mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GRAB_KEYBOARD, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GRAB_KEYBOARD, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3364,22 +4493,22 @@ xcb_grab_keyboard_unchecked (xcb_connection_t *c /**< */, } xcb_grab_keyboard_reply_t * -xcb_grab_keyboard_reply (xcb_connection_t *c /**< */, +xcb_grab_keyboard_reply (xcb_connection_t *c, xcb_grab_keyboard_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_grab_keyboard_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_ungrab_keyboard_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */) +xcb_ungrab_keyboard_checked (xcb_connection_t *c, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNGRAB_KEYBOARD, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNGRAB_KEYBOARD, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3399,14 +4528,14 @@ xcb_ungrab_keyboard_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_ungrab_keyboard (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */) +xcb_ungrab_keyboard (xcb_connection_t *c, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNGRAB_KEYBOARD, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNGRAB_KEYBOARD, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3426,19 +4555,19 @@ xcb_ungrab_keyboard (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_grab_key_checked (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */, - xcb_keycode_t key /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */) +xcb_grab_key_checked (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t modifiers, + xcb_keycode_t key, + uint8_t pointer_mode, + uint8_t keyboard_mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GRAB_KEY, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_GRAB_KEY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3463,19 +4592,19 @@ xcb_grab_key_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_grab_key (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */, - xcb_keycode_t key /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */) +xcb_grab_key (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t modifiers, + xcb_keycode_t key, + uint8_t pointer_mode, + uint8_t keyboard_mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GRAB_KEY, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_GRAB_KEY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3500,16 +4629,16 @@ xcb_grab_key (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_ungrab_key_checked (xcb_connection_t *c /**< */, - xcb_keycode_t key /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */) +xcb_ungrab_key_checked (xcb_connection_t *c, + xcb_keycode_t key, + xcb_window_t grab_window, + uint16_t modifiers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNGRAB_KEY, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNGRAB_KEY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3531,16 +4660,16 @@ xcb_ungrab_key_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_ungrab_key (xcb_connection_t *c /**< */, - xcb_keycode_t key /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */) +xcb_ungrab_key (xcb_connection_t *c, + xcb_keycode_t key, + xcb_window_t grab_window, + uint16_t modifiers) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNGRAB_KEY, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNGRAB_KEY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3562,15 +4691,15 @@ xcb_ungrab_key (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_allow_events_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_timestamp_t time /**< */) +xcb_allow_events_checked (xcb_connection_t *c, + uint8_t mode, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_ALLOW_EVENTS, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_ALLOW_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3590,15 +4719,15 @@ xcb_allow_events_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_allow_events (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_timestamp_t time /**< */) +xcb_allow_events (xcb_connection_t *c, + uint8_t mode, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_ALLOW_EVENTS, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_ALLOW_EVENTS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3618,13 +4747,13 @@ xcb_allow_events (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_grab_server_checked (xcb_connection_t *c /**< */) +xcb_grab_server_checked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GRAB_SERVER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_GRAB_SERVER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3643,13 +4772,13 @@ xcb_grab_server_checked (xcb_connection_t *c /**< */) } xcb_void_cookie_t -xcb_grab_server (xcb_connection_t *c /**< */) +xcb_grab_server (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GRAB_SERVER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_GRAB_SERVER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3668,13 +4797,13 @@ xcb_grab_server (xcb_connection_t *c /**< */) } xcb_void_cookie_t -xcb_ungrab_server_checked (xcb_connection_t *c /**< */) +xcb_ungrab_server_checked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNGRAB_SERVER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNGRAB_SERVER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3693,13 +4822,13 @@ xcb_ungrab_server_checked (xcb_connection_t *c /**< */) } xcb_void_cookie_t -xcb_ungrab_server (xcb_connection_t *c /**< */) +xcb_ungrab_server (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNGRAB_SERVER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNGRAB_SERVER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -3718,14 +4847,14 @@ xcb_ungrab_server (xcb_connection_t *c /**< */) } xcb_query_pointer_cookie_t -xcb_query_pointer (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_query_pointer (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_QUERY_POINTER, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_QUERY_POINTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3745,14 +4874,14 @@ xcb_query_pointer (xcb_connection_t *c /**< */, } xcb_query_pointer_cookie_t -xcb_query_pointer_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_query_pointer_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_QUERY_POINTER, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_QUERY_POINTER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3772,15 +4901,15 @@ xcb_query_pointer_unchecked (xcb_connection_t *c /**< */, } xcb_query_pointer_reply_t * -xcb_query_pointer_reply (xcb_connection_t *c /**< */, +xcb_query_pointer_reply (xcb_connection_t *c, xcb_query_pointer_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_query_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } void -xcb_timecoord_next (xcb_timecoord_iterator_t *i /**< */) +xcb_timecoord_next (xcb_timecoord_iterator_t *i) { --i->rem; ++i->data; @@ -3788,7 +4917,7 @@ xcb_timecoord_next (xcb_timecoord_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_timecoord_end (xcb_timecoord_iterator_t i /**< */) +xcb_timecoord_end (xcb_timecoord_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -3798,7 +4927,7 @@ xcb_timecoord_end (xcb_timecoord_iterator_t i /**< */) } int -xcb_get_motion_events_sizeof (const void *_buffer /**< */) +xcb_get_motion_events_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_get_motion_events_reply_t *_aux = (xcb_get_motion_events_reply_t *)_buffer; @@ -3829,16 +4958,16 @@ xcb_get_motion_events_sizeof (const void *_buffer /**< */) } xcb_get_motion_events_cookie_t -xcb_get_motion_events (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t start /**< */, - xcb_timestamp_t stop /**< */) +xcb_get_motion_events (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t start, + xcb_timestamp_t stop) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_MOTION_EVENTS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_MOTION_EVENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3860,16 +4989,16 @@ xcb_get_motion_events (xcb_connection_t *c /**< */, } xcb_get_motion_events_cookie_t -xcb_get_motion_events_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t start /**< */, - xcb_timestamp_t stop /**< */) +xcb_get_motion_events_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t start, + xcb_timestamp_t stop) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_MOTION_EVENTS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_MOTION_EVENTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3891,19 +5020,19 @@ xcb_get_motion_events_unchecked (xcb_connection_t *c /**< */, } xcb_timecoord_t * -xcb_get_motion_events_events (const xcb_get_motion_events_reply_t *R /**< */) +xcb_get_motion_events_events (const xcb_get_motion_events_reply_t *R) { return (xcb_timecoord_t *) (R + 1); } int -xcb_get_motion_events_events_length (const xcb_get_motion_events_reply_t *R /**< */) +xcb_get_motion_events_events_length (const xcb_get_motion_events_reply_t *R) { return R->events_len; } xcb_timecoord_iterator_t -xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R /**< */) +xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R) { xcb_timecoord_iterator_t i; i.data = (xcb_timecoord_t *) (R + 1); @@ -3913,25 +5042,25 @@ xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R / } xcb_get_motion_events_reply_t * -xcb_get_motion_events_reply (xcb_connection_t *c /**< */, +xcb_get_motion_events_reply (xcb_connection_t *c, xcb_get_motion_events_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_motion_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_translate_coordinates_cookie_t -xcb_translate_coordinates (xcb_connection_t *c /**< */, - xcb_window_t src_window /**< */, - xcb_window_t dst_window /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */) +xcb_translate_coordinates (xcb_connection_t *c, + xcb_window_t src_window, + xcb_window_t dst_window, + int16_t src_x, + int16_t src_y) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_TRANSLATE_COORDINATES, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_TRANSLATE_COORDINATES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3954,17 +5083,17 @@ xcb_translate_coordinates (xcb_connection_t *c /**< */, } xcb_translate_coordinates_cookie_t -xcb_translate_coordinates_unchecked (xcb_connection_t *c /**< */, - xcb_window_t src_window /**< */, - xcb_window_t dst_window /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */) +xcb_translate_coordinates_unchecked (xcb_connection_t *c, + xcb_window_t src_window, + xcb_window_t dst_window, + int16_t src_x, + int16_t src_y) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_TRANSLATE_COORDINATES, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_TRANSLATE_COORDINATES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -3987,29 +5116,29 @@ xcb_translate_coordinates_unchecked (xcb_connection_t *c /**< */, } xcb_translate_coordinates_reply_t * -xcb_translate_coordinates_reply (xcb_connection_t *c /**< */, +xcb_translate_coordinates_reply (xcb_connection_t *c, xcb_translate_coordinates_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_translate_coordinates_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_warp_pointer_checked (xcb_connection_t *c /**< */, - xcb_window_t src_window /**< */, - xcb_window_t dst_window /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */) +xcb_warp_pointer_checked (xcb_connection_t *c, + xcb_window_t src_window, + xcb_window_t dst_window, + int16_t src_x, + int16_t src_y, + uint16_t src_width, + uint16_t src_height, + int16_t dst_x, + int16_t dst_y) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_WARP_POINTER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_WARP_POINTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4036,21 +5165,21 @@ xcb_warp_pointer_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_warp_pointer (xcb_connection_t *c /**< */, - xcb_window_t src_window /**< */, - xcb_window_t dst_window /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */) +xcb_warp_pointer (xcb_connection_t *c, + xcb_window_t src_window, + xcb_window_t dst_window, + int16_t src_x, + int16_t src_y, + uint16_t src_width, + uint16_t src_height, + int16_t dst_x, + int16_t dst_y) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_WARP_POINTER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_WARP_POINTER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4077,16 +5206,16 @@ xcb_warp_pointer (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_set_input_focus_checked (xcb_connection_t *c /**< */, - uint8_t revert_to /**< */, - xcb_window_t focus /**< */, - xcb_timestamp_t time /**< */) +xcb_set_input_focus_checked (xcb_connection_t *c, + uint8_t revert_to, + xcb_window_t focus, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SET_INPUT_FOCUS, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SET_INPUT_FOCUS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4107,16 +5236,16 @@ xcb_set_input_focus_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_set_input_focus (xcb_connection_t *c /**< */, - uint8_t revert_to /**< */, - xcb_window_t focus /**< */, - xcb_timestamp_t time /**< */) +xcb_set_input_focus (xcb_connection_t *c, + uint8_t revert_to, + xcb_window_t focus, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SET_INPUT_FOCUS, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SET_INPUT_FOCUS, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4137,13 +5266,13 @@ xcb_set_input_focus (xcb_connection_t *c /**< */, } xcb_get_input_focus_cookie_t -xcb_get_input_focus (xcb_connection_t *c /**< */) +xcb_get_input_focus (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_INPUT_FOCUS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_INPUT_FOCUS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4162,13 +5291,13 @@ xcb_get_input_focus (xcb_connection_t *c /**< */) } xcb_get_input_focus_cookie_t -xcb_get_input_focus_unchecked (xcb_connection_t *c /**< */) +xcb_get_input_focus_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_INPUT_FOCUS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_INPUT_FOCUS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4187,21 +5316,21 @@ xcb_get_input_focus_unchecked (xcb_connection_t *c /**< */) } xcb_get_input_focus_reply_t * -xcb_get_input_focus_reply (xcb_connection_t *c /**< */, +xcb_get_input_focus_reply (xcb_connection_t *c, xcb_get_input_focus_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_input_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_query_keymap_cookie_t -xcb_query_keymap (xcb_connection_t *c /**< */) +xcb_query_keymap (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_QUERY_KEYMAP, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_QUERY_KEYMAP, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4220,13 +5349,13 @@ xcb_query_keymap (xcb_connection_t *c /**< */) } xcb_query_keymap_cookie_t -xcb_query_keymap_unchecked (xcb_connection_t *c /**< */) +xcb_query_keymap_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_QUERY_KEYMAP, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_QUERY_KEYMAP, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4245,15 +5374,15 @@ xcb_query_keymap_unchecked (xcb_connection_t *c /**< */) } xcb_query_keymap_reply_t * -xcb_query_keymap_reply (xcb_connection_t *c /**< */, +xcb_query_keymap_reply (xcb_connection_t *c, xcb_query_keymap_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_query_keymap_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_open_font_sizeof (const void *_buffer /**< */) +xcb_open_font_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_open_font_request_t *_aux = (xcb_open_font_request_t *)_buffer; @@ -4284,16 +5413,16 @@ xcb_open_font_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_open_font_checked (xcb_connection_t *c /**< */, - xcb_font_t fid /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_open_font_checked (xcb_connection_t *c, + xcb_font_t fid, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_OPEN_FONT, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_OPEN_FONT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -4320,16 +5449,16 @@ xcb_open_font_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_open_font (xcb_connection_t *c /**< */, - xcb_font_t fid /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_open_font (xcb_connection_t *c, + xcb_font_t fid, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_OPEN_FONT, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_OPEN_FONT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -4355,15 +5484,37 @@ xcb_open_font (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_open_font_name (const xcb_open_font_request_t *R) +{ + return (char *) (R + 1); +} + +int +xcb_open_font_name_length (const xcb_open_font_request_t *R) +{ + return R->name_len; +} + +xcb_generic_iterator_t +xcb_open_font_name_end (const xcb_open_font_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->name_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_close_font_checked (xcb_connection_t *c /**< */, - xcb_font_t font /**< */) +xcb_close_font_checked (xcb_connection_t *c, + xcb_font_t font) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CLOSE_FONT, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CLOSE_FONT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4383,14 +5534,14 @@ xcb_close_font_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_close_font (xcb_connection_t *c /**< */, - xcb_font_t font /**< */) +xcb_close_font (xcb_connection_t *c, + xcb_font_t font) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CLOSE_FONT, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CLOSE_FONT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -4410,7 +5561,7 @@ xcb_close_font (xcb_connection_t *c /**< */, } void -xcb_fontprop_next (xcb_fontprop_iterator_t *i /**< */) +xcb_fontprop_next (xcb_fontprop_iterator_t *i) { --i->rem; ++i->data; @@ -4418,7 +5569,7 @@ xcb_fontprop_next (xcb_fontprop_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_fontprop_end (xcb_fontprop_iterator_t i /**< */) +xcb_fontprop_end (xcb_fontprop_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4428,7 +5579,7 @@ xcb_fontprop_end (xcb_fontprop_iterator_t i /**< */) } void -xcb_charinfo_next (xcb_charinfo_iterator_t *i /**< */) +xcb_charinfo_next (xcb_charinfo_iterator_t *i) { --i->rem; ++i->data; @@ -4436,7 +5587,7 @@ xcb_charinfo_next (xcb_charinfo_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_charinfo_end (xcb_charinfo_iterator_t i /**< */) +xcb_charinfo_end (xcb_charinfo_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -4446,7 +5597,7 @@ xcb_charinfo_end (xcb_charinfo_iterator_t i /**< */) } int -xcb_query_font_sizeof (const void *_buffer /**< */) +xcb_query_font_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_query_font_reply_t *_aux = (xcb_query_font_reply_t *)_buffer; @@ -4489,14 +5640,14 @@ xcb_query_font_sizeof (const void *_buffer /**< */) } xcb_query_font_cookie_t -xcb_query_font (xcb_connection_t *c /**< */, - xcb_fontable_t font /**< */) +xcb_query_font (xcb_connection_t *c, + xcb_fontable_t font) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_QUERY_FONT, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_QUERY_FONT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4516,14 +5667,14 @@ xcb_query_font (xcb_connection_t *c /**< */, } xcb_query_font_cookie_t -xcb_query_font_unchecked (xcb_connection_t *c /**< */, - xcb_fontable_t font /**< */) +xcb_query_font_unchecked (xcb_connection_t *c, + xcb_fontable_t font) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_QUERY_FONT, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_QUERY_FONT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -4543,19 +5694,19 @@ xcb_query_font_unchecked (xcb_connection_t *c /**< */, } xcb_fontprop_t * -xcb_query_font_properties (const xcb_query_font_reply_t *R /**< */) +xcb_query_font_properties (const xcb_query_font_reply_t *R) { return (xcb_fontprop_t *) (R + 1); } int -xcb_query_font_properties_length (const xcb_query_font_reply_t *R /**< */) +xcb_query_font_properties_length (const xcb_query_font_reply_t *R) { return R->properties_len; } xcb_fontprop_iterator_t -xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R /**< */) +xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R) { xcb_fontprop_iterator_t i; i.data = (xcb_fontprop_t *) (R + 1); @@ -4565,20 +5716,20 @@ xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R /**< */) } xcb_charinfo_t * -xcb_query_font_char_infos (const xcb_query_font_reply_t *R /**< */) +xcb_query_font_char_infos (const xcb_query_font_reply_t *R) { xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_query_font_properties_iterator(R)); return (xcb_charinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_charinfo_t, prev.index) + 0); } int -xcb_query_font_char_infos_length (const xcb_query_font_reply_t *R /**< */) +xcb_query_font_char_infos_length (const xcb_query_font_reply_t *R) { return R->char_infos_len; } xcb_charinfo_iterator_t -xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R /**< */) +xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R) { xcb_charinfo_iterator_t i; xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_query_font_properties_iterator(R)); @@ -4589,16 +5740,16 @@ xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R /**< */) } xcb_query_font_reply_t * -xcb_query_font_reply (xcb_connection_t *c /**< */, +xcb_query_font_reply (xcb_connection_t *c, xcb_query_font_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_query_font_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_query_text_extents_sizeof (const void *_buffer /**< */, - uint32_t string_len /**< */) +xcb_query_text_extents_sizeof (const void *_buffer, + uint32_t string_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -4628,16 +5779,16 @@ xcb_query_text_extents_sizeof (const void *_buffer /**< */, } xcb_query_text_extents_cookie_t -xcb_query_text_extents (xcb_connection_t *c /**< */, - xcb_fontable_t font /**< */, - uint32_t string_len /**< */, - const xcb_char2b_t *string /**< */) +xcb_query_text_extents (xcb_connection_t *c, + xcb_fontable_t font, + uint32_t string_len, + const xcb_char2b_t *string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_QUERY_TEXT_EXTENTS, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_QUERY_TEXT_EXTENTS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -4662,16 +5813,16 @@ xcb_query_text_extents (xcb_connection_t *c /**< */, } xcb_query_text_extents_cookie_t -xcb_query_text_extents_unchecked (xcb_connection_t *c /**< */, - xcb_fontable_t font /**< */, - uint32_t string_len /**< */, - const xcb_char2b_t *string /**< */) +xcb_query_text_extents_unchecked (xcb_connection_t *c, + xcb_fontable_t font, + uint32_t string_len, + const xcb_char2b_t *string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_QUERY_TEXT_EXTENTS, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_QUERY_TEXT_EXTENTS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -4696,15 +5847,15 @@ xcb_query_text_extents_unchecked (xcb_connection_t *c /**< */, } xcb_query_text_extents_reply_t * -xcb_query_text_extents_reply (xcb_connection_t *c /**< */, +xcb_query_text_extents_reply (xcb_connection_t *c, xcb_query_text_extents_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_query_text_extents_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_str_sizeof (const void *_buffer /**< */) +xcb_str_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_str_t *_aux = (xcb_str_t *)_buffer; @@ -4735,19 +5886,19 @@ xcb_str_sizeof (const void *_buffer /**< */) } char * -xcb_str_name (const xcb_str_t *R /**< */) +xcb_str_name (const xcb_str_t *R) { return (char *) (R + 1); } int -xcb_str_name_length (const xcb_str_t *R /**< */) +xcb_str_name_length (const xcb_str_t *R) { return R->name_len; } xcb_generic_iterator_t -xcb_str_name_end (const xcb_str_t *R /**< */) +xcb_str_name_end (const xcb_str_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->name_len); @@ -4757,7 +5908,7 @@ xcb_str_name_end (const xcb_str_t *R /**< */) } void -xcb_str_next (xcb_str_iterator_t *i /**< */) +xcb_str_next (xcb_str_iterator_t *i) { xcb_str_t *R = i->data; xcb_generic_iterator_t child; @@ -4768,7 +5919,7 @@ xcb_str_next (xcb_str_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_str_end (xcb_str_iterator_t i /**< */) +xcb_str_end (xcb_str_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -4780,7 +5931,7 @@ xcb_str_end (xcb_str_iterator_t i /**< */) } int -xcb_list_fonts_sizeof (const void *_buffer /**< */) +xcb_list_fonts_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_list_fonts_request_t *_aux = (xcb_list_fonts_request_t *)_buffer; @@ -4811,16 +5962,16 @@ xcb_list_fonts_sizeof (const void *_buffer /**< */) } xcb_list_fonts_cookie_t -xcb_list_fonts (xcb_connection_t *c /**< */, - uint16_t max_names /**< */, - uint16_t pattern_len /**< */, - const char *pattern /**< */) +xcb_list_fonts (xcb_connection_t *c, + uint16_t max_names, + uint16_t pattern_len, + const char *pattern) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_LIST_FONTS, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_LIST_FONTS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -4846,16 +5997,16 @@ xcb_list_fonts (xcb_connection_t *c /**< */, } xcb_list_fonts_cookie_t -xcb_list_fonts_unchecked (xcb_connection_t *c /**< */, - uint16_t max_names /**< */, - uint16_t pattern_len /**< */, - const char *pattern /**< */) +xcb_list_fonts_unchecked (xcb_connection_t *c, + uint16_t max_names, + uint16_t pattern_len, + const char *pattern) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_LIST_FONTS, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_LIST_FONTS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -4881,13 +6032,13 @@ xcb_list_fonts_unchecked (xcb_connection_t *c /**< */, } int -xcb_list_fonts_names_length (const xcb_list_fonts_reply_t *R /**< */) +xcb_list_fonts_names_length (const xcb_list_fonts_reply_t *R) { return R->names_len; } xcb_str_iterator_t -xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R /**< */) +xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R) { xcb_str_iterator_t i; i.data = (xcb_str_t *) (R + 1); @@ -4897,15 +6048,15 @@ xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R /**< */) } xcb_list_fonts_reply_t * -xcb_list_fonts_reply (xcb_connection_t *c /**< */, +xcb_list_fonts_reply (xcb_connection_t *c, xcb_list_fonts_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_list_fonts_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_list_fonts_with_info_sizeof (const void *_buffer /**< */) +xcb_list_fonts_with_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_list_fonts_with_info_request_t *_aux = (xcb_list_fonts_with_info_request_t *)_buffer; @@ -4936,16 +6087,16 @@ xcb_list_fonts_with_info_sizeof (const void *_buffer /**< */) } xcb_list_fonts_with_info_cookie_t -xcb_list_fonts_with_info (xcb_connection_t *c /**< */, - uint16_t max_names /**< */, - uint16_t pattern_len /**< */, - const char *pattern /**< */) +xcb_list_fonts_with_info (xcb_connection_t *c, + uint16_t max_names, + uint16_t pattern_len, + const char *pattern) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_LIST_FONTS_WITH_INFO, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_LIST_FONTS_WITH_INFO, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -4971,16 +6122,16 @@ xcb_list_fonts_with_info (xcb_connection_t *c /**< */, } xcb_list_fonts_with_info_cookie_t -xcb_list_fonts_with_info_unchecked (xcb_connection_t *c /**< */, - uint16_t max_names /**< */, - uint16_t pattern_len /**< */, - const char *pattern /**< */) +xcb_list_fonts_with_info_unchecked (xcb_connection_t *c, + uint16_t max_names, + uint16_t pattern_len, + const char *pattern) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_LIST_FONTS_WITH_INFO, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_LIST_FONTS_WITH_INFO, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -5006,19 +6157,19 @@ xcb_list_fonts_with_info_unchecked (xcb_connection_t *c /**< */, } xcb_fontprop_t * -xcb_list_fonts_with_info_properties (const xcb_list_fonts_with_info_reply_t *R /**< */) +xcb_list_fonts_with_info_properties (const xcb_list_fonts_with_info_reply_t *R) { return (xcb_fontprop_t *) (R + 1); } int -xcb_list_fonts_with_info_properties_length (const xcb_list_fonts_with_info_reply_t *R /**< */) +xcb_list_fonts_with_info_properties_length (const xcb_list_fonts_with_info_reply_t *R) { return R->properties_len; } xcb_fontprop_iterator_t -xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_reply_t *R /**< */) +xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_reply_t *R) { xcb_fontprop_iterator_t i; i.data = (xcb_fontprop_t *) (R + 1); @@ -5028,39 +6179,39 @@ xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_rep } char * -xcb_list_fonts_with_info_name (const xcb_list_fonts_with_info_reply_t *R /**< */) +xcb_list_fonts_with_info_name (const xcb_list_fonts_with_info_reply_t *R) { xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_list_fonts_with_info_properties_iterator(R)); return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); } int -xcb_list_fonts_with_info_name_length (const xcb_list_fonts_with_info_reply_t *R /**< */) +xcb_list_fonts_with_info_name_length (const xcb_list_fonts_with_info_reply_t *R) { return R->name_len; } xcb_generic_iterator_t -xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R /**< */) +xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_fontprop_end(xcb_list_fonts_with_info_properties_iterator(R)); - i.data = ((char *) child.data) + (R->name_len); + xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_list_fonts_with_info_properties_iterator(R)); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->name_len); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_list_fonts_with_info_reply_t * -xcb_list_fonts_with_info_reply (xcb_connection_t *c /**< */, +xcb_list_fonts_with_info_reply (xcb_connection_t *c, xcb_list_fonts_with_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_list_fonts_with_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_set_font_path_sizeof (const void *_buffer /**< */) +xcb_set_font_path_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_set_font_path_request_t *_aux = (xcb_set_font_path_request_t *)_buffer; @@ -5096,15 +6247,15 @@ xcb_set_font_path_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_set_font_path_checked (xcb_connection_t *c /**< */, - uint16_t font_qty /**< */, - const xcb_str_t *font /**< */) +xcb_set_font_path_checked (xcb_connection_t *c, + uint16_t font_qty, + const xcb_str_t *font) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_SET_FONT_PATH, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_SET_FONT_PATH, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -5139,15 +6290,15 @@ xcb_set_font_path_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_set_font_path (xcb_connection_t *c /**< */, - uint16_t font_qty /**< */, - const xcb_str_t *font /**< */) +xcb_set_font_path (xcb_connection_t *c, + uint16_t font_qty, + const xcb_str_t *font) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_SET_FONT_PATH, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_SET_FONT_PATH, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -5182,7 +6333,23 @@ xcb_set_font_path (xcb_connection_t *c /**< */, } int -xcb_get_font_path_sizeof (const void *_buffer /**< */) +xcb_set_font_path_font_length (const xcb_set_font_path_request_t *R) +{ + return R->font_qty; +} + +xcb_str_iterator_t +xcb_set_font_path_font_iterator (const xcb_set_font_path_request_t *R) +{ + xcb_str_iterator_t i; + i.data = (xcb_str_t *) (R + 1); + i.rem = R->font_qty; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_get_font_path_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_get_font_path_reply_t *_aux = (xcb_get_font_path_reply_t *)_buffer; @@ -5218,13 +6385,13 @@ xcb_get_font_path_sizeof (const void *_buffer /**< */) } xcb_get_font_path_cookie_t -xcb_get_font_path (xcb_connection_t *c /**< */) +xcb_get_font_path (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_FONT_PATH, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_FONT_PATH, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5243,13 +6410,13 @@ xcb_get_font_path (xcb_connection_t *c /**< */) } xcb_get_font_path_cookie_t -xcb_get_font_path_unchecked (xcb_connection_t *c /**< */) +xcb_get_font_path_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_FONT_PATH, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_FONT_PATH, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -5268,13 +6435,13 @@ xcb_get_font_path_unchecked (xcb_connection_t *c /**< */) } int -xcb_get_font_path_path_length (const xcb_get_font_path_reply_t *R /**< */) +xcb_get_font_path_path_length (const xcb_get_font_path_reply_t *R) { return R->path_len; } xcb_str_iterator_t -xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R /**< */) +xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R) { xcb_str_iterator_t i; i.data = (xcb_str_t *) (R + 1); @@ -5284,26 +6451,26 @@ xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R /**< */) } xcb_get_font_path_reply_t * -xcb_get_font_path_reply (xcb_connection_t *c /**< */, +xcb_get_font_path_reply (xcb_connection_t *c, xcb_get_font_path_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_font_path_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_create_pixmap_checked (xcb_connection_t *c /**< */, - uint8_t depth /**< */, - xcb_pixmap_t pid /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_create_pixmap_checked (xcb_connection_t *c, + uint8_t depth, + xcb_pixmap_t pid, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CREATE_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CREATE_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5326,18 +6493,18 @@ xcb_create_pixmap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_create_pixmap (xcb_connection_t *c /**< */, - uint8_t depth /**< */, - xcb_pixmap_t pid /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_create_pixmap (xcb_connection_t *c, + uint8_t depth, + xcb_pixmap_t pid, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CREATE_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CREATE_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5360,14 +6527,14 @@ xcb_create_pixmap (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_free_pixmap_checked (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */) +xcb_free_pixmap_checked (xcb_connection_t *c, + xcb_pixmap_t pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_FREE_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_FREE_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5387,14 +6554,14 @@ xcb_free_pixmap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_free_pixmap (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */) +xcb_free_pixmap (xcb_connection_t *c, + xcb_pixmap_t pixmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_FREE_PIXMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_FREE_PIXMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5414,7 +6581,433 @@ xcb_free_pixmap (xcb_connection_t *c /**< */, } int -xcb_create_gc_sizeof (const void *_buffer /**< */) +xcb_create_gc_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_create_gc_value_list_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[24]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(value_mask & XCB_GC_FUNCTION) { + /* xcb_create_gc_value_list_t.function */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->function; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_PLANE_MASK) { + /* xcb_create_gc_value_list_t.plane_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->plane_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FOREGROUND) { + /* xcb_create_gc_value_list_t.foreground */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->foreground; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_BACKGROUND) { + /* xcb_create_gc_value_list_t.background */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_LINE_WIDTH) { + /* xcb_create_gc_value_list_t.line_width */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_width; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_LINE_STYLE) { + /* xcb_create_gc_value_list_t.line_style */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_style; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_CAP_STYLE) { + /* xcb_create_gc_value_list_t.cap_style */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cap_style; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_JOIN_STYLE) { + /* xcb_create_gc_value_list_t.join_style */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->join_style; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FILL_STYLE) { + /* xcb_create_gc_value_list_t.fill_style */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_style; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FILL_RULE) { + /* xcb_create_gc_value_list_t.fill_rule */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_rule; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_TILE) { + /* xcb_create_gc_value_list_t.tile */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_STIPPLE) { + /* xcb_create_gc_value_list_t.stipple */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stipple; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) { + /* xcb_create_gc_value_list_t.tile_stipple_x_origin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_x_origin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) { + /* xcb_create_gc_value_list_t.tile_stipple_y_origin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_y_origin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_FONT) { + /* xcb_create_gc_value_list_t.font */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->font; + xcb_block_len += sizeof(xcb_font_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_font_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_font_t); + } + if(value_mask & XCB_GC_SUBWINDOW_MODE) { + /* xcb_create_gc_value_list_t.subwindow_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindow_mode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) { + /* xcb_create_gc_value_list_t.graphics_exposures */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphics_exposures; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_GC_CLIP_ORIGIN_X) { + /* xcb_create_gc_value_list_t.clip_x_origin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_x_origin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_CLIP_ORIGIN_Y) { + /* xcb_create_gc_value_list_t.clip_y_origin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_y_origin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_CLIP_MASK) { + /* xcb_create_gc_value_list_t.clip_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_mask; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_DASH_OFFSET) { + /* xcb_create_gc_value_list_t.dash_offset */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dash_offset; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_DASH_LIST) { + /* xcb_create_gc_value_list_t.dashes */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dashes; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_ARC_MODE) { + /* xcb_create_gc_value_list_t.arc_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->arc_mode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ifunction = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_PLANE_MASK) { + /* xcb_create_gc_value_list_t.plane_mask */ + _aux->plane_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FOREGROUND) { + /* xcb_create_gc_value_list_t.foreground */ + _aux->foreground = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_BACKGROUND) { + /* xcb_create_gc_value_list_t.background */ + _aux->background = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_LINE_WIDTH) { + /* xcb_create_gc_value_list_t.line_width */ + _aux->line_width = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_LINE_STYLE) { + /* xcb_create_gc_value_list_t.line_style */ + _aux->line_style = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_CAP_STYLE) { + /* xcb_create_gc_value_list_t.cap_style */ + _aux->cap_style = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_JOIN_STYLE) { + /* xcb_create_gc_value_list_t.join_style */ + _aux->join_style = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FILL_STYLE) { + /* xcb_create_gc_value_list_t.fill_style */ + _aux->fill_style = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FILL_RULE) { + /* xcb_create_gc_value_list_t.fill_rule */ + _aux->fill_rule = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_TILE) { + /* xcb_create_gc_value_list_t.tile */ + _aux->tile = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_STIPPLE) { + /* xcb_create_gc_value_list_t.stipple */ + _aux->stipple = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) { + /* xcb_create_gc_value_list_t.tile_stipple_x_origin */ + _aux->tile_stipple_x_origin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) { + /* xcb_create_gc_value_list_t.tile_stipple_y_origin */ + _aux->tile_stipple_y_origin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_FONT) { + /* xcb_create_gc_value_list_t.font */ + _aux->font = *(xcb_font_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_font_t); + xcb_tmp += sizeof(xcb_font_t); + xcb_align_to = ALIGNOF(xcb_font_t); + } + if(value_mask & XCB_GC_SUBWINDOW_MODE) { + /* xcb_create_gc_value_list_t.subwindow_mode */ + _aux->subwindow_mode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) { + /* xcb_create_gc_value_list_t.graphics_exposures */ + _aux->graphics_exposures = *(xcb_bool32_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_tmp += sizeof(xcb_bool32_t); + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_GC_CLIP_ORIGIN_X) { + /* xcb_create_gc_value_list_t.clip_x_origin */ + _aux->clip_x_origin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_CLIP_ORIGIN_Y) { + /* xcb_create_gc_value_list_t.clip_y_origin */ + _aux->clip_y_origin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_CLIP_MASK) { + /* xcb_create_gc_value_list_t.clip_mask */ + _aux->clip_mask = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_DASH_OFFSET) { + /* xcb_create_gc_value_list_t.dash_offset */ + _aux->dash_offset = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_DASH_LIST) { + /* xcb_create_gc_value_list_t.dashes */ + _aux->dashes = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_ARC_MODE) { + /* xcb_create_gc_value_list_t.arc_mode */ + _aux->arc_mode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_create_gc_value_list_sizeof (const void *_buffer, + uint32_t value_mask) +{ + xcb_create_gc_value_list_t _aux; + return xcb_create_gc_value_list_unpack(_buffer, value_mask, &_aux); +} + +int +xcb_create_gc_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_create_gc_request_t *_aux = (xcb_create_gc_request_t *)_buffer; @@ -5429,9 +7022,9 @@ xcb_create_gc_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* value_list */ - xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_block_len += xcb_create_gc_value_list_sizeof(xcb_tmp, _aux->value_mask); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -5445,20 +7038,20 @@ xcb_create_gc_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_create_gc_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t cid /**< */, - xcb_drawable_t drawable /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_create_gc_checked (xcb_connection_t *c, + xcb_gcontext_t cid, + xcb_drawable_t drawable, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CREATE_GC, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CREATE_GC, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_create_gc_request_t xcb_out; @@ -5471,31 +7064,30 @@ xcb_create_gc_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_create_gc_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_create_gc_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_create_gc (xcb_connection_t *c /**< */, - xcb_gcontext_t cid /**< */, - xcb_drawable_t drawable /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_create_gc (xcb_connection_t *c, + xcb_gcontext_t cid, + xcb_drawable_t drawable, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CREATE_GC, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CREATE_GC, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_create_gc_request_t xcb_out; @@ -5508,18 +7100,525 @@ xcb_create_gc (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_create_gc_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_create_gc_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } +xcb_void_cookie_t +xcb_create_gc_aux_checked (xcb_connection_t *c, + xcb_gcontext_t cid, + xcb_drawable_t drawable, + uint32_t value_mask, + const xcb_create_gc_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = 0, + .opcode = XCB_CREATE_GC, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_create_gc_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pad0 = 0; + xcb_out.cid = cid; + xcb_out.drawable = drawable; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_create_gc_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_create_gc_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_create_gc_aux (xcb_connection_t *c, + xcb_gcontext_t cid, + xcb_drawable_t drawable, + uint32_t value_mask, + const xcb_create_gc_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = 0, + .opcode = XCB_CREATE_GC, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_create_gc_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pad0 = 0; + xcb_out.cid = cid; + xcb_out.drawable = drawable; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_create_gc_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_create_gc_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_create_gc_value_list (const xcb_create_gc_request_t *R) +{ + return (void *) (R + 1); +} + int -xcb_change_gc_sizeof (const void *_buffer /**< */) +xcb_change_gc_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_change_gc_value_list_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[24]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(value_mask & XCB_GC_FUNCTION) { + /* xcb_change_gc_value_list_t.function */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->function; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_PLANE_MASK) { + /* xcb_change_gc_value_list_t.plane_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->plane_mask; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FOREGROUND) { + /* xcb_change_gc_value_list_t.foreground */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->foreground; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_BACKGROUND) { + /* xcb_change_gc_value_list_t.background */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_LINE_WIDTH) { + /* xcb_change_gc_value_list_t.line_width */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_width; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_LINE_STYLE) { + /* xcb_change_gc_value_list_t.line_style */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_style; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_CAP_STYLE) { + /* xcb_change_gc_value_list_t.cap_style */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cap_style; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_JOIN_STYLE) { + /* xcb_change_gc_value_list_t.join_style */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->join_style; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FILL_STYLE) { + /* xcb_change_gc_value_list_t.fill_style */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_style; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FILL_RULE) { + /* xcb_change_gc_value_list_t.fill_rule */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_rule; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_TILE) { + /* xcb_change_gc_value_list_t.tile */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_STIPPLE) { + /* xcb_change_gc_value_list_t.stipple */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stipple; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) { + /* xcb_change_gc_value_list_t.tile_stipple_x_origin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_x_origin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) { + /* xcb_change_gc_value_list_t.tile_stipple_y_origin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_y_origin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_FONT) { + /* xcb_change_gc_value_list_t.font */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->font; + xcb_block_len += sizeof(xcb_font_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_font_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_font_t); + } + if(value_mask & XCB_GC_SUBWINDOW_MODE) { + /* xcb_change_gc_value_list_t.subwindow_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindow_mode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) { + /* xcb_change_gc_value_list_t.graphics_exposures */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphics_exposures; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_GC_CLIP_ORIGIN_X) { + /* xcb_change_gc_value_list_t.clip_x_origin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_x_origin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_CLIP_ORIGIN_Y) { + /* xcb_change_gc_value_list_t.clip_y_origin */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_y_origin; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_CLIP_MASK) { + /* xcb_change_gc_value_list_t.clip_mask */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_mask; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_DASH_OFFSET) { + /* xcb_change_gc_value_list_t.dash_offset */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dash_offset; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_DASH_LIST) { + /* xcb_change_gc_value_list_t.dashes */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dashes; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_ARC_MODE) { + /* xcb_change_gc_value_list_t.arc_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->arc_mode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ifunction = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_PLANE_MASK) { + /* xcb_change_gc_value_list_t.plane_mask */ + _aux->plane_mask = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FOREGROUND) { + /* xcb_change_gc_value_list_t.foreground */ + _aux->foreground = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_BACKGROUND) { + /* xcb_change_gc_value_list_t.background */ + _aux->background = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_LINE_WIDTH) { + /* xcb_change_gc_value_list_t.line_width */ + _aux->line_width = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_LINE_STYLE) { + /* xcb_change_gc_value_list_t.line_style */ + _aux->line_style = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_CAP_STYLE) { + /* xcb_change_gc_value_list_t.cap_style */ + _aux->cap_style = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_JOIN_STYLE) { + /* xcb_change_gc_value_list_t.join_style */ + _aux->join_style = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FILL_STYLE) { + /* xcb_change_gc_value_list_t.fill_style */ + _aux->fill_style = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_FILL_RULE) { + /* xcb_change_gc_value_list_t.fill_rule */ + _aux->fill_rule = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_TILE) { + /* xcb_change_gc_value_list_t.tile */ + _aux->tile = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_STIPPLE) { + /* xcb_change_gc_value_list_t.stipple */ + _aux->stipple = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) { + /* xcb_change_gc_value_list_t.tile_stipple_x_origin */ + _aux->tile_stipple_x_origin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) { + /* xcb_change_gc_value_list_t.tile_stipple_y_origin */ + _aux->tile_stipple_y_origin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_FONT) { + /* xcb_change_gc_value_list_t.font */ + _aux->font = *(xcb_font_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_font_t); + xcb_tmp += sizeof(xcb_font_t); + xcb_align_to = ALIGNOF(xcb_font_t); + } + if(value_mask & XCB_GC_SUBWINDOW_MODE) { + /* xcb_change_gc_value_list_t.subwindow_mode */ + _aux->subwindow_mode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) { + /* xcb_change_gc_value_list_t.graphics_exposures */ + _aux->graphics_exposures = *(xcb_bool32_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_bool32_t); + xcb_tmp += sizeof(xcb_bool32_t); + xcb_align_to = ALIGNOF(xcb_bool32_t); + } + if(value_mask & XCB_GC_CLIP_ORIGIN_X) { + /* xcb_change_gc_value_list_t.clip_x_origin */ + _aux->clip_x_origin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_CLIP_ORIGIN_Y) { + /* xcb_change_gc_value_list_t.clip_y_origin */ + _aux->clip_y_origin = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_GC_CLIP_MASK) { + /* xcb_change_gc_value_list_t.clip_mask */ + _aux->clip_mask = *(xcb_pixmap_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_pixmap_t); + xcb_tmp += sizeof(xcb_pixmap_t); + xcb_align_to = ALIGNOF(xcb_pixmap_t); + } + if(value_mask & XCB_GC_DASH_OFFSET) { + /* xcb_change_gc_value_list_t.dash_offset */ + _aux->dash_offset = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_DASH_LIST) { + /* xcb_change_gc_value_list_t.dashes */ + _aux->dashes = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_GC_ARC_MODE) { + /* xcb_change_gc_value_list_t.arc_mode */ + _aux->arc_mode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_change_gc_value_list_sizeof (const void *_buffer, + uint32_t value_mask) +{ + xcb_change_gc_value_list_t _aux; + return xcb_change_gc_value_list_unpack(_buffer, value_mask, &_aux); +} + +int +xcb_change_gc_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_change_gc_request_t *_aux = (xcb_change_gc_request_t *)_buffer; @@ -5534,9 +7633,9 @@ xcb_change_gc_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* value_list */ - xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_block_len += xcb_change_gc_value_list_sizeof(xcb_tmp, _aux->value_mask); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -5550,19 +7649,19 @@ xcb_change_gc_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_change_gc_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_change_gc_checked (xcb_connection_t *c, + xcb_gcontext_t gc, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_GC, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_GC, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_change_gc_request_t xcb_out; @@ -5574,30 +7673,29 @@ xcb_change_gc_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_change_gc_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_change_gc_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_change_gc (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_change_gc (xcb_connection_t *c, + xcb_gcontext_t gc, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_GC, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_GC, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_change_gc_request_t xcb_out; @@ -5609,27 +7707,104 @@ xcb_change_gc (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_change_gc_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_change_gc_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_copy_gc_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t src_gc /**< */, - xcb_gcontext_t dst_gc /**< */, - uint32_t value_mask /**< */) +xcb_change_gc_aux_checked (xcb_connection_t *c, + xcb_gcontext_t gc, + uint32_t value_mask, + const xcb_change_gc_value_list_t *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_COPY_GC, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_GC, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_change_gc_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pad0 = 0; + xcb_out.gc = gc; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_change_gc_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_change_gc_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_change_gc_aux (xcb_connection_t *c, + xcb_gcontext_t gc, + uint32_t value_mask, + const xcb_change_gc_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_GC, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_change_gc_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pad0 = 0; + xcb_out.gc = gc; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_change_gc_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_change_gc_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_change_gc_value_list (const xcb_change_gc_request_t *R) +{ + return (void *) (R + 1); +} + +xcb_void_cookie_t +xcb_copy_gc_checked (xcb_connection_t *c, + xcb_gcontext_t src_gc, + xcb_gcontext_t dst_gc, + uint32_t value_mask) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = 0, + .opcode = XCB_COPY_GC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5651,16 +7826,16 @@ xcb_copy_gc_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_copy_gc (xcb_connection_t *c /**< */, - xcb_gcontext_t src_gc /**< */, - xcb_gcontext_t dst_gc /**< */, - uint32_t value_mask /**< */) +xcb_copy_gc (xcb_connection_t *c, + xcb_gcontext_t src_gc, + xcb_gcontext_t dst_gc, + uint32_t value_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_COPY_GC, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_COPY_GC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5682,7 +7857,7 @@ xcb_copy_gc (xcb_connection_t *c /**< */, } int -xcb_set_dashes_sizeof (const void *_buffer /**< */) +xcb_set_dashes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_set_dashes_request_t *_aux = (xcb_set_dashes_request_t *)_buffer; @@ -5713,17 +7888,17 @@ xcb_set_dashes_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_set_dashes_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - uint16_t dash_offset /**< */, - uint16_t dashes_len /**< */, - const uint8_t *dashes /**< */) +xcb_set_dashes_checked (xcb_connection_t *c, + xcb_gcontext_t gc, + uint16_t dash_offset, + uint16_t dashes_len, + const uint8_t *dashes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_SET_DASHES, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_SET_DASHES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -5750,17 +7925,17 @@ xcb_set_dashes_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_set_dashes (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - uint16_t dash_offset /**< */, - uint16_t dashes_len /**< */, - const uint8_t *dashes /**< */) +xcb_set_dashes (xcb_connection_t *c, + xcb_gcontext_t gc, + uint16_t dash_offset, + uint16_t dashes_len, + const uint8_t *dashes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_SET_DASHES, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_SET_DASHES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -5786,9 +7961,31 @@ xcb_set_dashes (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_set_dashes_dashes (const xcb_set_dashes_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_set_clip_rectangles_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */) +xcb_set_dashes_dashes_length (const xcb_set_dashes_request_t *R) +{ + return R->dashes_len; +} + +xcb_generic_iterator_t +xcb_set_dashes_dashes_end (const xcb_set_dashes_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + (R->dashes_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_set_clip_rectangles_sizeof (const void *_buffer, + uint32_t rectangles_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -5818,19 +8015,19 @@ xcb_set_clip_rectangles_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_set_clip_rectangles_checked (xcb_connection_t *c /**< */, - uint8_t ordering /**< */, - xcb_gcontext_t gc /**< */, - int16_t clip_x_origin /**< */, - int16_t clip_y_origin /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_set_clip_rectangles_checked (xcb_connection_t *c, + uint8_t ordering, + xcb_gcontext_t gc, + int16_t clip_x_origin, + int16_t clip_y_origin, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_SET_CLIP_RECTANGLES, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_SET_CLIP_RECTANGLES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -5857,19 +8054,19 @@ xcb_set_clip_rectangles_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_set_clip_rectangles (xcb_connection_t *c /**< */, - uint8_t ordering /**< */, - xcb_gcontext_t gc /**< */, - int16_t clip_x_origin /**< */, - int16_t clip_y_origin /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_set_clip_rectangles (xcb_connection_t *c, + uint8_t ordering, + xcb_gcontext_t gc, + int16_t clip_x_origin, + int16_t clip_y_origin, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_SET_CLIP_RECTANGLES, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_SET_CLIP_RECTANGLES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -5895,15 +8092,37 @@ xcb_set_clip_rectangles (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_rectangle_t * +xcb_set_clip_rectangles_rectangles (const xcb_set_clip_rectangles_request_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + +int +xcb_set_clip_rectangles_rectangles_length (const xcb_set_clip_rectangles_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_set_clip_rectangles_request_t))/sizeof(xcb_rectangle_t)); +} + +xcb_rectangle_iterator_t +xcb_set_clip_rectangles_rectangles_iterator (const xcb_set_clip_rectangles_request_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_set_clip_rectangles_request_t))/sizeof(xcb_rectangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_free_gc_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */) +xcb_free_gc_checked (xcb_connection_t *c, + xcb_gcontext_t gc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_FREE_GC, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_FREE_GC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5923,14 +8142,14 @@ xcb_free_gc_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_free_gc (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */) +xcb_free_gc (xcb_connection_t *c, + xcb_gcontext_t gc) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_FREE_GC, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_FREE_GC, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5950,19 +8169,19 @@ xcb_free_gc (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_clear_area_checked (xcb_connection_t *c /**< */, - uint8_t exposures /**< */, - xcb_window_t window /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_clear_area_checked (xcb_connection_t *c, + uint8_t exposures, + xcb_window_t window, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CLEAR_AREA, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CLEAR_AREA, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -5986,19 +8205,19 @@ xcb_clear_area_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_clear_area (xcb_connection_t *c /**< */, - uint8_t exposures /**< */, - xcb_window_t window /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_clear_area (xcb_connection_t *c, + uint8_t exposures, + xcb_window_t window, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CLEAR_AREA, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CLEAR_AREA, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6022,22 +8241,22 @@ xcb_clear_area (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_copy_area_checked (xcb_connection_t *c /**< */, - xcb_drawable_t src_drawable /**< */, - xcb_drawable_t dst_drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_copy_area_checked (xcb_connection_t *c, + xcb_drawable_t src_drawable, + xcb_drawable_t dst_drawable, + xcb_gcontext_t gc, + int16_t src_x, + int16_t src_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_COPY_AREA, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_COPY_AREA, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6065,22 +8284,22 @@ xcb_copy_area_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_copy_area (xcb_connection_t *c /**< */, - xcb_drawable_t src_drawable /**< */, - xcb_drawable_t dst_drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_copy_area (xcb_connection_t *c, + xcb_drawable_t src_drawable, + xcb_drawable_t dst_drawable, + xcb_gcontext_t gc, + int16_t src_x, + int16_t src_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_COPY_AREA, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_COPY_AREA, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6108,23 +8327,23 @@ xcb_copy_area (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_copy_plane_checked (xcb_connection_t *c /**< */, - xcb_drawable_t src_drawable /**< */, - xcb_drawable_t dst_drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t bit_plane /**< */) +xcb_copy_plane_checked (xcb_connection_t *c, + xcb_drawable_t src_drawable, + xcb_drawable_t dst_drawable, + xcb_gcontext_t gc, + int16_t src_x, + int16_t src_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height, + uint32_t bit_plane) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_COPY_PLANE, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_COPY_PLANE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6153,23 +8372,23 @@ xcb_copy_plane_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_copy_plane (xcb_connection_t *c /**< */, - xcb_drawable_t src_drawable /**< */, - xcb_drawable_t dst_drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t bit_plane /**< */) +xcb_copy_plane (xcb_connection_t *c, + xcb_drawable_t src_drawable, + xcb_drawable_t dst_drawable, + xcb_gcontext_t gc, + int16_t src_x, + int16_t src_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height, + uint32_t bit_plane) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_COPY_PLANE, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_COPY_PLANE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -6198,8 +8417,8 @@ xcb_copy_plane (xcb_connection_t *c /**< */, } int -xcb_poly_point_sizeof (const void *_buffer /**< */, - uint32_t points_len /**< */) +xcb_poly_point_sizeof (const void *_buffer, + uint32_t points_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -6229,18 +8448,18 @@ xcb_poly_point_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_poly_point_checked (xcb_connection_t *c /**< */, - uint8_t coordinate_mode /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */) +xcb_poly_point_checked (xcb_connection_t *c, + uint8_t coordinate_mode, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t points_len, + const xcb_point_t *points) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_POINT, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_POINT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6266,18 +8485,18 @@ xcb_poly_point_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_poly_point (xcb_connection_t *c /**< */, - uint8_t coordinate_mode /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */) +xcb_poly_point (xcb_connection_t *c, + uint8_t coordinate_mode, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t points_len, + const xcb_point_t *points) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_POINT, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_POINT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6302,9 +8521,31 @@ xcb_poly_point (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_point_t * +xcb_poly_point_points (const xcb_poly_point_request_t *R) +{ + return (xcb_point_t *) (R + 1); +} + int -xcb_poly_line_sizeof (const void *_buffer /**< */, - uint32_t points_len /**< */) +xcb_poly_point_points_length (const xcb_poly_point_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_poly_point_request_t))/sizeof(xcb_point_t)); +} + +xcb_point_iterator_t +xcb_poly_point_points_iterator (const xcb_poly_point_request_t *R) +{ + xcb_point_iterator_t i; + i.data = (xcb_point_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_poly_point_request_t))/sizeof(xcb_point_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_poly_line_sizeof (const void *_buffer, + uint32_t points_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -6334,18 +8575,18 @@ xcb_poly_line_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_poly_line_checked (xcb_connection_t *c /**< */, - uint8_t coordinate_mode /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */) +xcb_poly_line_checked (xcb_connection_t *c, + uint8_t coordinate_mode, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t points_len, + const xcb_point_t *points) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_LINE, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_LINE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6371,18 +8612,18 @@ xcb_poly_line_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_poly_line (xcb_connection_t *c /**< */, - uint8_t coordinate_mode /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */) +xcb_poly_line (xcb_connection_t *c, + uint8_t coordinate_mode, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t points_len, + const xcb_point_t *points) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_LINE, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_LINE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6407,8 +8648,30 @@ xcb_poly_line (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_point_t * +xcb_poly_line_points (const xcb_poly_line_request_t *R) +{ + return (xcb_point_t *) (R + 1); +} + +int +xcb_poly_line_points_length (const xcb_poly_line_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_poly_line_request_t))/sizeof(xcb_point_t)); +} + +xcb_point_iterator_t +xcb_poly_line_points_iterator (const xcb_poly_line_request_t *R) +{ + xcb_point_iterator_t i; + i.data = (xcb_point_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_poly_line_request_t))/sizeof(xcb_point_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + void -xcb_segment_next (xcb_segment_iterator_t *i /**< */) +xcb_segment_next (xcb_segment_iterator_t *i) { --i->rem; ++i->data; @@ -6416,7 +8679,7 @@ xcb_segment_next (xcb_segment_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_segment_end (xcb_segment_iterator_t i /**< */) +xcb_segment_end (xcb_segment_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -6426,8 +8689,8 @@ xcb_segment_end (xcb_segment_iterator_t i /**< */) } int -xcb_poly_segment_sizeof (const void *_buffer /**< */, - uint32_t segments_len /**< */) +xcb_poly_segment_sizeof (const void *_buffer, + uint32_t segments_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -6457,17 +8720,17 @@ xcb_poly_segment_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_poly_segment_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t segments_len /**< */, - const xcb_segment_t *segments /**< */) +xcb_poly_segment_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t segments_len, + const xcb_segment_t *segments) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_SEGMENT, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_SEGMENT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6493,17 +8756,17 @@ xcb_poly_segment_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_poly_segment (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t segments_len /**< */, - const xcb_segment_t *segments /**< */) +xcb_poly_segment (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t segments_len, + const xcb_segment_t *segments) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_SEGMENT, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_SEGMENT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6528,9 +8791,31 @@ xcb_poly_segment (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_segment_t * +xcb_poly_segment_segments (const xcb_poly_segment_request_t *R) +{ + return (xcb_segment_t *) (R + 1); +} + int -xcb_poly_rectangle_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */) +xcb_poly_segment_segments_length (const xcb_poly_segment_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_poly_segment_request_t))/sizeof(xcb_segment_t)); +} + +xcb_segment_iterator_t +xcb_poly_segment_segments_iterator (const xcb_poly_segment_request_t *R) +{ + xcb_segment_iterator_t i; + i.data = (xcb_segment_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_poly_segment_request_t))/sizeof(xcb_segment_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_poly_rectangle_sizeof (const void *_buffer, + uint32_t rectangles_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -6560,17 +8845,17 @@ xcb_poly_rectangle_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_poly_rectangle_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_poly_rectangle_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_RECTANGLE, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_RECTANGLE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6596,17 +8881,17 @@ xcb_poly_rectangle_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_poly_rectangle (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_poly_rectangle (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_RECTANGLE, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_RECTANGLE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6631,9 +8916,31 @@ xcb_poly_rectangle (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_rectangle_t * +xcb_poly_rectangle_rectangles (const xcb_poly_rectangle_request_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + int -xcb_poly_arc_sizeof (const void *_buffer /**< */, - uint32_t arcs_len /**< */) +xcb_poly_rectangle_rectangles_length (const xcb_poly_rectangle_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_poly_rectangle_request_t))/sizeof(xcb_rectangle_t)); +} + +xcb_rectangle_iterator_t +xcb_poly_rectangle_rectangles_iterator (const xcb_poly_rectangle_request_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_poly_rectangle_request_t))/sizeof(xcb_rectangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_poly_arc_sizeof (const void *_buffer, + uint32_t arcs_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -6663,17 +8970,17 @@ xcb_poly_arc_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_poly_arc_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t arcs_len /**< */, - const xcb_arc_t *arcs /**< */) +xcb_poly_arc_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t arcs_len, + const xcb_arc_t *arcs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_ARC, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_ARC, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6699,17 +9006,17 @@ xcb_poly_arc_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_poly_arc (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t arcs_len /**< */, - const xcb_arc_t *arcs /**< */) +xcb_poly_arc (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t arcs_len, + const xcb_arc_t *arcs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_ARC, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_ARC, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6734,9 +9041,31 @@ xcb_poly_arc (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_arc_t * +xcb_poly_arc_arcs (const xcb_poly_arc_request_t *R) +{ + return (xcb_arc_t *) (R + 1); +} + int -xcb_fill_poly_sizeof (const void *_buffer /**< */, - uint32_t points_len /**< */) +xcb_poly_arc_arcs_length (const xcb_poly_arc_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_poly_arc_request_t))/sizeof(xcb_arc_t)); +} + +xcb_arc_iterator_t +xcb_poly_arc_arcs_iterator (const xcb_poly_arc_request_t *R) +{ + xcb_arc_iterator_t i; + i.data = (xcb_arc_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_poly_arc_request_t))/sizeof(xcb_arc_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_fill_poly_sizeof (const void *_buffer, + uint32_t points_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -6766,19 +9095,19 @@ xcb_fill_poly_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_fill_poly_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint8_t shape /**< */, - uint8_t coordinate_mode /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */) +xcb_fill_poly_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint8_t shape, + uint8_t coordinate_mode, + uint32_t points_len, + const xcb_point_t *points) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_FILL_POLY, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_FILL_POLY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6807,19 +9136,19 @@ xcb_fill_poly_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_fill_poly (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint8_t shape /**< */, - uint8_t coordinate_mode /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */) +xcb_fill_poly (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint8_t shape, + uint8_t coordinate_mode, + uint32_t points_len, + const xcb_point_t *points) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_FILL_POLY, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_FILL_POLY, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6847,9 +9176,31 @@ xcb_fill_poly (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_point_t * +xcb_fill_poly_points (const xcb_fill_poly_request_t *R) +{ + return (xcb_point_t *) (R + 1); +} + int -xcb_poly_fill_rectangle_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */) +xcb_fill_poly_points_length (const xcb_fill_poly_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_fill_poly_request_t))/sizeof(xcb_point_t)); +} + +xcb_point_iterator_t +xcb_fill_poly_points_iterator (const xcb_fill_poly_request_t *R) +{ + xcb_point_iterator_t i; + i.data = (xcb_point_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_fill_poly_request_t))/sizeof(xcb_point_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_poly_fill_rectangle_sizeof (const void *_buffer, + uint32_t rectangles_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -6879,17 +9230,17 @@ xcb_poly_fill_rectangle_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_poly_fill_rectangle_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_poly_fill_rectangle_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_FILL_RECTANGLE, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_FILL_RECTANGLE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6915,17 +9266,17 @@ xcb_poly_fill_rectangle_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_poly_fill_rectangle (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */) +xcb_poly_fill_rectangle (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_FILL_RECTANGLE, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_FILL_RECTANGLE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -6950,9 +9301,31 @@ xcb_poly_fill_rectangle (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_rectangle_t * +xcb_poly_fill_rectangle_rectangles (const xcb_poly_fill_rectangle_request_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + int -xcb_poly_fill_arc_sizeof (const void *_buffer /**< */, - uint32_t arcs_len /**< */) +xcb_poly_fill_rectangle_rectangles_length (const xcb_poly_fill_rectangle_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_poly_fill_rectangle_request_t))/sizeof(xcb_rectangle_t)); +} + +xcb_rectangle_iterator_t +xcb_poly_fill_rectangle_rectangles_iterator (const xcb_poly_fill_rectangle_request_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_poly_fill_rectangle_request_t))/sizeof(xcb_rectangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_poly_fill_arc_sizeof (const void *_buffer, + uint32_t arcs_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -6982,17 +9355,17 @@ xcb_poly_fill_arc_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_poly_fill_arc_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t arcs_len /**< */, - const xcb_arc_t *arcs /**< */) +xcb_poly_fill_arc_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t arcs_len, + const xcb_arc_t *arcs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_FILL_ARC, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_FILL_ARC, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7018,17 +9391,17 @@ xcb_poly_fill_arc_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_poly_fill_arc (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t arcs_len /**< */, - const xcb_arc_t *arcs /**< */) +xcb_poly_fill_arc (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t arcs_len, + const xcb_arc_t *arcs) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_FILL_ARC, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_FILL_ARC, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7053,9 +9426,31 @@ xcb_poly_fill_arc (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_arc_t * +xcb_poly_fill_arc_arcs (const xcb_poly_fill_arc_request_t *R) +{ + return (xcb_arc_t *) (R + 1); +} + int -xcb_put_image_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */) +xcb_poly_fill_arc_arcs_length (const xcb_poly_fill_arc_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_poly_fill_arc_request_t))/sizeof(xcb_arc_t)); +} + +xcb_arc_iterator_t +xcb_poly_fill_arc_arcs_iterator (const xcb_poly_fill_arc_request_t *R) +{ + xcb_arc_iterator_t i; + i.data = (xcb_arc_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_poly_fill_arc_request_t))/sizeof(xcb_arc_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_put_image_sizeof (const void *_buffer, + uint32_t data_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -7085,24 +9480,24 @@ xcb_put_image_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_put_image_checked (xcb_connection_t *c /**< */, - uint8_t format /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint8_t left_pad /**< */, - uint8_t depth /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_put_image_checked (xcb_connection_t *c, + uint8_t format, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint16_t width, + uint16_t height, + int16_t dst_x, + int16_t dst_y, + uint8_t left_pad, + uint8_t depth, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_PUT_IMAGE, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_PUT_IMAGE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7135,24 +9530,24 @@ xcb_put_image_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_put_image (xcb_connection_t *c /**< */, - uint8_t format /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint8_t left_pad /**< */, - uint8_t depth /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_put_image (xcb_connection_t *c, + uint8_t format, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint16_t width, + uint16_t height, + int16_t dst_x, + int16_t dst_y, + uint8_t left_pad, + uint8_t depth, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_PUT_IMAGE, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_PUT_IMAGE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7184,8 +9579,30 @@ xcb_put_image (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_put_image_data (const xcb_put_image_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_get_image_sizeof (const void *_buffer /**< */) +xcb_put_image_data_length (const xcb_put_image_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_put_image_request_t))/sizeof(uint8_t)); +} + +xcb_generic_iterator_t +xcb_put_image_data_end (const xcb_put_image_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_put_image_request_t))/sizeof(uint8_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_get_image_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_get_image_reply_t *_aux = (xcb_get_image_reply_t *)_buffer; @@ -7216,20 +9633,20 @@ xcb_get_image_sizeof (const void *_buffer /**< */) } xcb_get_image_cookie_t -xcb_get_image (xcb_connection_t *c /**< */, - uint8_t format /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t plane_mask /**< */) +xcb_get_image (xcb_connection_t *c, + uint8_t format, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint32_t plane_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_IMAGE, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_IMAGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7254,20 +9671,20 @@ xcb_get_image (xcb_connection_t *c /**< */, } xcb_get_image_cookie_t -xcb_get_image_unchecked (xcb_connection_t *c /**< */, - uint8_t format /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t plane_mask /**< */) +xcb_get_image_unchecked (xcb_connection_t *c, + uint8_t format, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint32_t plane_mask) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_IMAGE, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_IMAGE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -7292,19 +9709,19 @@ xcb_get_image_unchecked (xcb_connection_t *c /**< */, } uint8_t * -xcb_get_image_data (const xcb_get_image_reply_t *R /**< */) +xcb_get_image_data (const xcb_get_image_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_get_image_data_length (const xcb_get_image_reply_t *R /**< */) +xcb_get_image_data_length (const xcb_get_image_reply_t *R) { return (R->length * 4); } xcb_generic_iterator_t -xcb_get_image_data_end (const xcb_get_image_reply_t *R /**< */) +xcb_get_image_data_end (const xcb_get_image_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); @@ -7314,16 +9731,16 @@ xcb_get_image_data_end (const xcb_get_image_reply_t *R /**< */) } xcb_get_image_reply_t * -xcb_get_image_reply (xcb_connection_t *c /**< */, +xcb_get_image_reply (xcb_connection_t *c, xcb_get_image_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_poly_text_8_sizeof (const void *_buffer /**< */, - uint32_t items_len /**< */) +xcb_poly_text_8_sizeof (const void *_buffer, + uint32_t items_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -7353,19 +9770,19 @@ xcb_poly_text_8_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_poly_text_8_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint32_t items_len /**< */, - const uint8_t *items /**< */) +xcb_poly_text_8_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + uint32_t items_len, + const uint8_t *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_TEXT_8, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_TEXT_8, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7393,19 +9810,19 @@ xcb_poly_text_8_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_poly_text_8 (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint32_t items_len /**< */, - const uint8_t *items /**< */) +xcb_poly_text_8 (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + uint32_t items_len, + const uint8_t *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_TEXT_8, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_TEXT_8, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7432,9 +9849,31 @@ xcb_poly_text_8 (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_poly_text_8_items (const xcb_poly_text_8_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_poly_text_16_sizeof (const void *_buffer /**< */, - uint32_t items_len /**< */) +xcb_poly_text_8_items_length (const xcb_poly_text_8_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_poly_text_8_request_t))/sizeof(uint8_t)); +} + +xcb_generic_iterator_t +xcb_poly_text_8_items_end (const xcb_poly_text_8_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_poly_text_8_request_t))/sizeof(uint8_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_poly_text_16_sizeof (const void *_buffer, + uint32_t items_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -7464,19 +9903,19 @@ xcb_poly_text_16_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_poly_text_16_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint32_t items_len /**< */, - const uint8_t *items /**< */) +xcb_poly_text_16_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + uint32_t items_len, + const uint8_t *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_TEXT_16, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_TEXT_16, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7504,19 +9943,19 @@ xcb_poly_text_16_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_poly_text_16 (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint32_t items_len /**< */, - const uint8_t *items /**< */) +xcb_poly_text_16 (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + uint32_t items_len, + const uint8_t *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_POLY_TEXT_16, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_POLY_TEXT_16, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7543,8 +9982,30 @@ xcb_poly_text_16 (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_poly_text_16_items (const xcb_poly_text_16_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_image_text_8_sizeof (const void *_buffer /**< */) +xcb_poly_text_16_items_length (const xcb_poly_text_16_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_poly_text_16_request_t))/sizeof(uint8_t)); +} + +xcb_generic_iterator_t +xcb_poly_text_16_items_end (const xcb_poly_text_16_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_poly_text_16_request_t))/sizeof(uint8_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_image_text_8_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_image_text_8_request_t *_aux = (xcb_image_text_8_request_t *)_buffer; @@ -7575,19 +10036,19 @@ xcb_image_text_8_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_image_text_8_checked (xcb_connection_t *c /**< */, - uint8_t string_len /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - const char *string /**< */) +xcb_image_text_8_checked (xcb_connection_t *c, + uint8_t string_len, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + const char *string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_IMAGE_TEXT_8, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_IMAGE_TEXT_8, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7615,19 +10076,19 @@ xcb_image_text_8_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_image_text_8 (xcb_connection_t *c /**< */, - uint8_t string_len /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - const char *string /**< */) +xcb_image_text_8 (xcb_connection_t *c, + uint8_t string_len, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + const char *string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_IMAGE_TEXT_8, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_IMAGE_TEXT_8, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7654,8 +10115,30 @@ xcb_image_text_8 (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_image_text_8_string (const xcb_image_text_8_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_image_text_16_sizeof (const void *_buffer /**< */) +xcb_image_text_8_string_length (const xcb_image_text_8_request_t *R) +{ + return R->string_len; +} + +xcb_generic_iterator_t +xcb_image_text_8_string_end (const xcb_image_text_8_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->string_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_image_text_16_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_image_text_16_request_t *_aux = (xcb_image_text_16_request_t *)_buffer; @@ -7686,19 +10169,19 @@ xcb_image_text_16_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_image_text_16_checked (xcb_connection_t *c /**< */, - uint8_t string_len /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - const xcb_char2b_t *string /**< */) +xcb_image_text_16_checked (xcb_connection_t *c, + uint8_t string_len, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + const xcb_char2b_t *string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_IMAGE_TEXT_16, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_IMAGE_TEXT_16, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7726,19 +10209,19 @@ xcb_image_text_16_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_image_text_16 (xcb_connection_t *c /**< */, - uint8_t string_len /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - const xcb_char2b_t *string /**< */) +xcb_image_text_16 (xcb_connection_t *c, + uint8_t string_len, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + const xcb_char2b_t *string) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_IMAGE_TEXT_16, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_IMAGE_TEXT_16, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -7765,18 +10248,40 @@ xcb_image_text_16 (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_char2b_t * +xcb_image_text_16_string (const xcb_image_text_16_request_t *R) +{ + return (xcb_char2b_t *) (R + 1); +} + +int +xcb_image_text_16_string_length (const xcb_image_text_16_request_t *R) +{ + return R->string_len; +} + +xcb_char2b_iterator_t +xcb_image_text_16_string_iterator (const xcb_image_text_16_request_t *R) +{ + xcb_char2b_iterator_t i; + i.data = (xcb_char2b_t *) (R + 1); + i.rem = R->string_len; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_create_colormap_checked (xcb_connection_t *c /**< */, - uint8_t alloc /**< */, - xcb_colormap_t mid /**< */, - xcb_window_t window /**< */, - xcb_visualid_t visual /**< */) +xcb_create_colormap_checked (xcb_connection_t *c, + uint8_t alloc, + xcb_colormap_t mid, + xcb_window_t window, + xcb_visualid_t visual) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CREATE_COLORMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CREATE_COLORMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7798,17 +10303,17 @@ xcb_create_colormap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_create_colormap (xcb_connection_t *c /**< */, - uint8_t alloc /**< */, - xcb_colormap_t mid /**< */, - xcb_window_t window /**< */, - xcb_visualid_t visual /**< */) +xcb_create_colormap (xcb_connection_t *c, + uint8_t alloc, + xcb_colormap_t mid, + xcb_window_t window, + xcb_visualid_t visual) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CREATE_COLORMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CREATE_COLORMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7830,14 +10335,14 @@ xcb_create_colormap (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_free_colormap_checked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */) +xcb_free_colormap_checked (xcb_connection_t *c, + xcb_colormap_t cmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_FREE_COLORMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_FREE_COLORMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7857,14 +10362,14 @@ xcb_free_colormap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_free_colormap (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */) +xcb_free_colormap (xcb_connection_t *c, + xcb_colormap_t cmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_FREE_COLORMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_FREE_COLORMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7884,15 +10389,15 @@ xcb_free_colormap (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_copy_colormap_and_free_checked (xcb_connection_t *c /**< */, - xcb_colormap_t mid /**< */, - xcb_colormap_t src_cmap /**< */) +xcb_copy_colormap_and_free_checked (xcb_connection_t *c, + xcb_colormap_t mid, + xcb_colormap_t src_cmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_COPY_COLORMAP_AND_FREE, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_COPY_COLORMAP_AND_FREE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7913,15 +10418,15 @@ xcb_copy_colormap_and_free_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_copy_colormap_and_free (xcb_connection_t *c /**< */, - xcb_colormap_t mid /**< */, - xcb_colormap_t src_cmap /**< */) +xcb_copy_colormap_and_free (xcb_connection_t *c, + xcb_colormap_t mid, + xcb_colormap_t src_cmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_COPY_COLORMAP_AND_FREE, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_COPY_COLORMAP_AND_FREE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7942,14 +10447,14 @@ xcb_copy_colormap_and_free (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_install_colormap_checked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */) +xcb_install_colormap_checked (xcb_connection_t *c, + xcb_colormap_t cmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_INSTALL_COLORMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_INSTALL_COLORMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7969,14 +10474,14 @@ xcb_install_colormap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_install_colormap (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */) +xcb_install_colormap (xcb_connection_t *c, + xcb_colormap_t cmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_INSTALL_COLORMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_INSTALL_COLORMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -7996,14 +10501,14 @@ xcb_install_colormap (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_uninstall_colormap_checked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */) +xcb_uninstall_colormap_checked (xcb_connection_t *c, + xcb_colormap_t cmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNINSTALL_COLORMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNINSTALL_COLORMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -8023,14 +10528,14 @@ xcb_uninstall_colormap_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_uninstall_colormap (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */) +xcb_uninstall_colormap (xcb_connection_t *c, + xcb_colormap_t cmap) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_UNINSTALL_COLORMAP, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_UNINSTALL_COLORMAP, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -8050,7 +10555,7 @@ xcb_uninstall_colormap (xcb_connection_t *c /**< */, } int -xcb_list_installed_colormaps_sizeof (const void *_buffer /**< */) +xcb_list_installed_colormaps_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_list_installed_colormaps_reply_t *_aux = (xcb_list_installed_colormaps_reply_t *)_buffer; @@ -8081,14 +10586,14 @@ xcb_list_installed_colormaps_sizeof (const void *_buffer /**< */) } xcb_list_installed_colormaps_cookie_t -xcb_list_installed_colormaps (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_list_installed_colormaps (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_LIST_INSTALLED_COLORMAPS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_LIST_INSTALLED_COLORMAPS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8108,14 +10613,14 @@ xcb_list_installed_colormaps (xcb_connection_t *c /**< */, } xcb_list_installed_colormaps_cookie_t -xcb_list_installed_colormaps_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_list_installed_colormaps_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_LIST_INSTALLED_COLORMAPS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_LIST_INSTALLED_COLORMAPS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8135,19 +10640,19 @@ xcb_list_installed_colormaps_unchecked (xcb_connection_t *c /**< */, } xcb_colormap_t * -xcb_list_installed_colormaps_cmaps (const xcb_list_installed_colormaps_reply_t *R /**< */) +xcb_list_installed_colormaps_cmaps (const xcb_list_installed_colormaps_reply_t *R) { return (xcb_colormap_t *) (R + 1); } int -xcb_list_installed_colormaps_cmaps_length (const xcb_list_installed_colormaps_reply_t *R /**< */) +xcb_list_installed_colormaps_cmaps_length (const xcb_list_installed_colormaps_reply_t *R) { return R->cmaps_len; } xcb_generic_iterator_t -xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply_t *R /**< */) +xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_colormap_t *) (R + 1)) + (R->cmaps_len); @@ -8157,25 +10662,25 @@ xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply } xcb_list_installed_colormaps_reply_t * -xcb_list_installed_colormaps_reply (xcb_connection_t *c /**< */, +xcb_list_installed_colormaps_reply (xcb_connection_t *c, xcb_list_installed_colormaps_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_list_installed_colormaps_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_alloc_color_cookie_t -xcb_alloc_color (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t red /**< */, - uint16_t green /**< */, - uint16_t blue /**< */) +xcb_alloc_color (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t red, + uint16_t green, + uint16_t blue) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_ALLOC_COLOR, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_ALLOC_COLOR, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8199,17 +10704,17 @@ xcb_alloc_color (xcb_connection_t *c /**< */, } xcb_alloc_color_cookie_t -xcb_alloc_color_unchecked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t red /**< */, - uint16_t green /**< */, - uint16_t blue /**< */) +xcb_alloc_color_unchecked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t red, + uint16_t green, + uint16_t blue) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_ALLOC_COLOR, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_ALLOC_COLOR, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8233,15 +10738,15 @@ xcb_alloc_color_unchecked (xcb_connection_t *c /**< */, } xcb_alloc_color_reply_t * -xcb_alloc_color_reply (xcb_connection_t *c /**< */, +xcb_alloc_color_reply (xcb_connection_t *c, xcb_alloc_color_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_alloc_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_alloc_named_color_sizeof (const void *_buffer /**< */) +xcb_alloc_named_color_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_alloc_named_color_request_t *_aux = (xcb_alloc_named_color_request_t *)_buffer; @@ -8272,16 +10777,16 @@ xcb_alloc_named_color_sizeof (const void *_buffer /**< */) } xcb_alloc_named_color_cookie_t -xcb_alloc_named_color (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_alloc_named_color (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_ALLOC_NAMED_COLOR, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_ALLOC_NAMED_COLOR, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -8308,16 +10813,16 @@ xcb_alloc_named_color (xcb_connection_t *c /**< */, } xcb_alloc_named_color_cookie_t -xcb_alloc_named_color_unchecked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_alloc_named_color_unchecked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_ALLOC_NAMED_COLOR, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_ALLOC_NAMED_COLOR, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -8344,15 +10849,15 @@ xcb_alloc_named_color_unchecked (xcb_connection_t *c /**< */, } xcb_alloc_named_color_reply_t * -xcb_alloc_named_color_reply (xcb_connection_t *c /**< */, +xcb_alloc_named_color_reply (xcb_connection_t *c, xcb_alloc_named_color_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_alloc_named_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_alloc_color_cells_sizeof (const void *_buffer /**< */) +xcb_alloc_color_cells_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_alloc_color_cells_reply_t *_aux = (xcb_alloc_color_cells_reply_t *)_buffer; @@ -8395,17 +10900,17 @@ xcb_alloc_color_cells_sizeof (const void *_buffer /**< */) } xcb_alloc_color_cells_cookie_t -xcb_alloc_color_cells (xcb_connection_t *c /**< */, - uint8_t contiguous /**< */, - xcb_colormap_t cmap /**< */, - uint16_t colors /**< */, - uint16_t planes /**< */) +xcb_alloc_color_cells (xcb_connection_t *c, + uint8_t contiguous, + xcb_colormap_t cmap, + uint16_t colors, + uint16_t planes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_ALLOC_COLOR_CELLS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_ALLOC_COLOR_CELLS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8427,17 +10932,17 @@ xcb_alloc_color_cells (xcb_connection_t *c /**< */, } xcb_alloc_color_cells_cookie_t -xcb_alloc_color_cells_unchecked (xcb_connection_t *c /**< */, - uint8_t contiguous /**< */, - xcb_colormap_t cmap /**< */, - uint16_t colors /**< */, - uint16_t planes /**< */) +xcb_alloc_color_cells_unchecked (xcb_connection_t *c, + uint8_t contiguous, + xcb_colormap_t cmap, + uint16_t colors, + uint16_t planes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_ALLOC_COLOR_CELLS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_ALLOC_COLOR_CELLS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8459,19 +10964,19 @@ xcb_alloc_color_cells_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_alloc_color_cells_pixels (const xcb_alloc_color_cells_reply_t *R /**< */) +xcb_alloc_color_cells_pixels (const xcb_alloc_color_cells_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_alloc_color_cells_pixels_length (const xcb_alloc_color_cells_reply_t *R /**< */) +xcb_alloc_color_cells_pixels_length (const xcb_alloc_color_cells_reply_t *R) { return R->pixels_len; } xcb_generic_iterator_t -xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R /**< */) +xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->pixels_len); @@ -8481,39 +10986,39 @@ xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R /**< * } uint32_t * -xcb_alloc_color_cells_masks (const xcb_alloc_color_cells_reply_t *R /**< */) +xcb_alloc_color_cells_masks (const xcb_alloc_color_cells_reply_t *R) { xcb_generic_iterator_t prev = xcb_alloc_color_cells_pixels_end(R); return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); } int -xcb_alloc_color_cells_masks_length (const xcb_alloc_color_cells_reply_t *R /**< */) +xcb_alloc_color_cells_masks_length (const xcb_alloc_color_cells_reply_t *R) { return R->masks_len; } xcb_generic_iterator_t -xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R /**< */) +xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_alloc_color_cells_pixels_end(R); - i.data = ((uint32_t *) child.data) + (R->masks_len); + xcb_generic_iterator_t prev = xcb_alloc_color_cells_pixels_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->masks_len); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_alloc_color_cells_reply_t * -xcb_alloc_color_cells_reply (xcb_connection_t *c /**< */, +xcb_alloc_color_cells_reply (xcb_connection_t *c, xcb_alloc_color_cells_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_alloc_color_cells_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_alloc_color_planes_sizeof (const void *_buffer /**< */) +xcb_alloc_color_planes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_alloc_color_planes_reply_t *_aux = (xcb_alloc_color_planes_reply_t *)_buffer; @@ -8544,19 +11049,19 @@ xcb_alloc_color_planes_sizeof (const void *_buffer /**< */) } xcb_alloc_color_planes_cookie_t -xcb_alloc_color_planes (xcb_connection_t *c /**< */, - uint8_t contiguous /**< */, - xcb_colormap_t cmap /**< */, - uint16_t colors /**< */, - uint16_t reds /**< */, - uint16_t greens /**< */, - uint16_t blues /**< */) +xcb_alloc_color_planes (xcb_connection_t *c, + uint8_t contiguous, + xcb_colormap_t cmap, + uint16_t colors, + uint16_t reds, + uint16_t greens, + uint16_t blues) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_ALLOC_COLOR_PLANES, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_ALLOC_COLOR_PLANES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8580,19 +11085,19 @@ xcb_alloc_color_planes (xcb_connection_t *c /**< */, } xcb_alloc_color_planes_cookie_t -xcb_alloc_color_planes_unchecked (xcb_connection_t *c /**< */, - uint8_t contiguous /**< */, - xcb_colormap_t cmap /**< */, - uint16_t colors /**< */, - uint16_t reds /**< */, - uint16_t greens /**< */, - uint16_t blues /**< */) +xcb_alloc_color_planes_unchecked (xcb_connection_t *c, + uint8_t contiguous, + xcb_colormap_t cmap, + uint16_t colors, + uint16_t reds, + uint16_t greens, + uint16_t blues) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_ALLOC_COLOR_PLANES, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_ALLOC_COLOR_PLANES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -8616,19 +11121,19 @@ xcb_alloc_color_planes_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_alloc_color_planes_pixels (const xcb_alloc_color_planes_reply_t *R /**< */) +xcb_alloc_color_planes_pixels (const xcb_alloc_color_planes_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_alloc_color_planes_pixels_length (const xcb_alloc_color_planes_reply_t *R /**< */) +xcb_alloc_color_planes_pixels_length (const xcb_alloc_color_planes_reply_t *R) { return R->pixels_len; } xcb_generic_iterator_t -xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R /**< */) +xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->pixels_len); @@ -8638,16 +11143,16 @@ xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R /**< } xcb_alloc_color_planes_reply_t * -xcb_alloc_color_planes_reply (xcb_connection_t *c /**< */, +xcb_alloc_color_planes_reply (xcb_connection_t *c, xcb_alloc_color_planes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_alloc_color_planes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_free_colors_sizeof (const void *_buffer /**< */, - uint32_t pixels_len /**< */) +xcb_free_colors_sizeof (const void *_buffer, + uint32_t pixels_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -8677,17 +11182,17 @@ xcb_free_colors_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_free_colors_checked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t plane_mask /**< */, - uint32_t pixels_len /**< */, - const uint32_t *pixels /**< */) +xcb_free_colors_checked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t plane_mask, + uint32_t pixels_len, + const uint32_t *pixels) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_FREE_COLORS, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_FREE_COLORS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -8713,17 +11218,17 @@ xcb_free_colors_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_free_colors (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t plane_mask /**< */, - uint32_t pixels_len /**< */, - const uint32_t *pixels /**< */) +xcb_free_colors (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t plane_mask, + uint32_t pixels_len, + const uint32_t *pixels) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_FREE_COLORS, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_FREE_COLORS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -8748,8 +11253,30 @@ xcb_free_colors (xcb_connection_t *c /**< */, return xcb_ret; } +uint32_t * +xcb_free_colors_pixels (const xcb_free_colors_request_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_free_colors_pixels_length (const xcb_free_colors_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_free_colors_request_t))/sizeof(uint32_t)); +} + +xcb_generic_iterator_t +xcb_free_colors_pixels_end (const xcb_free_colors_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_free_colors_request_t))/sizeof(uint32_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + void -xcb_coloritem_next (xcb_coloritem_iterator_t *i /**< */) +xcb_coloritem_next (xcb_coloritem_iterator_t *i) { --i->rem; ++i->data; @@ -8757,7 +11284,7 @@ xcb_coloritem_next (xcb_coloritem_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_coloritem_end (xcb_coloritem_iterator_t i /**< */) +xcb_coloritem_end (xcb_coloritem_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -8767,8 +11294,8 @@ xcb_coloritem_end (xcb_coloritem_iterator_t i /**< */) } int -xcb_store_colors_sizeof (const void *_buffer /**< */, - uint32_t items_len /**< */) +xcb_store_colors_sizeof (const void *_buffer, + uint32_t items_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -8798,16 +11325,16 @@ xcb_store_colors_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_store_colors_checked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t items_len /**< */, - const xcb_coloritem_t *items /**< */) +xcb_store_colors_checked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t items_len, + const xcb_coloritem_t *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_STORE_COLORS, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_STORE_COLORS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -8832,16 +11359,16 @@ xcb_store_colors_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_store_colors (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t items_len /**< */, - const xcb_coloritem_t *items /**< */) +xcb_store_colors (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t items_len, + const xcb_coloritem_t *items) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_STORE_COLORS, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_STORE_COLORS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -8865,8 +11392,30 @@ xcb_store_colors (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_coloritem_t * +xcb_store_colors_items (const xcb_store_colors_request_t *R) +{ + return (xcb_coloritem_t *) (R + 1); +} + int -xcb_store_named_color_sizeof (const void *_buffer /**< */) +xcb_store_colors_items_length (const xcb_store_colors_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_store_colors_request_t))/sizeof(xcb_coloritem_t)); +} + +xcb_coloritem_iterator_t +xcb_store_colors_items_iterator (const xcb_store_colors_request_t *R) +{ + xcb_coloritem_iterator_t i; + i.data = (xcb_coloritem_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_store_colors_request_t))/sizeof(xcb_coloritem_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_store_named_color_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_store_named_color_request_t *_aux = (xcb_store_named_color_request_t *)_buffer; @@ -8897,18 +11446,18 @@ xcb_store_named_color_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_store_named_color_checked (xcb_connection_t *c /**< */, - uint8_t flags /**< */, - xcb_colormap_t cmap /**< */, - uint32_t pixel /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_store_named_color_checked (xcb_connection_t *c, + uint8_t flags, + xcb_colormap_t cmap, + uint32_t pixel, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_STORE_NAMED_COLOR, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_STORE_NAMED_COLOR, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -8936,18 +11485,18 @@ xcb_store_named_color_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_store_named_color (xcb_connection_t *c /**< */, - uint8_t flags /**< */, - xcb_colormap_t cmap /**< */, - uint32_t pixel /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_store_named_color (xcb_connection_t *c, + uint8_t flags, + xcb_colormap_t cmap, + uint32_t pixel, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_STORE_NAMED_COLOR, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_STORE_NAMED_COLOR, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -8974,8 +11523,30 @@ xcb_store_named_color (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_store_named_color_name (const xcb_store_named_color_request_t *R) +{ + return (char *) (R + 1); +} + +int +xcb_store_named_color_name_length (const xcb_store_named_color_request_t *R) +{ + return R->name_len; +} + +xcb_generic_iterator_t +xcb_store_named_color_name_end (const xcb_store_named_color_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->name_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + void -xcb_rgb_next (xcb_rgb_iterator_t *i /**< */) +xcb_rgb_next (xcb_rgb_iterator_t *i) { --i->rem; ++i->data; @@ -8983,7 +11554,7 @@ xcb_rgb_next (xcb_rgb_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_rgb_end (xcb_rgb_iterator_t i /**< */) +xcb_rgb_end (xcb_rgb_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -8993,8 +11564,8 @@ xcb_rgb_end (xcb_rgb_iterator_t i /**< */) } int -xcb_query_colors_sizeof (const void *_buffer /**< */, - uint32_t pixels_len /**< */) +xcb_query_colors_sizeof (const void *_buffer, + uint32_t pixels_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -9024,16 +11595,16 @@ xcb_query_colors_sizeof (const void *_buffer /**< */, } xcb_query_colors_cookie_t -xcb_query_colors (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t pixels_len /**< */, - const uint32_t *pixels /**< */) +xcb_query_colors (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t pixels_len, + const uint32_t *pixels) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_QUERY_COLORS, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_QUERY_COLORS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -9058,16 +11629,16 @@ xcb_query_colors (xcb_connection_t *c /**< */, } xcb_query_colors_cookie_t -xcb_query_colors_unchecked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t pixels_len /**< */, - const uint32_t *pixels /**< */) +xcb_query_colors_unchecked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t pixels_len, + const uint32_t *pixels) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_QUERY_COLORS, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_QUERY_COLORS, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -9092,19 +11663,19 @@ xcb_query_colors_unchecked (xcb_connection_t *c /**< */, } xcb_rgb_t * -xcb_query_colors_colors (const xcb_query_colors_reply_t *R /**< */) +xcb_query_colors_colors (const xcb_query_colors_reply_t *R) { return (xcb_rgb_t *) (R + 1); } int -xcb_query_colors_colors_length (const xcb_query_colors_reply_t *R /**< */) +xcb_query_colors_colors_length (const xcb_query_colors_reply_t *R) { return R->colors_len; } xcb_rgb_iterator_t -xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R /**< */) +xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R) { xcb_rgb_iterator_t i; i.data = (xcb_rgb_t *) (R + 1); @@ -9114,15 +11685,15 @@ xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R /**< */) } xcb_query_colors_reply_t * -xcb_query_colors_reply (xcb_connection_t *c /**< */, +xcb_query_colors_reply (xcb_connection_t *c, xcb_query_colors_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_query_colors_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_lookup_color_sizeof (const void *_buffer /**< */) +xcb_lookup_color_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_lookup_color_request_t *_aux = (xcb_lookup_color_request_t *)_buffer; @@ -9153,16 +11724,16 @@ xcb_lookup_color_sizeof (const void *_buffer /**< */) } xcb_lookup_color_cookie_t -xcb_lookup_color (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_lookup_color (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_LOOKUP_COLOR, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_LOOKUP_COLOR, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -9189,16 +11760,16 @@ xcb_lookup_color (xcb_connection_t *c /**< */, } xcb_lookup_color_cookie_t -xcb_lookup_color_unchecked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_lookup_color_unchecked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_LOOKUP_COLOR, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_LOOKUP_COLOR, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -9225,32 +11796,32 @@ xcb_lookup_color_unchecked (xcb_connection_t *c /**< */, } xcb_lookup_color_reply_t * -xcb_lookup_color_reply (xcb_connection_t *c /**< */, +xcb_lookup_color_reply (xcb_connection_t *c, xcb_lookup_color_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_lookup_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_create_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_pixmap_t source /**< */, - xcb_pixmap_t mask /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */, - uint16_t x /**< */, - uint16_t y /**< */) +xcb_create_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_pixmap_t source, + xcb_pixmap_t mask, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue, + uint16_t x, + uint16_t y) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CREATE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CREATE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -9280,24 +11851,24 @@ xcb_create_cursor_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_create_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_pixmap_t source /**< */, - xcb_pixmap_t mask /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */, - uint16_t x /**< */, - uint16_t y /**< */) +xcb_create_cursor (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_pixmap_t source, + xcb_pixmap_t mask, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue, + uint16_t x, + uint16_t y) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CREATE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CREATE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -9327,24 +11898,24 @@ xcb_create_cursor (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_create_glyph_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_font_t source_font /**< */, - xcb_font_t mask_font /**< */, - uint16_t source_char /**< */, - uint16_t mask_char /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */) +xcb_create_glyph_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_font_t source_font, + xcb_font_t mask_font, + uint16_t source_char, + uint16_t mask_char, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CREATE_GLYPH_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CREATE_GLYPH_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -9374,24 +11945,24 @@ xcb_create_glyph_cursor_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_create_glyph_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_font_t source_font /**< */, - xcb_font_t mask_font /**< */, - uint16_t source_char /**< */, - uint16_t mask_char /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */) +xcb_create_glyph_cursor (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_font_t source_font, + xcb_font_t mask_font, + uint16_t source_char, + uint16_t mask_char, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CREATE_GLYPH_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CREATE_GLYPH_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -9421,14 +11992,14 @@ xcb_create_glyph_cursor (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_free_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */) +xcb_free_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cursor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_FREE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_FREE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -9448,14 +12019,14 @@ xcb_free_cursor_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_free_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */) +xcb_free_cursor (xcb_connection_t *c, + xcb_cursor_t cursor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_FREE_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_FREE_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -9475,20 +12046,20 @@ xcb_free_cursor (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_recolor_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */) +xcb_recolor_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cursor, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_RECOLOR_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_RECOLOR_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -9514,20 +12085,20 @@ xcb_recolor_cursor_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_recolor_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */) +xcb_recolor_cursor (xcb_connection_t *c, + xcb_cursor_t cursor, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_RECOLOR_CURSOR, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_RECOLOR_CURSOR, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -9553,17 +12124,17 @@ xcb_recolor_cursor (xcb_connection_t *c /**< */, } xcb_query_best_size_cookie_t -xcb_query_best_size (xcb_connection_t *c /**< */, - uint8_t _class /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_query_best_size (xcb_connection_t *c, + uint8_t _class, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_QUERY_BEST_SIZE, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_QUERY_BEST_SIZE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9585,17 +12156,17 @@ xcb_query_best_size (xcb_connection_t *c /**< */, } xcb_query_best_size_cookie_t -xcb_query_best_size_unchecked (xcb_connection_t *c /**< */, - uint8_t _class /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_query_best_size_unchecked (xcb_connection_t *c, + uint8_t _class, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_QUERY_BEST_SIZE, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_QUERY_BEST_SIZE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9617,15 +12188,15 @@ xcb_query_best_size_unchecked (xcb_connection_t *c /**< */, } xcb_query_best_size_reply_t * -xcb_query_best_size_reply (xcb_connection_t *c /**< */, +xcb_query_best_size_reply (xcb_connection_t *c, xcb_query_best_size_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_query_best_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_query_extension_sizeof (const void *_buffer /**< */) +xcb_query_extension_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_query_extension_request_t *_aux = (xcb_query_extension_request_t *)_buffer; @@ -9656,15 +12227,15 @@ xcb_query_extension_sizeof (const void *_buffer /**< */) } xcb_query_extension_cookie_t -xcb_query_extension (xcb_connection_t *c /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_query_extension (xcb_connection_t *c, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_QUERY_EXTENSION, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_QUERY_EXTENSION, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -9690,15 +12261,15 @@ xcb_query_extension (xcb_connection_t *c /**< */, } xcb_query_extension_cookie_t -xcb_query_extension_unchecked (xcb_connection_t *c /**< */, - uint16_t name_len /**< */, - const char *name /**< */) +xcb_query_extension_unchecked (xcb_connection_t *c, + uint16_t name_len, + const char *name) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_QUERY_EXTENSION, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_QUERY_EXTENSION, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -9724,15 +12295,15 @@ xcb_query_extension_unchecked (xcb_connection_t *c /**< */, } xcb_query_extension_reply_t * -xcb_query_extension_reply (xcb_connection_t *c /**< */, +xcb_query_extension_reply (xcb_connection_t *c, xcb_query_extension_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_query_extension_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_list_extensions_sizeof (const void *_buffer /**< */) +xcb_list_extensions_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_list_extensions_reply_t *_aux = (xcb_list_extensions_reply_t *)_buffer; @@ -9768,13 +12339,13 @@ xcb_list_extensions_sizeof (const void *_buffer /**< */) } xcb_list_extensions_cookie_t -xcb_list_extensions (xcb_connection_t *c /**< */) +xcb_list_extensions (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_LIST_EXTENSIONS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_LIST_EXTENSIONS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9793,13 +12364,13 @@ xcb_list_extensions (xcb_connection_t *c /**< */) } xcb_list_extensions_cookie_t -xcb_list_extensions_unchecked (xcb_connection_t *c /**< */) +xcb_list_extensions_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_LIST_EXTENSIONS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_LIST_EXTENSIONS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -9818,13 +12389,13 @@ xcb_list_extensions_unchecked (xcb_connection_t *c /**< */) } int -xcb_list_extensions_names_length (const xcb_list_extensions_reply_t *R /**< */) +xcb_list_extensions_names_length (const xcb_list_extensions_reply_t *R) { return R->names_len; } xcb_str_iterator_t -xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R /**< */) +xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R) { xcb_str_iterator_t i; i.data = (xcb_str_t *) (R + 1); @@ -9834,15 +12405,15 @@ xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R /**< * } xcb_list_extensions_reply_t * -xcb_list_extensions_reply (xcb_connection_t *c /**< */, +xcb_list_extensions_reply (xcb_connection_t *c, xcb_list_extensions_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_list_extensions_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_change_keyboard_mapping_sizeof (const void *_buffer /**< */) +xcb_change_keyboard_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_change_keyboard_mapping_request_t *_aux = (xcb_change_keyboard_mapping_request_t *)_buffer; @@ -9873,17 +12444,17 @@ xcb_change_keyboard_mapping_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_change_keyboard_mapping_checked (xcb_connection_t *c /**< */, - uint8_t keycode_count /**< */, - xcb_keycode_t first_keycode /**< */, - uint8_t keysyms_per_keycode /**< */, - const xcb_keysym_t *keysyms /**< */) +xcb_change_keyboard_mapping_checked (xcb_connection_t *c, + uint8_t keycode_count, + xcb_keycode_t first_keycode, + uint8_t keysyms_per_keycode, + const xcb_keysym_t *keysyms) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_KEYBOARD_MAPPING, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_CHANGE_KEYBOARD_MAPPING, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -9910,17 +12481,17 @@ xcb_change_keyboard_mapping_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_change_keyboard_mapping (xcb_connection_t *c /**< */, - uint8_t keycode_count /**< */, - xcb_keycode_t first_keycode /**< */, - uint8_t keysyms_per_keycode /**< */, - const xcb_keysym_t *keysyms /**< */) +xcb_change_keyboard_mapping (xcb_connection_t *c, + uint8_t keycode_count, + xcb_keycode_t first_keycode, + uint8_t keysyms_per_keycode, + const xcb_keysym_t *keysyms) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_KEYBOARD_MAPPING, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_CHANGE_KEYBOARD_MAPPING, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -9946,8 +12517,30 @@ xcb_change_keyboard_mapping (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_keysym_t * +xcb_change_keyboard_mapping_keysyms (const xcb_change_keyboard_mapping_request_t *R) +{ + return (xcb_keysym_t *) (R + 1); +} + int -xcb_get_keyboard_mapping_sizeof (const void *_buffer /**< */) +xcb_change_keyboard_mapping_keysyms_length (const xcb_change_keyboard_mapping_request_t *R) +{ + return (R->keycode_count * R->keysyms_per_keycode); +} + +xcb_generic_iterator_t +xcb_change_keyboard_mapping_keysyms_end (const xcb_change_keyboard_mapping_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_keysym_t *) (R + 1)) + ((R->keycode_count * R->keysyms_per_keycode)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_get_keyboard_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_get_keyboard_mapping_reply_t *_aux = (xcb_get_keyboard_mapping_reply_t *)_buffer; @@ -9978,15 +12571,15 @@ xcb_get_keyboard_mapping_sizeof (const void *_buffer /**< */) } xcb_get_keyboard_mapping_cookie_t -xcb_get_keyboard_mapping (xcb_connection_t *c /**< */, - xcb_keycode_t first_keycode /**< */, - uint8_t count /**< */) +xcb_get_keyboard_mapping (xcb_connection_t *c, + xcb_keycode_t first_keycode, + uint8_t count) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_KEYBOARD_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_KEYBOARD_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10007,15 +12600,15 @@ xcb_get_keyboard_mapping (xcb_connection_t *c /**< */, } xcb_get_keyboard_mapping_cookie_t -xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c /**< */, - xcb_keycode_t first_keycode /**< */, - uint8_t count /**< */) +xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c, + xcb_keycode_t first_keycode, + uint8_t count) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_KEYBOARD_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_KEYBOARD_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10036,19 +12629,19 @@ xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c /**< */, } xcb_keysym_t * -xcb_get_keyboard_mapping_keysyms (const xcb_get_keyboard_mapping_reply_t *R /**< */) +xcb_get_keyboard_mapping_keysyms (const xcb_get_keyboard_mapping_reply_t *R) { return (xcb_keysym_t *) (R + 1); } int -xcb_get_keyboard_mapping_keysyms_length (const xcb_get_keyboard_mapping_reply_t *R /**< */) +xcb_get_keyboard_mapping_keysyms_length (const xcb_get_keyboard_mapping_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R /**< */) +xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_keysym_t *) (R + 1)) + (R->length); @@ -10058,15 +12651,216 @@ xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R } xcb_get_keyboard_mapping_reply_t * -xcb_get_keyboard_mapping_reply (xcb_connection_t *c /**< */, +xcb_get_keyboard_mapping_reply (xcb_connection_t *c, xcb_get_keyboard_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_keyboard_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_change_keyboard_control_sizeof (const void *_buffer /**< */) +xcb_change_keyboard_control_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_change_keyboard_control_value_list_t *_aux) +{ + char *xcb_out = *_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_align_to = 0; + unsigned int xcb_padding_offset = 0; + + unsigned int xcb_pad = 0; + char xcb_pad0[3] = {0, 0, 0}; + struct iovec xcb_parts[9]; + unsigned int xcb_parts_idx = 0; + unsigned int xcb_block_len = 0; + unsigned int i; + char *xcb_tmp; + + if(value_mask & XCB_KB_KEY_CLICK_PERCENT) { + /* xcb_change_keyboard_control_value_list_t.key_click_percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_click_percent; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_KB_BELL_PERCENT) { + /* xcb_change_keyboard_control_value_list_t.bell_percent */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell_percent; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_KB_BELL_PITCH) { + /* xcb_change_keyboard_control_value_list_t.bell_pitch */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell_pitch; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_KB_BELL_DURATION) { + /* xcb_change_keyboard_control_value_list_t.bell_duration */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell_duration; + xcb_block_len += sizeof(int32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_KB_LED) { + /* xcb_change_keyboard_control_value_list_t.led */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_KB_LED_MODE) { + /* xcb_change_keyboard_control_value_list_t.led_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led_mode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_KB_KEY) { + /* xcb_change_keyboard_control_value_list_t.key */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key; + xcb_block_len += sizeof(xcb_keycode32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(xcb_keycode32_t); + } + if(value_mask & XCB_KB_AUTO_REPEAT_MODE) { + /* xcb_change_keyboard_control_value_list_t.auto_repeat_mode */ + xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->auto_repeat_mode; + xcb_block_len += sizeof(uint32_t); + xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); + xcb_parts_idx++; + xcb_align_to = ALIGNOF(uint32_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_parts[xcb_parts_idx].iov_base = xcb_pad0; + xcb_parts[xcb_parts_idx].iov_len = xcb_pad; + xcb_parts_idx++; + xcb_pad = 0; + } + xcb_block_len = 0; + xcb_padding_offset = 0; + + if (NULL == xcb_out) { + /* allocate memory */ + xcb_out = malloc(xcb_buffer_len); + *_buffer = xcb_out; + } + + xcb_tmp = xcb_out; + for(i=0; ikey_click_percent = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_KB_BELL_PERCENT) { + /* xcb_change_keyboard_control_value_list_t.bell_percent */ + _aux->bell_percent = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_KB_BELL_PITCH) { + /* xcb_change_keyboard_control_value_list_t.bell_pitch */ + _aux->bell_pitch = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_KB_BELL_DURATION) { + /* xcb_change_keyboard_control_value_list_t.bell_duration */ + _aux->bell_duration = *(int32_t *)xcb_tmp; + xcb_block_len += sizeof(int32_t); + xcb_tmp += sizeof(int32_t); + xcb_align_to = ALIGNOF(int32_t); + } + if(value_mask & XCB_KB_LED) { + /* xcb_change_keyboard_control_value_list_t.led */ + _aux->led = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_KB_LED_MODE) { + /* xcb_change_keyboard_control_value_list_t.led_mode */ + _aux->led_mode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_t); + } + if(value_mask & XCB_KB_KEY) { + /* xcb_change_keyboard_control_value_list_t.key */ + _aux->key = *(xcb_keycode32_t *)xcb_tmp; + xcb_block_len += sizeof(xcb_keycode32_t); + xcb_tmp += sizeof(xcb_keycode32_t); + xcb_align_to = ALIGNOF(xcb_keycode32_t); + } + if(value_mask & XCB_KB_AUTO_REPEAT_MODE) { + /* xcb_change_keyboard_control_value_list_t.auto_repeat_mode */ + _aux->auto_repeat_mode = *(uint32_t *)xcb_tmp; + xcb_block_len += sizeof(uint32_t); + xcb_tmp += sizeof(uint32_t); + xcb_align_to = ALIGNOF(uint32_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; +} + +int +xcb_change_keyboard_control_value_list_sizeof (const void *_buffer, + uint32_t value_mask) +{ + xcb_change_keyboard_control_value_list_t _aux; + return xcb_change_keyboard_control_value_list_unpack(_buffer, value_mask, &_aux); +} + +int +xcb_change_keyboard_control_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_change_keyboard_control_request_t *_aux = (xcb_change_keyboard_control_request_t *)_buffer; @@ -10081,9 +12875,9 @@ xcb_change_keyboard_control_sizeof (const void *_buffer /**< */) xcb_buffer_len += xcb_block_len; xcb_block_len = 0; /* value_list */ - xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); + xcb_block_len += xcb_change_keyboard_control_value_list_sizeof(xcb_tmp, _aux->value_mask); xcb_tmp += xcb_block_len; - xcb_align_to = ALIGNOF(uint32_t); + xcb_align_to = ALIGNOF(char); /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -10097,18 +12891,18 @@ xcb_change_keyboard_control_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_change_keyboard_control_checked (xcb_connection_t *c /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_change_keyboard_control_checked (xcb_connection_t *c, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_KEYBOARD_CONTROL, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_KEYBOARD_CONTROL, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_change_keyboard_control_request_t xcb_out; @@ -10119,29 +12913,28 @@ xcb_change_keyboard_control_checked (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_change_keyboard_control_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_change_keyboard_control_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); return xcb_ret; } xcb_void_cookie_t -xcb_change_keyboard_control (xcb_connection_t *c /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */) +xcb_change_keyboard_control (xcb_connection_t *c, + uint32_t value_mask, + const void *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_KEYBOARD_CONTROL, - /* isvoid */ 1 + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_KEYBOARD_CONTROL, + .isvoid = 1 }; - struct iovec xcb_parts[6]; + struct iovec xcb_parts[5]; xcb_void_cookie_t xcb_ret; xcb_change_keyboard_control_request_t xcb_out; @@ -10152,24 +12945,97 @@ xcb_change_keyboard_control (xcb_connection_t *c /**< */, xcb_parts[2].iov_len = sizeof(xcb_out); xcb_parts[3].iov_base = 0; xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; - /* uint32_t value_list */ + /* xcb_change_keyboard_control_value_list_t value_list */ xcb_parts[4].iov_base = (char *) value_list; - xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); - xcb_parts[5].iov_base = 0; - xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + xcb_parts[4].iov_len = + xcb_change_keyboard_control_value_list_sizeof (value_list, value_mask); xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); return xcb_ret; } -xcb_get_keyboard_control_cookie_t -xcb_get_keyboard_control (xcb_connection_t *c /**< */) +xcb_void_cookie_t +xcb_change_keyboard_control_aux_checked (xcb_connection_t *c, + uint32_t value_mask, + const xcb_change_keyboard_control_value_list_t *value_list) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_KEYBOARD_CONTROL, - /* isvoid */ 0 + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_KEYBOARD_CONTROL, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_change_keyboard_control_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pad0 = 0; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_change_keyboard_control_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_change_keyboard_control_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_change_keyboard_control_aux (xcb_connection_t *c, + uint32_t value_mask, + const xcb_change_keyboard_control_value_list_t *value_list) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 3, + .ext = 0, + .opcode = XCB_CHANGE_KEYBOARD_CONTROL, + .isvoid = 1 + }; + + struct iovec xcb_parts[5]; + xcb_void_cookie_t xcb_ret; + xcb_change_keyboard_control_request_t xcb_out; + void *xcb_aux0 = 0; + + xcb_out.pad0 = 0; + xcb_out.value_mask = value_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_change_keyboard_control_value_list_t value_list */ + xcb_parts[4].iov_len = + xcb_change_keyboard_control_value_list_serialize (&xcb_aux0, value_mask, value_list); + xcb_parts[4].iov_base = xcb_aux0; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + free(xcb_aux0); + return xcb_ret; +} + +void * +xcb_change_keyboard_control_value_list (const xcb_change_keyboard_control_request_t *R) +{ + return (void *) (R + 1); +} + +xcb_get_keyboard_control_cookie_t +xcb_get_keyboard_control (xcb_connection_t *c) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = 0, + .opcode = XCB_GET_KEYBOARD_CONTROL, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10188,13 +13054,13 @@ xcb_get_keyboard_control (xcb_connection_t *c /**< */) } xcb_get_keyboard_control_cookie_t -xcb_get_keyboard_control_unchecked (xcb_connection_t *c /**< */) +xcb_get_keyboard_control_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_KEYBOARD_CONTROL, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_KEYBOARD_CONTROL, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10213,22 +13079,22 @@ xcb_get_keyboard_control_unchecked (xcb_connection_t *c /**< */) } xcb_get_keyboard_control_reply_t * -xcb_get_keyboard_control_reply (xcb_connection_t *c /**< */, +xcb_get_keyboard_control_reply (xcb_connection_t *c, xcb_get_keyboard_control_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_keyboard_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_bell_checked (xcb_connection_t *c /**< */, - int8_t percent /**< */) +xcb_bell_checked (xcb_connection_t *c, + int8_t percent) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_BELL, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_BELL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10247,14 +13113,14 @@ xcb_bell_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_bell (xcb_connection_t *c /**< */, - int8_t percent /**< */) +xcb_bell (xcb_connection_t *c, + int8_t percent) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_BELL, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_BELL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10273,18 +13139,18 @@ xcb_bell (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_change_pointer_control_checked (xcb_connection_t *c /**< */, - int16_t acceleration_numerator /**< */, - int16_t acceleration_denominator /**< */, - int16_t threshold /**< */, - uint8_t do_acceleration /**< */, - uint8_t do_threshold /**< */) +xcb_change_pointer_control_checked (xcb_connection_t *c, + int16_t acceleration_numerator, + int16_t acceleration_denominator, + int16_t threshold, + uint8_t do_acceleration, + uint8_t do_threshold) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CHANGE_POINTER_CONTROL, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CHANGE_POINTER_CONTROL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10308,18 +13174,18 @@ xcb_change_pointer_control_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_change_pointer_control (xcb_connection_t *c /**< */, - int16_t acceleration_numerator /**< */, - int16_t acceleration_denominator /**< */, - int16_t threshold /**< */, - uint8_t do_acceleration /**< */, - uint8_t do_threshold /**< */) +xcb_change_pointer_control (xcb_connection_t *c, + int16_t acceleration_numerator, + int16_t acceleration_denominator, + int16_t threshold, + uint8_t do_acceleration, + uint8_t do_threshold) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_CHANGE_POINTER_CONTROL, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_CHANGE_POINTER_CONTROL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10343,13 +13209,13 @@ xcb_change_pointer_control (xcb_connection_t *c /**< */, } xcb_get_pointer_control_cookie_t -xcb_get_pointer_control (xcb_connection_t *c /**< */) +xcb_get_pointer_control (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_POINTER_CONTROL, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_POINTER_CONTROL, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10368,13 +13234,13 @@ xcb_get_pointer_control (xcb_connection_t *c /**< */) } xcb_get_pointer_control_cookie_t -xcb_get_pointer_control_unchecked (xcb_connection_t *c /**< */) +xcb_get_pointer_control_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_POINTER_CONTROL, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_POINTER_CONTROL, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10393,25 +13259,25 @@ xcb_get_pointer_control_unchecked (xcb_connection_t *c /**< */) } xcb_get_pointer_control_reply_t * -xcb_get_pointer_control_reply (xcb_connection_t *c /**< */, +xcb_get_pointer_control_reply (xcb_connection_t *c, xcb_get_pointer_control_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_pointer_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_set_screen_saver_checked (xcb_connection_t *c /**< */, - int16_t timeout /**< */, - int16_t interval /**< */, - uint8_t prefer_blanking /**< */, - uint8_t allow_exposures /**< */) +xcb_set_screen_saver_checked (xcb_connection_t *c, + int16_t timeout, + int16_t interval, + uint8_t prefer_blanking, + uint8_t allow_exposures) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SET_SCREEN_SAVER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SET_SCREEN_SAVER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10434,17 +13300,17 @@ xcb_set_screen_saver_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_set_screen_saver (xcb_connection_t *c /**< */, - int16_t timeout /**< */, - int16_t interval /**< */, - uint8_t prefer_blanking /**< */, - uint8_t allow_exposures /**< */) +xcb_set_screen_saver (xcb_connection_t *c, + int16_t timeout, + int16_t interval, + uint8_t prefer_blanking, + uint8_t allow_exposures) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SET_SCREEN_SAVER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SET_SCREEN_SAVER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10467,13 +13333,13 @@ xcb_set_screen_saver (xcb_connection_t *c /**< */, } xcb_get_screen_saver_cookie_t -xcb_get_screen_saver (xcb_connection_t *c /**< */) +xcb_get_screen_saver (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_SCREEN_SAVER, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_SCREEN_SAVER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10492,13 +13358,13 @@ xcb_get_screen_saver (xcb_connection_t *c /**< */) } xcb_get_screen_saver_cookie_t -xcb_get_screen_saver_unchecked (xcb_connection_t *c /**< */) +xcb_get_screen_saver_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_SCREEN_SAVER, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_SCREEN_SAVER, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10517,15 +13383,15 @@ xcb_get_screen_saver_unchecked (xcb_connection_t *c /**< */) } xcb_get_screen_saver_reply_t * -xcb_get_screen_saver_reply (xcb_connection_t *c /**< */, +xcb_get_screen_saver_reply (xcb_connection_t *c, xcb_get_screen_saver_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_screen_saver_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_change_hosts_sizeof (const void *_buffer /**< */) +xcb_change_hosts_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_change_hosts_request_t *_aux = (xcb_change_hosts_request_t *)_buffer; @@ -10556,17 +13422,17 @@ xcb_change_hosts_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_change_hosts_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - uint8_t family /**< */, - uint16_t address_len /**< */, - const uint8_t *address /**< */) +xcb_change_hosts_checked (xcb_connection_t *c, + uint8_t mode, + uint8_t family, + uint16_t address_len, + const uint8_t *address) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_HOSTS, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_CHANGE_HOSTS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -10593,17 +13459,17 @@ xcb_change_hosts_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_change_hosts (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - uint8_t family /**< */, - uint16_t address_len /**< */, - const uint8_t *address /**< */) +xcb_change_hosts (xcb_connection_t *c, + uint8_t mode, + uint8_t family, + uint16_t address_len, + const uint8_t *address) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_CHANGE_HOSTS, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_CHANGE_HOSTS, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -10629,8 +13495,30 @@ xcb_change_hosts (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_change_hosts_address (const xcb_change_hosts_request_t *R) +{ + return (uint8_t *) (R + 1); +} + int -xcb_host_sizeof (const void *_buffer /**< */) +xcb_change_hosts_address_length (const xcb_change_hosts_request_t *R) +{ + return R->address_len; +} + +xcb_generic_iterator_t +xcb_change_hosts_address_end (const xcb_change_hosts_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + (R->address_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_host_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_host_t *_aux = (xcb_host_t *)_buffer; @@ -10648,6 +13536,15 @@ xcb_host_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->address_len * sizeof(uint8_t); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(uint8_t); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -10661,19 +13558,19 @@ xcb_host_sizeof (const void *_buffer /**< */) } uint8_t * -xcb_host_address (const xcb_host_t *R /**< */) +xcb_host_address (const xcb_host_t *R) { return (uint8_t *) (R + 1); } int -xcb_host_address_length (const xcb_host_t *R /**< */) +xcb_host_address_length (const xcb_host_t *R) { return R->address_len; } xcb_generic_iterator_t -xcb_host_address_end (const xcb_host_t *R /**< */) +xcb_host_address_end (const xcb_host_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + (R->address_len); @@ -10683,7 +13580,7 @@ xcb_host_address_end (const xcb_host_t *R /**< */) } void -xcb_host_next (xcb_host_iterator_t *i /**< */) +xcb_host_next (xcb_host_iterator_t *i) { xcb_host_t *R = i->data; xcb_generic_iterator_t child; @@ -10694,7 +13591,7 @@ xcb_host_next (xcb_host_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_host_end (xcb_host_iterator_t i /**< */) +xcb_host_end (xcb_host_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -10706,7 +13603,7 @@ xcb_host_end (xcb_host_iterator_t i /**< */) } int -xcb_list_hosts_sizeof (const void *_buffer /**< */) +xcb_list_hosts_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_list_hosts_reply_t *_aux = (xcb_list_hosts_reply_t *)_buffer; @@ -10742,13 +13639,13 @@ xcb_list_hosts_sizeof (const void *_buffer /**< */) } xcb_list_hosts_cookie_t -xcb_list_hosts (xcb_connection_t *c /**< */) +xcb_list_hosts (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_LIST_HOSTS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_LIST_HOSTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10767,13 +13664,13 @@ xcb_list_hosts (xcb_connection_t *c /**< */) } xcb_list_hosts_cookie_t -xcb_list_hosts_unchecked (xcb_connection_t *c /**< */) +xcb_list_hosts_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_LIST_HOSTS, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_LIST_HOSTS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -10792,13 +13689,13 @@ xcb_list_hosts_unchecked (xcb_connection_t *c /**< */) } int -xcb_list_hosts_hosts_length (const xcb_list_hosts_reply_t *R /**< */) +xcb_list_hosts_hosts_length (const xcb_list_hosts_reply_t *R) { return R->hosts_len; } xcb_host_iterator_t -xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R /**< */) +xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R) { xcb_host_iterator_t i; i.data = (xcb_host_t *) (R + 1); @@ -10808,22 +13705,22 @@ xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R /**< */) } xcb_list_hosts_reply_t * -xcb_list_hosts_reply (xcb_connection_t *c /**< */, +xcb_list_hosts_reply (xcb_connection_t *c, xcb_list_hosts_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_list_hosts_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_set_access_control_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */) +xcb_set_access_control_checked (xcb_connection_t *c, + uint8_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SET_ACCESS_CONTROL, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SET_ACCESS_CONTROL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10842,14 +13739,14 @@ xcb_set_access_control_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_set_access_control (xcb_connection_t *c /**< */, - uint8_t mode /**< */) +xcb_set_access_control (xcb_connection_t *c, + uint8_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SET_ACCESS_CONTROL, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SET_ACCESS_CONTROL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10868,14 +13765,14 @@ xcb_set_access_control (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_set_close_down_mode_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */) +xcb_set_close_down_mode_checked (xcb_connection_t *c, + uint8_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SET_CLOSE_DOWN_MODE, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SET_CLOSE_DOWN_MODE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10894,14 +13791,14 @@ xcb_set_close_down_mode_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_set_close_down_mode (xcb_connection_t *c /**< */, - uint8_t mode /**< */) +xcb_set_close_down_mode (xcb_connection_t *c, + uint8_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_SET_CLOSE_DOWN_MODE, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_SET_CLOSE_DOWN_MODE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10920,14 +13817,14 @@ xcb_set_close_down_mode (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_kill_client_checked (xcb_connection_t *c /**< */, - uint32_t resource /**< */) +xcb_kill_client_checked (xcb_connection_t *c, + uint32_t resource) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_KILL_CLIENT, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_KILL_CLIENT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10947,14 +13844,14 @@ xcb_kill_client_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_kill_client (xcb_connection_t *c /**< */, - uint32_t resource /**< */) +xcb_kill_client (xcb_connection_t *c, + uint32_t resource) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_KILL_CLIENT, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_KILL_CLIENT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -10974,7 +13871,7 @@ xcb_kill_client (xcb_connection_t *c /**< */, } int -xcb_rotate_properties_sizeof (const void *_buffer /**< */) +xcb_rotate_properties_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_rotate_properties_request_t *_aux = (xcb_rotate_properties_request_t *)_buffer; @@ -11005,17 +13902,17 @@ xcb_rotate_properties_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_rotate_properties_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t atoms_len /**< */, - int16_t delta /**< */, - const xcb_atom_t *atoms /**< */) +xcb_rotate_properties_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t atoms_len, + int16_t delta, + const xcb_atom_t *atoms) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_ROTATE_PROPERTIES, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_ROTATE_PROPERTIES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -11042,17 +13939,17 @@ xcb_rotate_properties_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_rotate_properties (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t atoms_len /**< */, - int16_t delta /**< */, - const xcb_atom_t *atoms /**< */) +xcb_rotate_properties (xcb_connection_t *c, + xcb_window_t window, + uint16_t atoms_len, + int16_t delta, + const xcb_atom_t *atoms) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_ROTATE_PROPERTIES, - /* isvoid */ 1 + .count = 4, + .ext = 0, + .opcode = XCB_ROTATE_PROPERTIES, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -11078,15 +13975,37 @@ xcb_rotate_properties (xcb_connection_t *c /**< */, return xcb_ret; } +xcb_atom_t * +xcb_rotate_properties_atoms (const xcb_rotate_properties_request_t *R) +{ + return (xcb_atom_t *) (R + 1); +} + +int +xcb_rotate_properties_atoms_length (const xcb_rotate_properties_request_t *R) +{ + return R->atoms_len; +} + +xcb_generic_iterator_t +xcb_rotate_properties_atoms_end (const xcb_rotate_properties_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((xcb_atom_t *) (R + 1)) + (R->atoms_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_force_screen_saver_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */) +xcb_force_screen_saver_checked (xcb_connection_t *c, + uint8_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_FORCE_SCREEN_SAVER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_FORCE_SCREEN_SAVER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -11105,14 +14024,14 @@ xcb_force_screen_saver_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_force_screen_saver (xcb_connection_t *c /**< */, - uint8_t mode /**< */) +xcb_force_screen_saver (xcb_connection_t *c, + uint8_t mode) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_FORCE_SCREEN_SAVER, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_FORCE_SCREEN_SAVER, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -11131,7 +14050,7 @@ xcb_force_screen_saver (xcb_connection_t *c /**< */, } int -xcb_set_pointer_mapping_sizeof (const void *_buffer /**< */) +xcb_set_pointer_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_set_pointer_mapping_request_t *_aux = (xcb_set_pointer_mapping_request_t *)_buffer; @@ -11162,15 +14081,15 @@ xcb_set_pointer_mapping_sizeof (const void *_buffer /**< */) } xcb_set_pointer_mapping_cookie_t -xcb_set_pointer_mapping (xcb_connection_t *c /**< */, - uint8_t map_len /**< */, - const uint8_t *map /**< */) +xcb_set_pointer_mapping (xcb_connection_t *c, + uint8_t map_len, + const uint8_t *map) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_SET_POINTER_MAPPING, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_SET_POINTER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -11194,15 +14113,15 @@ xcb_set_pointer_mapping (xcb_connection_t *c /**< */, } xcb_set_pointer_mapping_cookie_t -xcb_set_pointer_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t map_len /**< */, - const uint8_t *map /**< */) +xcb_set_pointer_mapping_unchecked (xcb_connection_t *c, + uint8_t map_len, + const uint8_t *map) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_SET_POINTER_MAPPING, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_SET_POINTER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -11226,15 +14145,15 @@ xcb_set_pointer_mapping_unchecked (xcb_connection_t *c /**< */, } xcb_set_pointer_mapping_reply_t * -xcb_set_pointer_mapping_reply (xcb_connection_t *c /**< */, +xcb_set_pointer_mapping_reply (xcb_connection_t *c, xcb_set_pointer_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_set_pointer_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_get_pointer_mapping_sizeof (const void *_buffer /**< */) +xcb_get_pointer_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_get_pointer_mapping_reply_t *_aux = (xcb_get_pointer_mapping_reply_t *)_buffer; @@ -11265,13 +14184,13 @@ xcb_get_pointer_mapping_sizeof (const void *_buffer /**< */) } xcb_get_pointer_mapping_cookie_t -xcb_get_pointer_mapping (xcb_connection_t *c /**< */) +xcb_get_pointer_mapping (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_POINTER_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_POINTER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -11290,13 +14209,13 @@ xcb_get_pointer_mapping (xcb_connection_t *c /**< */) } xcb_get_pointer_mapping_cookie_t -xcb_get_pointer_mapping_unchecked (xcb_connection_t *c /**< */) +xcb_get_pointer_mapping_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_POINTER_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_POINTER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -11315,19 +14234,19 @@ xcb_get_pointer_mapping_unchecked (xcb_connection_t *c /**< */) } uint8_t * -xcb_get_pointer_mapping_map (const xcb_get_pointer_mapping_reply_t *R /**< */) +xcb_get_pointer_mapping_map (const xcb_get_pointer_mapping_reply_t *R) { return (uint8_t *) (R + 1); } int -xcb_get_pointer_mapping_map_length (const xcb_get_pointer_mapping_reply_t *R /**< */) +xcb_get_pointer_mapping_map_length (const xcb_get_pointer_mapping_reply_t *R) { return R->map_len; } xcb_generic_iterator_t -xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R /**< */) +xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint8_t *) (R + 1)) + (R->map_len); @@ -11337,15 +14256,15 @@ xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R /**< } xcb_get_pointer_mapping_reply_t * -xcb_get_pointer_mapping_reply (xcb_connection_t *c /**< */, +xcb_get_pointer_mapping_reply (xcb_connection_t *c, xcb_get_pointer_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_pointer_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_set_modifier_mapping_sizeof (const void *_buffer /**< */) +xcb_set_modifier_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_set_modifier_mapping_request_t *_aux = (xcb_set_modifier_mapping_request_t *)_buffer; @@ -11376,15 +14295,15 @@ xcb_set_modifier_mapping_sizeof (const void *_buffer /**< */) } xcb_set_modifier_mapping_cookie_t -xcb_set_modifier_mapping (xcb_connection_t *c /**< */, - uint8_t keycodes_per_modifier /**< */, - const xcb_keycode_t *keycodes /**< */) +xcb_set_modifier_mapping (xcb_connection_t *c, + uint8_t keycodes_per_modifier, + const xcb_keycode_t *keycodes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_SET_MODIFIER_MAPPING, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_SET_MODIFIER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -11408,15 +14327,15 @@ xcb_set_modifier_mapping (xcb_connection_t *c /**< */, } xcb_set_modifier_mapping_cookie_t -xcb_set_modifier_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t keycodes_per_modifier /**< */, - const xcb_keycode_t *keycodes /**< */) +xcb_set_modifier_mapping_unchecked (xcb_connection_t *c, + uint8_t keycodes_per_modifier, + const xcb_keycode_t *keycodes) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ 0, - /* opcode */ XCB_SET_MODIFIER_MAPPING, - /* isvoid */ 0 + .count = 4, + .ext = 0, + .opcode = XCB_SET_MODIFIER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[6]; @@ -11440,15 +14359,15 @@ xcb_set_modifier_mapping_unchecked (xcb_connection_t *c /**< */, } xcb_set_modifier_mapping_reply_t * -xcb_set_modifier_mapping_reply (xcb_connection_t *c /**< */, +xcb_set_modifier_mapping_reply (xcb_connection_t *c, xcb_set_modifier_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_set_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_get_modifier_mapping_sizeof (const void *_buffer /**< */) +xcb_get_modifier_mapping_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_get_modifier_mapping_reply_t *_aux = (xcb_get_modifier_mapping_reply_t *)_buffer; @@ -11479,13 +14398,13 @@ xcb_get_modifier_mapping_sizeof (const void *_buffer /**< */) } xcb_get_modifier_mapping_cookie_t -xcb_get_modifier_mapping (xcb_connection_t *c /**< */) +xcb_get_modifier_mapping (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_MODIFIER_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_MODIFIER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -11504,13 +14423,13 @@ xcb_get_modifier_mapping (xcb_connection_t *c /**< */) } xcb_get_modifier_mapping_cookie_t -xcb_get_modifier_mapping_unchecked (xcb_connection_t *c /**< */) +xcb_get_modifier_mapping_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_GET_MODIFIER_MAPPING, - /* isvoid */ 0 + .count = 2, + .ext = 0, + .opcode = XCB_GET_MODIFIER_MAPPING, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -11529,19 +14448,19 @@ xcb_get_modifier_mapping_unchecked (xcb_connection_t *c /**< */) } xcb_keycode_t * -xcb_get_modifier_mapping_keycodes (const xcb_get_modifier_mapping_reply_t *R /**< */) +xcb_get_modifier_mapping_keycodes (const xcb_get_modifier_mapping_reply_t *R) { return (xcb_keycode_t *) (R + 1); } int -xcb_get_modifier_mapping_keycodes_length (const xcb_get_modifier_mapping_reply_t *R /**< */) +xcb_get_modifier_mapping_keycodes_length (const xcb_get_modifier_mapping_reply_t *R) { return (R->keycodes_per_modifier * 8); } xcb_generic_iterator_t -xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R /**< */) +xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R) { xcb_generic_iterator_t i; i.data = ((xcb_keycode_t *) (R + 1)) + ((R->keycodes_per_modifier * 8)); @@ -11551,21 +14470,21 @@ xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R } xcb_get_modifier_mapping_reply_t * -xcb_get_modifier_mapping_reply (xcb_connection_t *c /**< */, +xcb_get_modifier_mapping_reply (xcb_connection_t *c, xcb_get_modifier_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_get_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_no_operation_checked (xcb_connection_t *c /**< */) +xcb_no_operation_checked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_NO_OPERATION, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_NO_OPERATION, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -11584,13 +14503,13 @@ xcb_no_operation_checked (xcb_connection_t *c /**< */) } xcb_void_cookie_t -xcb_no_operation (xcb_connection_t *c /**< */) +xcb_no_operation (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ 0, - /* opcode */ XCB_NO_OPERATION, - /* isvoid */ 1 + .count = 2, + .ext = 0, + .opcode = XCB_NO_OPERATION, + .isvoid = 1 }; struct iovec xcb_parts[4]; diff --git a/lib/libxcb/src/xproto.h b/lib/libxcb/src/xproto.h index d1643247c..64ec3fce8 100644 --- a/lib/libxcb/src/xproto.h +++ b/lib/libxcb/src/xproto.h @@ -22,17 +22,17 @@ extern "C" { * @brief xcb_char2b_t **/ typedef struct xcb_char2b_t { - uint8_t byte1; /**< */ - uint8_t byte2; /**< */ + uint8_t byte1; + uint8_t byte2; } xcb_char2b_t; /** * @brief xcb_char2b_iterator_t **/ typedef struct xcb_char2b_iterator_t { - xcb_char2b_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_char2b_t *data; + int rem; + int index; } xcb_char2b_iterator_t; typedef uint32_t xcb_window_t; @@ -41,9 +41,9 @@ typedef uint32_t xcb_window_t; * @brief xcb_window_iterator_t **/ typedef struct xcb_window_iterator_t { - xcb_window_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_window_t *data; + int rem; + int index; } xcb_window_iterator_t; typedef uint32_t xcb_pixmap_t; @@ -52,9 +52,9 @@ typedef uint32_t xcb_pixmap_t; * @brief xcb_pixmap_iterator_t **/ typedef struct xcb_pixmap_iterator_t { - xcb_pixmap_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_pixmap_t *data; + int rem; + int index; } xcb_pixmap_iterator_t; typedef uint32_t xcb_cursor_t; @@ -63,9 +63,9 @@ typedef uint32_t xcb_cursor_t; * @brief xcb_cursor_iterator_t **/ typedef struct xcb_cursor_iterator_t { - xcb_cursor_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_cursor_t *data; + int rem; + int index; } xcb_cursor_iterator_t; typedef uint32_t xcb_font_t; @@ -74,9 +74,9 @@ typedef uint32_t xcb_font_t; * @brief xcb_font_iterator_t **/ typedef struct xcb_font_iterator_t { - xcb_font_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_font_t *data; + int rem; + int index; } xcb_font_iterator_t; typedef uint32_t xcb_gcontext_t; @@ -85,9 +85,9 @@ typedef uint32_t xcb_gcontext_t; * @brief xcb_gcontext_iterator_t **/ typedef struct xcb_gcontext_iterator_t { - xcb_gcontext_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_gcontext_t *data; + int rem; + int index; } xcb_gcontext_iterator_t; typedef uint32_t xcb_colormap_t; @@ -96,9 +96,9 @@ typedef uint32_t xcb_colormap_t; * @brief xcb_colormap_iterator_t **/ typedef struct xcb_colormap_iterator_t { - xcb_colormap_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_colormap_t *data; + int rem; + int index; } xcb_colormap_iterator_t; typedef uint32_t xcb_atom_t; @@ -107,9 +107,9 @@ typedef uint32_t xcb_atom_t; * @brief xcb_atom_iterator_t **/ typedef struct xcb_atom_iterator_t { - xcb_atom_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_atom_t *data; + int rem; + int index; } xcb_atom_iterator_t; typedef uint32_t xcb_drawable_t; @@ -118,9 +118,9 @@ typedef uint32_t xcb_drawable_t; * @brief xcb_drawable_iterator_t **/ typedef struct xcb_drawable_iterator_t { - xcb_drawable_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_drawable_t *data; + int rem; + int index; } xcb_drawable_iterator_t; typedef uint32_t xcb_fontable_t; @@ -129,20 +129,31 @@ typedef uint32_t xcb_fontable_t; * @brief xcb_fontable_iterator_t **/ typedef struct xcb_fontable_iterator_t { - xcb_fontable_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_fontable_t *data; + int rem; + int index; } xcb_fontable_iterator_t; +typedef uint32_t xcb_bool32_t; + +/** + * @brief xcb_bool32_iterator_t + **/ +typedef struct xcb_bool32_iterator_t { + xcb_bool32_t *data; + int rem; + int index; +} xcb_bool32_iterator_t; + typedef uint32_t xcb_visualid_t; /** * @brief xcb_visualid_iterator_t **/ typedef struct xcb_visualid_iterator_t { - xcb_visualid_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_visualid_t *data; + int rem; + int index; } xcb_visualid_iterator_t; typedef uint32_t xcb_timestamp_t; @@ -151,9 +162,9 @@ typedef uint32_t xcb_timestamp_t; * @brief xcb_timestamp_iterator_t **/ typedef struct xcb_timestamp_iterator_t { - xcb_timestamp_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_timestamp_t *data; + int rem; + int index; } xcb_timestamp_iterator_t; typedef uint32_t xcb_keysym_t; @@ -162,9 +173,9 @@ typedef uint32_t xcb_keysym_t; * @brief xcb_keysym_iterator_t **/ typedef struct xcb_keysym_iterator_t { - xcb_keysym_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_keysym_t *data; + int rem; + int index; } xcb_keysym_iterator_t; typedef uint8_t xcb_keycode_t; @@ -173,96 +184,107 @@ typedef uint8_t xcb_keycode_t; * @brief xcb_keycode_iterator_t **/ typedef struct xcb_keycode_iterator_t { - xcb_keycode_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_keycode_t *data; + int rem; + int index; } xcb_keycode_iterator_t; +typedef uint32_t xcb_keycode32_t; + +/** + * @brief xcb_keycode32_iterator_t + **/ +typedef struct xcb_keycode32_iterator_t { + xcb_keycode32_t *data; + int rem; + int index; +} xcb_keycode32_iterator_t; + typedef uint8_t xcb_button_t; /** * @brief xcb_button_iterator_t **/ typedef struct xcb_button_iterator_t { - xcb_button_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_button_t *data; + int rem; + int index; } xcb_button_iterator_t; /** * @brief xcb_point_t **/ typedef struct xcb_point_t { - int16_t x; /**< */ - int16_t y; /**< */ + int16_t x; + int16_t y; } xcb_point_t; /** * @brief xcb_point_iterator_t **/ typedef struct xcb_point_iterator_t { - xcb_point_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_point_t *data; + int rem; + int index; } xcb_point_iterator_t; /** * @brief xcb_rectangle_t **/ typedef struct xcb_rectangle_t { - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; } xcb_rectangle_t; /** * @brief xcb_rectangle_iterator_t **/ typedef struct xcb_rectangle_iterator_t { - xcb_rectangle_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_rectangle_t *data; + int rem; + int index; } xcb_rectangle_iterator_t; /** * @brief xcb_arc_t **/ typedef struct xcb_arc_t { - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - int16_t angle1; /**< */ - int16_t angle2; /**< */ + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + int16_t angle1; + int16_t angle2; } xcb_arc_t; /** * @brief xcb_arc_iterator_t **/ typedef struct xcb_arc_iterator_t { - xcb_arc_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_arc_t *data; + int rem; + int index; } xcb_arc_iterator_t; /** * @brief xcb_format_t **/ typedef struct xcb_format_t { - uint8_t depth; /**< */ - uint8_t bits_per_pixel; /**< */ - uint8_t scanline_pad; /**< */ - uint8_t pad0[5]; /**< */ + uint8_t depth; + uint8_t bits_per_pixel; + uint8_t scanline_pad; + uint8_t pad0[5]; } xcb_format_t; /** * @brief xcb_format_iterator_t **/ typedef struct xcb_format_iterator_t { - xcb_format_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_format_t *data; + int rem; + int index; } xcb_format_iterator_t; typedef enum xcb_visual_class_t { @@ -278,42 +300,42 @@ typedef enum xcb_visual_class_t { * @brief xcb_visualtype_t **/ typedef struct xcb_visualtype_t { - xcb_visualid_t visual_id; /**< */ - uint8_t _class; /**< */ - uint8_t bits_per_rgb_value; /**< */ - uint16_t colormap_entries; /**< */ - uint32_t red_mask; /**< */ - uint32_t green_mask; /**< */ - uint32_t blue_mask; /**< */ - uint8_t pad0[4]; /**< */ + xcb_visualid_t visual_id; + uint8_t _class; + uint8_t bits_per_rgb_value; + uint16_t colormap_entries; + uint32_t red_mask; + uint32_t green_mask; + uint32_t blue_mask; + uint8_t pad0[4]; } xcb_visualtype_t; /** * @brief xcb_visualtype_iterator_t **/ typedef struct xcb_visualtype_iterator_t { - xcb_visualtype_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_visualtype_t *data; + int rem; + int index; } xcb_visualtype_iterator_t; /** * @brief xcb_depth_t **/ typedef struct xcb_depth_t { - uint8_t depth; /**< */ - uint8_t pad0; /**< */ - uint16_t visuals_len; /**< */ - uint8_t pad1[4]; /**< */ + uint8_t depth; + uint8_t pad0; + uint16_t visuals_len; + uint8_t pad1[4]; } xcb_depth_t; /** * @brief xcb_depth_iterator_t **/ typedef struct xcb_depth_iterator_t { - xcb_depth_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_depth_t *data; + int rem; + int index; } xcb_depth_iterator_t; typedef enum xcb_event_mask_t { @@ -355,91 +377,91 @@ typedef enum xcb_backing_store_t { * @brief xcb_screen_t **/ typedef struct xcb_screen_t { - xcb_window_t root; /**< */ - xcb_colormap_t default_colormap; /**< */ - uint32_t white_pixel; /**< */ - uint32_t black_pixel; /**< */ - uint32_t current_input_masks; /**< */ - uint16_t width_in_pixels; /**< */ - uint16_t height_in_pixels; /**< */ - uint16_t width_in_millimeters; /**< */ - uint16_t height_in_millimeters; /**< */ - uint16_t min_installed_maps; /**< */ - uint16_t max_installed_maps; /**< */ - xcb_visualid_t root_visual; /**< */ - uint8_t backing_stores; /**< */ - uint8_t save_unders; /**< */ - uint8_t root_depth; /**< */ - uint8_t allowed_depths_len; /**< */ + xcb_window_t root; + xcb_colormap_t default_colormap; + uint32_t white_pixel; + uint32_t black_pixel; + uint32_t current_input_masks; + uint16_t width_in_pixels; + uint16_t height_in_pixels; + uint16_t width_in_millimeters; + uint16_t height_in_millimeters; + uint16_t min_installed_maps; + uint16_t max_installed_maps; + xcb_visualid_t root_visual; + uint8_t backing_stores; + uint8_t save_unders; + uint8_t root_depth; + uint8_t allowed_depths_len; } xcb_screen_t; /** * @brief xcb_screen_iterator_t **/ typedef struct xcb_screen_iterator_t { - xcb_screen_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_screen_t *data; + int rem; + int index; } xcb_screen_iterator_t; /** * @brief xcb_setup_request_t **/ typedef struct xcb_setup_request_t { - uint8_t byte_order; /**< */ - uint8_t pad0; /**< */ - uint16_t protocol_major_version; /**< */ - uint16_t protocol_minor_version; /**< */ - uint16_t authorization_protocol_name_len; /**< */ - uint16_t authorization_protocol_data_len; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t byte_order; + uint8_t pad0; + uint16_t protocol_major_version; + uint16_t protocol_minor_version; + uint16_t authorization_protocol_name_len; + uint16_t authorization_protocol_data_len; + uint8_t pad1[2]; } xcb_setup_request_t; /** * @brief xcb_setup_request_iterator_t **/ typedef struct xcb_setup_request_iterator_t { - xcb_setup_request_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_setup_request_t *data; + int rem; + int index; } xcb_setup_request_iterator_t; /** * @brief xcb_setup_failed_t **/ typedef struct xcb_setup_failed_t { - uint8_t status; /**< */ - uint8_t reason_len; /**< */ - uint16_t protocol_major_version; /**< */ - uint16_t protocol_minor_version; /**< */ - uint16_t length; /**< */ + uint8_t status; + uint8_t reason_len; + uint16_t protocol_major_version; + uint16_t protocol_minor_version; + uint16_t length; } xcb_setup_failed_t; /** * @brief xcb_setup_failed_iterator_t **/ typedef struct xcb_setup_failed_iterator_t { - xcb_setup_failed_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_setup_failed_t *data; + int rem; + int index; } xcb_setup_failed_iterator_t; /** * @brief xcb_setup_authenticate_t **/ typedef struct xcb_setup_authenticate_t { - uint8_t status; /**< */ - uint8_t pad0[5]; /**< */ - uint16_t length; /**< */ + uint8_t status; + uint8_t pad0[5]; + uint16_t length; } xcb_setup_authenticate_t; /** * @brief xcb_setup_authenticate_iterator_t **/ typedef struct xcb_setup_authenticate_iterator_t { - xcb_setup_authenticate_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_setup_authenticate_t *data; + int rem; + int index; } xcb_setup_authenticate_iterator_t; typedef enum xcb_image_order_t { @@ -451,35 +473,35 @@ typedef enum xcb_image_order_t { * @brief xcb_setup_t **/ typedef struct xcb_setup_t { - uint8_t status; /**< */ - uint8_t pad0; /**< */ - uint16_t protocol_major_version; /**< */ - uint16_t protocol_minor_version; /**< */ - uint16_t length; /**< */ - uint32_t release_number; /**< */ - uint32_t resource_id_base; /**< */ - uint32_t resource_id_mask; /**< */ - uint32_t motion_buffer_size; /**< */ - uint16_t vendor_len; /**< */ - uint16_t maximum_request_length; /**< */ - uint8_t roots_len; /**< */ - uint8_t pixmap_formats_len; /**< */ - uint8_t image_byte_order; /**< */ - uint8_t bitmap_format_bit_order; /**< */ - uint8_t bitmap_format_scanline_unit; /**< */ - uint8_t bitmap_format_scanline_pad; /**< */ - xcb_keycode_t min_keycode; /**< */ - xcb_keycode_t max_keycode; /**< */ - uint8_t pad1[4]; /**< */ + uint8_t status; + uint8_t pad0; + uint16_t protocol_major_version; + uint16_t protocol_minor_version; + uint16_t length; + uint32_t release_number; + uint32_t resource_id_base; + uint32_t resource_id_mask; + uint32_t motion_buffer_size; + uint16_t vendor_len; + uint16_t maximum_request_length; + uint8_t roots_len; + uint8_t pixmap_formats_len; + uint8_t image_byte_order; + uint8_t bitmap_format_bit_order; + uint8_t bitmap_format_scanline_unit; + uint8_t bitmap_format_scanline_pad; + xcb_keycode_t min_keycode; + xcb_keycode_t max_keycode; + uint8_t pad1[4]; } xcb_setup_t; /** * @brief xcb_setup_iterator_t **/ typedef struct xcb_setup_iterator_t { - xcb_setup_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_setup_t *data; + int rem; + int index; } xcb_setup_iterator_t; typedef enum xcb_mod_mask_t { @@ -521,20 +543,20 @@ typedef enum xcb_window_enum_t { * @brief xcb_key_press_event_t **/ typedef struct xcb_key_press_event_t { - uint8_t response_type; /**< */ - xcb_keycode_t detail; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_window_t child; /**< */ - int16_t root_x; /**< */ - int16_t root_y; /**< */ - int16_t event_x; /**< */ - int16_t event_y; /**< */ - uint16_t state; /**< */ - uint8_t same_screen; /**< */ - uint8_t pad0; /**< */ + uint8_t response_type; + xcb_keycode_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t event_x; + int16_t event_y; + uint16_t state; + uint8_t same_screen; + uint8_t pad0; } xcb_key_press_event_t; /** Opcode for xcb_key_release. */ @@ -558,20 +580,20 @@ typedef enum xcb_button_mask_t { * @brief xcb_button_press_event_t **/ typedef struct xcb_button_press_event_t { - uint8_t response_type; /**< */ - xcb_button_t detail; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_window_t child; /**< */ - int16_t root_x; /**< */ - int16_t root_y; /**< */ - int16_t event_x; /**< */ - int16_t event_y; /**< */ - uint16_t state; /**< */ - uint8_t same_screen; /**< */ - uint8_t pad0; /**< */ + uint8_t response_type; + xcb_button_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t event_x; + int16_t event_y; + uint16_t state; + uint8_t same_screen; + uint8_t pad0; } xcb_button_press_event_t; /** Opcode for xcb_button_release. */ @@ -591,20 +613,20 @@ typedef enum xcb_motion_t { * @brief xcb_motion_notify_event_t **/ typedef struct xcb_motion_notify_event_t { - uint8_t response_type; /**< */ - uint8_t detail; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_window_t child; /**< */ - int16_t root_x; /**< */ - int16_t root_y; /**< */ - int16_t event_x; /**< */ - int16_t event_y; /**< */ - uint16_t state; /**< */ - uint8_t same_screen; /**< */ - uint8_t pad0; /**< */ + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t event_x; + int16_t event_y; + uint16_t state; + uint8_t same_screen; + uint8_t pad0; } xcb_motion_notify_event_t; typedef enum xcb_notify_detail_t { @@ -632,20 +654,20 @@ typedef enum xcb_notify_mode_t { * @brief xcb_enter_notify_event_t **/ typedef struct xcb_enter_notify_event_t { - uint8_t response_type; /**< */ - uint8_t detail; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t root; /**< */ - xcb_window_t event; /**< */ - xcb_window_t child; /**< */ - int16_t root_x; /**< */ - int16_t root_y; /**< */ - int16_t event_x; /**< */ - int16_t event_y; /**< */ - uint16_t state; /**< */ - uint8_t mode; /**< */ - uint8_t same_screen_focus; /**< */ + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t event_x; + int16_t event_y; + uint16_t state; + uint8_t mode; + uint8_t same_screen_focus; } xcb_enter_notify_event_t; /** Opcode for xcb_leave_notify. */ @@ -660,12 +682,12 @@ typedef xcb_enter_notify_event_t xcb_leave_notify_event_t; * @brief xcb_focus_in_event_t **/ typedef struct xcb_focus_in_event_t { - uint8_t response_type; /**< */ - uint8_t detail; /**< */ - uint16_t sequence; /**< */ - xcb_window_t event; /**< */ - uint8_t mode; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_window_t event; + uint8_t mode; + uint8_t pad0[3]; } xcb_focus_in_event_t; /** Opcode for xcb_focus_out. */ @@ -680,8 +702,8 @@ typedef xcb_focus_in_event_t xcb_focus_out_event_t; * @brief xcb_keymap_notify_event_t **/ typedef struct xcb_keymap_notify_event_t { - uint8_t response_type; /**< */ - uint8_t keys[31]; /**< */ + uint8_t response_type; + uint8_t keys[31]; } xcb_keymap_notify_event_t; /** Opcode for xcb_expose. */ @@ -691,16 +713,16 @@ typedef struct xcb_keymap_notify_event_t { * @brief xcb_expose_event_t **/ typedef struct xcb_expose_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t window; /**< */ - uint16_t x; /**< */ - uint16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t count; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t window; + uint16_t x; + uint16_t y; + uint16_t width; + uint16_t height; + uint16_t count; + uint8_t pad1[2]; } xcb_expose_event_t; /** Opcode for xcb_graphics_exposure. */ @@ -710,18 +732,18 @@ typedef struct xcb_expose_event_t { * @brief xcb_graphics_exposure_event_t **/ typedef struct xcb_graphics_exposure_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_drawable_t drawable; /**< */ - uint16_t x; /**< */ - uint16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t minor_opcode; /**< */ - uint16_t count; /**< */ - uint8_t major_opcode; /**< */ - uint8_t pad1[3]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_drawable_t drawable; + uint16_t x; + uint16_t y; + uint16_t width; + uint16_t height; + uint16_t minor_opcode; + uint16_t count; + uint8_t major_opcode; + uint8_t pad1[3]; } xcb_graphics_exposure_event_t; /** Opcode for xcb_no_exposure. */ @@ -731,13 +753,13 @@ typedef struct xcb_graphics_exposure_event_t { * @brief xcb_no_exposure_event_t **/ typedef struct xcb_no_exposure_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_drawable_t drawable; /**< */ - uint16_t minor_opcode; /**< */ - uint8_t major_opcode; /**< */ - uint8_t pad1; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_drawable_t drawable; + uint16_t minor_opcode; + uint8_t major_opcode; + uint8_t pad1; } xcb_no_exposure_event_t; typedef enum xcb_visibility_t { @@ -753,12 +775,12 @@ typedef enum xcb_visibility_t { * @brief xcb_visibility_notify_event_t **/ typedef struct xcb_visibility_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t window; /**< */ - uint8_t state; /**< */ - uint8_t pad1[3]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t window; + uint8_t state; + uint8_t pad1[3]; } xcb_visibility_notify_event_t; /** Opcode for xcb_create_notify. */ @@ -768,18 +790,18 @@ typedef struct xcb_visibility_notify_event_t { * @brief xcb_create_notify_event_t **/ typedef struct xcb_create_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t parent; /**< */ - xcb_window_t window; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t border_width; /**< */ - uint8_t override_redirect; /**< */ - uint8_t pad1; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t parent; + xcb_window_t window; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint8_t override_redirect; + uint8_t pad1; } xcb_create_notify_event_t; /** Opcode for xcb_destroy_notify. */ @@ -789,11 +811,11 @@ typedef struct xcb_create_notify_event_t { * @brief xcb_destroy_notify_event_t **/ typedef struct xcb_destroy_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t event; /**< */ - xcb_window_t window; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; } xcb_destroy_notify_event_t; /** Opcode for xcb_unmap_notify. */ @@ -803,13 +825,13 @@ typedef struct xcb_destroy_notify_event_t { * @brief xcb_unmap_notify_event_t **/ typedef struct xcb_unmap_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t event; /**< */ - xcb_window_t window; /**< */ - uint8_t from_configure; /**< */ - uint8_t pad1[3]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + uint8_t from_configure; + uint8_t pad1[3]; } xcb_unmap_notify_event_t; /** Opcode for xcb_map_notify. */ @@ -819,13 +841,13 @@ typedef struct xcb_unmap_notify_event_t { * @brief xcb_map_notify_event_t **/ typedef struct xcb_map_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t event; /**< */ - xcb_window_t window; /**< */ - uint8_t override_redirect; /**< */ - uint8_t pad1[3]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + uint8_t override_redirect; + uint8_t pad1[3]; } xcb_map_notify_event_t; /** Opcode for xcb_map_request. */ @@ -835,11 +857,11 @@ typedef struct xcb_map_notify_event_t { * @brief xcb_map_request_event_t **/ typedef struct xcb_map_request_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t parent; /**< */ - xcb_window_t window; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t parent; + xcb_window_t window; } xcb_map_request_event_t; /** Opcode for xcb_reparent_notify. */ @@ -849,16 +871,16 @@ typedef struct xcb_map_request_event_t { * @brief xcb_reparent_notify_event_t **/ typedef struct xcb_reparent_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t event; /**< */ - xcb_window_t window; /**< */ - xcb_window_t parent; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint8_t override_redirect; /**< */ - uint8_t pad1[3]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + xcb_window_t parent; + int16_t x; + int16_t y; + uint8_t override_redirect; + uint8_t pad1[3]; } xcb_reparent_notify_event_t; /** Opcode for xcb_configure_notify. */ @@ -868,19 +890,19 @@ typedef struct xcb_reparent_notify_event_t { * @brief xcb_configure_notify_event_t **/ typedef struct xcb_configure_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t event; /**< */ - xcb_window_t window; /**< */ - xcb_window_t above_sibling; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t border_width; /**< */ - uint8_t override_redirect; /**< */ - uint8_t pad1; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + xcb_window_t above_sibling; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint8_t override_redirect; + uint8_t pad1; } xcb_configure_notify_event_t; /** Opcode for xcb_configure_request. */ @@ -890,18 +912,18 @@ typedef struct xcb_configure_notify_event_t { * @brief xcb_configure_request_event_t **/ typedef struct xcb_configure_request_event_t { - uint8_t response_type; /**< */ - uint8_t stack_mode; /**< */ - uint16_t sequence; /**< */ - xcb_window_t parent; /**< */ - xcb_window_t window; /**< */ - xcb_window_t sibling; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t border_width; /**< */ - uint16_t value_mask; /**< */ + uint8_t response_type; + uint8_t stack_mode; + uint16_t sequence; + xcb_window_t parent; + xcb_window_t window; + xcb_window_t sibling; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint16_t value_mask; } xcb_configure_request_event_t; /** Opcode for xcb_gravity_notify. */ @@ -911,13 +933,13 @@ typedef struct xcb_configure_request_event_t { * @brief xcb_gravity_notify_event_t **/ typedef struct xcb_gravity_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t event; /**< */ - xcb_window_t window; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + int16_t x; + int16_t y; } xcb_gravity_notify_event_t; /** Opcode for xcb_resize_request. */ @@ -927,12 +949,12 @@ typedef struct xcb_gravity_notify_event_t { * @brief xcb_resize_request_event_t **/ typedef struct xcb_resize_request_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t window; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t window; + uint16_t width; + uint16_t height; } xcb_resize_request_event_t; typedef enum xcb_place_t { @@ -951,14 +973,14 @@ typedef enum xcb_place_t { * @brief xcb_circulate_notify_event_t **/ typedef struct xcb_circulate_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t event; /**< */ - xcb_window_t window; /**< */ - uint8_t pad1[4]; /**< */ - uint8_t place; /**< */ - uint8_t pad2[3]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + uint8_t pad1[4]; + uint8_t place; + uint8_t pad2[3]; } xcb_circulate_notify_event_t; /** Opcode for xcb_circulate_request. */ @@ -978,14 +1000,14 @@ typedef enum xcb_property_t { * @brief xcb_property_notify_event_t **/ typedef struct xcb_property_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t window; /**< */ - xcb_atom_t atom; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t state; /**< */ - uint8_t pad1[3]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t window; + xcb_atom_t atom; + xcb_timestamp_t time; + uint8_t state; + uint8_t pad1[3]; } xcb_property_notify_event_t; /** Opcode for xcb_selection_clear. */ @@ -995,12 +1017,12 @@ typedef struct xcb_property_notify_event_t { * @brief xcb_selection_clear_event_t **/ typedef struct xcb_selection_clear_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t owner; /**< */ - xcb_atom_t selection; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t owner; + xcb_atom_t selection; } xcb_selection_clear_event_t; typedef enum xcb_time_t { @@ -1087,15 +1109,15 @@ typedef enum xcb_atom_enum_t { * @brief xcb_selection_request_event_t **/ typedef struct xcb_selection_request_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t owner; /**< */ - xcb_window_t requestor; /**< */ - xcb_atom_t selection; /**< */ - xcb_atom_t target; /**< */ - xcb_atom_t property; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t owner; + xcb_window_t requestor; + xcb_atom_t selection; + xcb_atom_t target; + xcb_atom_t property; } xcb_selection_request_event_t; /** Opcode for xcb_selection_notify. */ @@ -1105,14 +1127,14 @@ typedef struct xcb_selection_request_event_t { * @brief xcb_selection_notify_event_t **/ typedef struct xcb_selection_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_window_t requestor; /**< */ - xcb_atom_t selection; /**< */ - xcb_atom_t target; /**< */ - xcb_atom_t property; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t requestor; + xcb_atom_t selection; + xcb_atom_t target; + xcb_atom_t property; } xcb_selection_notify_event_t; typedef enum xcb_colormap_state_t { @@ -1135,32 +1157,32 @@ typedef enum xcb_colormap_enum_t { * @brief xcb_colormap_notify_event_t **/ typedef struct xcb_colormap_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_window_t window; /**< */ - xcb_colormap_t colormap; /**< */ - uint8_t _new; /**< */ - uint8_t state; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t window; + xcb_colormap_t colormap; + uint8_t _new; + uint8_t state; + uint8_t pad1[2]; } xcb_colormap_notify_event_t; /** * @brief xcb_client_message_data_t **/ typedef union xcb_client_message_data_t { - uint8_t data8[20]; /**< */ - uint16_t data16[10]; /**< */ - uint32_t data32[5]; /**< */ + uint8_t data8[20]; + uint16_t data16[10]; + uint32_t data32[5]; } xcb_client_message_data_t; /** * @brief xcb_client_message_data_iterator_t **/ typedef struct xcb_client_message_data_iterator_t { - xcb_client_message_data_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_client_message_data_t *data; + int rem; + int index; } xcb_client_message_data_iterator_t; /** Opcode for xcb_client_message. */ @@ -1170,12 +1192,12 @@ typedef struct xcb_client_message_data_iterator_t { * @brief xcb_client_message_event_t **/ typedef struct xcb_client_message_event_t { - uint8_t response_type; /**< */ - uint8_t format; /**< */ - uint16_t sequence; /**< */ - xcb_window_t window; /**< */ - xcb_atom_t type; /**< */ - xcb_client_message_data_t data; /**< */ + uint8_t response_type; + uint8_t format; + uint16_t sequence; + xcb_window_t window; + xcb_atom_t type; + xcb_client_message_data_t data; } xcb_client_message_event_t; typedef enum xcb_mapping_t { @@ -1191,13 +1213,13 @@ typedef enum xcb_mapping_t { * @brief xcb_mapping_notify_event_t **/ typedef struct xcb_mapping_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint8_t request; /**< */ - xcb_keycode_t first_keycode; /**< */ - uint8_t count; /**< */ - uint8_t pad1; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint8_t request; + xcb_keycode_t first_keycode; + uint8_t count; + uint8_t pad1; } xcb_mapping_notify_event_t; /** Opcode for xcb_ge_generic. */ @@ -1207,13 +1229,13 @@ typedef struct xcb_mapping_notify_event_t { * @brief xcb_ge_generic_event_t **/ typedef struct xcb_ge_generic_event_t { - uint8_t response_type; /**< */ - uint8_t extension; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t event_type; /**< */ - uint8_t pad0[22]; /**< */ - uint32_t full_sequence; /**< */ + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + uint8_t pad0[22]; + uint32_t full_sequence; } xcb_ge_generic_event_t; /** Opcode for xcb_request. */ @@ -1223,13 +1245,13 @@ typedef struct xcb_ge_generic_event_t { * @brief xcb_request_error_t **/ typedef struct xcb_request_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ - uint32_t bad_value; /**< */ - uint16_t minor_opcode; /**< */ - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; + uint32_t bad_value; + uint16_t minor_opcode; + uint8_t major_opcode; + uint8_t pad0; } xcb_request_error_t; /** Opcode for xcb_value. */ @@ -1239,13 +1261,13 @@ typedef struct xcb_request_error_t { * @brief xcb_value_error_t **/ typedef struct xcb_value_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ - uint32_t bad_value; /**< */ - uint16_t minor_opcode; /**< */ - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; + uint32_t bad_value; + uint16_t minor_opcode; + uint8_t major_opcode; + uint8_t pad0; } xcb_value_error_t; /** Opcode for xcb_window. */ @@ -1450,6 +1472,27 @@ typedef enum xcb_gravity_t { XCB_GRAVITY_STATIC = 10 } xcb_gravity_t; +/** + * @brief xcb_create_window_value_list_t + **/ +typedef struct xcb_create_window_value_list_t { + xcb_pixmap_t background_pixmap; + uint32_t background_pixel; + xcb_pixmap_t border_pixmap; + uint32_t border_pixel; + uint32_t bit_gravity; + uint32_t win_gravity; + uint32_t backing_store; + uint32_t backing_planes; + uint32_t backing_pixel; + xcb_bool32_t override_redirect; + xcb_bool32_t save_under; + uint32_t event_mask; + uint32_t do_not_propogate_mask; + xcb_colormap_t colormap; + xcb_cursor_t cursor; +} xcb_create_window_value_list_t; + /** Opcode for xcb_create_window. */ #define XCB_CREATE_WINDOW 1 @@ -1457,21 +1500,42 @@ typedef enum xcb_gravity_t { * @brief xcb_create_window_request_t **/ typedef struct xcb_create_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t depth; /**< */ - uint16_t length; /**< */ - xcb_window_t wid; /**< */ - xcb_window_t parent; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t border_width; /**< */ - uint16_t _class; /**< */ - xcb_visualid_t visual; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t depth; + uint16_t length; + xcb_window_t wid; + xcb_window_t parent; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint16_t _class; + xcb_visualid_t visual; + uint32_t value_mask; } xcb_create_window_request_t; +/** + * @brief xcb_change_window_attributes_value_list_t + **/ +typedef struct xcb_change_window_attributes_value_list_t { + xcb_pixmap_t background_pixmap; + uint32_t background_pixel; + xcb_pixmap_t border_pixmap; + uint32_t border_pixel; + uint32_t bit_gravity; + uint32_t win_gravity; + uint32_t backing_store; + uint32_t backing_planes; + uint32_t backing_pixel; + xcb_bool32_t override_redirect; + xcb_bool32_t save_under; + uint32_t event_mask; + uint32_t do_not_propogate_mask; + xcb_colormap_t colormap; + xcb_cursor_t cursor; +} xcb_change_window_attributes_value_list_t; + /** Opcode for xcb_change_window_attributes. */ #define XCB_CHANGE_WINDOW_ATTRIBUTES 2 @@ -1479,11 +1543,11 @@ typedef struct xcb_create_window_request_t { * @brief xcb_change_window_attributes_request_t **/ typedef struct xcb_change_window_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + uint32_t value_mask; } xcb_change_window_attributes_request_t; typedef enum xcb_map_state_t { @@ -1496,7 +1560,7 @@ typedef enum xcb_map_state_t { * @brief xcb_get_window_attributes_cookie_t **/ typedef struct xcb_get_window_attributes_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_window_attributes_cookie_t; /** Opcode for xcb_get_window_attributes. */ @@ -1506,35 +1570,35 @@ typedef struct xcb_get_window_attributes_cookie_t { * @brief xcb_get_window_attributes_request_t **/ typedef struct xcb_get_window_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_get_window_attributes_request_t; /** * @brief xcb_get_window_attributes_reply_t **/ typedef struct xcb_get_window_attributes_reply_t { - uint8_t response_type; /**< */ - uint8_t backing_store; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_visualid_t visual; /**< */ - uint16_t _class; /**< */ - uint8_t bit_gravity; /**< */ - uint8_t win_gravity; /**< */ - uint32_t backing_planes; /**< */ - uint32_t backing_pixel; /**< */ - uint8_t save_under; /**< */ - uint8_t map_is_installed; /**< */ - uint8_t map_state; /**< */ - uint8_t override_redirect; /**< */ - xcb_colormap_t colormap; /**< */ - uint32_t all_event_masks; /**< */ - uint32_t your_event_mask; /**< */ - uint16_t do_not_propagate_mask; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t response_type; + uint8_t backing_store; + uint16_t sequence; + uint32_t length; + xcb_visualid_t visual; + uint16_t _class; + uint8_t bit_gravity; + uint8_t win_gravity; + uint32_t backing_planes; + uint32_t backing_pixel; + uint8_t save_under; + uint8_t map_is_installed; + uint8_t map_state; + uint8_t override_redirect; + xcb_colormap_t colormap; + uint32_t all_event_masks; + uint32_t your_event_mask; + uint16_t do_not_propagate_mask; + uint8_t pad0[2]; } xcb_get_window_attributes_reply_t; /** Opcode for xcb_destroy_window. */ @@ -1544,10 +1608,10 @@ typedef struct xcb_get_window_attributes_reply_t { * @brief xcb_destroy_window_request_t **/ typedef struct xcb_destroy_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_destroy_window_request_t; /** Opcode for xcb_destroy_subwindows. */ @@ -1557,10 +1621,10 @@ typedef struct xcb_destroy_window_request_t { * @brief xcb_destroy_subwindows_request_t **/ typedef struct xcb_destroy_subwindows_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_destroy_subwindows_request_t; typedef enum xcb_set_mode_t { @@ -1575,10 +1639,10 @@ typedef enum xcb_set_mode_t { * @brief xcb_change_save_set_request_t **/ typedef struct xcb_change_save_set_request_t { - uint8_t major_opcode; /**< */ - uint8_t mode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t mode; + uint16_t length; + xcb_window_t window; } xcb_change_save_set_request_t; /** Opcode for xcb_reparent_window. */ @@ -1588,13 +1652,13 @@ typedef struct xcb_change_save_set_request_t { * @brief xcb_reparent_window_request_t **/ typedef struct xcb_reparent_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_window_t parent; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + xcb_window_t parent; + int16_t x; + int16_t y; } xcb_reparent_window_request_t; /** Opcode for xcb_map_window. */ @@ -1604,10 +1668,10 @@ typedef struct xcb_reparent_window_request_t { * @brief xcb_map_window_request_t **/ typedef struct xcb_map_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_map_window_request_t; /** Opcode for xcb_map_subwindows. */ @@ -1617,10 +1681,10 @@ typedef struct xcb_map_window_request_t { * @brief xcb_map_subwindows_request_t **/ typedef struct xcb_map_subwindows_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_map_subwindows_request_t; /** Opcode for xcb_unmap_window. */ @@ -1630,10 +1694,10 @@ typedef struct xcb_map_subwindows_request_t { * @brief xcb_unmap_window_request_t **/ typedef struct xcb_unmap_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_unmap_window_request_t; /** Opcode for xcb_unmap_subwindows. */ @@ -1643,10 +1707,10 @@ typedef struct xcb_unmap_window_request_t { * @brief xcb_unmap_subwindows_request_t **/ typedef struct xcb_unmap_subwindows_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_unmap_subwindows_request_t; typedef enum xcb_config_window_t { @@ -1667,6 +1731,19 @@ typedef enum xcb_stack_mode_t { XCB_STACK_MODE_OPPOSITE = 4 } xcb_stack_mode_t; +/** + * @brief xcb_configure_window_value_list_t + **/ +typedef struct xcb_configure_window_value_list_t { + int32_t x; + int32_t y; + uint32_t width; + uint32_t height; + uint32_t border_width; + xcb_window_t sibling; + uint32_t stack_mode; +} xcb_configure_window_value_list_t; + /** Opcode for xcb_configure_window. */ #define XCB_CONFIGURE_WINDOW 12 @@ -1674,12 +1751,12 @@ typedef enum xcb_stack_mode_t { * @brief xcb_configure_window_request_t **/ typedef struct xcb_configure_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint16_t value_mask; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + uint16_t value_mask; + uint8_t pad1[2]; } xcb_configure_window_request_t; typedef enum xcb_circulate_t { @@ -1694,17 +1771,17 @@ typedef enum xcb_circulate_t { * @brief xcb_circulate_window_request_t **/ typedef struct xcb_circulate_window_request_t { - uint8_t major_opcode; /**< */ - uint8_t direction; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t direction; + uint16_t length; + xcb_window_t window; } xcb_circulate_window_request_t; /** * @brief xcb_get_geometry_cookie_t **/ typedef struct xcb_get_geometry_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_geometry_cookie_t; /** Opcode for xcb_get_geometry. */ @@ -1714,34 +1791,34 @@ typedef struct xcb_get_geometry_cookie_t { * @brief xcb_get_geometry_request_t **/ typedef struct xcb_get_geometry_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; } xcb_get_geometry_request_t; /** * @brief xcb_get_geometry_reply_t **/ typedef struct xcb_get_geometry_reply_t { - uint8_t response_type; /**< */ - uint8_t depth; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t root; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint16_t border_width; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t response_type; + uint8_t depth; + uint16_t sequence; + uint32_t length; + xcb_window_t root; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint8_t pad0[2]; } xcb_get_geometry_reply_t; /** * @brief xcb_query_tree_cookie_t **/ typedef struct xcb_query_tree_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_query_tree_cookie_t; /** Opcode for xcb_query_tree. */ @@ -1751,31 +1828,31 @@ typedef struct xcb_query_tree_cookie_t { * @brief xcb_query_tree_request_t **/ typedef struct xcb_query_tree_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_query_tree_request_t; /** * @brief xcb_query_tree_reply_t **/ typedef struct xcb_query_tree_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t root; /**< */ - xcb_window_t parent; /**< */ - uint16_t children_len; /**< */ - uint8_t pad1[14]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_window_t root; + xcb_window_t parent; + uint16_t children_len; + uint8_t pad1[14]; } xcb_query_tree_reply_t; /** * @brief xcb_intern_atom_cookie_t **/ typedef struct xcb_intern_atom_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_intern_atom_cookie_t; /** Opcode for xcb_intern_atom. */ @@ -1785,29 +1862,29 @@ typedef struct xcb_intern_atom_cookie_t { * @brief xcb_intern_atom_request_t **/ typedef struct xcb_intern_atom_request_t { - uint8_t major_opcode; /**< */ - uint8_t only_if_exists; /**< */ - uint16_t length; /**< */ - uint16_t name_len; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t only_if_exists; + uint16_t length; + uint16_t name_len; + uint8_t pad0[2]; } xcb_intern_atom_request_t; /** * @brief xcb_intern_atom_reply_t **/ typedef struct xcb_intern_atom_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_atom_t atom; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_atom_t atom; } xcb_intern_atom_reply_t; /** * @brief xcb_get_atom_name_cookie_t **/ typedef struct xcb_get_atom_name_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_atom_name_cookie_t; /** Opcode for xcb_get_atom_name. */ @@ -1817,22 +1894,22 @@ typedef struct xcb_get_atom_name_cookie_t { * @brief xcb_get_atom_name_request_t **/ typedef struct xcb_get_atom_name_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_atom_t atom; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_atom_t atom; } xcb_get_atom_name_request_t; /** * @brief xcb_get_atom_name_reply_t **/ typedef struct xcb_get_atom_name_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t name_len; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t name_len; + uint8_t pad1[22]; } xcb_get_atom_name_reply_t; typedef enum xcb_prop_mode_t { @@ -1858,15 +1935,15 @@ defined with the correct type and format with zero-length data. */ * @brief xcb_change_property_request_t **/ typedef struct xcb_change_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t mode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_atom_t property; /**< */ - xcb_atom_t type; /**< */ - uint8_t format; /**< */ - uint8_t pad0[3]; /**< */ - uint32_t data_len; /**< */ + uint8_t major_opcode; + uint8_t mode; + uint16_t length; + xcb_window_t window; + xcb_atom_t property; + xcb_atom_t type; + uint8_t format; + uint8_t pad0[3]; + uint32_t data_len; } xcb_change_property_request_t; /** Opcode for xcb_delete_property. */ @@ -1876,11 +1953,11 @@ typedef struct xcb_change_property_request_t { * @brief xcb_delete_property_request_t **/ typedef struct xcb_delete_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_atom_t property; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + xcb_atom_t property; } xcb_delete_property_request_t; typedef enum xcb_get_property_type_t { @@ -1891,7 +1968,7 @@ typedef enum xcb_get_property_type_t { * @brief xcb_get_property_cookie_t **/ typedef struct xcb_get_property_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_property_cookie_t; /** Opcode for xcb_get_property. */ @@ -1901,35 +1978,35 @@ typedef struct xcb_get_property_cookie_t { * @brief xcb_get_property_request_t **/ typedef struct xcb_get_property_request_t { - uint8_t major_opcode; /**< */ - uint8_t _delete; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_atom_t property; /**< */ - xcb_atom_t type; /**< */ - uint32_t long_offset; /**< */ - uint32_t long_length; /**< */ + uint8_t major_opcode; + uint8_t _delete; + uint16_t length; + xcb_window_t window; + xcb_atom_t property; + xcb_atom_t type; + uint32_t long_offset; + uint32_t long_length; } xcb_get_property_request_t; /** * @brief xcb_get_property_reply_t **/ typedef struct xcb_get_property_reply_t { - uint8_t response_type; /**< */ - uint8_t format; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_atom_t type; /**< */ - uint32_t bytes_after; /**< */ - uint32_t value_len; /**< */ - uint8_t pad0[12]; /**< */ + uint8_t response_type; + uint8_t format; + uint16_t sequence; + uint32_t length; + xcb_atom_t type; + uint32_t bytes_after; + uint32_t value_len; + uint8_t pad0[12]; } xcb_get_property_reply_t; /** * @brief xcb_list_properties_cookie_t **/ typedef struct xcb_list_properties_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_list_properties_cookie_t; /** Opcode for xcb_list_properties. */ @@ -1939,22 +2016,22 @@ typedef struct xcb_list_properties_cookie_t { * @brief xcb_list_properties_request_t **/ typedef struct xcb_list_properties_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_list_properties_request_t; /** * @brief xcb_list_properties_reply_t **/ typedef struct xcb_list_properties_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t atoms_len; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t atoms_len; + uint8_t pad1[22]; } xcb_list_properties_reply_t; /** Opcode for xcb_set_selection_owner. */ @@ -1964,19 +2041,19 @@ typedef struct xcb_list_properties_reply_t { * @brief xcb_set_selection_owner_request_t **/ typedef struct xcb_set_selection_owner_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t owner; /**< */ - xcb_atom_t selection; /**< */ - xcb_timestamp_t time; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t owner; + xcb_atom_t selection; + xcb_timestamp_t time; } xcb_set_selection_owner_request_t; /** * @brief xcb_get_selection_owner_cookie_t **/ typedef struct xcb_get_selection_owner_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_selection_owner_cookie_t; /** Opcode for xcb_get_selection_owner. */ @@ -1986,21 +2063,21 @@ typedef struct xcb_get_selection_owner_cookie_t { * @brief xcb_get_selection_owner_request_t **/ typedef struct xcb_get_selection_owner_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_atom_t selection; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_atom_t selection; } xcb_get_selection_owner_request_t; /** * @brief xcb_get_selection_owner_reply_t **/ typedef struct xcb_get_selection_owner_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t owner; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_window_t owner; } xcb_get_selection_owner_reply_t; /** Opcode for xcb_convert_selection. */ @@ -2010,14 +2087,14 @@ typedef struct xcb_get_selection_owner_reply_t { * @brief xcb_convert_selection_request_t **/ typedef struct xcb_convert_selection_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t requestor; /**< */ - xcb_atom_t selection; /**< */ - xcb_atom_t target; /**< */ - xcb_atom_t property; /**< */ - xcb_timestamp_t time; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t requestor; + xcb_atom_t selection; + xcb_atom_t target; + xcb_atom_t property; + xcb_timestamp_t time; } xcb_convert_selection_request_t; typedef enum xcb_send_event_dest_t { @@ -2032,12 +2109,12 @@ typedef enum xcb_send_event_dest_t { * @brief xcb_send_event_request_t **/ typedef struct xcb_send_event_request_t { - uint8_t major_opcode; /**< */ - uint8_t propagate; /**< */ - uint16_t length; /**< */ - xcb_window_t destination; /**< */ - uint32_t event_mask; /**< */ - char event[32]; /**< */ + uint8_t major_opcode; + uint8_t propagate; + uint16_t length; + xcb_window_t destination; + uint32_t event_mask; + char event[32]; } xcb_send_event_request_t; typedef enum xcb_grab_mode_t { @@ -2067,7 +2144,7 @@ typedef enum xcb_cursor_enum_t { * @brief xcb_grab_pointer_cookie_t **/ typedef struct xcb_grab_pointer_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_grab_pointer_cookie_t; /** Opcode for xcb_grab_pointer. */ @@ -2077,26 +2154,26 @@ typedef struct xcb_grab_pointer_cookie_t { * @brief xcb_grab_pointer_request_t **/ typedef struct xcb_grab_pointer_request_t { - uint8_t major_opcode; /**< */ - uint8_t owner_events; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - uint16_t event_mask; /**< */ - uint8_t pointer_mode; /**< */ - uint8_t keyboard_mode; /**< */ - xcb_window_t confine_to; /**< */ - xcb_cursor_t cursor; /**< */ - xcb_timestamp_t time; /**< */ + uint8_t major_opcode; + uint8_t owner_events; + uint16_t length; + xcb_window_t grab_window; + uint16_t event_mask; + uint8_t pointer_mode; + uint8_t keyboard_mode; + xcb_window_t confine_to; + xcb_cursor_t cursor; + xcb_timestamp_t time; } xcb_grab_pointer_request_t; /** * @brief xcb_grab_pointer_reply_t **/ typedef struct xcb_grab_pointer_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; } xcb_grab_pointer_reply_t; /** Opcode for xcb_ungrab_pointer. */ @@ -2106,10 +2183,10 @@ typedef struct xcb_grab_pointer_reply_t { * @brief xcb_ungrab_pointer_request_t **/ typedef struct xcb_ungrab_pointer_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_timestamp_t time; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_timestamp_t time; } xcb_ungrab_pointer_request_t; typedef enum xcb_button_index_t { @@ -2140,18 +2217,18 @@ typedef enum xcb_button_index_t { * @brief xcb_grab_button_request_t **/ typedef struct xcb_grab_button_request_t { - uint8_t major_opcode; /**< */ - uint8_t owner_events; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - uint16_t event_mask; /**< */ - uint8_t pointer_mode; /**< */ - uint8_t keyboard_mode; /**< */ - xcb_window_t confine_to; /**< */ - xcb_cursor_t cursor; /**< */ - uint8_t button; /**< */ - uint8_t pad0; /**< */ - uint16_t modifiers; /**< */ + uint8_t major_opcode; + uint8_t owner_events; + uint16_t length; + xcb_window_t grab_window; + uint16_t event_mask; + uint8_t pointer_mode; + uint8_t keyboard_mode; + xcb_window_t confine_to; + xcb_cursor_t cursor; + uint8_t button; + uint8_t pad0; + uint16_t modifiers; } xcb_grab_button_request_t; /** Opcode for xcb_ungrab_button. */ @@ -2161,12 +2238,12 @@ typedef struct xcb_grab_button_request_t { * @brief xcb_ungrab_button_request_t **/ typedef struct xcb_ungrab_button_request_t { - uint8_t major_opcode; /**< */ - uint8_t button; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - uint16_t modifiers; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t button; + uint16_t length; + xcb_window_t grab_window; + uint16_t modifiers; + uint8_t pad0[2]; } xcb_ungrab_button_request_t; /** Opcode for xcb_change_active_pointer_grab. */ @@ -2176,20 +2253,20 @@ typedef struct xcb_ungrab_button_request_t { * @brief xcb_change_active_pointer_grab_request_t **/ typedef struct xcb_change_active_pointer_grab_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_cursor_t cursor; /**< */ - xcb_timestamp_t time; /**< */ - uint16_t event_mask; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_cursor_t cursor; + xcb_timestamp_t time; + uint16_t event_mask; + uint8_t pad1[2]; } xcb_change_active_pointer_grab_request_t; /** * @brief xcb_grab_keyboard_cookie_t **/ typedef struct xcb_grab_keyboard_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_grab_keyboard_cookie_t; /** Opcode for xcb_grab_keyboard. */ @@ -2199,24 +2276,24 @@ typedef struct xcb_grab_keyboard_cookie_t { * @brief xcb_grab_keyboard_request_t **/ typedef struct xcb_grab_keyboard_request_t { - uint8_t major_opcode; /**< */ - uint8_t owner_events; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - xcb_timestamp_t time; /**< */ - uint8_t pointer_mode; /**< */ - uint8_t keyboard_mode; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t owner_events; + uint16_t length; + xcb_window_t grab_window; + xcb_timestamp_t time; + uint8_t pointer_mode; + uint8_t keyboard_mode; + uint8_t pad0[2]; } xcb_grab_keyboard_request_t; /** * @brief xcb_grab_keyboard_reply_t **/ typedef struct xcb_grab_keyboard_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; } xcb_grab_keyboard_reply_t; /** Opcode for xcb_ungrab_keyboard. */ @@ -2226,10 +2303,10 @@ typedef struct xcb_grab_keyboard_reply_t { * @brief xcb_ungrab_keyboard_request_t **/ typedef struct xcb_ungrab_keyboard_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_timestamp_t time; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_timestamp_t time; } xcb_ungrab_keyboard_request_t; typedef enum xcb_grab_t { @@ -2243,15 +2320,15 @@ typedef enum xcb_grab_t { * @brief xcb_grab_key_request_t **/ typedef struct xcb_grab_key_request_t { - uint8_t major_opcode; /**< */ - uint8_t owner_events; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - uint16_t modifiers; /**< */ - xcb_keycode_t key; /**< */ - uint8_t pointer_mode; /**< */ - uint8_t keyboard_mode; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t owner_events; + uint16_t length; + xcb_window_t grab_window; + uint16_t modifiers; + xcb_keycode_t key; + uint8_t pointer_mode; + uint8_t keyboard_mode; + uint8_t pad0[3]; } xcb_grab_key_request_t; /** Opcode for xcb_ungrab_key. */ @@ -2261,12 +2338,12 @@ typedef struct xcb_grab_key_request_t { * @brief xcb_ungrab_key_request_t **/ typedef struct xcb_ungrab_key_request_t { - uint8_t major_opcode; /**< */ - xcb_keycode_t key; /**< */ - uint16_t length; /**< */ - xcb_window_t grab_window; /**< */ - uint16_t modifiers; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + xcb_keycode_t key; + uint16_t length; + xcb_window_t grab_window; + uint16_t modifiers; + uint8_t pad0[2]; } xcb_ungrab_key_request_t; typedef enum xcb_allow_t { @@ -2352,10 +2429,10 @@ subsequent freeze for SyncBoth will only freeze each device once). */ * @brief xcb_allow_events_request_t **/ typedef struct xcb_allow_events_request_t { - uint8_t major_opcode; /**< */ - uint8_t mode; /**< */ - uint16_t length; /**< */ - xcb_timestamp_t time; /**< */ + uint8_t major_opcode; + uint8_t mode; + uint16_t length; + xcb_timestamp_t time; } xcb_allow_events_request_t; /** Opcode for xcb_grab_server. */ @@ -2365,9 +2442,9 @@ typedef struct xcb_allow_events_request_t { * @brief xcb_grab_server_request_t **/ typedef struct xcb_grab_server_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_grab_server_request_t; /** Opcode for xcb_ungrab_server. */ @@ -2377,16 +2454,16 @@ typedef struct xcb_grab_server_request_t { * @brief xcb_ungrab_server_request_t **/ typedef struct xcb_ungrab_server_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_ungrab_server_request_t; /** * @brief xcb_query_pointer_cookie_t **/ typedef struct xcb_query_pointer_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_query_pointer_cookie_t; /** Opcode for xcb_query_pointer. */ @@ -2396,53 +2473,53 @@ typedef struct xcb_query_pointer_cookie_t { * @brief xcb_query_pointer_request_t **/ typedef struct xcb_query_pointer_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_query_pointer_request_t; /** * @brief xcb_query_pointer_reply_t **/ typedef struct xcb_query_pointer_reply_t { - uint8_t response_type; /**< */ - uint8_t same_screen; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t root; /**< */ - xcb_window_t child; /**< */ - int16_t root_x; /**< */ - int16_t root_y; /**< */ - int16_t win_x; /**< */ - int16_t win_y; /**< */ - uint16_t mask; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t response_type; + uint8_t same_screen; + uint16_t sequence; + uint32_t length; + xcb_window_t root; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t win_x; + int16_t win_y; + uint16_t mask; + uint8_t pad0[2]; } xcb_query_pointer_reply_t; /** * @brief xcb_timecoord_t **/ typedef struct xcb_timecoord_t { - xcb_timestamp_t time; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ + xcb_timestamp_t time; + int16_t x; + int16_t y; } xcb_timecoord_t; /** * @brief xcb_timecoord_iterator_t **/ typedef struct xcb_timecoord_iterator_t { - xcb_timecoord_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_timecoord_t *data; + int rem; + int index; } xcb_timecoord_iterator_t; /** * @brief xcb_get_motion_events_cookie_t **/ typedef struct xcb_get_motion_events_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_motion_events_cookie_t; /** Opcode for xcb_get_motion_events. */ @@ -2452,31 +2529,31 @@ typedef struct xcb_get_motion_events_cookie_t { * @brief xcb_get_motion_events_request_t **/ typedef struct xcb_get_motion_events_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_timestamp_t start; /**< */ - xcb_timestamp_t stop; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + xcb_timestamp_t start; + xcb_timestamp_t stop; } xcb_get_motion_events_request_t; /** * @brief xcb_get_motion_events_reply_t **/ typedef struct xcb_get_motion_events_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t events_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t events_len; + uint8_t pad1[20]; } xcb_get_motion_events_reply_t; /** * @brief xcb_translate_coordinates_cookie_t **/ typedef struct xcb_translate_coordinates_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_translate_coordinates_cookie_t; /** Opcode for xcb_translate_coordinates. */ @@ -2486,26 +2563,26 @@ typedef struct xcb_translate_coordinates_cookie_t { * @brief xcb_translate_coordinates_request_t **/ typedef struct xcb_translate_coordinates_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t src_window; /**< */ - xcb_window_t dst_window; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t src_window; + xcb_window_t dst_window; + int16_t src_x; + int16_t src_y; } xcb_translate_coordinates_request_t; /** * @brief xcb_translate_coordinates_reply_t **/ typedef struct xcb_translate_coordinates_reply_t { - uint8_t response_type; /**< */ - uint8_t same_screen; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t child; /**< */ - int16_t dst_x; /**< */ - int16_t dst_y; /**< */ + uint8_t response_type; + uint8_t same_screen; + uint16_t sequence; + uint32_t length; + xcb_window_t child; + int16_t dst_x; + int16_t dst_y; } xcb_translate_coordinates_reply_t; /** Opcode for xcb_warp_pointer. */ @@ -2515,17 +2592,17 @@ typedef struct xcb_translate_coordinates_reply_t { * @brief xcb_warp_pointer_request_t **/ typedef struct xcb_warp_pointer_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t src_window; /**< */ - xcb_window_t dst_window; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ - uint16_t src_width; /**< */ - uint16_t src_height; /**< */ - int16_t dst_x; /**< */ - int16_t dst_y; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t src_window; + xcb_window_t dst_window; + int16_t src_x; + int16_t src_y; + uint16_t src_width; + uint16_t src_height; + int16_t dst_x; + int16_t dst_y; } xcb_warp_pointer_request_t; typedef enum xcb_input_focus_t { @@ -2553,18 +2630,18 @@ revert_to value is `XCB_INPUT_FOCUS_NONE`. */ * @brief xcb_set_input_focus_request_t **/ typedef struct xcb_set_input_focus_request_t { - uint8_t major_opcode; /**< */ - uint8_t revert_to; /**< */ - uint16_t length; /**< */ - xcb_window_t focus; /**< */ - xcb_timestamp_t time; /**< */ + uint8_t major_opcode; + uint8_t revert_to; + uint16_t length; + xcb_window_t focus; + xcb_timestamp_t time; } xcb_set_input_focus_request_t; /** * @brief xcb_get_input_focus_cookie_t **/ typedef struct xcb_get_input_focus_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_input_focus_cookie_t; /** Opcode for xcb_get_input_focus. */ @@ -2574,27 +2651,27 @@ typedef struct xcb_get_input_focus_cookie_t { * @brief xcb_get_input_focus_request_t **/ typedef struct xcb_get_input_focus_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_get_input_focus_request_t; /** * @brief xcb_get_input_focus_reply_t **/ typedef struct xcb_get_input_focus_reply_t { - uint8_t response_type; /**< */ - uint8_t revert_to; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_window_t focus; /**< */ + uint8_t response_type; + uint8_t revert_to; + uint16_t sequence; + uint32_t length; + xcb_window_t focus; } xcb_get_input_focus_reply_t; /** * @brief xcb_query_keymap_cookie_t **/ typedef struct xcb_query_keymap_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_query_keymap_cookie_t; /** Opcode for xcb_query_keymap. */ @@ -2604,20 +2681,20 @@ typedef struct xcb_query_keymap_cookie_t { * @brief xcb_query_keymap_request_t **/ typedef struct xcb_query_keymap_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_query_keymap_request_t; /** * @brief xcb_query_keymap_reply_t **/ typedef struct xcb_query_keymap_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t keys[32]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t keys[32]; } xcb_query_keymap_reply_t; /** Opcode for xcb_open_font. */ @@ -2627,12 +2704,12 @@ typedef struct xcb_query_keymap_reply_t { * @brief xcb_open_font_request_t **/ typedef struct xcb_open_font_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_font_t fid; /**< */ - uint16_t name_len; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_font_t fid; + uint16_t name_len; + uint8_t pad1[2]; } xcb_open_font_request_t; /** Opcode for xcb_close_font. */ @@ -2642,10 +2719,10 @@ typedef struct xcb_open_font_request_t { * @brief xcb_close_font_request_t **/ typedef struct xcb_close_font_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_font_t font; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_font_t font; } xcb_close_font_request_t; typedef enum xcb_font_draw_t { @@ -2657,45 +2734,45 @@ typedef enum xcb_font_draw_t { * @brief xcb_fontprop_t **/ typedef struct xcb_fontprop_t { - xcb_atom_t name; /**< */ - uint32_t value; /**< */ + xcb_atom_t name; + uint32_t value; } xcb_fontprop_t; /** * @brief xcb_fontprop_iterator_t **/ typedef struct xcb_fontprop_iterator_t { - xcb_fontprop_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_fontprop_t *data; + int rem; + int index; } xcb_fontprop_iterator_t; /** * @brief xcb_charinfo_t **/ typedef struct xcb_charinfo_t { - int16_t left_side_bearing; /**< */ - int16_t right_side_bearing; /**< */ - int16_t character_width; /**< */ - int16_t ascent; /**< */ - int16_t descent; /**< */ - uint16_t attributes; /**< */ + int16_t left_side_bearing; + int16_t right_side_bearing; + int16_t character_width; + int16_t ascent; + int16_t descent; + uint16_t attributes; } xcb_charinfo_t; /** * @brief xcb_charinfo_iterator_t **/ typedef struct xcb_charinfo_iterator_t { - xcb_charinfo_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_charinfo_t *data; + int rem; + int index; } xcb_charinfo_iterator_t; /** * @brief xcb_query_font_cookie_t **/ typedef struct xcb_query_font_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_query_font_cookie_t; /** Opcode for xcb_query_font. */ @@ -2705,42 +2782,42 @@ typedef struct xcb_query_font_cookie_t { * @brief xcb_query_font_request_t **/ typedef struct xcb_query_font_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_fontable_t font; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_fontable_t font; } xcb_query_font_request_t; /** * @brief xcb_query_font_reply_t **/ typedef struct xcb_query_font_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_charinfo_t min_bounds; /**< */ - uint8_t pad1[4]; /**< */ - xcb_charinfo_t max_bounds; /**< */ - uint8_t pad2[4]; /**< */ - uint16_t min_char_or_byte2; /**< */ - uint16_t max_char_or_byte2; /**< */ - uint16_t default_char; /**< */ - uint16_t properties_len; /**< */ - uint8_t draw_direction; /**< */ - uint8_t min_byte1; /**< */ - uint8_t max_byte1; /**< */ - uint8_t all_chars_exist; /**< */ - int16_t font_ascent; /**< */ - int16_t font_descent; /**< */ - uint32_t char_infos_len; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_charinfo_t min_bounds; + uint8_t pad1[4]; + xcb_charinfo_t max_bounds; + uint8_t pad2[4]; + uint16_t min_char_or_byte2; + uint16_t max_char_or_byte2; + uint16_t default_char; + uint16_t properties_len; + uint8_t draw_direction; + uint8_t min_byte1; + uint8_t max_byte1; + uint8_t all_chars_exist; + int16_t font_ascent; + int16_t font_descent; + uint32_t char_infos_len; } xcb_query_font_reply_t; /** * @brief xcb_query_text_extents_cookie_t **/ typedef struct xcb_query_text_extents_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_query_text_extents_cookie_t; /** Opcode for xcb_query_text_extents. */ @@ -2750,50 +2827,50 @@ typedef struct xcb_query_text_extents_cookie_t { * @brief xcb_query_text_extents_request_t **/ typedef struct xcb_query_text_extents_request_t { - uint8_t major_opcode; /**< */ - uint8_t odd_length; /**< */ - uint16_t length; /**< */ - xcb_fontable_t font; /**< */ + uint8_t major_opcode; + uint8_t odd_length; + uint16_t length; + xcb_fontable_t font; } xcb_query_text_extents_request_t; /** * @brief xcb_query_text_extents_reply_t **/ typedef struct xcb_query_text_extents_reply_t { - uint8_t response_type; /**< */ - uint8_t draw_direction; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - int16_t font_ascent; /**< */ - int16_t font_descent; /**< */ - int16_t overall_ascent; /**< */ - int16_t overall_descent; /**< */ - int32_t overall_width; /**< */ - int32_t overall_left; /**< */ - int32_t overall_right; /**< */ + uint8_t response_type; + uint8_t draw_direction; + uint16_t sequence; + uint32_t length; + int16_t font_ascent; + int16_t font_descent; + int16_t overall_ascent; + int16_t overall_descent; + int32_t overall_width; + int32_t overall_left; + int32_t overall_right; } xcb_query_text_extents_reply_t; /** * @brief xcb_str_t **/ typedef struct xcb_str_t { - uint8_t name_len; /**< */ + uint8_t name_len; } xcb_str_t; /** * @brief xcb_str_iterator_t **/ typedef struct xcb_str_iterator_t { - xcb_str_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_str_t *data; + int rem; + int index; } xcb_str_iterator_t; /** * @brief xcb_list_fonts_cookie_t **/ typedef struct xcb_list_fonts_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_list_fonts_cookie_t; /** Opcode for xcb_list_fonts. */ @@ -2803,30 +2880,30 @@ typedef struct xcb_list_fonts_cookie_t { * @brief xcb_list_fonts_request_t **/ typedef struct xcb_list_fonts_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - uint16_t max_names; /**< */ - uint16_t pattern_len; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint16_t max_names; + uint16_t pattern_len; } xcb_list_fonts_request_t; /** * @brief xcb_list_fonts_reply_t **/ typedef struct xcb_list_fonts_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t names_len; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t names_len; + uint8_t pad1[22]; } xcb_list_fonts_reply_t; /** * @brief xcb_list_fonts_with_info_cookie_t **/ typedef struct xcb_list_fonts_with_info_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_list_fonts_with_info_cookie_t; /** Opcode for xcb_list_fonts_with_info. */ @@ -2836,36 +2913,36 @@ typedef struct xcb_list_fonts_with_info_cookie_t { * @brief xcb_list_fonts_with_info_request_t **/ typedef struct xcb_list_fonts_with_info_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - uint16_t max_names; /**< */ - uint16_t pattern_len; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint16_t max_names; + uint16_t pattern_len; } xcb_list_fonts_with_info_request_t; /** * @brief xcb_list_fonts_with_info_reply_t **/ typedef struct xcb_list_fonts_with_info_reply_t { - uint8_t response_type; /**< */ - uint8_t name_len; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_charinfo_t min_bounds; /**< */ - uint8_t pad0[4]; /**< */ - xcb_charinfo_t max_bounds; /**< */ - uint8_t pad1[4]; /**< */ - uint16_t min_char_or_byte2; /**< */ - uint16_t max_char_or_byte2; /**< */ - uint16_t default_char; /**< */ - uint16_t properties_len; /**< */ - uint8_t draw_direction; /**< */ - uint8_t min_byte1; /**< */ - uint8_t max_byte1; /**< */ - uint8_t all_chars_exist; /**< */ - int16_t font_ascent; /**< */ - int16_t font_descent; /**< */ - uint32_t replies_hint; /**< */ + uint8_t response_type; + uint8_t name_len; + uint16_t sequence; + uint32_t length; + xcb_charinfo_t min_bounds; + uint8_t pad0[4]; + xcb_charinfo_t max_bounds; + uint8_t pad1[4]; + uint16_t min_char_or_byte2; + uint16_t max_char_or_byte2; + uint16_t default_char; + uint16_t properties_len; + uint8_t draw_direction; + uint8_t min_byte1; + uint8_t max_byte1; + uint8_t all_chars_exist; + int16_t font_ascent; + int16_t font_descent; + uint32_t replies_hint; } xcb_list_fonts_with_info_reply_t; /** Opcode for xcb_set_font_path. */ @@ -2875,18 +2952,18 @@ typedef struct xcb_list_fonts_with_info_reply_t { * @brief xcb_set_font_path_request_t **/ typedef struct xcb_set_font_path_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - uint16_t font_qty; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint16_t font_qty; + uint8_t pad1[2]; } xcb_set_font_path_request_t; /** * @brief xcb_get_font_path_cookie_t **/ typedef struct xcb_get_font_path_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_font_path_cookie_t; /** Opcode for xcb_get_font_path. */ @@ -2896,21 +2973,21 @@ typedef struct xcb_get_font_path_cookie_t { * @brief xcb_get_font_path_request_t **/ typedef struct xcb_get_font_path_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_get_font_path_request_t; /** * @brief xcb_get_font_path_reply_t **/ typedef struct xcb_get_font_path_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t path_len; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t path_len; + uint8_t pad1[22]; } xcb_get_font_path_reply_t; /** Opcode for xcb_create_pixmap. */ @@ -2920,13 +2997,13 @@ typedef struct xcb_get_font_path_reply_t { * @brief xcb_create_pixmap_request_t **/ typedef struct xcb_create_pixmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t depth; /**< */ - uint16_t length; /**< */ - xcb_pixmap_t pid; /**< */ - xcb_drawable_t drawable; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + uint8_t major_opcode; + uint8_t depth; + uint16_t length; + xcb_pixmap_t pid; + xcb_drawable_t drawable; + uint16_t width; + uint16_t height; } xcb_create_pixmap_request_t; /** Opcode for xcb_free_pixmap. */ @@ -2936,10 +3013,10 @@ typedef struct xcb_create_pixmap_request_t { * @brief xcb_free_pixmap_request_t **/ typedef struct xcb_free_pixmap_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_pixmap_t pixmap; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_pixmap_t pixmap; } xcb_free_pixmap_request_t; typedef enum xcb_gc_t { @@ -3151,6 +3228,35 @@ typedef enum xcb_arc_mode_t { XCB_ARC_MODE_PIE_SLICE = 1 } xcb_arc_mode_t; +/** + * @brief xcb_create_gc_value_list_t + **/ +typedef struct xcb_create_gc_value_list_t { + uint32_t function; + uint32_t plane_mask; + uint32_t foreground; + uint32_t background; + uint32_t line_width; + uint32_t line_style; + uint32_t cap_style; + uint32_t join_style; + uint32_t fill_style; + uint32_t fill_rule; + xcb_pixmap_t tile; + xcb_pixmap_t stipple; + int32_t tile_stipple_x_origin; + int32_t tile_stipple_y_origin; + xcb_font_t font; + uint32_t subwindow_mode; + xcb_bool32_t graphics_exposures; + int32_t clip_x_origin; + int32_t clip_y_origin; + xcb_pixmap_t clip_mask; + uint32_t dash_offset; + uint32_t dashes; + uint32_t arc_mode; +} xcb_create_gc_value_list_t; + /** Opcode for xcb_create_gc. */ #define XCB_CREATE_GC 55 @@ -3158,14 +3264,43 @@ typedef enum xcb_arc_mode_t { * @brief xcb_create_gc_request_t **/ typedef struct xcb_create_gc_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_gcontext_t cid; /**< */ - xcb_drawable_t drawable; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_gcontext_t cid; + xcb_drawable_t drawable; + uint32_t value_mask; } xcb_create_gc_request_t; +/** + * @brief xcb_change_gc_value_list_t + **/ +typedef struct xcb_change_gc_value_list_t { + uint32_t function; + uint32_t plane_mask; + uint32_t foreground; + uint32_t background; + uint32_t line_width; + uint32_t line_style; + uint32_t cap_style; + uint32_t join_style; + uint32_t fill_style; + uint32_t fill_rule; + xcb_pixmap_t tile; + xcb_pixmap_t stipple; + int32_t tile_stipple_x_origin; + int32_t tile_stipple_y_origin; + xcb_font_t font; + uint32_t subwindow_mode; + xcb_bool32_t graphics_exposures; + int32_t clip_x_origin; + int32_t clip_y_origin; + xcb_pixmap_t clip_mask; + uint32_t dash_offset; + uint32_t dashes; + uint32_t arc_mode; +} xcb_change_gc_value_list_t; + /** Opcode for xcb_change_gc. */ #define XCB_CHANGE_GC 56 @@ -3173,11 +3308,11 @@ typedef struct xcb_create_gc_request_t { * @brief xcb_change_gc_request_t **/ typedef struct xcb_change_gc_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_gcontext_t gc; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_gcontext_t gc; + uint32_t value_mask; } xcb_change_gc_request_t; /** Opcode for xcb_copy_gc. */ @@ -3187,12 +3322,12 @@ typedef struct xcb_change_gc_request_t { * @brief xcb_copy_gc_request_t **/ typedef struct xcb_copy_gc_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_gcontext_t src_gc; /**< */ - xcb_gcontext_t dst_gc; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_gcontext_t src_gc; + xcb_gcontext_t dst_gc; + uint32_t value_mask; } xcb_copy_gc_request_t; /** Opcode for xcb_set_dashes. */ @@ -3202,12 +3337,12 @@ typedef struct xcb_copy_gc_request_t { * @brief xcb_set_dashes_request_t **/ typedef struct xcb_set_dashes_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_gcontext_t gc; /**< */ - uint16_t dash_offset; /**< */ - uint16_t dashes_len; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_gcontext_t gc; + uint16_t dash_offset; + uint16_t dashes_len; } xcb_set_dashes_request_t; typedef enum xcb_clip_ordering_t { @@ -3224,12 +3359,12 @@ typedef enum xcb_clip_ordering_t { * @brief xcb_set_clip_rectangles_request_t **/ typedef struct xcb_set_clip_rectangles_request_t { - uint8_t major_opcode; /**< */ - uint8_t ordering; /**< */ - uint16_t length; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t clip_x_origin; /**< */ - int16_t clip_y_origin; /**< */ + uint8_t major_opcode; + uint8_t ordering; + uint16_t length; + xcb_gcontext_t gc; + int16_t clip_x_origin; + int16_t clip_y_origin; } xcb_set_clip_rectangles_request_t; /** Opcode for xcb_free_gc. */ @@ -3239,10 +3374,10 @@ typedef struct xcb_set_clip_rectangles_request_t { * @brief xcb_free_gc_request_t **/ typedef struct xcb_free_gc_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_gcontext_t gc; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_gcontext_t gc; } xcb_free_gc_request_t; /** Opcode for xcb_clear_area. */ @@ -3252,14 +3387,14 @@ typedef struct xcb_free_gc_request_t { * @brief xcb_clear_area_request_t **/ typedef struct xcb_clear_area_request_t { - uint8_t major_opcode; /**< */ - uint8_t exposures; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + uint8_t major_opcode; + uint8_t exposures; + uint16_t length; + xcb_window_t window; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; } xcb_clear_area_request_t; /** Opcode for xcb_copy_area. */ @@ -3269,18 +3404,18 @@ typedef struct xcb_clear_area_request_t { * @brief xcb_copy_area_request_t **/ typedef struct xcb_copy_area_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t src_drawable; /**< */ - xcb_drawable_t dst_drawable; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ - int16_t dst_x; /**< */ - int16_t dst_y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t src_drawable; + xcb_drawable_t dst_drawable; + xcb_gcontext_t gc; + int16_t src_x; + int16_t src_y; + int16_t dst_x; + int16_t dst_y; + uint16_t width; + uint16_t height; } xcb_copy_area_request_t; /** Opcode for xcb_copy_plane. */ @@ -3290,19 +3425,19 @@ typedef struct xcb_copy_area_request_t { * @brief xcb_copy_plane_request_t **/ typedef struct xcb_copy_plane_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t src_drawable; /**< */ - xcb_drawable_t dst_drawable; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ - int16_t dst_x; /**< */ - int16_t dst_y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint32_t bit_plane; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t src_drawable; + xcb_drawable_t dst_drawable; + xcb_gcontext_t gc; + int16_t src_x; + int16_t src_y; + int16_t dst_x; + int16_t dst_y; + uint16_t width; + uint16_t height; + uint32_t bit_plane; } xcb_copy_plane_request_t; typedef enum xcb_coord_mode_t { @@ -3321,11 +3456,11 @@ typedef enum xcb_coord_mode_t { * @brief xcb_poly_point_request_t **/ typedef struct xcb_poly_point_request_t { - uint8_t major_opcode; /**< */ - uint8_t coordinate_mode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ + uint8_t major_opcode; + uint8_t coordinate_mode; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; } xcb_poly_point_request_t; /** Opcode for xcb_poly_line. */ @@ -3335,30 +3470,30 @@ typedef struct xcb_poly_point_request_t { * @brief xcb_poly_line_request_t **/ typedef struct xcb_poly_line_request_t { - uint8_t major_opcode; /**< */ - uint8_t coordinate_mode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ + uint8_t major_opcode; + uint8_t coordinate_mode; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; } xcb_poly_line_request_t; /** * @brief xcb_segment_t **/ typedef struct xcb_segment_t { - int16_t x1; /**< */ - int16_t y1; /**< */ - int16_t x2; /**< */ - int16_t y2; /**< */ + int16_t x1; + int16_t y1; + int16_t x2; + int16_t y2; } xcb_segment_t; /** * @brief xcb_segment_iterator_t **/ typedef struct xcb_segment_iterator_t { - xcb_segment_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_segment_t *data; + int rem; + int index; } xcb_segment_iterator_t; /** Opcode for xcb_poly_segment. */ @@ -3368,11 +3503,11 @@ typedef struct xcb_segment_iterator_t { * @brief xcb_poly_segment_request_t **/ typedef struct xcb_poly_segment_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; } xcb_poly_segment_request_t; /** Opcode for xcb_poly_rectangle. */ @@ -3382,11 +3517,11 @@ typedef struct xcb_poly_segment_request_t { * @brief xcb_poly_rectangle_request_t **/ typedef struct xcb_poly_rectangle_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; } xcb_poly_rectangle_request_t; /** Opcode for xcb_poly_arc. */ @@ -3396,11 +3531,11 @@ typedef struct xcb_poly_rectangle_request_t { * @brief xcb_poly_arc_request_t **/ typedef struct xcb_poly_arc_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; } xcb_poly_arc_request_t; typedef enum xcb_poly_shape_t { @@ -3416,14 +3551,14 @@ typedef enum xcb_poly_shape_t { * @brief xcb_fill_poly_request_t **/ typedef struct xcb_fill_poly_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - uint8_t shape; /**< */ - uint8_t coordinate_mode; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + uint8_t shape; + uint8_t coordinate_mode; + uint8_t pad1[2]; } xcb_fill_poly_request_t; /** Opcode for xcb_poly_fill_rectangle. */ @@ -3433,11 +3568,11 @@ typedef struct xcb_fill_poly_request_t { * @brief xcb_poly_fill_rectangle_request_t **/ typedef struct xcb_poly_fill_rectangle_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; } xcb_poly_fill_rectangle_request_t; /** Opcode for xcb_poly_fill_arc. */ @@ -3447,11 +3582,11 @@ typedef struct xcb_poly_fill_rectangle_request_t { * @brief xcb_poly_fill_arc_request_t **/ typedef struct xcb_poly_fill_arc_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; } xcb_poly_fill_arc_request_t; typedef enum xcb_image_format_t { @@ -3467,25 +3602,25 @@ typedef enum xcb_image_format_t { * @brief xcb_put_image_request_t **/ typedef struct xcb_put_image_request_t { - uint8_t major_opcode; /**< */ - uint8_t format; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - int16_t dst_x; /**< */ - int16_t dst_y; /**< */ - uint8_t left_pad; /**< */ - uint8_t depth; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t format; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + uint16_t width; + uint16_t height; + int16_t dst_x; + int16_t dst_y; + uint8_t left_pad; + uint8_t depth; + uint8_t pad0[2]; } xcb_put_image_request_t; /** * @brief xcb_get_image_cookie_t **/ typedef struct xcb_get_image_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_image_cookie_t; /** Opcode for xcb_get_image. */ @@ -3495,27 +3630,27 @@ typedef struct xcb_get_image_cookie_t { * @brief xcb_get_image_request_t **/ typedef struct xcb_get_image_request_t { - uint8_t major_opcode; /**< */ - uint8_t format; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint32_t plane_mask; /**< */ + uint8_t major_opcode; + uint8_t format; + uint16_t length; + xcb_drawable_t drawable; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint32_t plane_mask; } xcb_get_image_request_t; /** * @brief xcb_get_image_reply_t **/ typedef struct xcb_get_image_reply_t { - uint8_t response_type; /**< */ - uint8_t depth; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - xcb_visualid_t visual; /**< */ - uint8_t pad0[20]; /**< */ + uint8_t response_type; + uint8_t depth; + uint16_t sequence; + uint32_t length; + xcb_visualid_t visual; + uint8_t pad0[20]; } xcb_get_image_reply_t; /** Opcode for xcb_poly_text_8. */ @@ -3525,13 +3660,13 @@ typedef struct xcb_get_image_reply_t { * @brief xcb_poly_text_8_request_t **/ typedef struct xcb_poly_text_8_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t x; + int16_t y; } xcb_poly_text_8_request_t; /** Opcode for xcb_poly_text_16. */ @@ -3541,13 +3676,13 @@ typedef struct xcb_poly_text_8_request_t { * @brief xcb_poly_text_16_request_t **/ typedef struct xcb_poly_text_16_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t x; + int16_t y; } xcb_poly_text_16_request_t; /** Opcode for xcb_image_text_8. */ @@ -3557,13 +3692,13 @@ typedef struct xcb_poly_text_16_request_t { * @brief xcb_image_text_8_request_t **/ typedef struct xcb_image_text_8_request_t { - uint8_t major_opcode; /**< */ - uint8_t string_len; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ + uint8_t major_opcode; + uint8_t string_len; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t x; + int16_t y; } xcb_image_text_8_request_t; /** Opcode for xcb_image_text_16. */ @@ -3573,13 +3708,13 @@ typedef struct xcb_image_text_8_request_t { * @brief xcb_image_text_16_request_t **/ typedef struct xcb_image_text_16_request_t { - uint8_t major_opcode; /**< */ - uint8_t string_len; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t x; /**< */ - int16_t y; /**< */ + uint8_t major_opcode; + uint8_t string_len; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t x; + int16_t y; } xcb_image_text_16_request_t; typedef enum xcb_colormap_alloc_t { @@ -3594,12 +3729,12 @@ typedef enum xcb_colormap_alloc_t { * @brief xcb_create_colormap_request_t **/ typedef struct xcb_create_colormap_request_t { - uint8_t major_opcode; /**< */ - uint8_t alloc; /**< */ - uint16_t length; /**< */ - xcb_colormap_t mid; /**< */ - xcb_window_t window; /**< */ - xcb_visualid_t visual; /**< */ + uint8_t major_opcode; + uint8_t alloc; + uint16_t length; + xcb_colormap_t mid; + xcb_window_t window; + xcb_visualid_t visual; } xcb_create_colormap_request_t; /** Opcode for xcb_free_colormap. */ @@ -3609,10 +3744,10 @@ typedef struct xcb_create_colormap_request_t { * @brief xcb_free_colormap_request_t **/ typedef struct xcb_free_colormap_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; } xcb_free_colormap_request_t; /** Opcode for xcb_copy_colormap_and_free. */ @@ -3622,11 +3757,11 @@ typedef struct xcb_free_colormap_request_t { * @brief xcb_copy_colormap_and_free_request_t **/ typedef struct xcb_copy_colormap_and_free_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_colormap_t mid; /**< */ - xcb_colormap_t src_cmap; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t mid; + xcb_colormap_t src_cmap; } xcb_copy_colormap_and_free_request_t; /** Opcode for xcb_install_colormap. */ @@ -3636,10 +3771,10 @@ typedef struct xcb_copy_colormap_and_free_request_t { * @brief xcb_install_colormap_request_t **/ typedef struct xcb_install_colormap_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; } xcb_install_colormap_request_t; /** Opcode for xcb_uninstall_colormap. */ @@ -3649,17 +3784,17 @@ typedef struct xcb_install_colormap_request_t { * @brief xcb_uninstall_colormap_request_t **/ typedef struct xcb_uninstall_colormap_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; } xcb_uninstall_colormap_request_t; /** * @brief xcb_list_installed_colormaps_cookie_t **/ typedef struct xcb_list_installed_colormaps_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_list_installed_colormaps_cookie_t; /** Opcode for xcb_list_installed_colormaps. */ @@ -3669,29 +3804,29 @@ typedef struct xcb_list_installed_colormaps_cookie_t { * @brief xcb_list_installed_colormaps_request_t **/ typedef struct xcb_list_installed_colormaps_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; } xcb_list_installed_colormaps_request_t; /** * @brief xcb_list_installed_colormaps_reply_t **/ typedef struct xcb_list_installed_colormaps_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t cmaps_len; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t cmaps_len; + uint8_t pad1[22]; } xcb_list_installed_colormaps_reply_t; /** * @brief xcb_alloc_color_cookie_t **/ typedef struct xcb_alloc_color_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_alloc_color_cookie_t; /** Opcode for xcb_alloc_color. */ @@ -3701,36 +3836,36 @@ typedef struct xcb_alloc_color_cookie_t { * @brief xcb_alloc_color_request_t **/ typedef struct xcb_alloc_color_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ - uint16_t red; /**< */ - uint16_t green; /**< */ - uint16_t blue; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; + uint16_t red; + uint16_t green; + uint16_t blue; + uint8_t pad1[2]; } xcb_alloc_color_request_t; /** * @brief xcb_alloc_color_reply_t **/ typedef struct xcb_alloc_color_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t red; /**< */ - uint16_t green; /**< */ - uint16_t blue; /**< */ - uint8_t pad1[2]; /**< */ - uint32_t pixel; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t red; + uint16_t green; + uint16_t blue; + uint8_t pad1[2]; + uint32_t pixel; } xcb_alloc_color_reply_t; /** * @brief xcb_alloc_named_color_cookie_t **/ typedef struct xcb_alloc_named_color_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_alloc_named_color_cookie_t; /** Opcode for xcb_alloc_named_color. */ @@ -3740,36 +3875,36 @@ typedef struct xcb_alloc_named_color_cookie_t { * @brief xcb_alloc_named_color_request_t **/ typedef struct xcb_alloc_named_color_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ - uint16_t name_len; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; + uint16_t name_len; + uint8_t pad1[2]; } xcb_alloc_named_color_request_t; /** * @brief xcb_alloc_named_color_reply_t **/ typedef struct xcb_alloc_named_color_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t pixel; /**< */ - uint16_t exact_red; /**< */ - uint16_t exact_green; /**< */ - uint16_t exact_blue; /**< */ - uint16_t visual_red; /**< */ - uint16_t visual_green; /**< */ - uint16_t visual_blue; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t pixel; + uint16_t exact_red; + uint16_t exact_green; + uint16_t exact_blue; + uint16_t visual_red; + uint16_t visual_green; + uint16_t visual_blue; } xcb_alloc_named_color_reply_t; /** * @brief xcb_alloc_color_cells_cookie_t **/ typedef struct xcb_alloc_color_cells_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_alloc_color_cells_cookie_t; /** Opcode for xcb_alloc_color_cells. */ @@ -3779,32 +3914,32 @@ typedef struct xcb_alloc_color_cells_cookie_t { * @brief xcb_alloc_color_cells_request_t **/ typedef struct xcb_alloc_color_cells_request_t { - uint8_t major_opcode; /**< */ - uint8_t contiguous; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ - uint16_t colors; /**< */ - uint16_t planes; /**< */ + uint8_t major_opcode; + uint8_t contiguous; + uint16_t length; + xcb_colormap_t cmap; + uint16_t colors; + uint16_t planes; } xcb_alloc_color_cells_request_t; /** * @brief xcb_alloc_color_cells_reply_t **/ typedef struct xcb_alloc_color_cells_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t pixels_len; /**< */ - uint16_t masks_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t pixels_len; + uint16_t masks_len; + uint8_t pad1[20]; } xcb_alloc_color_cells_reply_t; /** * @brief xcb_alloc_color_planes_cookie_t **/ typedef struct xcb_alloc_color_planes_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_alloc_color_planes_cookie_t; /** Opcode for xcb_alloc_color_planes. */ @@ -3814,30 +3949,30 @@ typedef struct xcb_alloc_color_planes_cookie_t { * @brief xcb_alloc_color_planes_request_t **/ typedef struct xcb_alloc_color_planes_request_t { - uint8_t major_opcode; /**< */ - uint8_t contiguous; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ - uint16_t colors; /**< */ - uint16_t reds; /**< */ - uint16_t greens; /**< */ - uint16_t blues; /**< */ + uint8_t major_opcode; + uint8_t contiguous; + uint16_t length; + xcb_colormap_t cmap; + uint16_t colors; + uint16_t reds; + uint16_t greens; + uint16_t blues; } xcb_alloc_color_planes_request_t; /** * @brief xcb_alloc_color_planes_reply_t **/ typedef struct xcb_alloc_color_planes_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t pixels_len; /**< */ - uint8_t pad1[2]; /**< */ - uint32_t red_mask; /**< */ - uint32_t green_mask; /**< */ - uint32_t blue_mask; /**< */ - uint8_t pad2[8]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t pixels_len; + uint8_t pad1[2]; + uint32_t red_mask; + uint32_t green_mask; + uint32_t blue_mask; + uint8_t pad2[8]; } xcb_alloc_color_planes_reply_t; /** Opcode for xcb_free_colors. */ @@ -3847,11 +3982,11 @@ typedef struct xcb_alloc_color_planes_reply_t { * @brief xcb_free_colors_request_t **/ typedef struct xcb_free_colors_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ - uint32_t plane_mask; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; + uint32_t plane_mask; } xcb_free_colors_request_t; typedef enum xcb_color_flag_t { @@ -3864,21 +3999,21 @@ typedef enum xcb_color_flag_t { * @brief xcb_coloritem_t **/ typedef struct xcb_coloritem_t { - uint32_t pixel; /**< */ - uint16_t red; /**< */ - uint16_t green; /**< */ - uint16_t blue; /**< */ - uint8_t flags; /**< */ - uint8_t pad0; /**< */ + uint32_t pixel; + uint16_t red; + uint16_t green; + uint16_t blue; + uint8_t flags; + uint8_t pad0; } xcb_coloritem_t; /** * @brief xcb_coloritem_iterator_t **/ typedef struct xcb_coloritem_iterator_t { - xcb_coloritem_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_coloritem_t *data; + int rem; + int index; } xcb_coloritem_iterator_t; /** Opcode for xcb_store_colors. */ @@ -3888,10 +4023,10 @@ typedef struct xcb_coloritem_iterator_t { * @brief xcb_store_colors_request_t **/ typedef struct xcb_store_colors_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; } xcb_store_colors_request_t; /** Opcode for xcb_store_named_color. */ @@ -3901,39 +4036,39 @@ typedef struct xcb_store_colors_request_t { * @brief xcb_store_named_color_request_t **/ typedef struct xcb_store_named_color_request_t { - uint8_t major_opcode; /**< */ - uint8_t flags; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ - uint32_t pixel; /**< */ - uint16_t name_len; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t flags; + uint16_t length; + xcb_colormap_t cmap; + uint32_t pixel; + uint16_t name_len; + uint8_t pad0[2]; } xcb_store_named_color_request_t; /** * @brief xcb_rgb_t **/ typedef struct xcb_rgb_t { - uint16_t red; /**< */ - uint16_t green; /**< */ - uint16_t blue; /**< */ - uint8_t pad0[2]; /**< */ + uint16_t red; + uint16_t green; + uint16_t blue; + uint8_t pad0[2]; } xcb_rgb_t; /** * @brief xcb_rgb_iterator_t **/ typedef struct xcb_rgb_iterator_t { - xcb_rgb_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_rgb_t *data; + int rem; + int index; } xcb_rgb_iterator_t; /** * @brief xcb_query_colors_cookie_t **/ typedef struct xcb_query_colors_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_query_colors_cookie_t; /** Opcode for xcb_query_colors. */ @@ -3943,29 +4078,29 @@ typedef struct xcb_query_colors_cookie_t { * @brief xcb_query_colors_request_t **/ typedef struct xcb_query_colors_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; } xcb_query_colors_request_t; /** * @brief xcb_query_colors_reply_t **/ typedef struct xcb_query_colors_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t colors_len; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t colors_len; + uint8_t pad1[22]; } xcb_query_colors_reply_t; /** * @brief xcb_lookup_color_cookie_t **/ typedef struct xcb_lookup_color_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_lookup_color_cookie_t; /** Opcode for xcb_lookup_color. */ @@ -3975,28 +4110,28 @@ typedef struct xcb_lookup_color_cookie_t { * @brief xcb_lookup_color_request_t **/ typedef struct xcb_lookup_color_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_colormap_t cmap; /**< */ - uint16_t name_len; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; + uint16_t name_len; + uint8_t pad1[2]; } xcb_lookup_color_request_t; /** * @brief xcb_lookup_color_reply_t **/ typedef struct xcb_lookup_color_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t exact_red; /**< */ - uint16_t exact_green; /**< */ - uint16_t exact_blue; /**< */ - uint16_t visual_red; /**< */ - uint16_t visual_green; /**< */ - uint16_t visual_blue; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t exact_red; + uint16_t exact_green; + uint16_t exact_blue; + uint16_t visual_red; + uint16_t visual_green; + uint16_t visual_blue; } xcb_lookup_color_reply_t; typedef enum xcb_pixmap_enum_t { @@ -4010,20 +4145,20 @@ typedef enum xcb_pixmap_enum_t { * @brief xcb_create_cursor_request_t **/ typedef struct xcb_create_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_cursor_t cid; /**< */ - xcb_pixmap_t source; /**< */ - xcb_pixmap_t mask; /**< */ - uint16_t fore_red; /**< */ - uint16_t fore_green; /**< */ - uint16_t fore_blue; /**< */ - uint16_t back_red; /**< */ - uint16_t back_green; /**< */ - uint16_t back_blue; /**< */ - uint16_t x; /**< */ - uint16_t y; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_cursor_t cid; + xcb_pixmap_t source; + xcb_pixmap_t mask; + uint16_t fore_red; + uint16_t fore_green; + uint16_t fore_blue; + uint16_t back_red; + uint16_t back_green; + uint16_t back_blue; + uint16_t x; + uint16_t y; } xcb_create_cursor_request_t; typedef enum xcb_font_enum_t { @@ -4037,20 +4172,20 @@ typedef enum xcb_font_enum_t { * @brief xcb_create_glyph_cursor_request_t **/ typedef struct xcb_create_glyph_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_cursor_t cid; /**< */ - xcb_font_t source_font; /**< */ - xcb_font_t mask_font; /**< */ - uint16_t source_char; /**< */ - uint16_t mask_char; /**< */ - uint16_t fore_red; /**< */ - uint16_t fore_green; /**< */ - uint16_t fore_blue; /**< */ - uint16_t back_red; /**< */ - uint16_t back_green; /**< */ - uint16_t back_blue; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_cursor_t cid; + xcb_font_t source_font; + xcb_font_t mask_font; + uint16_t source_char; + uint16_t mask_char; + uint16_t fore_red; + uint16_t fore_green; + uint16_t fore_blue; + uint16_t back_red; + uint16_t back_green; + uint16_t back_blue; } xcb_create_glyph_cursor_request_t; /** Opcode for xcb_free_cursor. */ @@ -4060,10 +4195,10 @@ typedef struct xcb_create_glyph_cursor_request_t { * @brief xcb_free_cursor_request_t **/ typedef struct xcb_free_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_cursor_t cursor; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_cursor_t cursor; } xcb_free_cursor_request_t; /** Opcode for xcb_recolor_cursor. */ @@ -4073,16 +4208,16 @@ typedef struct xcb_free_cursor_request_t { * @brief xcb_recolor_cursor_request_t **/ typedef struct xcb_recolor_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_cursor_t cursor; /**< */ - uint16_t fore_red; /**< */ - uint16_t fore_green; /**< */ - uint16_t fore_blue; /**< */ - uint16_t back_red; /**< */ - uint16_t back_green; /**< */ - uint16_t back_blue; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_cursor_t cursor; + uint16_t fore_red; + uint16_t fore_green; + uint16_t fore_blue; + uint16_t back_red; + uint16_t back_green; + uint16_t back_blue; } xcb_recolor_cursor_request_t; typedef enum xcb_query_shape_of_t { @@ -4095,7 +4230,7 @@ typedef enum xcb_query_shape_of_t { * @brief xcb_query_best_size_cookie_t **/ typedef struct xcb_query_best_size_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_query_best_size_cookie_t; /** Opcode for xcb_query_best_size. */ @@ -4105,31 +4240,31 @@ typedef struct xcb_query_best_size_cookie_t { * @brief xcb_query_best_size_request_t **/ typedef struct xcb_query_best_size_request_t { - uint8_t major_opcode; /**< */ - uint8_t _class; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + uint8_t major_opcode; + uint8_t _class; + uint16_t length; + xcb_drawable_t drawable; + uint16_t width; + uint16_t height; } xcb_query_best_size_request_t; /** * @brief xcb_query_best_size_reply_t **/ typedef struct xcb_query_best_size_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t width; + uint16_t height; } xcb_query_best_size_reply_t; /** * @brief xcb_query_extension_cookie_t **/ typedef struct xcb_query_extension_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_query_extension_cookie_t; /** Opcode for xcb_query_extension. */ @@ -4139,32 +4274,32 @@ typedef struct xcb_query_extension_cookie_t { * @brief xcb_query_extension_request_t **/ typedef struct xcb_query_extension_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - uint16_t name_len; /**< */ - uint8_t pad1[2]; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint16_t name_len; + uint8_t pad1[2]; } xcb_query_extension_request_t; /** * @brief xcb_query_extension_reply_t **/ typedef struct xcb_query_extension_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t present; /**< */ - uint8_t major_opcode; /**< */ - uint8_t first_event; /**< */ - uint8_t first_error; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t present; + uint8_t major_opcode; + uint8_t first_event; + uint8_t first_error; } xcb_query_extension_reply_t; /** * @brief xcb_list_extensions_cookie_t **/ typedef struct xcb_list_extensions_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_list_extensions_cookie_t; /** Opcode for xcb_list_extensions. */ @@ -4174,20 +4309,20 @@ typedef struct xcb_list_extensions_cookie_t { * @brief xcb_list_extensions_request_t **/ typedef struct xcb_list_extensions_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_list_extensions_request_t; /** * @brief xcb_list_extensions_reply_t **/ typedef struct xcb_list_extensions_reply_t { - uint8_t response_type; /**< */ - uint8_t names_len; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad0[24]; /**< */ + uint8_t response_type; + uint8_t names_len; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; } xcb_list_extensions_reply_t; /** Opcode for xcb_change_keyboard_mapping. */ @@ -4197,19 +4332,19 @@ typedef struct xcb_list_extensions_reply_t { * @brief xcb_change_keyboard_mapping_request_t **/ typedef struct xcb_change_keyboard_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t keycode_count; /**< */ - uint16_t length; /**< */ - xcb_keycode_t first_keycode; /**< */ - uint8_t keysyms_per_keycode; /**< */ - uint8_t pad0[2]; /**< */ + uint8_t major_opcode; + uint8_t keycode_count; + uint16_t length; + xcb_keycode_t first_keycode; + uint8_t keysyms_per_keycode; + uint8_t pad0[2]; } xcb_change_keyboard_mapping_request_t; /** * @brief xcb_get_keyboard_mapping_cookie_t **/ typedef struct xcb_get_keyboard_mapping_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_keyboard_mapping_cookie_t; /** Opcode for xcb_get_keyboard_mapping. */ @@ -4219,22 +4354,22 @@ typedef struct xcb_get_keyboard_mapping_cookie_t { * @brief xcb_get_keyboard_mapping_request_t **/ typedef struct xcb_get_keyboard_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_keycode_t first_keycode; /**< */ - uint8_t count; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_keycode_t first_keycode; + uint8_t count; } xcb_get_keyboard_mapping_request_t; /** * @brief xcb_get_keyboard_mapping_reply_t **/ typedef struct xcb_get_keyboard_mapping_reply_t { - uint8_t response_type; /**< */ - uint8_t keysyms_per_keycode; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad0[24]; /**< */ + uint8_t response_type; + uint8_t keysyms_per_keycode; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; } xcb_get_keyboard_mapping_reply_t; typedef enum xcb_kb_t { @@ -4259,6 +4394,20 @@ typedef enum xcb_auto_repeat_mode_t { XCB_AUTO_REPEAT_MODE_DEFAULT = 2 } xcb_auto_repeat_mode_t; +/** + * @brief xcb_change_keyboard_control_value_list_t + **/ +typedef struct xcb_change_keyboard_control_value_list_t { + int32_t key_click_percent; + int32_t bell_percent; + int32_t bell_pitch; + int32_t bell_duration; + uint32_t led; + uint32_t led_mode; + xcb_keycode32_t key; + uint32_t auto_repeat_mode; +} xcb_change_keyboard_control_value_list_t; + /** Opcode for xcb_change_keyboard_control. */ #define XCB_CHANGE_KEYBOARD_CONTROL 102 @@ -4266,17 +4415,17 @@ typedef enum xcb_auto_repeat_mode_t { * @brief xcb_change_keyboard_control_request_t **/ typedef struct xcb_change_keyboard_control_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - uint32_t value_mask; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint32_t value_mask; } xcb_change_keyboard_control_request_t; /** * @brief xcb_get_keyboard_control_cookie_t **/ typedef struct xcb_get_keyboard_control_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_keyboard_control_cookie_t; /** Opcode for xcb_get_keyboard_control. */ @@ -4286,26 +4435,26 @@ typedef struct xcb_get_keyboard_control_cookie_t { * @brief xcb_get_keyboard_control_request_t **/ typedef struct xcb_get_keyboard_control_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_get_keyboard_control_request_t; /** * @brief xcb_get_keyboard_control_reply_t **/ typedef struct xcb_get_keyboard_control_reply_t { - uint8_t response_type; /**< */ - uint8_t global_auto_repeat; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t led_mask; /**< */ - uint8_t key_click_percent; /**< */ - uint8_t bell_percent; /**< */ - uint16_t bell_pitch; /**< */ - uint16_t bell_duration; /**< */ - uint8_t pad0[2]; /**< */ - uint8_t auto_repeats[32]; /**< */ + uint8_t response_type; + uint8_t global_auto_repeat; + uint16_t sequence; + uint32_t length; + uint32_t led_mask; + uint8_t key_click_percent; + uint8_t bell_percent; + uint16_t bell_pitch; + uint16_t bell_duration; + uint8_t pad0[2]; + uint8_t auto_repeats[32]; } xcb_get_keyboard_control_reply_t; /** Opcode for xcb_bell. */ @@ -4315,9 +4464,9 @@ typedef struct xcb_get_keyboard_control_reply_t { * @brief xcb_bell_request_t **/ typedef struct xcb_bell_request_t { - uint8_t major_opcode; /**< */ - int8_t percent; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + int8_t percent; + uint16_t length; } xcb_bell_request_t; /** Opcode for xcb_change_pointer_control. */ @@ -4327,21 +4476,21 @@ typedef struct xcb_bell_request_t { * @brief xcb_change_pointer_control_request_t **/ typedef struct xcb_change_pointer_control_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - int16_t acceleration_numerator; /**< */ - int16_t acceleration_denominator; /**< */ - int16_t threshold; /**< */ - uint8_t do_acceleration; /**< */ - uint8_t do_threshold; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + int16_t acceleration_numerator; + int16_t acceleration_denominator; + int16_t threshold; + uint8_t do_acceleration; + uint8_t do_threshold; } xcb_change_pointer_control_request_t; /** * @brief xcb_get_pointer_control_cookie_t **/ typedef struct xcb_get_pointer_control_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_pointer_control_cookie_t; /** Opcode for xcb_get_pointer_control. */ @@ -4351,23 +4500,23 @@ typedef struct xcb_get_pointer_control_cookie_t { * @brief xcb_get_pointer_control_request_t **/ typedef struct xcb_get_pointer_control_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_get_pointer_control_request_t; /** * @brief xcb_get_pointer_control_reply_t **/ typedef struct xcb_get_pointer_control_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t acceleration_numerator; /**< */ - uint16_t acceleration_denominator; /**< */ - uint16_t threshold; /**< */ - uint8_t pad1[18]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t acceleration_numerator; + uint16_t acceleration_denominator; + uint16_t threshold; + uint8_t pad1[18]; } xcb_get_pointer_control_reply_t; typedef enum xcb_blanking_t { @@ -4389,20 +4538,20 @@ typedef enum xcb_exposures_t { * @brief xcb_set_screen_saver_request_t **/ typedef struct xcb_set_screen_saver_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - int16_t timeout; /**< */ - int16_t interval; /**< */ - uint8_t prefer_blanking; /**< */ - uint8_t allow_exposures; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + int16_t timeout; + int16_t interval; + uint8_t prefer_blanking; + uint8_t allow_exposures; } xcb_set_screen_saver_request_t; /** * @brief xcb_get_screen_saver_cookie_t **/ typedef struct xcb_get_screen_saver_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_screen_saver_cookie_t; /** Opcode for xcb_get_screen_saver. */ @@ -4412,24 +4561,24 @@ typedef struct xcb_get_screen_saver_cookie_t { * @brief xcb_get_screen_saver_request_t **/ typedef struct xcb_get_screen_saver_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_get_screen_saver_request_t; /** * @brief xcb_get_screen_saver_reply_t **/ typedef struct xcb_get_screen_saver_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t timeout; /**< */ - uint16_t interval; /**< */ - uint8_t prefer_blanking; /**< */ - uint8_t allow_exposures; /**< */ - uint8_t pad1[18]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t timeout; + uint16_t interval; + uint8_t prefer_blanking; + uint8_t allow_exposures; + uint8_t pad1[18]; } xcb_get_screen_saver_reply_t; typedef enum xcb_host_mode_t { @@ -4452,37 +4601,37 @@ typedef enum xcb_family_t { * @brief xcb_change_hosts_request_t **/ typedef struct xcb_change_hosts_request_t { - uint8_t major_opcode; /**< */ - uint8_t mode; /**< */ - uint16_t length; /**< */ - uint8_t family; /**< */ - uint8_t pad0; /**< */ - uint16_t address_len; /**< */ + uint8_t major_opcode; + uint8_t mode; + uint16_t length; + uint8_t family; + uint8_t pad0; + uint16_t address_len; } xcb_change_hosts_request_t; /** * @brief xcb_host_t **/ typedef struct xcb_host_t { - uint8_t family; /**< */ - uint8_t pad0; /**< */ - uint16_t address_len; /**< */ + uint8_t family; + uint8_t pad0; + uint16_t address_len; } xcb_host_t; /** * @brief xcb_host_iterator_t **/ typedef struct xcb_host_iterator_t { - xcb_host_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_host_t *data; + int rem; + int index; } xcb_host_iterator_t; /** * @brief xcb_list_hosts_cookie_t **/ typedef struct xcb_list_hosts_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_list_hosts_cookie_t; /** Opcode for xcb_list_hosts. */ @@ -4492,21 +4641,21 @@ typedef struct xcb_list_hosts_cookie_t { * @brief xcb_list_hosts_request_t **/ typedef struct xcb_list_hosts_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_list_hosts_request_t; /** * @brief xcb_list_hosts_reply_t **/ typedef struct xcb_list_hosts_reply_t { - uint8_t response_type; /**< */ - uint8_t mode; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t hosts_len; /**< */ - uint8_t pad0[22]; /**< */ + uint8_t response_type; + uint8_t mode; + uint16_t sequence; + uint32_t length; + uint16_t hosts_len; + uint8_t pad0[22]; } xcb_list_hosts_reply_t; typedef enum xcb_access_control_t { @@ -4521,9 +4670,9 @@ typedef enum xcb_access_control_t { * @brief xcb_set_access_control_request_t **/ typedef struct xcb_set_access_control_request_t { - uint8_t major_opcode; /**< */ - uint8_t mode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t mode; + uint16_t length; } xcb_set_access_control_request_t; typedef enum xcb_close_down_t { @@ -4539,9 +4688,9 @@ typedef enum xcb_close_down_t { * @brief xcb_set_close_down_mode_request_t **/ typedef struct xcb_set_close_down_mode_request_t { - uint8_t major_opcode; /**< */ - uint8_t mode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t mode; + uint16_t length; } xcb_set_close_down_mode_request_t; typedef enum xcb_kill_t { @@ -4555,10 +4704,10 @@ typedef enum xcb_kill_t { * @brief xcb_kill_client_request_t **/ typedef struct xcb_kill_client_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - uint32_t resource; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint32_t resource; } xcb_kill_client_request_t; /** Opcode for xcb_rotate_properties. */ @@ -4568,12 +4717,12 @@ typedef struct xcb_kill_client_request_t { * @brief xcb_rotate_properties_request_t **/ typedef struct xcb_rotate_properties_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - uint16_t atoms_len; /**< */ - int16_t delta; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + uint16_t atoms_len; + int16_t delta; } xcb_rotate_properties_request_t; typedef enum xcb_screen_saver_t { @@ -4588,9 +4737,9 @@ typedef enum xcb_screen_saver_t { * @brief xcb_force_screen_saver_request_t **/ typedef struct xcb_force_screen_saver_request_t { - uint8_t major_opcode; /**< */ - uint8_t mode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t mode; + uint16_t length; } xcb_force_screen_saver_request_t; typedef enum xcb_mapping_status_t { @@ -4603,7 +4752,7 @@ typedef enum xcb_mapping_status_t { * @brief xcb_set_pointer_mapping_cookie_t **/ typedef struct xcb_set_pointer_mapping_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_set_pointer_mapping_cookie_t; /** Opcode for xcb_set_pointer_mapping. */ @@ -4613,26 +4762,26 @@ typedef struct xcb_set_pointer_mapping_cookie_t { * @brief xcb_set_pointer_mapping_request_t **/ typedef struct xcb_set_pointer_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t map_len; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t map_len; + uint16_t length; } xcb_set_pointer_mapping_request_t; /** * @brief xcb_set_pointer_mapping_reply_t **/ typedef struct xcb_set_pointer_mapping_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; } xcb_set_pointer_mapping_reply_t; /** * @brief xcb_get_pointer_mapping_cookie_t **/ typedef struct xcb_get_pointer_mapping_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_pointer_mapping_cookie_t; /** Opcode for xcb_get_pointer_mapping. */ @@ -4642,20 +4791,20 @@ typedef struct xcb_get_pointer_mapping_cookie_t { * @brief xcb_get_pointer_mapping_request_t **/ typedef struct xcb_get_pointer_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_get_pointer_mapping_request_t; /** * @brief xcb_get_pointer_mapping_reply_t **/ typedef struct xcb_get_pointer_mapping_reply_t { - uint8_t response_type; /**< */ - uint8_t map_len; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad0[24]; /**< */ + uint8_t response_type; + uint8_t map_len; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; } xcb_get_pointer_mapping_reply_t; typedef enum xcb_map_index_t { @@ -4673,7 +4822,7 @@ typedef enum xcb_map_index_t { * @brief xcb_set_modifier_mapping_cookie_t **/ typedef struct xcb_set_modifier_mapping_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_set_modifier_mapping_cookie_t; /** Opcode for xcb_set_modifier_mapping. */ @@ -4683,26 +4832,26 @@ typedef struct xcb_set_modifier_mapping_cookie_t { * @brief xcb_set_modifier_mapping_request_t **/ typedef struct xcb_set_modifier_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t keycodes_per_modifier; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t keycodes_per_modifier; + uint16_t length; } xcb_set_modifier_mapping_request_t; /** * @brief xcb_set_modifier_mapping_reply_t **/ typedef struct xcb_set_modifier_mapping_reply_t { - uint8_t response_type; /**< */ - uint8_t status; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; } xcb_set_modifier_mapping_reply_t; /** * @brief xcb_get_modifier_mapping_cookie_t **/ typedef struct xcb_get_modifier_mapping_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_get_modifier_mapping_cookie_t; /** Opcode for xcb_get_modifier_mapping. */ @@ -4712,20 +4861,20 @@ typedef struct xcb_get_modifier_mapping_cookie_t { * @brief xcb_get_modifier_mapping_request_t **/ typedef struct xcb_get_modifier_mapping_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_get_modifier_mapping_request_t; /** * @brief xcb_get_modifier_mapping_reply_t **/ typedef struct xcb_get_modifier_mapping_reply_t { - uint8_t response_type; /**< */ - uint8_t keycodes_per_modifier; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad0[24]; /**< */ + uint8_t response_type; + uint8_t keycodes_per_modifier; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; } xcb_get_modifier_mapping_reply_t; /** Opcode for xcb_no_operation. */ @@ -4735,9 +4884,9 @@ typedef struct xcb_get_modifier_mapping_reply_t { * @brief xcb_no_operation_request_t **/ typedef struct xcb_no_operation_request_t { - uint8_t major_opcode; /**< */ - uint8_t pad0; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; } xcb_no_operation_request_t; /** @@ -4749,7 +4898,7 @@ typedef struct xcb_no_operation_request_t { * element. The member index is increased by sizeof(xcb_char2b_t) */ void -xcb_char2b_next (xcb_char2b_iterator_t *i /**< */); +xcb_char2b_next (xcb_char2b_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4761,7 +4910,7 @@ xcb_char2b_next (xcb_char2b_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_char2b_end (xcb_char2b_iterator_t i /**< */); +xcb_char2b_end (xcb_char2b_iterator_t i); /** * Get the next element of the iterator @@ -4772,7 +4921,7 @@ xcb_char2b_end (xcb_char2b_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_window_t) */ void -xcb_window_next (xcb_window_iterator_t *i /**< */); +xcb_window_next (xcb_window_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4784,7 +4933,7 @@ xcb_window_next (xcb_window_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_window_end (xcb_window_iterator_t i /**< */); +xcb_window_end (xcb_window_iterator_t i); /** * Get the next element of the iterator @@ -4795,7 +4944,7 @@ xcb_window_end (xcb_window_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_pixmap_t) */ void -xcb_pixmap_next (xcb_pixmap_iterator_t *i /**< */); +xcb_pixmap_next (xcb_pixmap_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4807,7 +4956,7 @@ xcb_pixmap_next (xcb_pixmap_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_pixmap_end (xcb_pixmap_iterator_t i /**< */); +xcb_pixmap_end (xcb_pixmap_iterator_t i); /** * Get the next element of the iterator @@ -4818,7 +4967,7 @@ xcb_pixmap_end (xcb_pixmap_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_cursor_t) */ void -xcb_cursor_next (xcb_cursor_iterator_t *i /**< */); +xcb_cursor_next (xcb_cursor_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4830,7 +4979,7 @@ xcb_cursor_next (xcb_cursor_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_cursor_end (xcb_cursor_iterator_t i /**< */); +xcb_cursor_end (xcb_cursor_iterator_t i); /** * Get the next element of the iterator @@ -4841,7 +4990,7 @@ xcb_cursor_end (xcb_cursor_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_font_t) */ void -xcb_font_next (xcb_font_iterator_t *i /**< */); +xcb_font_next (xcb_font_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4853,7 +5002,7 @@ xcb_font_next (xcb_font_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_font_end (xcb_font_iterator_t i /**< */); +xcb_font_end (xcb_font_iterator_t i); /** * Get the next element of the iterator @@ -4864,7 +5013,7 @@ xcb_font_end (xcb_font_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_gcontext_t) */ void -xcb_gcontext_next (xcb_gcontext_iterator_t *i /**< */); +xcb_gcontext_next (xcb_gcontext_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4876,7 +5025,7 @@ xcb_gcontext_next (xcb_gcontext_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_gcontext_end (xcb_gcontext_iterator_t i /**< */); +xcb_gcontext_end (xcb_gcontext_iterator_t i); /** * Get the next element of the iterator @@ -4887,7 +5036,7 @@ xcb_gcontext_end (xcb_gcontext_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_colormap_t) */ void -xcb_colormap_next (xcb_colormap_iterator_t *i /**< */); +xcb_colormap_next (xcb_colormap_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4899,7 +5048,7 @@ xcb_colormap_next (xcb_colormap_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_colormap_end (xcb_colormap_iterator_t i /**< */); +xcb_colormap_end (xcb_colormap_iterator_t i); /** * Get the next element of the iterator @@ -4910,7 +5059,7 @@ xcb_colormap_end (xcb_colormap_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_atom_t) */ void -xcb_atom_next (xcb_atom_iterator_t *i /**< */); +xcb_atom_next (xcb_atom_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4922,7 +5071,7 @@ xcb_atom_next (xcb_atom_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_atom_end (xcb_atom_iterator_t i /**< */); +xcb_atom_end (xcb_atom_iterator_t i); /** * Get the next element of the iterator @@ -4933,7 +5082,7 @@ xcb_atom_end (xcb_atom_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_drawable_t) */ void -xcb_drawable_next (xcb_drawable_iterator_t *i /**< */); +xcb_drawable_next (xcb_drawable_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4945,7 +5094,7 @@ xcb_drawable_next (xcb_drawable_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_drawable_end (xcb_drawable_iterator_t i /**< */); +xcb_drawable_end (xcb_drawable_iterator_t i); /** * Get the next element of the iterator @@ -4956,7 +5105,7 @@ xcb_drawable_end (xcb_drawable_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_fontable_t) */ void -xcb_fontable_next (xcb_fontable_iterator_t *i /**< */); +xcb_fontable_next (xcb_fontable_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4968,7 +5117,30 @@ xcb_fontable_next (xcb_fontable_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_fontable_end (xcb_fontable_iterator_t i /**< */); +xcb_fontable_end (xcb_fontable_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_bool32_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_bool32_t) + */ +void +xcb_bool32_next (xcb_bool32_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_bool32_iterator_t + * @return The iterator pointing to the last element + * + * 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_bool32_end (xcb_bool32_iterator_t i); /** * Get the next element of the iterator @@ -4979,7 +5151,7 @@ xcb_fontable_end (xcb_fontable_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_visualid_t) */ void -xcb_visualid_next (xcb_visualid_iterator_t *i /**< */); +xcb_visualid_next (xcb_visualid_iterator_t *i); /** * Return the iterator pointing to the last element @@ -4991,7 +5163,7 @@ xcb_visualid_next (xcb_visualid_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_visualid_end (xcb_visualid_iterator_t i /**< */); +xcb_visualid_end (xcb_visualid_iterator_t i); /** * Get the next element of the iterator @@ -5002,7 +5174,7 @@ xcb_visualid_end (xcb_visualid_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_timestamp_t) */ void -xcb_timestamp_next (xcb_timestamp_iterator_t *i /**< */); +xcb_timestamp_next (xcb_timestamp_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5014,7 +5186,7 @@ xcb_timestamp_next (xcb_timestamp_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_timestamp_end (xcb_timestamp_iterator_t i /**< */); +xcb_timestamp_end (xcb_timestamp_iterator_t i); /** * Get the next element of the iterator @@ -5025,7 +5197,7 @@ xcb_timestamp_end (xcb_timestamp_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_keysym_t) */ void -xcb_keysym_next (xcb_keysym_iterator_t *i /**< */); +xcb_keysym_next (xcb_keysym_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5037,7 +5209,7 @@ xcb_keysym_next (xcb_keysym_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_keysym_end (xcb_keysym_iterator_t i /**< */); +xcb_keysym_end (xcb_keysym_iterator_t i); /** * Get the next element of the iterator @@ -5048,7 +5220,7 @@ xcb_keysym_end (xcb_keysym_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_keycode_t) */ void -xcb_keycode_next (xcb_keycode_iterator_t *i /**< */); +xcb_keycode_next (xcb_keycode_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5060,7 +5232,30 @@ xcb_keycode_next (xcb_keycode_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_keycode_end (xcb_keycode_iterator_t i /**< */); +xcb_keycode_end (xcb_keycode_iterator_t i); + +/** + * Get the next element of the iterator + * @param i Pointer to a xcb_keycode32_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_keycode32_t) + */ +void +xcb_keycode32_next (xcb_keycode32_iterator_t *i); + +/** + * Return the iterator pointing to the last element + * @param i An xcb_keycode32_iterator_t + * @return The iterator pointing to the last element + * + * 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_keycode32_end (xcb_keycode32_iterator_t i); /** * Get the next element of the iterator @@ -5071,7 +5266,7 @@ xcb_keycode_end (xcb_keycode_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_button_t) */ void -xcb_button_next (xcb_button_iterator_t *i /**< */); +xcb_button_next (xcb_button_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5083,7 +5278,7 @@ xcb_button_next (xcb_button_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_button_end (xcb_button_iterator_t i /**< */); +xcb_button_end (xcb_button_iterator_t i); /** * Get the next element of the iterator @@ -5094,7 +5289,7 @@ xcb_button_end (xcb_button_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_point_t) */ void -xcb_point_next (xcb_point_iterator_t *i /**< */); +xcb_point_next (xcb_point_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5106,7 +5301,7 @@ xcb_point_next (xcb_point_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_point_end (xcb_point_iterator_t i /**< */); +xcb_point_end (xcb_point_iterator_t i); /** * Get the next element of the iterator @@ -5117,7 +5312,7 @@ xcb_point_end (xcb_point_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_rectangle_t) */ void -xcb_rectangle_next (xcb_rectangle_iterator_t *i /**< */); +xcb_rectangle_next (xcb_rectangle_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5129,7 +5324,7 @@ xcb_rectangle_next (xcb_rectangle_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_rectangle_end (xcb_rectangle_iterator_t i /**< */); +xcb_rectangle_end (xcb_rectangle_iterator_t i); /** * Get the next element of the iterator @@ -5140,7 +5335,7 @@ xcb_rectangle_end (xcb_rectangle_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_arc_t) */ void -xcb_arc_next (xcb_arc_iterator_t *i /**< */); +xcb_arc_next (xcb_arc_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5152,7 +5347,7 @@ xcb_arc_next (xcb_arc_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_arc_end (xcb_arc_iterator_t i /**< */); +xcb_arc_end (xcb_arc_iterator_t i); /** * Get the next element of the iterator @@ -5163,7 +5358,7 @@ xcb_arc_end (xcb_arc_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_format_t) */ void -xcb_format_next (xcb_format_iterator_t *i /**< */); +xcb_format_next (xcb_format_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5175,7 +5370,7 @@ xcb_format_next (xcb_format_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_format_end (xcb_format_iterator_t i /**< */); +xcb_format_end (xcb_format_iterator_t i); /** * Get the next element of the iterator @@ -5186,7 +5381,7 @@ xcb_format_end (xcb_format_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_visualtype_t) */ void -xcb_visualtype_next (xcb_visualtype_iterator_t *i /**< */); +xcb_visualtype_next (xcb_visualtype_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5198,19 +5393,19 @@ xcb_visualtype_next (xcb_visualtype_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_visualtype_end (xcb_visualtype_iterator_t i /**< */); +xcb_visualtype_end (xcb_visualtype_iterator_t i); int -xcb_depth_sizeof (const void *_buffer /**< */); +xcb_depth_sizeof (const void *_buffer); xcb_visualtype_t * -xcb_depth_visuals (const xcb_depth_t *R /**< */); +xcb_depth_visuals (const xcb_depth_t *R); int -xcb_depth_visuals_length (const xcb_depth_t *R /**< */); +xcb_depth_visuals_length (const xcb_depth_t *R); xcb_visualtype_iterator_t -xcb_depth_visuals_iterator (const xcb_depth_t *R /**< */); +xcb_depth_visuals_iterator (const xcb_depth_t *R); /** * Get the next element of the iterator @@ -5221,7 +5416,7 @@ xcb_depth_visuals_iterator (const xcb_depth_t *R /**< */); * element. The member index is increased by sizeof(xcb_depth_t) */ void -xcb_depth_next (xcb_depth_iterator_t *i /**< */); +xcb_depth_next (xcb_depth_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5233,16 +5428,16 @@ xcb_depth_next (xcb_depth_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_depth_end (xcb_depth_iterator_t i /**< */); +xcb_depth_end (xcb_depth_iterator_t i); int -xcb_screen_sizeof (const void *_buffer /**< */); +xcb_screen_sizeof (const void *_buffer); int -xcb_screen_allowed_depths_length (const xcb_screen_t *R /**< */); +xcb_screen_allowed_depths_length (const xcb_screen_t *R); xcb_depth_iterator_t -xcb_screen_allowed_depths_iterator (const xcb_screen_t *R /**< */); +xcb_screen_allowed_depths_iterator (const xcb_screen_t *R); /** * Get the next element of the iterator @@ -5253,7 +5448,7 @@ xcb_screen_allowed_depths_iterator (const xcb_screen_t *R /**< */); * element. The member index is increased by sizeof(xcb_screen_t) */ void -xcb_screen_next (xcb_screen_iterator_t *i /**< */); +xcb_screen_next (xcb_screen_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5265,28 +5460,28 @@ xcb_screen_next (xcb_screen_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_screen_end (xcb_screen_iterator_t i /**< */); +xcb_screen_end (xcb_screen_iterator_t i); int -xcb_setup_request_sizeof (const void *_buffer /**< */); +xcb_setup_request_sizeof (const void *_buffer); char * -xcb_setup_request_authorization_protocol_name (const xcb_setup_request_t *R /**< */); +xcb_setup_request_authorization_protocol_name (const xcb_setup_request_t *R); int -xcb_setup_request_authorization_protocol_name_length (const xcb_setup_request_t *R /**< */); +xcb_setup_request_authorization_protocol_name_length (const xcb_setup_request_t *R); xcb_generic_iterator_t -xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R /**< */); +xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R); char * -xcb_setup_request_authorization_protocol_data (const xcb_setup_request_t *R /**< */); +xcb_setup_request_authorization_protocol_data (const xcb_setup_request_t *R); int -xcb_setup_request_authorization_protocol_data_length (const xcb_setup_request_t *R /**< */); +xcb_setup_request_authorization_protocol_data_length (const xcb_setup_request_t *R); xcb_generic_iterator_t -xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R /**< */); +xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R); /** * Get the next element of the iterator @@ -5297,7 +5492,7 @@ xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R * element. The member index is increased by sizeof(xcb_setup_request_t) */ void -xcb_setup_request_next (xcb_setup_request_iterator_t *i /**< */); +xcb_setup_request_next (xcb_setup_request_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5309,19 +5504,19 @@ xcb_setup_request_next (xcb_setup_request_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_setup_request_end (xcb_setup_request_iterator_t i /**< */); +xcb_setup_request_end (xcb_setup_request_iterator_t i); int -xcb_setup_failed_sizeof (const void *_buffer /**< */); +xcb_setup_failed_sizeof (const void *_buffer); char * -xcb_setup_failed_reason (const xcb_setup_failed_t *R /**< */); +xcb_setup_failed_reason (const xcb_setup_failed_t *R); int -xcb_setup_failed_reason_length (const xcb_setup_failed_t *R /**< */); +xcb_setup_failed_reason_length (const xcb_setup_failed_t *R); xcb_generic_iterator_t -xcb_setup_failed_reason_end (const xcb_setup_failed_t *R /**< */); +xcb_setup_failed_reason_end (const xcb_setup_failed_t *R); /** * Get the next element of the iterator @@ -5332,7 +5527,7 @@ xcb_setup_failed_reason_end (const xcb_setup_failed_t *R /**< */); * element. The member index is increased by sizeof(xcb_setup_failed_t) */ void -xcb_setup_failed_next (xcb_setup_failed_iterator_t *i /**< */); +xcb_setup_failed_next (xcb_setup_failed_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5344,19 +5539,19 @@ xcb_setup_failed_next (xcb_setup_failed_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_setup_failed_end (xcb_setup_failed_iterator_t i /**< */); +xcb_setup_failed_end (xcb_setup_failed_iterator_t i); int -xcb_setup_authenticate_sizeof (const void *_buffer /**< */); +xcb_setup_authenticate_sizeof (const void *_buffer); char * -xcb_setup_authenticate_reason (const xcb_setup_authenticate_t *R /**< */); +xcb_setup_authenticate_reason (const xcb_setup_authenticate_t *R); int -xcb_setup_authenticate_reason_length (const xcb_setup_authenticate_t *R /**< */); +xcb_setup_authenticate_reason_length (const xcb_setup_authenticate_t *R); xcb_generic_iterator_t -xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R /**< */); +xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R); /** * Get the next element of the iterator @@ -5367,7 +5562,7 @@ xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R /**< */); * element. The member index is increased by sizeof(xcb_setup_authenticate_t) */ void -xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i /**< */); +xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5379,34 +5574,34 @@ xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i /**< */); +xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i); int -xcb_setup_sizeof (const void *_buffer /**< */); +xcb_setup_sizeof (const void *_buffer); char * -xcb_setup_vendor (const xcb_setup_t *R /**< */); +xcb_setup_vendor (const xcb_setup_t *R); int -xcb_setup_vendor_length (const xcb_setup_t *R /**< */); +xcb_setup_vendor_length (const xcb_setup_t *R); xcb_generic_iterator_t -xcb_setup_vendor_end (const xcb_setup_t *R /**< */); +xcb_setup_vendor_end (const xcb_setup_t *R); xcb_format_t * -xcb_setup_pixmap_formats (const xcb_setup_t *R /**< */); +xcb_setup_pixmap_formats (const xcb_setup_t *R); int -xcb_setup_pixmap_formats_length (const xcb_setup_t *R /**< */); +xcb_setup_pixmap_formats_length (const xcb_setup_t *R); xcb_format_iterator_t -xcb_setup_pixmap_formats_iterator (const xcb_setup_t *R /**< */); +xcb_setup_pixmap_formats_iterator (const xcb_setup_t *R); int -xcb_setup_roots_length (const xcb_setup_t *R /**< */); +xcb_setup_roots_length (const xcb_setup_t *R); xcb_screen_iterator_t -xcb_setup_roots_iterator (const xcb_setup_t *R /**< */); +xcb_setup_roots_iterator (const xcb_setup_t *R); /** * Get the next element of the iterator @@ -5417,7 +5612,7 @@ xcb_setup_roots_iterator (const xcb_setup_t *R /**< */); * element. The member index is increased by sizeof(xcb_setup_t) */ void -xcb_setup_next (xcb_setup_iterator_t *i /**< */); +xcb_setup_next (xcb_setup_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5429,7 +5624,7 @@ xcb_setup_next (xcb_setup_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_setup_end (xcb_setup_iterator_t i /**< */); +xcb_setup_end (xcb_setup_iterator_t i); /** * Get the next element of the iterator @@ -5440,7 +5635,7 @@ xcb_setup_end (xcb_setup_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_client_message_data_t) */ void -xcb_client_message_data_next (xcb_client_message_data_iterator_t *i /**< */); +xcb_client_message_data_next (xcb_client_message_data_iterator_t *i); /** * Return the iterator pointing to the last element @@ -5452,10 +5647,24 @@ xcb_client_message_data_next (xcb_client_message_data_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_client_message_data_end (xcb_client_message_data_iterator_t i /**< */); +xcb_client_message_data_end (xcb_client_message_data_iterator_t i); int -xcb_create_window_sizeof (const void *_buffer /**< */); +xcb_create_window_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_create_window_value_list_t *_aux); + +int +xcb_create_window_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_create_window_value_list_t *_aux); + +int +xcb_create_window_value_list_sizeof (const void *_buffer, + uint32_t value_mask); + +int +xcb_create_window_sizeof (const void *_buffer); /** * @brief Creates a window @@ -5504,19 +5713,19 @@ xcb_create_window_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_create_window_checked (xcb_connection_t *c /**< */, - uint8_t depth /**< */, - xcb_window_t wid /**< */, - xcb_window_t parent /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t border_width /**< */, - uint16_t _class /**< */, - xcb_visualid_t visual /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_create_window_checked (xcb_connection_t *c, + uint8_t depth, + xcb_window_t wid, + xcb_window_t parent, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint16_t _class, + xcb_visualid_t visual, + uint32_t value_mask, + const void *value_list); /** * @brief Creates a window @@ -5562,22 +5771,158 @@ xcb_create_window_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_create_window (xcb_connection_t *c /**< */, - uint8_t depth /**< */, - xcb_window_t wid /**< */, - xcb_window_t parent /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint16_t border_width /**< */, - uint16_t _class /**< */, - xcb_visualid_t visual /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_create_window (xcb_connection_t *c, + uint8_t depth, + xcb_window_t wid, + xcb_window_t parent, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint16_t _class, + xcb_visualid_t visual, + uint32_t value_mask, + const void *value_list); + +/** + * @brief Creates a window + * + * @param c The connection + * @param depth Specifies the new window's depth (TODO: what unit?). + * \n + * The special value `XCB_COPY_FROM_PARENT` means the depth is taken from the + * \a parent window. + * @param wid The ID with which you will refer to the new window, created by + * `xcb_generate_id`. + * @param parent The parent window of the new window. + * @param x The X coordinate of the new window. + * @param y The Y coordinate of the new window. + * @param width The width of the new window. + * @param height The height of the new window. + * @param border_width TODO: + * \n + * Must be zero if the `class` is `InputOnly` or a `xcb_match_error_t` occurs. + * @param _class A bitmask of #xcb_window_class_t values. + * @param _class \n + * @param visual Specifies the id for the new window's visual. + * \n + * The special value `XCB_COPY_FROM_PARENT` means the visual is taken from the + * \a parent window. + * @param value_mask A bitmask of #xcb_cw_t values. + * @return A cookie + * + * Creates an unmapped window as child of the specified \a parent window. A + * CreateNotify event will be generated. The new window is placed on top in the + * stacking order with respect to siblings. + * + * The coordinate system has the X axis horizontal and the Y axis vertical with + * the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms + * of pixels, and coincide with pixel centers. Each window and pixmap has its own + * coordinate system. For a window, the origin is inside the border at the inside, + * upper-left corner. + * + * The created window is not yet displayed (mapped), call `xcb_map_window` to + * display it. + * + * The created window will initially use the same cursor as its parent. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_create_window_aux_checked (xcb_connection_t *c, + uint8_t depth, + xcb_window_t wid, + xcb_window_t parent, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint16_t _class, + xcb_visualid_t visual, + uint32_t value_mask, + const xcb_create_window_value_list_t *value_list); + +/** + * @brief Creates a window + * + * @param c The connection + * @param depth Specifies the new window's depth (TODO: what unit?). + * \n + * The special value `XCB_COPY_FROM_PARENT` means the depth is taken from the + * \a parent window. + * @param wid The ID with which you will refer to the new window, created by + * `xcb_generate_id`. + * @param parent The parent window of the new window. + * @param x The X coordinate of the new window. + * @param y The Y coordinate of the new window. + * @param width The width of the new window. + * @param height The height of the new window. + * @param border_width TODO: + * \n + * Must be zero if the `class` is `InputOnly` or a `xcb_match_error_t` occurs. + * @param _class A bitmask of #xcb_window_class_t values. + * @param _class \n + * @param visual Specifies the id for the new window's visual. + * \n + * The special value `XCB_COPY_FROM_PARENT` means the visual is taken from the + * \a parent window. + * @param value_mask A bitmask of #xcb_cw_t values. + * @return A cookie + * + * Creates an unmapped window as child of the specified \a parent window. A + * CreateNotify event will be generated. The new window is placed on top in the + * stacking order with respect to siblings. + * + * The coordinate system has the X axis horizontal and the Y axis vertical with + * the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms + * of pixels, and coincide with pixel centers. Each window and pixmap has its own + * coordinate system. For a window, the origin is inside the border at the inside, + * upper-left corner. + * + * The created window is not yet displayed (mapped), call `xcb_map_window` to + * display it. + * + * The created window will initially use the same cursor as its parent. + * + */ +xcb_void_cookie_t +xcb_create_window_aux (xcb_connection_t *c, + uint8_t depth, + xcb_window_t wid, + xcb_window_t parent, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint16_t border_width, + uint16_t _class, + xcb_visualid_t visual, + uint32_t value_mask, + const xcb_create_window_value_list_t *value_list); + +void * +xcb_create_window_value_list (const xcb_create_window_request_t *R); int -xcb_change_window_attributes_sizeof (const void *_buffer /**< */); +xcb_change_window_attributes_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_change_window_attributes_value_list_t *_aux); + +int +xcb_change_window_attributes_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_change_window_attributes_value_list_t *_aux); + +int +xcb_change_window_attributes_value_list_sizeof (const void *_buffer, + uint32_t value_mask); + +int +xcb_change_window_attributes_sizeof (const void *_buffer); /** * @brief change window attributes @@ -5598,10 +5943,10 @@ xcb_change_window_attributes_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_change_window_attributes_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_change_window_attributes_checked (xcb_connection_t *c, + xcb_window_t window, + uint32_t value_mask, + const void *value_list); /** * @brief change window attributes @@ -5619,10 +5964,58 @@ xcb_change_window_attributes_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_change_window_attributes (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_change_window_attributes (xcb_connection_t *c, + xcb_window_t window, + uint32_t value_mask, + const void *value_list); + +/** + * @brief change window attributes + * + * @param c The connection + * @param window The window to change. + * @param value_mask A bitmask of #xcb_cw_t values. + * @param value_mask \n + * @param value_list Values for each of the attributes specified in the bitmask \a value_mask. The + * order has to correspond to the order of possible \a value_mask bits. See the + * example. + * @return A cookie + * + * Changes the attributes specified by \a value_mask for the specified \a window. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_change_window_attributes_aux_checked (xcb_connection_t *c, + xcb_window_t window, + uint32_t value_mask, + const xcb_change_window_attributes_value_list_t *value_list); + +/** + * @brief change window attributes + * + * @param c The connection + * @param window The window to change. + * @param value_mask A bitmask of #xcb_cw_t values. + * @param value_mask \n + * @param value_list Values for each of the attributes specified in the bitmask \a value_mask. The + * order has to correspond to the order of possible \a value_mask bits. See the + * example. + * @return A cookie + * + * Changes the attributes specified by \a value_mask for the specified \a window. + * + */ +xcb_void_cookie_t +xcb_change_window_attributes_aux (xcb_connection_t *c, + xcb_window_t window, + uint32_t value_mask, + const xcb_change_window_attributes_value_list_t *value_list); + +void * +xcb_change_window_attributes_value_list (const xcb_change_window_attributes_request_t *R); /** * @brief Gets window attributes @@ -5635,8 +6028,8 @@ xcb_change_window_attributes (xcb_connection_t *c /**< */, * */ xcb_get_window_attributes_cookie_t -xcb_get_window_attributes (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_get_window_attributes (xcb_connection_t *c, + xcb_window_t window); /** * @brief Gets window attributes @@ -5652,8 +6045,8 @@ xcb_get_window_attributes (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_get_window_attributes_cookie_t -xcb_get_window_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_get_window_attributes_unchecked (xcb_connection_t *c, + xcb_window_t window); /** * Return the reply @@ -5670,9 +6063,9 @@ xcb_get_window_attributes_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_get_window_attributes_reply_t * -xcb_get_window_attributes_reply (xcb_connection_t *c /**< */, +xcb_get_window_attributes_reply (xcb_connection_t *c, xcb_get_window_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @brief Destroys a window @@ -5693,8 +6086,8 @@ xcb_get_window_attributes_reply (xcb_connection_t *c /**< */ * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_destroy_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_destroy_window_checked (xcb_connection_t *c, + xcb_window_t window); /** * @brief Destroys a window @@ -5712,8 +6105,8 @@ xcb_destroy_window_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_destroy_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_destroy_window (xcb_connection_t *c, + xcb_window_t window); /** * @@ -5727,8 +6120,8 @@ xcb_destroy_window (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_destroy_subwindows_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_destroy_subwindows_checked (xcb_connection_t *c, + xcb_window_t window); /** * @@ -5739,8 +6132,8 @@ xcb_destroy_subwindows_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_destroy_subwindows (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_destroy_subwindows (xcb_connection_t *c, + xcb_window_t window); /** * @brief Changes a client's save set @@ -5761,9 +6154,9 @@ xcb_destroy_subwindows (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_change_save_set_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_window_t window /**< */); +xcb_change_save_set_checked (xcb_connection_t *c, + uint8_t mode, + xcb_window_t window); /** * @brief Changes a client's save set @@ -5781,9 +6174,9 @@ xcb_change_save_set_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_change_save_set (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_window_t window /**< */); +xcb_change_save_set (xcb_connection_t *c, + uint8_t mode, + xcb_window_t window); /** * @brief Reparents a window @@ -5807,11 +6200,11 @@ xcb_change_save_set (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_reparent_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_window_t parent /**< */, - int16_t x /**< */, - int16_t y /**< */); +xcb_reparent_window_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_window_t parent, + int16_t x, + int16_t y); /** * @brief Reparents a window @@ -5832,11 +6225,11 @@ xcb_reparent_window_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_reparent_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_window_t parent /**< */, - int16_t x /**< */, - int16_t y /**< */); +xcb_reparent_window (xcb_connection_t *c, + xcb_window_t window, + xcb_window_t parent, + int16_t x, + int16_t y); /** * @brief Makes a window visible @@ -5870,8 +6263,8 @@ xcb_reparent_window (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_map_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_map_window_checked (xcb_connection_t *c, + xcb_window_t window); /** * @brief Makes a window visible @@ -5902,8 +6295,8 @@ xcb_map_window_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_map_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_map_window (xcb_connection_t *c, + xcb_window_t window); /** * @@ -5917,8 +6310,8 @@ xcb_map_window (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_map_subwindows_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_map_subwindows_checked (xcb_connection_t *c, + xcb_window_t window); /** * @@ -5929,8 +6322,8 @@ xcb_map_subwindows_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_map_subwindows (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_map_subwindows (xcb_connection_t *c, + xcb_window_t window); /** * @brief Makes a window invisible @@ -5950,8 +6343,8 @@ xcb_map_subwindows (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_unmap_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_unmap_window_checked (xcb_connection_t *c, + xcb_window_t window); /** * @brief Makes a window invisible @@ -5968,8 +6361,8 @@ xcb_unmap_window_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_unmap_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_unmap_window (xcb_connection_t *c, + xcb_window_t window); /** * @@ -5983,8 +6376,8 @@ xcb_unmap_window (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_unmap_subwindows_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_unmap_subwindows_checked (xcb_connection_t *c, + xcb_window_t window); /** * @@ -5995,11 +6388,25 @@ xcb_unmap_subwindows_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_unmap_subwindows (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_unmap_subwindows (xcb_connection_t *c, + xcb_window_t window); int -xcb_configure_window_sizeof (const void *_buffer /**< */); +xcb_configure_window_value_list_serialize (void **_buffer, + uint16_t value_mask, + const xcb_configure_window_value_list_t *_aux); + +int +xcb_configure_window_value_list_unpack (const void *_buffer, + uint16_t value_mask, + xcb_configure_window_value_list_t *_aux); + +int +xcb_configure_window_value_list_sizeof (const void *_buffer, + uint16_t value_mask); + +int +xcb_configure_window_sizeof (const void *_buffer); /** * @brief Configures window attributes @@ -6018,10 +6425,10 @@ xcb_configure_window_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_configure_window_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_configure_window_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t value_mask, + const void *value_list); /** * @brief Configures window attributes @@ -6037,10 +6444,54 @@ xcb_configure_window_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_configure_window (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_configure_window (xcb_connection_t *c, + xcb_window_t window, + uint16_t value_mask, + const void *value_list); + +/** + * @brief Configures window attributes + * + * @param c The connection + * @param window The window to configure. + * @param value_mask Bitmask of attributes to change. + * @param value_list New values, corresponding to the attributes in value_mask. The order has to + * correspond to the order of possible \a value_mask bits. See the example. + * @return A cookie + * + * Configures a window's size, position, border width and stacking order. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_configure_window_aux_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t value_mask, + const xcb_configure_window_value_list_t *value_list); + +/** + * @brief Configures window attributes + * + * @param c The connection + * @param window The window to configure. + * @param value_mask Bitmask of attributes to change. + * @param value_list New values, corresponding to the attributes in value_mask. The order has to + * correspond to the order of possible \a value_mask bits. See the example. + * @return A cookie + * + * Configures a window's size, position, border width and stacking order. + * + */ +xcb_void_cookie_t +xcb_configure_window_aux (xcb_connection_t *c, + xcb_window_t window, + uint16_t value_mask, + const xcb_configure_window_value_list_t *value_list); + +void * +xcb_configure_window_value_list (const xcb_configure_window_request_t *R); /** * @brief Change window stacking order @@ -6062,9 +6513,9 @@ xcb_configure_window (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_circulate_window_checked (xcb_connection_t *c /**< */, - uint8_t direction /**< */, - xcb_window_t window /**< */); +xcb_circulate_window_checked (xcb_connection_t *c, + uint8_t direction, + xcb_window_t window); /** * @brief Change window stacking order @@ -6083,9 +6534,9 @@ xcb_circulate_window_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_circulate_window (xcb_connection_t *c /**< */, - uint8_t direction /**< */, - xcb_window_t window /**< */); +xcb_circulate_window (xcb_connection_t *c, + uint8_t direction, + xcb_window_t window); /** * @brief Get current window geometry @@ -6098,8 +6549,8 @@ xcb_circulate_window (xcb_connection_t *c /**< */, * */ xcb_get_geometry_cookie_t -xcb_get_geometry (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_get_geometry (xcb_connection_t *c, + xcb_drawable_t drawable); /** * @brief Get current window geometry @@ -6115,8 +6566,8 @@ xcb_get_geometry (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_get_geometry_cookie_t -xcb_get_geometry_unchecked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */); +xcb_get_geometry_unchecked (xcb_connection_t *c, + xcb_drawable_t drawable); /** * Return the reply @@ -6133,12 +6584,12 @@ xcb_get_geometry_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_get_geometry_reply_t * -xcb_get_geometry_reply (xcb_connection_t *c /**< */, +xcb_get_geometry_reply (xcb_connection_t *c, xcb_get_geometry_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_query_tree_sizeof (const void *_buffer /**< */); +xcb_query_tree_sizeof (const void *_buffer); /** * @brief query the window tree @@ -6152,8 +6603,8 @@ xcb_query_tree_sizeof (const void *_buffer /**< */); * */ xcb_query_tree_cookie_t -xcb_query_tree (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_query_tree (xcb_connection_t *c, + xcb_window_t window); /** * @brief query the window tree @@ -6170,17 +6621,17 @@ xcb_query_tree (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_query_tree_cookie_t -xcb_query_tree_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_query_tree_unchecked (xcb_connection_t *c, + xcb_window_t window); xcb_window_t * -xcb_query_tree_children (const xcb_query_tree_reply_t *R /**< */); +xcb_query_tree_children (const xcb_query_tree_reply_t *R); int -xcb_query_tree_children_length (const xcb_query_tree_reply_t *R /**< */); +xcb_query_tree_children_length (const xcb_query_tree_reply_t *R); xcb_generic_iterator_t -xcb_query_tree_children_end (const xcb_query_tree_reply_t *R /**< */); +xcb_query_tree_children_end (const xcb_query_tree_reply_t *R); /** * Return the reply @@ -6197,12 +6648,12 @@ xcb_query_tree_children_end (const xcb_query_tree_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_query_tree_reply_t * -xcb_query_tree_reply (xcb_connection_t *c /**< */, +xcb_query_tree_reply (xcb_connection_t *c, xcb_query_tree_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_intern_atom_sizeof (const void *_buffer /**< */); +xcb_intern_atom_sizeof (const void *_buffer); /** * @brief Get atom identifier by name @@ -6223,10 +6674,10 @@ xcb_intern_atom_sizeof (const void *_buffer /**< */); * */ xcb_intern_atom_cookie_t -xcb_intern_atom (xcb_connection_t *c /**< */, - uint8_t only_if_exists /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_intern_atom (xcb_connection_t *c, + uint8_t only_if_exists, + uint16_t name_len, + const char *name); /** * @brief Get atom identifier by name @@ -6250,10 +6701,10 @@ xcb_intern_atom (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_intern_atom_cookie_t -xcb_intern_atom_unchecked (xcb_connection_t *c /**< */, - uint8_t only_if_exists /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_intern_atom_unchecked (xcb_connection_t *c, + uint8_t only_if_exists, + uint16_t name_len, + const char *name); /** * Return the reply @@ -6270,12 +6721,12 @@ xcb_intern_atom_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_intern_atom_reply_t * -xcb_intern_atom_reply (xcb_connection_t *c /**< */, +xcb_intern_atom_reply (xcb_connection_t *c, xcb_intern_atom_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_get_atom_name_sizeof (const void *_buffer /**< */); +xcb_get_atom_name_sizeof (const void *_buffer); /** * @@ -6286,8 +6737,8 @@ xcb_get_atom_name_sizeof (const void *_buffer /**< */); * */ xcb_get_atom_name_cookie_t -xcb_get_atom_name (xcb_connection_t *c /**< */, - xcb_atom_t atom /**< */); +xcb_get_atom_name (xcb_connection_t *c, + xcb_atom_t atom); /** * @@ -6301,17 +6752,17 @@ xcb_get_atom_name (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_get_atom_name_cookie_t -xcb_get_atom_name_unchecked (xcb_connection_t *c /**< */, - xcb_atom_t atom /**< */); +xcb_get_atom_name_unchecked (xcb_connection_t *c, + xcb_atom_t atom); char * -xcb_get_atom_name_name (const xcb_get_atom_name_reply_t *R /**< */); +xcb_get_atom_name_name (const xcb_get_atom_name_reply_t *R); int -xcb_get_atom_name_name_length (const xcb_get_atom_name_reply_t *R /**< */); +xcb_get_atom_name_name_length (const xcb_get_atom_name_reply_t *R); xcb_generic_iterator_t -xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R /**< */); +xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R); /** * Return the reply @@ -6328,12 +6779,12 @@ xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_get_atom_name_reply_t * -xcb_get_atom_name_reply (xcb_connection_t *c /**< */, +xcb_get_atom_name_reply (xcb_connection_t *c, xcb_get_atom_name_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_change_property_sizeof (const void *_buffer /**< */); +xcb_change_property_sizeof (const void *_buffer); /** * @brief Changes a window property @@ -6361,14 +6812,14 @@ xcb_change_property_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_change_property_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint32_t data_len /**< */, - const void *data /**< */); +xcb_change_property_checked (xcb_connection_t *c, + uint8_t mode, + xcb_window_t window, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint32_t data_len, + const void *data); /** * @brief Changes a window property @@ -6393,14 +6844,23 @@ xcb_change_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_change_property (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint8_t format /**< */, - uint32_t data_len /**< */, - const void *data /**< */); +xcb_change_property (xcb_connection_t *c, + uint8_t mode, + xcb_window_t window, + xcb_atom_t property, + xcb_atom_t type, + uint8_t format, + uint32_t data_len, + const void *data); + +void * +xcb_change_property_data (const xcb_change_property_request_t *R); + +int +xcb_change_property_data_length (const xcb_change_property_request_t *R); + +xcb_generic_iterator_t +xcb_change_property_data_end (const xcb_change_property_request_t *R); /** * @@ -6414,9 +6874,9 @@ xcb_change_property (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_delete_property_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */); +xcb_delete_property_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property); /** * @@ -6427,12 +6887,12 @@ xcb_delete_property_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_delete_property (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */); +xcb_delete_property (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property); int -xcb_get_property_sizeof (const void *_buffer /**< */); +xcb_get_property_sizeof (const void *_buffer); /** * @brief Gets a window property @@ -6462,13 +6922,13 @@ xcb_get_property_sizeof (const void *_buffer /**< */); * */ xcb_get_property_cookie_t -xcb_get_property (xcb_connection_t *c /**< */, - uint8_t _delete /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */); +xcb_get_property (xcb_connection_t *c, + uint8_t _delete, + xcb_window_t window, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length); /** * @brief Gets a window property @@ -6501,22 +6961,22 @@ xcb_get_property (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_get_property_cookie_t -xcb_get_property_unchecked (xcb_connection_t *c /**< */, - uint8_t _delete /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */, - xcb_atom_t type /**< */, - uint32_t long_offset /**< */, - uint32_t long_length /**< */); +xcb_get_property_unchecked (xcb_connection_t *c, + uint8_t _delete, + xcb_window_t window, + xcb_atom_t property, + xcb_atom_t type, + uint32_t long_offset, + uint32_t long_length); void * -xcb_get_property_value (const xcb_get_property_reply_t *R /**< */); +xcb_get_property_value (const xcb_get_property_reply_t *R); int -xcb_get_property_value_length (const xcb_get_property_reply_t *R /**< */); +xcb_get_property_value_length (const xcb_get_property_reply_t *R); xcb_generic_iterator_t -xcb_get_property_value_end (const xcb_get_property_reply_t *R /**< */); +xcb_get_property_value_end (const xcb_get_property_reply_t *R); /** * Return the reply @@ -6533,12 +6993,12 @@ xcb_get_property_value_end (const xcb_get_property_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_get_property_reply_t * -xcb_get_property_reply (xcb_connection_t *c /**< */, +xcb_get_property_reply (xcb_connection_t *c, xcb_get_property_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_list_properties_sizeof (const void *_buffer /**< */); +xcb_list_properties_sizeof (const void *_buffer); /** * @@ -6549,8 +7009,8 @@ xcb_list_properties_sizeof (const void *_buffer /**< */); * */ xcb_list_properties_cookie_t -xcb_list_properties (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_list_properties (xcb_connection_t *c, + xcb_window_t window); /** * @@ -6564,17 +7024,17 @@ xcb_list_properties (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_list_properties_cookie_t -xcb_list_properties_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_list_properties_unchecked (xcb_connection_t *c, + xcb_window_t window); xcb_atom_t * -xcb_list_properties_atoms (const xcb_list_properties_reply_t *R /**< */); +xcb_list_properties_atoms (const xcb_list_properties_reply_t *R); int -xcb_list_properties_atoms_length (const xcb_list_properties_reply_t *R /**< */); +xcb_list_properties_atoms_length (const xcb_list_properties_reply_t *R); xcb_generic_iterator_t -xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R /**< */); +xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R); /** * Return the reply @@ -6591,9 +7051,9 @@ xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_list_properties_reply_t * -xcb_list_properties_reply (xcb_connection_t *c /**< */, +xcb_list_properties_reply (xcb_connection_t *c, xcb_list_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @brief Sets the owner of a selection @@ -6623,10 +7083,10 @@ xcb_list_properties_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_set_selection_owner_checked (xcb_connection_t *c /**< */, - xcb_window_t owner /**< */, - xcb_atom_t selection /**< */, - xcb_timestamp_t time /**< */); +xcb_set_selection_owner_checked (xcb_connection_t *c, + xcb_window_t owner, + xcb_atom_t selection, + xcb_timestamp_t time); /** * @brief Sets the owner of a selection @@ -6653,10 +7113,10 @@ xcb_set_selection_owner_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_set_selection_owner (xcb_connection_t *c /**< */, - xcb_window_t owner /**< */, - xcb_atom_t selection /**< */, - xcb_timestamp_t time /**< */); +xcb_set_selection_owner (xcb_connection_t *c, + xcb_window_t owner, + xcb_atom_t selection, + xcb_timestamp_t time); /** * @brief Gets the owner of a selection @@ -6671,8 +7131,8 @@ xcb_set_selection_owner (xcb_connection_t *c /**< */, * */ xcb_get_selection_owner_cookie_t -xcb_get_selection_owner (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */); +xcb_get_selection_owner (xcb_connection_t *c, + xcb_atom_t selection); /** * @brief Gets the owner of a selection @@ -6690,8 +7150,8 @@ xcb_get_selection_owner (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_get_selection_owner_cookie_t -xcb_get_selection_owner_unchecked (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */); +xcb_get_selection_owner_unchecked (xcb_connection_t *c, + xcb_atom_t selection); /** * Return the reply @@ -6708,9 +7168,9 @@ xcb_get_selection_owner_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_get_selection_owner_reply_t * -xcb_get_selection_owner_reply (xcb_connection_t *c /**< */, +xcb_get_selection_owner_reply (xcb_connection_t *c, xcb_get_selection_owner_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -6724,12 +7184,12 @@ xcb_get_selection_owner_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_convert_selection_checked (xcb_connection_t *c /**< */, - xcb_window_t requestor /**< */, - xcb_atom_t selection /**< */, - xcb_atom_t target /**< */, - xcb_atom_t property /**< */, - xcb_timestamp_t time /**< */); +xcb_convert_selection_checked (xcb_connection_t *c, + xcb_window_t requestor, + xcb_atom_t selection, + xcb_atom_t target, + xcb_atom_t property, + xcb_timestamp_t time); /** * @@ -6740,12 +7200,12 @@ xcb_convert_selection_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_convert_selection (xcb_connection_t *c /**< */, - xcb_window_t requestor /**< */, - xcb_atom_t selection /**< */, - xcb_atom_t target /**< */, - xcb_atom_t property /**< */, - xcb_timestamp_t time /**< */); +xcb_convert_selection (xcb_connection_t *c, + xcb_window_t requestor, + xcb_atom_t selection, + xcb_atom_t target, + xcb_atom_t property, + xcb_timestamp_t time); /** * @brief send an event @@ -6785,11 +7245,11 @@ xcb_convert_selection (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_send_event_checked (xcb_connection_t *c /**< */, - uint8_t propagate /**< */, - xcb_window_t destination /**< */, - uint32_t event_mask /**< */, - const char *event /**< */); +xcb_send_event_checked (xcb_connection_t *c, + uint8_t propagate, + xcb_window_t destination, + uint32_t event_mask, + const char *event); /** * @brief send an event @@ -6826,11 +7286,11 @@ xcb_send_event_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_send_event (xcb_connection_t *c /**< */, - uint8_t propagate /**< */, - xcb_window_t destination /**< */, - uint32_t event_mask /**< */, - const char *event /**< */); +xcb_send_event (xcb_connection_t *c, + uint8_t propagate, + xcb_window_t destination, + uint32_t event_mask, + const char *event); /** * @brief Grab the pointer @@ -6869,15 +7329,15 @@ xcb_send_event (xcb_connection_t *c /**< */, * */ xcb_grab_pointer_cookie_t -xcb_grab_pointer (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t event_mask /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */, - xcb_window_t confine_to /**< */, - xcb_cursor_t cursor /**< */, - xcb_timestamp_t time /**< */); +xcb_grab_pointer (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t event_mask, + uint8_t pointer_mode, + uint8_t keyboard_mode, + xcb_window_t confine_to, + xcb_cursor_t cursor, + xcb_timestamp_t time); /** * @brief Grab the pointer @@ -6919,15 +7379,15 @@ xcb_grab_pointer (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_grab_pointer_cookie_t -xcb_grab_pointer_unchecked (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t event_mask /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */, - xcb_window_t confine_to /**< */, - xcb_cursor_t cursor /**< */, - xcb_timestamp_t time /**< */); +xcb_grab_pointer_unchecked (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t event_mask, + uint8_t pointer_mode, + uint8_t keyboard_mode, + xcb_window_t confine_to, + xcb_cursor_t cursor, + xcb_timestamp_t time); /** * Return the reply @@ -6944,9 +7404,9 @@ xcb_grab_pointer_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_grab_pointer_reply_t * -xcb_grab_pointer_reply (xcb_connection_t *c /**< */, +xcb_grab_pointer_reply (xcb_connection_t *c, xcb_grab_pointer_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @brief release the pointer @@ -6969,8 +7429,8 @@ xcb_grab_pointer_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_ungrab_pointer_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */); +xcb_ungrab_pointer_checked (xcb_connection_t *c, + xcb_timestamp_t time); /** * @brief release the pointer @@ -6990,8 +7450,8 @@ xcb_ungrab_pointer_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_ungrab_pointer (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */); +xcb_ungrab_pointer (xcb_connection_t *c, + xcb_timestamp_t time); /** * @brief Grab pointer button(s) @@ -7062,16 +7522,16 @@ xcb_ungrab_pointer (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_grab_button_checked (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t event_mask /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */, - xcb_window_t confine_to /**< */, - xcb_cursor_t cursor /**< */, - uint8_t button /**< */, - uint16_t modifiers /**< */); +xcb_grab_button_checked (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t event_mask, + uint8_t pointer_mode, + uint8_t keyboard_mode, + xcb_window_t confine_to, + xcb_cursor_t cursor, + uint8_t button, + uint16_t modifiers); /** * @brief Grab pointer button(s) @@ -7139,16 +7599,16 @@ xcb_grab_button_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_grab_button (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t event_mask /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */, - xcb_window_t confine_to /**< */, - xcb_cursor_t cursor /**< */, - uint8_t button /**< */, - uint16_t modifiers /**< */); +xcb_grab_button (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t event_mask, + uint8_t pointer_mode, + uint8_t keyboard_mode, + xcb_window_t confine_to, + xcb_cursor_t cursor, + uint8_t button, + uint16_t modifiers); /** * @@ -7162,10 +7622,10 @@ xcb_grab_button (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_ungrab_button_checked (xcb_connection_t *c /**< */, - uint8_t button /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */); +xcb_ungrab_button_checked (xcb_connection_t *c, + uint8_t button, + xcb_window_t grab_window, + uint16_t modifiers); /** * @@ -7176,10 +7636,10 @@ xcb_ungrab_button_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_ungrab_button (xcb_connection_t *c /**< */, - uint8_t button /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */); +xcb_ungrab_button (xcb_connection_t *c, + uint8_t button, + xcb_window_t grab_window, + uint16_t modifiers); /** * @@ -7193,10 +7653,10 @@ xcb_ungrab_button (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_change_active_pointer_grab_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - xcb_timestamp_t time /**< */, - uint16_t event_mask /**< */); +xcb_change_active_pointer_grab_checked (xcb_connection_t *c, + xcb_cursor_t cursor, + xcb_timestamp_t time, + uint16_t event_mask); /** * @@ -7207,10 +7667,10 @@ xcb_change_active_pointer_grab_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_change_active_pointer_grab (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - xcb_timestamp_t time /**< */, - uint16_t event_mask /**< */); +xcb_change_active_pointer_grab (xcb_connection_t *c, + xcb_cursor_t cursor, + xcb_timestamp_t time, + uint16_t event_mask); /** * @brief Grab the keyboard @@ -7242,12 +7702,12 @@ xcb_change_active_pointer_grab (xcb_connection_t *c /**< */, * */ xcb_grab_keyboard_cookie_t -xcb_grab_keyboard (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - xcb_timestamp_t time /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */); +xcb_grab_keyboard (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint8_t pointer_mode, + uint8_t keyboard_mode); /** * @brief Grab the keyboard @@ -7282,12 +7742,12 @@ xcb_grab_keyboard (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_grab_keyboard_cookie_t -xcb_grab_keyboard_unchecked (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - xcb_timestamp_t time /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */); +xcb_grab_keyboard_unchecked (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + xcb_timestamp_t time, + uint8_t pointer_mode, + uint8_t keyboard_mode); /** * Return the reply @@ -7304,9 +7764,9 @@ xcb_grab_keyboard_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_grab_keyboard_reply_t * -xcb_grab_keyboard_reply (xcb_connection_t *c /**< */, +xcb_grab_keyboard_reply (xcb_connection_t *c, xcb_grab_keyboard_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -7320,8 +7780,8 @@ xcb_grab_keyboard_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_ungrab_keyboard_checked (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */); +xcb_ungrab_keyboard_checked (xcb_connection_t *c, + xcb_timestamp_t time); /** * @@ -7332,8 +7792,8 @@ xcb_ungrab_keyboard_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_ungrab_keyboard (xcb_connection_t *c /**< */, - xcb_timestamp_t time /**< */); +xcb_ungrab_keyboard (xcb_connection_t *c, + xcb_timestamp_t time); /** * @brief Grab keyboard key(s) @@ -7391,13 +7851,13 @@ xcb_ungrab_keyboard (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_grab_key_checked (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */, - xcb_keycode_t key /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */); +xcb_grab_key_checked (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t modifiers, + xcb_keycode_t key, + uint8_t pointer_mode, + uint8_t keyboard_mode); /** * @brief Grab keyboard key(s) @@ -7452,13 +7912,13 @@ xcb_grab_key_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_grab_key (xcb_connection_t *c /**< */, - uint8_t owner_events /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */, - xcb_keycode_t key /**< */, - uint8_t pointer_mode /**< */, - uint8_t keyboard_mode /**< */); +xcb_grab_key (xcb_connection_t *c, + uint8_t owner_events, + xcb_window_t grab_window, + uint16_t modifiers, + xcb_keycode_t key, + uint8_t pointer_mode, + uint8_t keyboard_mode); /** * @brief release a key combination @@ -7482,10 +7942,10 @@ xcb_grab_key (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_ungrab_key_checked (xcb_connection_t *c /**< */, - xcb_keycode_t key /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */); +xcb_ungrab_key_checked (xcb_connection_t *c, + xcb_keycode_t key, + xcb_window_t grab_window, + uint16_t modifiers); /** * @brief release a key combination @@ -7506,10 +7966,10 @@ xcb_ungrab_key_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_ungrab_key (xcb_connection_t *c /**< */, - xcb_keycode_t key /**< */, - xcb_window_t grab_window /**< */, - uint16_t modifiers /**< */); +xcb_ungrab_key (xcb_connection_t *c, + xcb_keycode_t key, + xcb_window_t grab_window, + uint16_t modifiers); /** * @brief release queued events @@ -7533,9 +7993,9 @@ xcb_ungrab_key (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_allow_events_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_timestamp_t time /**< */); +xcb_allow_events_checked (xcb_connection_t *c, + uint8_t mode, + xcb_timestamp_t time); /** * @brief release queued events @@ -7556,9 +8016,9 @@ xcb_allow_events_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_allow_events (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - xcb_timestamp_t time /**< */); +xcb_allow_events (xcb_connection_t *c, + uint8_t mode, + xcb_timestamp_t time); /** * @@ -7572,7 +8032,7 @@ xcb_allow_events (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_grab_server_checked (xcb_connection_t *c /**< */); +xcb_grab_server_checked (xcb_connection_t *c); /** * @@ -7583,7 +8043,7 @@ xcb_grab_server_checked (xcb_connection_t *c /**< */); * */ xcb_void_cookie_t -xcb_grab_server (xcb_connection_t *c /**< */); +xcb_grab_server (xcb_connection_t *c); /** * @@ -7597,7 +8057,7 @@ xcb_grab_server (xcb_connection_t *c /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_ungrab_server_checked (xcb_connection_t *c /**< */); +xcb_ungrab_server_checked (xcb_connection_t *c); /** * @@ -7608,7 +8068,7 @@ xcb_ungrab_server_checked (xcb_connection_t *c /**< */); * */ xcb_void_cookie_t -xcb_ungrab_server (xcb_connection_t *c /**< */); +xcb_ungrab_server (xcb_connection_t *c); /** * @brief get pointer coordinates @@ -7623,8 +8083,8 @@ xcb_ungrab_server (xcb_connection_t *c /**< */); * */ xcb_query_pointer_cookie_t -xcb_query_pointer (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_query_pointer (xcb_connection_t *c, + xcb_window_t window); /** * @brief get pointer coordinates @@ -7642,8 +8102,8 @@ xcb_query_pointer (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_query_pointer_cookie_t -xcb_query_pointer_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_query_pointer_unchecked (xcb_connection_t *c, + xcb_window_t window); /** * Return the reply @@ -7660,9 +8120,9 @@ xcb_query_pointer_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_query_pointer_reply_t * -xcb_query_pointer_reply (xcb_connection_t *c /**< */, +xcb_query_pointer_reply (xcb_connection_t *c, xcb_query_pointer_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * Get the next element of the iterator @@ -7673,7 +8133,7 @@ xcb_query_pointer_reply (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_timecoord_t) */ void -xcb_timecoord_next (xcb_timecoord_iterator_t *i /**< */); +xcb_timecoord_next (xcb_timecoord_iterator_t *i); /** * Return the iterator pointing to the last element @@ -7685,10 +8145,10 @@ xcb_timecoord_next (xcb_timecoord_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_timecoord_end (xcb_timecoord_iterator_t i /**< */); +xcb_timecoord_end (xcb_timecoord_iterator_t i); int -xcb_get_motion_events_sizeof (const void *_buffer /**< */); +xcb_get_motion_events_sizeof (const void *_buffer); /** * @@ -7699,10 +8159,10 @@ xcb_get_motion_events_sizeof (const void *_buffer /**< */); * */ xcb_get_motion_events_cookie_t -xcb_get_motion_events (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t start /**< */, - xcb_timestamp_t stop /**< */); +xcb_get_motion_events (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t start, + xcb_timestamp_t stop); /** * @@ -7716,19 +8176,19 @@ xcb_get_motion_events (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_get_motion_events_cookie_t -xcb_get_motion_events_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_timestamp_t start /**< */, - xcb_timestamp_t stop /**< */); +xcb_get_motion_events_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_timestamp_t start, + xcb_timestamp_t stop); xcb_timecoord_t * -xcb_get_motion_events_events (const xcb_get_motion_events_reply_t *R /**< */); +xcb_get_motion_events_events (const xcb_get_motion_events_reply_t *R); int -xcb_get_motion_events_events_length (const xcb_get_motion_events_reply_t *R /**< */); +xcb_get_motion_events_events_length (const xcb_get_motion_events_reply_t *R); xcb_timecoord_iterator_t -xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R /**< */); +xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R); /** * Return the reply @@ -7745,9 +8205,9 @@ xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R / * The returned value must be freed by the caller using free(). */ xcb_get_motion_events_reply_t * -xcb_get_motion_events_reply (xcb_connection_t *c /**< */, +xcb_get_motion_events_reply (xcb_connection_t *c, xcb_get_motion_events_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -7758,11 +8218,11 @@ xcb_get_motion_events_reply (xcb_connection_t *c /**< */, * */ xcb_translate_coordinates_cookie_t -xcb_translate_coordinates (xcb_connection_t *c /**< */, - xcb_window_t src_window /**< */, - xcb_window_t dst_window /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */); +xcb_translate_coordinates (xcb_connection_t *c, + xcb_window_t src_window, + xcb_window_t dst_window, + int16_t src_x, + int16_t src_y); /** * @@ -7776,11 +8236,11 @@ xcb_translate_coordinates (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_translate_coordinates_cookie_t -xcb_translate_coordinates_unchecked (xcb_connection_t *c /**< */, - xcb_window_t src_window /**< */, - xcb_window_t dst_window /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */); +xcb_translate_coordinates_unchecked (xcb_connection_t *c, + xcb_window_t src_window, + xcb_window_t dst_window, + int16_t src_x, + int16_t src_y); /** * Return the reply @@ -7797,9 +8257,9 @@ xcb_translate_coordinates_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_translate_coordinates_reply_t * -xcb_translate_coordinates_reply (xcb_connection_t *c /**< */, +xcb_translate_coordinates_reply (xcb_connection_t *c, xcb_translate_coordinates_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @brief move mouse pointer @@ -7832,15 +8292,15 @@ xcb_translate_coordinates_reply (xcb_connection_t *c /**< */ * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_warp_pointer_checked (xcb_connection_t *c /**< */, - xcb_window_t src_window /**< */, - xcb_window_t dst_window /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */); +xcb_warp_pointer_checked (xcb_connection_t *c, + xcb_window_t src_window, + xcb_window_t dst_window, + int16_t src_x, + int16_t src_y, + uint16_t src_width, + uint16_t src_height, + int16_t dst_x, + int16_t dst_y); /** * @brief move mouse pointer @@ -7870,15 +8330,15 @@ xcb_warp_pointer_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_warp_pointer (xcb_connection_t *c /**< */, - xcb_window_t src_window /**< */, - xcb_window_t dst_window /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_width /**< */, - uint16_t src_height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */); +xcb_warp_pointer (xcb_connection_t *c, + xcb_window_t src_window, + xcb_window_t dst_window, + int16_t src_x, + int16_t src_y, + uint16_t src_width, + uint16_t src_height, + int16_t dst_x, + int16_t dst_y); /** * @brief Sets input focus @@ -7912,10 +8372,10 @@ xcb_warp_pointer (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_set_input_focus_checked (xcb_connection_t *c /**< */, - uint8_t revert_to /**< */, - xcb_window_t focus /**< */, - xcb_timestamp_t time /**< */); +xcb_set_input_focus_checked (xcb_connection_t *c, + uint8_t revert_to, + xcb_window_t focus, + xcb_timestamp_t time); /** * @brief Sets input focus @@ -7946,10 +8406,10 @@ xcb_set_input_focus_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_set_input_focus (xcb_connection_t *c /**< */, - uint8_t revert_to /**< */, - xcb_window_t focus /**< */, - xcb_timestamp_t time /**< */); +xcb_set_input_focus (xcb_connection_t *c, + uint8_t revert_to, + xcb_window_t focus, + xcb_timestamp_t time); /** * @@ -7960,7 +8420,7 @@ xcb_set_input_focus (xcb_connection_t *c /**< */, * */ xcb_get_input_focus_cookie_t -xcb_get_input_focus (xcb_connection_t *c /**< */); +xcb_get_input_focus (xcb_connection_t *c); /** * @@ -7974,7 +8434,7 @@ xcb_get_input_focus (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_get_input_focus_cookie_t -xcb_get_input_focus_unchecked (xcb_connection_t *c /**< */); +xcb_get_input_focus_unchecked (xcb_connection_t *c); /** * Return the reply @@ -7991,9 +8451,9 @@ xcb_get_input_focus_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_get_input_focus_reply_t * -xcb_get_input_focus_reply (xcb_connection_t *c /**< */, +xcb_get_input_focus_reply (xcb_connection_t *c, xcb_get_input_focus_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -8004,7 +8464,7 @@ xcb_get_input_focus_reply (xcb_connection_t *c /**< */, * */ xcb_query_keymap_cookie_t -xcb_query_keymap (xcb_connection_t *c /**< */); +xcb_query_keymap (xcb_connection_t *c); /** * @@ -8018,7 +8478,7 @@ xcb_query_keymap (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_query_keymap_cookie_t -xcb_query_keymap_unchecked (xcb_connection_t *c /**< */); +xcb_query_keymap_unchecked (xcb_connection_t *c); /** * Return the reply @@ -8035,12 +8495,12 @@ xcb_query_keymap_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_query_keymap_reply_t * -xcb_query_keymap_reply (xcb_connection_t *c /**< */, +xcb_query_keymap_reply (xcb_connection_t *c, xcb_query_keymap_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_open_font_sizeof (const void *_buffer /**< */); +xcb_open_font_sizeof (const void *_buffer); /** * @brief opens a font @@ -8061,10 +8521,10 @@ xcb_open_font_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_open_font_checked (xcb_connection_t *c /**< */, - xcb_font_t fid /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_open_font_checked (xcb_connection_t *c, + xcb_font_t fid, + uint16_t name_len, + const char *name); /** * @brief opens a font @@ -8082,10 +8542,19 @@ xcb_open_font_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_open_font (xcb_connection_t *c /**< */, - xcb_font_t fid /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_open_font (xcb_connection_t *c, + xcb_font_t fid, + uint16_t name_len, + const char *name); + +char * +xcb_open_font_name (const xcb_open_font_request_t *R); + +int +xcb_open_font_name_length (const xcb_open_font_request_t *R); + +xcb_generic_iterator_t +xcb_open_font_name_end (const xcb_open_font_request_t *R); /** * @@ -8099,8 +8568,8 @@ xcb_open_font (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_close_font_checked (xcb_connection_t *c /**< */, - xcb_font_t font /**< */); +xcb_close_font_checked (xcb_connection_t *c, + xcb_font_t font); /** * @@ -8111,8 +8580,8 @@ xcb_close_font_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_close_font (xcb_connection_t *c /**< */, - xcb_font_t font /**< */); +xcb_close_font (xcb_connection_t *c, + xcb_font_t font); /** * Get the next element of the iterator @@ -8123,7 +8592,7 @@ xcb_close_font (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_fontprop_t) */ void -xcb_fontprop_next (xcb_fontprop_iterator_t *i /**< */); +xcb_fontprop_next (xcb_fontprop_iterator_t *i); /** * Return the iterator pointing to the last element @@ -8135,7 +8604,7 @@ xcb_fontprop_next (xcb_fontprop_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_fontprop_end (xcb_fontprop_iterator_t i /**< */); +xcb_fontprop_end (xcb_fontprop_iterator_t i); /** * Get the next element of the iterator @@ -8146,7 +8615,7 @@ xcb_fontprop_end (xcb_fontprop_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_charinfo_t) */ void -xcb_charinfo_next (xcb_charinfo_iterator_t *i /**< */); +xcb_charinfo_next (xcb_charinfo_iterator_t *i); /** * Return the iterator pointing to the last element @@ -8158,10 +8627,10 @@ xcb_charinfo_next (xcb_charinfo_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_charinfo_end (xcb_charinfo_iterator_t i /**< */); +xcb_charinfo_end (xcb_charinfo_iterator_t i); int -xcb_query_font_sizeof (const void *_buffer /**< */); +xcb_query_font_sizeof (const void *_buffer); /** * @brief query font metrics @@ -8174,8 +8643,8 @@ xcb_query_font_sizeof (const void *_buffer /**< */); * */ xcb_query_font_cookie_t -xcb_query_font (xcb_connection_t *c /**< */, - xcb_fontable_t font /**< */); +xcb_query_font (xcb_connection_t *c, + xcb_fontable_t font); /** * @brief query font metrics @@ -8191,26 +8660,26 @@ xcb_query_font (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_query_font_cookie_t -xcb_query_font_unchecked (xcb_connection_t *c /**< */, - xcb_fontable_t font /**< */); +xcb_query_font_unchecked (xcb_connection_t *c, + xcb_fontable_t font); xcb_fontprop_t * -xcb_query_font_properties (const xcb_query_font_reply_t *R /**< */); +xcb_query_font_properties (const xcb_query_font_reply_t *R); int -xcb_query_font_properties_length (const xcb_query_font_reply_t *R /**< */); +xcb_query_font_properties_length (const xcb_query_font_reply_t *R); xcb_fontprop_iterator_t -xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R /**< */); +xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R); xcb_charinfo_t * -xcb_query_font_char_infos (const xcb_query_font_reply_t *R /**< */); +xcb_query_font_char_infos (const xcb_query_font_reply_t *R); int -xcb_query_font_char_infos_length (const xcb_query_font_reply_t *R /**< */); +xcb_query_font_char_infos_length (const xcb_query_font_reply_t *R); xcb_charinfo_iterator_t -xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R /**< */); +xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R); /** * Return the reply @@ -8227,13 +8696,13 @@ xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_query_font_reply_t * -xcb_query_font_reply (xcb_connection_t *c /**< */, +xcb_query_font_reply (xcb_connection_t *c, xcb_query_font_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_query_text_extents_sizeof (const void *_buffer /**< */, - uint32_t string_len /**< */); +xcb_query_text_extents_sizeof (const void *_buffer, + uint32_t string_len); /** * @brief get text extents @@ -8268,10 +8737,10 @@ xcb_query_text_extents_sizeof (const void *_buffer /**< */, * */ xcb_query_text_extents_cookie_t -xcb_query_text_extents (xcb_connection_t *c /**< */, - xcb_fontable_t font /**< */, - uint32_t string_len /**< */, - const xcb_char2b_t *string /**< */); +xcb_query_text_extents (xcb_connection_t *c, + xcb_fontable_t font, + uint32_t string_len, + const xcb_char2b_t *string); /** * @brief get text extents @@ -8309,10 +8778,10 @@ xcb_query_text_extents (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_query_text_extents_cookie_t -xcb_query_text_extents_unchecked (xcb_connection_t *c /**< */, - xcb_fontable_t font /**< */, - uint32_t string_len /**< */, - const xcb_char2b_t *string /**< */); +xcb_query_text_extents_unchecked (xcb_connection_t *c, + xcb_fontable_t font, + uint32_t string_len, + const xcb_char2b_t *string); /** * Return the reply @@ -8329,21 +8798,21 @@ xcb_query_text_extents_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_query_text_extents_reply_t * -xcb_query_text_extents_reply (xcb_connection_t *c /**< */, +xcb_query_text_extents_reply (xcb_connection_t *c, xcb_query_text_extents_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_str_sizeof (const void *_buffer /**< */); +xcb_str_sizeof (const void *_buffer); char * -xcb_str_name (const xcb_str_t *R /**< */); +xcb_str_name (const xcb_str_t *R); int -xcb_str_name_length (const xcb_str_t *R /**< */); +xcb_str_name_length (const xcb_str_t *R); xcb_generic_iterator_t -xcb_str_name_end (const xcb_str_t *R /**< */); +xcb_str_name_end (const xcb_str_t *R); /** * Get the next element of the iterator @@ -8354,7 +8823,7 @@ xcb_str_name_end (const xcb_str_t *R /**< */); * element. The member index is increased by sizeof(xcb_str_t) */ void -xcb_str_next (xcb_str_iterator_t *i /**< */); +xcb_str_next (xcb_str_iterator_t *i); /** * Return the iterator pointing to the last element @@ -8366,10 +8835,10 @@ xcb_str_next (xcb_str_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_str_end (xcb_str_iterator_t i /**< */); +xcb_str_end (xcb_str_iterator_t i); int -xcb_list_fonts_sizeof (const void *_buffer /**< */); +xcb_list_fonts_sizeof (const void *_buffer); /** * @brief get matching font names @@ -8388,10 +8857,10 @@ xcb_list_fonts_sizeof (const void *_buffer /**< */); * */ xcb_list_fonts_cookie_t -xcb_list_fonts (xcb_connection_t *c /**< */, - uint16_t max_names /**< */, - uint16_t pattern_len /**< */, - const char *pattern /**< */); +xcb_list_fonts (xcb_connection_t *c, + uint16_t max_names, + uint16_t pattern_len, + const char *pattern); /** * @brief get matching font names @@ -8413,16 +8882,16 @@ xcb_list_fonts (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_list_fonts_cookie_t -xcb_list_fonts_unchecked (xcb_connection_t *c /**< */, - uint16_t max_names /**< */, - uint16_t pattern_len /**< */, - const char *pattern /**< */); +xcb_list_fonts_unchecked (xcb_connection_t *c, + uint16_t max_names, + uint16_t pattern_len, + const char *pattern); int -xcb_list_fonts_names_length (const xcb_list_fonts_reply_t *R /**< */); +xcb_list_fonts_names_length (const xcb_list_fonts_reply_t *R); xcb_str_iterator_t -xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R /**< */); +xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R); /** * Return the reply @@ -8439,12 +8908,12 @@ xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_list_fonts_reply_t * -xcb_list_fonts_reply (xcb_connection_t *c /**< */, +xcb_list_fonts_reply (xcb_connection_t *c, xcb_list_fonts_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_list_fonts_with_info_sizeof (const void *_buffer /**< */); +xcb_list_fonts_with_info_sizeof (const void *_buffer); /** * @brief get matching font names and information @@ -8463,10 +8932,10 @@ xcb_list_fonts_with_info_sizeof (const void *_buffer /**< */); * */ xcb_list_fonts_with_info_cookie_t -xcb_list_fonts_with_info (xcb_connection_t *c /**< */, - uint16_t max_names /**< */, - uint16_t pattern_len /**< */, - const char *pattern /**< */); +xcb_list_fonts_with_info (xcb_connection_t *c, + uint16_t max_names, + uint16_t pattern_len, + const char *pattern); /** * @brief get matching font names and information @@ -8488,28 +8957,28 @@ xcb_list_fonts_with_info (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_list_fonts_with_info_cookie_t -xcb_list_fonts_with_info_unchecked (xcb_connection_t *c /**< */, - uint16_t max_names /**< */, - uint16_t pattern_len /**< */, - const char *pattern /**< */); +xcb_list_fonts_with_info_unchecked (xcb_connection_t *c, + uint16_t max_names, + uint16_t pattern_len, + const char *pattern); xcb_fontprop_t * -xcb_list_fonts_with_info_properties (const xcb_list_fonts_with_info_reply_t *R /**< */); +xcb_list_fonts_with_info_properties (const xcb_list_fonts_with_info_reply_t *R); int -xcb_list_fonts_with_info_properties_length (const xcb_list_fonts_with_info_reply_t *R /**< */); +xcb_list_fonts_with_info_properties_length (const xcb_list_fonts_with_info_reply_t *R); xcb_fontprop_iterator_t -xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_reply_t *R /**< */); +xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_reply_t *R); char * -xcb_list_fonts_with_info_name (const xcb_list_fonts_with_info_reply_t *R /**< */); +xcb_list_fonts_with_info_name (const xcb_list_fonts_with_info_reply_t *R); int -xcb_list_fonts_with_info_name_length (const xcb_list_fonts_with_info_reply_t *R /**< */); +xcb_list_fonts_with_info_name_length (const xcb_list_fonts_with_info_reply_t *R); xcb_generic_iterator_t -xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R /**< */); +xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R); /** * Return the reply @@ -8526,12 +8995,12 @@ xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R /* * The returned value must be freed by the caller using free(). */ xcb_list_fonts_with_info_reply_t * -xcb_list_fonts_with_info_reply (xcb_connection_t *c /**< */, +xcb_list_fonts_with_info_reply (xcb_connection_t *c, xcb_list_fonts_with_info_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_set_font_path_sizeof (const void *_buffer /**< */); +xcb_set_font_path_sizeof (const void *_buffer); /** * @@ -8545,9 +9014,9 @@ xcb_set_font_path_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_set_font_path_checked (xcb_connection_t *c /**< */, - uint16_t font_qty /**< */, - const xcb_str_t *font /**< */); +xcb_set_font_path_checked (xcb_connection_t *c, + uint16_t font_qty, + const xcb_str_t *font); /** * @@ -8558,12 +9027,18 @@ xcb_set_font_path_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_set_font_path (xcb_connection_t *c /**< */, - uint16_t font_qty /**< */, - const xcb_str_t *font /**< */); +xcb_set_font_path (xcb_connection_t *c, + uint16_t font_qty, + const xcb_str_t *font); int -xcb_get_font_path_sizeof (const void *_buffer /**< */); +xcb_set_font_path_font_length (const xcb_set_font_path_request_t *R); + +xcb_str_iterator_t +xcb_set_font_path_font_iterator (const xcb_set_font_path_request_t *R); + +int +xcb_get_font_path_sizeof (const void *_buffer); /** * @@ -8574,7 +9049,7 @@ xcb_get_font_path_sizeof (const void *_buffer /**< */); * */ xcb_get_font_path_cookie_t -xcb_get_font_path (xcb_connection_t *c /**< */); +xcb_get_font_path (xcb_connection_t *c); /** * @@ -8588,13 +9063,13 @@ xcb_get_font_path (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_get_font_path_cookie_t -xcb_get_font_path_unchecked (xcb_connection_t *c /**< */); +xcb_get_font_path_unchecked (xcb_connection_t *c); int -xcb_get_font_path_path_length (const xcb_get_font_path_reply_t *R /**< */); +xcb_get_font_path_path_length (const xcb_get_font_path_reply_t *R); xcb_str_iterator_t -xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R /**< */); +xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R); /** * Return the reply @@ -8611,9 +9086,9 @@ xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_get_font_path_reply_t * -xcb_get_font_path_reply (xcb_connection_t *c /**< */, +xcb_get_font_path_reply (xcb_connection_t *c, xcb_get_font_path_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @brief Creates a pixmap @@ -8635,12 +9110,12 @@ xcb_get_font_path_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_create_pixmap_checked (xcb_connection_t *c /**< */, - uint8_t depth /**< */, - xcb_pixmap_t pid /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_create_pixmap_checked (xcb_connection_t *c, + uint8_t depth, + xcb_pixmap_t pid, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height); /** * @brief Creates a pixmap @@ -8659,12 +9134,12 @@ xcb_create_pixmap_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_create_pixmap (xcb_connection_t *c /**< */, - uint8_t depth /**< */, - xcb_pixmap_t pid /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_create_pixmap (xcb_connection_t *c, + uint8_t depth, + xcb_pixmap_t pid, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height); /** * @brief Destroys a pixmap @@ -8681,8 +9156,8 @@ xcb_create_pixmap (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_free_pixmap_checked (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */); +xcb_free_pixmap_checked (xcb_connection_t *c, + xcb_pixmap_t pixmap); /** * @brief Destroys a pixmap @@ -8696,11 +9171,25 @@ xcb_free_pixmap_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_free_pixmap (xcb_connection_t *c /**< */, - xcb_pixmap_t pixmap /**< */); +xcb_free_pixmap (xcb_connection_t *c, + xcb_pixmap_t pixmap); int -xcb_create_gc_sizeof (const void *_buffer /**< */); +xcb_create_gc_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_create_gc_value_list_t *_aux); + +int +xcb_create_gc_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_create_gc_value_list_t *_aux); + +int +xcb_create_gc_value_list_sizeof (const void *_buffer, + uint32_t value_mask); + +int +xcb_create_gc_sizeof (const void *_buffer); /** * @brief Creates a graphics context @@ -8719,11 +9208,11 @@ xcb_create_gc_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_create_gc_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t cid /**< */, - xcb_drawable_t drawable /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_create_gc_checked (xcb_connection_t *c, + xcb_gcontext_t cid, + xcb_drawable_t drawable, + uint32_t value_mask, + const void *value_list); /** * @brief Creates a graphics context @@ -8739,14 +9228,74 @@ xcb_create_gc_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_create_gc (xcb_connection_t *c /**< */, - xcb_gcontext_t cid /**< */, - xcb_drawable_t drawable /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_create_gc (xcb_connection_t *c, + xcb_gcontext_t cid, + xcb_drawable_t drawable, + uint32_t value_mask, + const void *value_list); + +/** + * @brief Creates a graphics context + * + * @param c The connection + * @param cid The ID with which you will refer to the graphics context, created by + * `xcb_generate_id`. + * @param drawable Drawable to get the root/depth from. + * @return A cookie + * + * Creates a graphics context. The graphics context can be used with any drawable + * that has the same root and depth as the specified drawable. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_create_gc_aux_checked (xcb_connection_t *c, + xcb_gcontext_t cid, + xcb_drawable_t drawable, + uint32_t value_mask, + const xcb_create_gc_value_list_t *value_list); + +/** + * @brief Creates a graphics context + * + * @param c The connection + * @param cid The ID with which you will refer to the graphics context, created by + * `xcb_generate_id`. + * @param drawable Drawable to get the root/depth from. + * @return A cookie + * + * Creates a graphics context. The graphics context can be used with any drawable + * that has the same root and depth as the specified drawable. + * + */ +xcb_void_cookie_t +xcb_create_gc_aux (xcb_connection_t *c, + xcb_gcontext_t cid, + xcb_drawable_t drawable, + uint32_t value_mask, + const xcb_create_gc_value_list_t *value_list); + +void * +xcb_create_gc_value_list (const xcb_create_gc_request_t *R); int -xcb_change_gc_sizeof (const void *_buffer /**< */); +xcb_change_gc_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_change_gc_value_list_t *_aux); + +int +xcb_change_gc_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_change_gc_value_list_t *_aux); + +int +xcb_change_gc_value_list_sizeof (const void *_buffer, + uint32_t value_mask); + +int +xcb_change_gc_sizeof (const void *_buffer); /** * @brief change graphics context components @@ -8767,10 +9316,10 @@ xcb_change_gc_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_change_gc_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_change_gc_checked (xcb_connection_t *c, + xcb_gcontext_t gc, + uint32_t value_mask, + const void *value_list); /** * @brief change graphics context components @@ -8788,10 +9337,58 @@ xcb_change_gc_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_change_gc (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_change_gc (xcb_connection_t *c, + xcb_gcontext_t gc, + uint32_t value_mask, + const void *value_list); + +/** + * @brief change graphics context components + * + * @param c The connection + * @param gc The graphics context to change. + * @param value_mask A bitmask of #xcb_gc_t values. + * @param value_mask \n + * @param value_list Values for each of the components specified in the bitmask \a value_mask. The + * order has to correspond to the order of possible \a value_mask bits. See the + * example. + * @return A cookie + * + * Changes the components specified by \a value_mask for the specified graphics context. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_change_gc_aux_checked (xcb_connection_t *c, + xcb_gcontext_t gc, + uint32_t value_mask, + const xcb_change_gc_value_list_t *value_list); + +/** + * @brief change graphics context components + * + * @param c The connection + * @param gc The graphics context to change. + * @param value_mask A bitmask of #xcb_gc_t values. + * @param value_mask \n + * @param value_list Values for each of the components specified in the bitmask \a value_mask. The + * order has to correspond to the order of possible \a value_mask bits. See the + * example. + * @return A cookie + * + * Changes the components specified by \a value_mask for the specified graphics context. + * + */ +xcb_void_cookie_t +xcb_change_gc_aux (xcb_connection_t *c, + xcb_gcontext_t gc, + uint32_t value_mask, + const xcb_change_gc_value_list_t *value_list); + +void * +xcb_change_gc_value_list (const xcb_change_gc_request_t *R); /** * @@ -8805,10 +9402,10 @@ xcb_change_gc (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_copy_gc_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t src_gc /**< */, - xcb_gcontext_t dst_gc /**< */, - uint32_t value_mask /**< */); +xcb_copy_gc_checked (xcb_connection_t *c, + xcb_gcontext_t src_gc, + xcb_gcontext_t dst_gc, + uint32_t value_mask); /** * @@ -8819,13 +9416,13 @@ xcb_copy_gc_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_copy_gc (xcb_connection_t *c /**< */, - xcb_gcontext_t src_gc /**< */, - xcb_gcontext_t dst_gc /**< */, - uint32_t value_mask /**< */); +xcb_copy_gc (xcb_connection_t *c, + xcb_gcontext_t src_gc, + xcb_gcontext_t dst_gc, + uint32_t value_mask); int -xcb_set_dashes_sizeof (const void *_buffer /**< */); +xcb_set_dashes_sizeof (const void *_buffer); /** * @@ -8839,11 +9436,11 @@ xcb_set_dashes_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_set_dashes_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - uint16_t dash_offset /**< */, - uint16_t dashes_len /**< */, - const uint8_t *dashes /**< */); +xcb_set_dashes_checked (xcb_connection_t *c, + xcb_gcontext_t gc, + uint16_t dash_offset, + uint16_t dashes_len, + const uint8_t *dashes); /** * @@ -8854,15 +9451,24 @@ xcb_set_dashes_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_set_dashes (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */, - uint16_t dash_offset /**< */, - uint16_t dashes_len /**< */, - const uint8_t *dashes /**< */); +xcb_set_dashes (xcb_connection_t *c, + xcb_gcontext_t gc, + uint16_t dash_offset, + uint16_t dashes_len, + const uint8_t *dashes); + +uint8_t * +xcb_set_dashes_dashes (const xcb_set_dashes_request_t *R); int -xcb_set_clip_rectangles_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */); +xcb_set_dashes_dashes_length (const xcb_set_dashes_request_t *R); + +xcb_generic_iterator_t +xcb_set_dashes_dashes_end (const xcb_set_dashes_request_t *R); + +int +xcb_set_clip_rectangles_sizeof (const void *_buffer, + uint32_t rectangles_len); /** * @@ -8876,13 +9482,13 @@ xcb_set_clip_rectangles_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_set_clip_rectangles_checked (xcb_connection_t *c /**< */, - uint8_t ordering /**< */, - xcb_gcontext_t gc /**< */, - int16_t clip_x_origin /**< */, - int16_t clip_y_origin /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_set_clip_rectangles_checked (xcb_connection_t *c, + uint8_t ordering, + xcb_gcontext_t gc, + int16_t clip_x_origin, + int16_t clip_y_origin, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); /** * @@ -8893,13 +9499,22 @@ xcb_set_clip_rectangles_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_set_clip_rectangles (xcb_connection_t *c /**< */, - uint8_t ordering /**< */, - xcb_gcontext_t gc /**< */, - int16_t clip_x_origin /**< */, - int16_t clip_y_origin /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_set_clip_rectangles (xcb_connection_t *c, + uint8_t ordering, + xcb_gcontext_t gc, + int16_t clip_x_origin, + int16_t clip_y_origin, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); + +xcb_rectangle_t * +xcb_set_clip_rectangles_rectangles (const xcb_set_clip_rectangles_request_t *R); + +int +xcb_set_clip_rectangles_rectangles_length (const xcb_set_clip_rectangles_request_t *R); + +xcb_rectangle_iterator_t +xcb_set_clip_rectangles_rectangles_iterator (const xcb_set_clip_rectangles_request_t *R); /** * @brief Destroys a graphics context @@ -8915,8 +9530,8 @@ xcb_set_clip_rectangles (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_free_gc_checked (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */); +xcb_free_gc_checked (xcb_connection_t *c, + xcb_gcontext_t gc); /** * @brief Destroys a graphics context @@ -8929,8 +9544,8 @@ xcb_free_gc_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_free_gc (xcb_connection_t *c /**< */, - xcb_gcontext_t gc /**< */); +xcb_free_gc (xcb_connection_t *c, + xcb_gcontext_t gc); /** * @@ -8944,13 +9559,13 @@ xcb_free_gc (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_clear_area_checked (xcb_connection_t *c /**< */, - uint8_t exposures /**< */, - xcb_window_t window /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_clear_area_checked (xcb_connection_t *c, + uint8_t exposures, + xcb_window_t window, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height); /** * @@ -8961,13 +9576,13 @@ xcb_clear_area_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_clear_area (xcb_connection_t *c /**< */, - uint8_t exposures /**< */, - xcb_window_t window /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_clear_area (xcb_connection_t *c, + uint8_t exposures, + xcb_window_t window, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height); /** * @brief copy areas @@ -8991,16 +9606,16 @@ xcb_clear_area (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_copy_area_checked (xcb_connection_t *c /**< */, - xcb_drawable_t src_drawable /**< */, - xcb_drawable_t dst_drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_copy_area_checked (xcb_connection_t *c, + xcb_drawable_t src_drawable, + xcb_drawable_t dst_drawable, + xcb_gcontext_t gc, + int16_t src_x, + int16_t src_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height); /** * @brief copy areas @@ -9021,16 +9636,16 @@ xcb_copy_area_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_copy_area (xcb_connection_t *c /**< */, - xcb_drawable_t src_drawable /**< */, - xcb_drawable_t dst_drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_copy_area (xcb_connection_t *c, + xcb_drawable_t src_drawable, + xcb_drawable_t dst_drawable, + xcb_gcontext_t gc, + int16_t src_x, + int16_t src_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height); /** * @@ -9044,17 +9659,17 @@ xcb_copy_area (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_copy_plane_checked (xcb_connection_t *c /**< */, - xcb_drawable_t src_drawable /**< */, - xcb_drawable_t dst_drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t bit_plane /**< */); +xcb_copy_plane_checked (xcb_connection_t *c, + xcb_drawable_t src_drawable, + xcb_drawable_t dst_drawable, + xcb_gcontext_t gc, + int16_t src_x, + int16_t src_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height, + uint32_t bit_plane); /** * @@ -9065,21 +9680,21 @@ xcb_copy_plane_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_copy_plane (xcb_connection_t *c /**< */, - xcb_drawable_t src_drawable /**< */, - xcb_drawable_t dst_drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t bit_plane /**< */); +xcb_copy_plane (xcb_connection_t *c, + xcb_drawable_t src_drawable, + xcb_drawable_t dst_drawable, + xcb_gcontext_t gc, + int16_t src_x, + int16_t src_y, + int16_t dst_x, + int16_t dst_y, + uint16_t width, + uint16_t height, + uint32_t bit_plane); int -xcb_poly_point_sizeof (const void *_buffer /**< */, - uint32_t points_len /**< */); +xcb_poly_point_sizeof (const void *_buffer, + uint32_t points_len); /** * @@ -9093,12 +9708,12 @@ xcb_poly_point_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_poly_point_checked (xcb_connection_t *c /**< */, - uint8_t coordinate_mode /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */); +xcb_poly_point_checked (xcb_connection_t *c, + uint8_t coordinate_mode, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t points_len, + const xcb_point_t *points); /** * @@ -9109,16 +9724,25 @@ xcb_poly_point_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_poly_point (xcb_connection_t *c /**< */, - uint8_t coordinate_mode /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */); +xcb_poly_point (xcb_connection_t *c, + uint8_t coordinate_mode, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t points_len, + const xcb_point_t *points); + +xcb_point_t * +xcb_poly_point_points (const xcb_poly_point_request_t *R); int -xcb_poly_line_sizeof (const void *_buffer /**< */, - uint32_t points_len /**< */); +xcb_poly_point_points_length (const xcb_poly_point_request_t *R); + +xcb_point_iterator_t +xcb_poly_point_points_iterator (const xcb_poly_point_request_t *R); + +int +xcb_poly_line_sizeof (const void *_buffer, + uint32_t points_len); /** * @brief draw lines @@ -9146,12 +9770,12 @@ xcb_poly_line_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_poly_line_checked (xcb_connection_t *c /**< */, - uint8_t coordinate_mode /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */); +xcb_poly_line_checked (xcb_connection_t *c, + uint8_t coordinate_mode, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t points_len, + const xcb_point_t *points); /** * @brief draw lines @@ -9176,12 +9800,21 @@ xcb_poly_line_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_poly_line (xcb_connection_t *c /**< */, - uint8_t coordinate_mode /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */); +xcb_poly_line (xcb_connection_t *c, + uint8_t coordinate_mode, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t points_len, + const xcb_point_t *points); + +xcb_point_t * +xcb_poly_line_points (const xcb_poly_line_request_t *R); + +int +xcb_poly_line_points_length (const xcb_poly_line_request_t *R); + +xcb_point_iterator_t +xcb_poly_line_points_iterator (const xcb_poly_line_request_t *R); /** * Get the next element of the iterator @@ -9192,7 +9825,7 @@ xcb_poly_line (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_segment_t) */ void -xcb_segment_next (xcb_segment_iterator_t *i /**< */); +xcb_segment_next (xcb_segment_iterator_t *i); /** * Return the iterator pointing to the last element @@ -9204,11 +9837,11 @@ xcb_segment_next (xcb_segment_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_segment_end (xcb_segment_iterator_t i /**< */); +xcb_segment_end (xcb_segment_iterator_t i); int -xcb_poly_segment_sizeof (const void *_buffer /**< */, - uint32_t segments_len /**< */); +xcb_poly_segment_sizeof (const void *_buffer, + uint32_t segments_len); /** * @brief draw lines @@ -9237,11 +9870,11 @@ xcb_poly_segment_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_poly_segment_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t segments_len /**< */, - const xcb_segment_t *segments /**< */); +xcb_poly_segment_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t segments_len, + const xcb_segment_t *segments); /** * @brief draw lines @@ -9267,15 +9900,24 @@ xcb_poly_segment_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_poly_segment (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t segments_len /**< */, - const xcb_segment_t *segments /**< */); +xcb_poly_segment (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t segments_len, + const xcb_segment_t *segments); + +xcb_segment_t * +xcb_poly_segment_segments (const xcb_poly_segment_request_t *R); int -xcb_poly_rectangle_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */); +xcb_poly_segment_segments_length (const xcb_poly_segment_request_t *R); + +xcb_segment_iterator_t +xcb_poly_segment_segments_iterator (const xcb_poly_segment_request_t *R); + +int +xcb_poly_rectangle_sizeof (const void *_buffer, + uint32_t rectangles_len); /** * @@ -9289,11 +9931,11 @@ xcb_poly_rectangle_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_poly_rectangle_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_poly_rectangle_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); /** * @@ -9304,15 +9946,24 @@ xcb_poly_rectangle_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_poly_rectangle (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_poly_rectangle (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); + +xcb_rectangle_t * +xcb_poly_rectangle_rectangles (const xcb_poly_rectangle_request_t *R); int -xcb_poly_arc_sizeof (const void *_buffer /**< */, - uint32_t arcs_len /**< */); +xcb_poly_rectangle_rectangles_length (const xcb_poly_rectangle_request_t *R); + +xcb_rectangle_iterator_t +xcb_poly_rectangle_rectangles_iterator (const xcb_poly_rectangle_request_t *R); + +int +xcb_poly_arc_sizeof (const void *_buffer, + uint32_t arcs_len); /** * @@ -9326,11 +9977,11 @@ xcb_poly_arc_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_poly_arc_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t arcs_len /**< */, - const xcb_arc_t *arcs /**< */); +xcb_poly_arc_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t arcs_len, + const xcb_arc_t *arcs); /** * @@ -9341,15 +9992,24 @@ xcb_poly_arc_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_poly_arc (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t arcs_len /**< */, - const xcb_arc_t *arcs /**< */); +xcb_poly_arc (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t arcs_len, + const xcb_arc_t *arcs); + +xcb_arc_t * +xcb_poly_arc_arcs (const xcb_poly_arc_request_t *R); int -xcb_fill_poly_sizeof (const void *_buffer /**< */, - uint32_t points_len /**< */); +xcb_poly_arc_arcs_length (const xcb_poly_arc_request_t *R); + +xcb_arc_iterator_t +xcb_poly_arc_arcs_iterator (const xcb_poly_arc_request_t *R); + +int +xcb_fill_poly_sizeof (const void *_buffer, + uint32_t points_len); /** * @@ -9363,13 +10023,13 @@ xcb_fill_poly_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_fill_poly_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint8_t shape /**< */, - uint8_t coordinate_mode /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */); +xcb_fill_poly_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint8_t shape, + uint8_t coordinate_mode, + uint32_t points_len, + const xcb_point_t *points); /** * @@ -9380,17 +10040,26 @@ xcb_fill_poly_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_fill_poly (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint8_t shape /**< */, - uint8_t coordinate_mode /**< */, - uint32_t points_len /**< */, - const xcb_point_t *points /**< */); +xcb_fill_poly (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint8_t shape, + uint8_t coordinate_mode, + uint32_t points_len, + const xcb_point_t *points); + +xcb_point_t * +xcb_fill_poly_points (const xcb_fill_poly_request_t *R); int -xcb_poly_fill_rectangle_sizeof (const void *_buffer /**< */, - uint32_t rectangles_len /**< */); +xcb_fill_poly_points_length (const xcb_fill_poly_request_t *R); + +xcb_point_iterator_t +xcb_fill_poly_points_iterator (const xcb_fill_poly_request_t *R); + +int +xcb_poly_fill_rectangle_sizeof (const void *_buffer, + uint32_t rectangles_len); /** * @brief Fills rectangles @@ -9418,11 +10087,11 @@ xcb_poly_fill_rectangle_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_poly_fill_rectangle_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_poly_fill_rectangle_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); /** * @brief Fills rectangles @@ -9447,15 +10116,24 @@ xcb_poly_fill_rectangle_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_poly_fill_rectangle (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t rectangles_len /**< */, - const xcb_rectangle_t *rectangles /**< */); +xcb_poly_fill_rectangle (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles); + +xcb_rectangle_t * +xcb_poly_fill_rectangle_rectangles (const xcb_poly_fill_rectangle_request_t *R); int -xcb_poly_fill_arc_sizeof (const void *_buffer /**< */, - uint32_t arcs_len /**< */); +xcb_poly_fill_rectangle_rectangles_length (const xcb_poly_fill_rectangle_request_t *R); + +xcb_rectangle_iterator_t +xcb_poly_fill_rectangle_rectangles_iterator (const xcb_poly_fill_rectangle_request_t *R); + +int +xcb_poly_fill_arc_sizeof (const void *_buffer, + uint32_t arcs_len); /** * @@ -9469,11 +10147,11 @@ xcb_poly_fill_arc_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_poly_fill_arc_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t arcs_len /**< */, - const xcb_arc_t *arcs /**< */); +xcb_poly_fill_arc_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t arcs_len, + const xcb_arc_t *arcs); /** * @@ -9484,15 +10162,24 @@ xcb_poly_fill_arc_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_poly_fill_arc (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t arcs_len /**< */, - const xcb_arc_t *arcs /**< */); +xcb_poly_fill_arc (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t arcs_len, + const xcb_arc_t *arcs); + +xcb_arc_t * +xcb_poly_fill_arc_arcs (const xcb_poly_fill_arc_request_t *R); int -xcb_put_image_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */); +xcb_poly_fill_arc_arcs_length (const xcb_poly_fill_arc_request_t *R); + +xcb_arc_iterator_t +xcb_poly_fill_arc_arcs_iterator (const xcb_poly_fill_arc_request_t *R); + +int +xcb_put_image_sizeof (const void *_buffer, + uint32_t data_len); /** * @@ -9506,18 +10193,18 @@ xcb_put_image_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_put_image_checked (xcb_connection_t *c /**< */, - uint8_t format /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint8_t left_pad /**< */, - uint8_t depth /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_put_image_checked (xcb_connection_t *c, + uint8_t format, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint16_t width, + uint16_t height, + int16_t dst_x, + int16_t dst_y, + uint8_t left_pad, + uint8_t depth, + uint32_t data_len, + const uint8_t *data); /** * @@ -9528,21 +10215,30 @@ xcb_put_image_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_put_image (xcb_connection_t *c /**< */, - uint8_t format /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - int16_t dst_x /**< */, - int16_t dst_y /**< */, - uint8_t left_pad /**< */, - uint8_t depth /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_put_image (xcb_connection_t *c, + uint8_t format, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint16_t width, + uint16_t height, + int16_t dst_x, + int16_t dst_y, + uint8_t left_pad, + uint8_t depth, + uint32_t data_len, + const uint8_t *data); + +uint8_t * +xcb_put_image_data (const xcb_put_image_request_t *R); int -xcb_get_image_sizeof (const void *_buffer /**< */); +xcb_put_image_data_length (const xcb_put_image_request_t *R); + +xcb_generic_iterator_t +xcb_put_image_data_end (const xcb_put_image_request_t *R); + +int +xcb_get_image_sizeof (const void *_buffer); /** * @@ -9553,14 +10249,14 @@ xcb_get_image_sizeof (const void *_buffer /**< */); * */ xcb_get_image_cookie_t -xcb_get_image (xcb_connection_t *c /**< */, - uint8_t format /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t plane_mask /**< */); +xcb_get_image (xcb_connection_t *c, + uint8_t format, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint32_t plane_mask); /** * @@ -9574,23 +10270,23 @@ xcb_get_image (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_get_image_cookie_t -xcb_get_image_unchecked (xcb_connection_t *c /**< */, - uint8_t format /**< */, - xcb_drawable_t drawable /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t plane_mask /**< */); +xcb_get_image_unchecked (xcb_connection_t *c, + uint8_t format, + xcb_drawable_t drawable, + int16_t x, + int16_t y, + uint16_t width, + uint16_t height, + uint32_t plane_mask); uint8_t * -xcb_get_image_data (const xcb_get_image_reply_t *R /**< */); +xcb_get_image_data (const xcb_get_image_reply_t *R); int -xcb_get_image_data_length (const xcb_get_image_reply_t *R /**< */); +xcb_get_image_data_length (const xcb_get_image_reply_t *R); xcb_generic_iterator_t -xcb_get_image_data_end (const xcb_get_image_reply_t *R /**< */); +xcb_get_image_data_end (const xcb_get_image_reply_t *R); /** * Return the reply @@ -9607,13 +10303,13 @@ xcb_get_image_data_end (const xcb_get_image_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_get_image_reply_t * -xcb_get_image_reply (xcb_connection_t *c /**< */, +xcb_get_image_reply (xcb_connection_t *c, xcb_get_image_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_poly_text_8_sizeof (const void *_buffer /**< */, - uint32_t items_len /**< */); +xcb_poly_text_8_sizeof (const void *_buffer, + uint32_t items_len); /** * @@ -9627,13 +10323,13 @@ xcb_poly_text_8_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_poly_text_8_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint32_t items_len /**< */, - const uint8_t *items /**< */); +xcb_poly_text_8_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + uint32_t items_len, + const uint8_t *items); /** * @@ -9644,17 +10340,26 @@ xcb_poly_text_8_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_poly_text_8 (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint32_t items_len /**< */, - const uint8_t *items /**< */); +xcb_poly_text_8 (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + uint32_t items_len, + const uint8_t *items); + +uint8_t * +xcb_poly_text_8_items (const xcb_poly_text_8_request_t *R); int -xcb_poly_text_16_sizeof (const void *_buffer /**< */, - uint32_t items_len /**< */); +xcb_poly_text_8_items_length (const xcb_poly_text_8_request_t *R); + +xcb_generic_iterator_t +xcb_poly_text_8_items_end (const xcb_poly_text_8_request_t *R); + +int +xcb_poly_text_16_sizeof (const void *_buffer, + uint32_t items_len); /** * @@ -9668,13 +10373,13 @@ xcb_poly_text_16_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_poly_text_16_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint32_t items_len /**< */, - const uint8_t *items /**< */); +xcb_poly_text_16_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + uint32_t items_len, + const uint8_t *items); /** * @@ -9685,16 +10390,25 @@ xcb_poly_text_16_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_poly_text_16 (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - uint32_t items_len /**< */, - const uint8_t *items /**< */); +xcb_poly_text_16 (xcb_connection_t *c, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + uint32_t items_len, + const uint8_t *items); + +uint8_t * +xcb_poly_text_16_items (const xcb_poly_text_16_request_t *R); int -xcb_image_text_8_sizeof (const void *_buffer /**< */); +xcb_poly_text_16_items_length (const xcb_poly_text_16_request_t *R); + +xcb_generic_iterator_t +xcb_poly_text_16_items_end (const xcb_poly_text_16_request_t *R); + +int +xcb_image_text_8_sizeof (const void *_buffer); /** * @brief Draws text @@ -9727,13 +10441,13 @@ xcb_image_text_8_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_image_text_8_checked (xcb_connection_t *c /**< */, - uint8_t string_len /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - const char *string /**< */); +xcb_image_text_8_checked (xcb_connection_t *c, + uint8_t string_len, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + const char *string); /** * @brief Draws text @@ -9763,16 +10477,25 @@ xcb_image_text_8_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_image_text_8 (xcb_connection_t *c /**< */, - uint8_t string_len /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - const char *string /**< */); +xcb_image_text_8 (xcb_connection_t *c, + uint8_t string_len, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + const char *string); + +char * +xcb_image_text_8_string (const xcb_image_text_8_request_t *R); int -xcb_image_text_16_sizeof (const void *_buffer /**< */); +xcb_image_text_8_string_length (const xcb_image_text_8_request_t *R); + +xcb_generic_iterator_t +xcb_image_text_8_string_end (const xcb_image_text_8_request_t *R); + +int +xcb_image_text_16_sizeof (const void *_buffer); /** * @brief Draws text @@ -9806,13 +10529,13 @@ xcb_image_text_16_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_image_text_16_checked (xcb_connection_t *c /**< */, - uint8_t string_len /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - const xcb_char2b_t *string /**< */); +xcb_image_text_16_checked (xcb_connection_t *c, + uint8_t string_len, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + const xcb_char2b_t *string); /** * @brief Draws text @@ -9843,159 +10566,168 @@ xcb_image_text_16_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_image_text_16 (xcb_connection_t *c /**< */, - uint8_t string_len /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t x /**< */, - int16_t y /**< */, - const xcb_char2b_t *string /**< */); +xcb_image_text_16 (xcb_connection_t *c, + uint8_t string_len, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t x, + int16_t y, + const xcb_char2b_t *string); -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_create_colormap_checked (xcb_connection_t *c /**< */, - uint8_t alloc /**< */, - xcb_colormap_t mid /**< */, - xcb_window_t window /**< */, - xcb_visualid_t visual /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_create_colormap (xcb_connection_t *c /**< */, - uint8_t alloc /**< */, - xcb_colormap_t mid /**< */, - xcb_window_t window /**< */, - xcb_visualid_t visual /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_free_colormap_checked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_free_colormap (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_copy_colormap_and_free_checked (xcb_connection_t *c /**< */, - xcb_colormap_t mid /**< */, - xcb_colormap_t src_cmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_copy_colormap_and_free (xcb_connection_t *c /**< */, - xcb_colormap_t mid /**< */, - xcb_colormap_t src_cmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_install_colormap_checked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_install_colormap (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - * This form can be used only if the request will not cause - * a reply to be generated. Any returned error will be - * saved for handling by xcb_request_check(). - */ -xcb_void_cookie_t -xcb_uninstall_colormap_checked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */); - -/** - * - * @param c The connection - * @return A cookie - * - * Delivers a request to the X server. - * - */ -xcb_void_cookie_t -xcb_uninstall_colormap (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */); +xcb_char2b_t * +xcb_image_text_16_string (const xcb_image_text_16_request_t *R); int -xcb_list_installed_colormaps_sizeof (const void *_buffer /**< */); +xcb_image_text_16_string_length (const xcb_image_text_16_request_t *R); + +xcb_char2b_iterator_t +xcb_image_text_16_string_iterator (const xcb_image_text_16_request_t *R); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_create_colormap_checked (xcb_connection_t *c, + uint8_t alloc, + xcb_colormap_t mid, + xcb_window_t window, + xcb_visualid_t visual); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_create_colormap (xcb_connection_t *c, + uint8_t alloc, + xcb_colormap_t mid, + xcb_window_t window, + xcb_visualid_t visual); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_free_colormap_checked (xcb_connection_t *c, + xcb_colormap_t cmap); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_free_colormap (xcb_connection_t *c, + xcb_colormap_t cmap); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_copy_colormap_and_free_checked (xcb_connection_t *c, + xcb_colormap_t mid, + xcb_colormap_t src_cmap); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_copy_colormap_and_free (xcb_connection_t *c, + xcb_colormap_t mid, + xcb_colormap_t src_cmap); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_install_colormap_checked (xcb_connection_t *c, + xcb_colormap_t cmap); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_install_colormap (xcb_connection_t *c, + xcb_colormap_t cmap); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_uninstall_colormap_checked (xcb_connection_t *c, + xcb_colormap_t cmap); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_uninstall_colormap (xcb_connection_t *c, + xcb_colormap_t cmap); + +int +xcb_list_installed_colormaps_sizeof (const void *_buffer); /** * @@ -10006,8 +10738,8 @@ xcb_list_installed_colormaps_sizeof (const void *_buffer /**< */); * */ xcb_list_installed_colormaps_cookie_t -xcb_list_installed_colormaps (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_list_installed_colormaps (xcb_connection_t *c, + xcb_window_t window); /** * @@ -10021,17 +10753,17 @@ xcb_list_installed_colormaps (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_list_installed_colormaps_cookie_t -xcb_list_installed_colormaps_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_list_installed_colormaps_unchecked (xcb_connection_t *c, + xcb_window_t window); xcb_colormap_t * -xcb_list_installed_colormaps_cmaps (const xcb_list_installed_colormaps_reply_t *R /**< */); +xcb_list_installed_colormaps_cmaps (const xcb_list_installed_colormaps_reply_t *R); int -xcb_list_installed_colormaps_cmaps_length (const xcb_list_installed_colormaps_reply_t *R /**< */); +xcb_list_installed_colormaps_cmaps_length (const xcb_list_installed_colormaps_reply_t *R); xcb_generic_iterator_t -xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply_t *R /**< */); +xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply_t *R); /** * Return the reply @@ -10048,9 +10780,9 @@ xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply * The returned value must be freed by the caller using free(). */ xcb_list_installed_colormaps_reply_t * -xcb_list_installed_colormaps_reply (xcb_connection_t *c /**< */, +xcb_list_installed_colormaps_reply (xcb_connection_t *c, xcb_list_installed_colormaps_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @brief Allocate a color @@ -10070,11 +10802,11 @@ xcb_list_installed_colormaps_reply (xcb_connection_t *c / * */ xcb_alloc_color_cookie_t -xcb_alloc_color (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t red /**< */, - uint16_t green /**< */, - uint16_t blue /**< */); +xcb_alloc_color (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t red, + uint16_t green, + uint16_t blue); /** * @brief Allocate a color @@ -10097,11 +10829,11 @@ xcb_alloc_color (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_alloc_color_cookie_t -xcb_alloc_color_unchecked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t red /**< */, - uint16_t green /**< */, - uint16_t blue /**< */); +xcb_alloc_color_unchecked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t red, + uint16_t green, + uint16_t blue); /** * Return the reply @@ -10118,12 +10850,12 @@ xcb_alloc_color_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_alloc_color_reply_t * -xcb_alloc_color_reply (xcb_connection_t *c /**< */, +xcb_alloc_color_reply (xcb_connection_t *c, xcb_alloc_color_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_alloc_named_color_sizeof (const void *_buffer /**< */); +xcb_alloc_named_color_sizeof (const void *_buffer); /** * @@ -10134,10 +10866,10 @@ xcb_alloc_named_color_sizeof (const void *_buffer /**< */); * */ xcb_alloc_named_color_cookie_t -xcb_alloc_named_color (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_alloc_named_color (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t name_len, + const char *name); /** * @@ -10151,10 +10883,10 @@ xcb_alloc_named_color (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_alloc_named_color_cookie_t -xcb_alloc_named_color_unchecked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_alloc_named_color_unchecked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t name_len, + const char *name); /** * Return the reply @@ -10171,12 +10903,12 @@ xcb_alloc_named_color_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_alloc_named_color_reply_t * -xcb_alloc_named_color_reply (xcb_connection_t *c /**< */, +xcb_alloc_named_color_reply (xcb_connection_t *c, xcb_alloc_named_color_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_alloc_color_cells_sizeof (const void *_buffer /**< */); +xcb_alloc_color_cells_sizeof (const void *_buffer); /** * @@ -10187,11 +10919,11 @@ xcb_alloc_color_cells_sizeof (const void *_buffer /**< */); * */ xcb_alloc_color_cells_cookie_t -xcb_alloc_color_cells (xcb_connection_t *c /**< */, - uint8_t contiguous /**< */, - xcb_colormap_t cmap /**< */, - uint16_t colors /**< */, - uint16_t planes /**< */); +xcb_alloc_color_cells (xcb_connection_t *c, + uint8_t contiguous, + xcb_colormap_t cmap, + uint16_t colors, + uint16_t planes); /** * @@ -10205,29 +10937,29 @@ xcb_alloc_color_cells (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_alloc_color_cells_cookie_t -xcb_alloc_color_cells_unchecked (xcb_connection_t *c /**< */, - uint8_t contiguous /**< */, - xcb_colormap_t cmap /**< */, - uint16_t colors /**< */, - uint16_t planes /**< */); +xcb_alloc_color_cells_unchecked (xcb_connection_t *c, + uint8_t contiguous, + xcb_colormap_t cmap, + uint16_t colors, + uint16_t planes); uint32_t * -xcb_alloc_color_cells_pixels (const xcb_alloc_color_cells_reply_t *R /**< */); +xcb_alloc_color_cells_pixels (const xcb_alloc_color_cells_reply_t *R); int -xcb_alloc_color_cells_pixels_length (const xcb_alloc_color_cells_reply_t *R /**< */); +xcb_alloc_color_cells_pixels_length (const xcb_alloc_color_cells_reply_t *R); xcb_generic_iterator_t -xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R /**< */); +xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R); uint32_t * -xcb_alloc_color_cells_masks (const xcb_alloc_color_cells_reply_t *R /**< */); +xcb_alloc_color_cells_masks (const xcb_alloc_color_cells_reply_t *R); int -xcb_alloc_color_cells_masks_length (const xcb_alloc_color_cells_reply_t *R /**< */); +xcb_alloc_color_cells_masks_length (const xcb_alloc_color_cells_reply_t *R); xcb_generic_iterator_t -xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R /**< */); +xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R); /** * Return the reply @@ -10244,12 +10976,12 @@ xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R /**< */ * The returned value must be freed by the caller using free(). */ xcb_alloc_color_cells_reply_t * -xcb_alloc_color_cells_reply (xcb_connection_t *c /**< */, +xcb_alloc_color_cells_reply (xcb_connection_t *c, xcb_alloc_color_cells_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_alloc_color_planes_sizeof (const void *_buffer /**< */); +xcb_alloc_color_planes_sizeof (const void *_buffer); /** * @@ -10260,13 +10992,13 @@ xcb_alloc_color_planes_sizeof (const void *_buffer /**< */); * */ xcb_alloc_color_planes_cookie_t -xcb_alloc_color_planes (xcb_connection_t *c /**< */, - uint8_t contiguous /**< */, - xcb_colormap_t cmap /**< */, - uint16_t colors /**< */, - uint16_t reds /**< */, - uint16_t greens /**< */, - uint16_t blues /**< */); +xcb_alloc_color_planes (xcb_connection_t *c, + uint8_t contiguous, + xcb_colormap_t cmap, + uint16_t colors, + uint16_t reds, + uint16_t greens, + uint16_t blues); /** * @@ -10280,22 +11012,22 @@ xcb_alloc_color_planes (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_alloc_color_planes_cookie_t -xcb_alloc_color_planes_unchecked (xcb_connection_t *c /**< */, - uint8_t contiguous /**< */, - xcb_colormap_t cmap /**< */, - uint16_t colors /**< */, - uint16_t reds /**< */, - uint16_t greens /**< */, - uint16_t blues /**< */); +xcb_alloc_color_planes_unchecked (xcb_connection_t *c, + uint8_t contiguous, + xcb_colormap_t cmap, + uint16_t colors, + uint16_t reds, + uint16_t greens, + uint16_t blues); uint32_t * -xcb_alloc_color_planes_pixels (const xcb_alloc_color_planes_reply_t *R /**< */); +xcb_alloc_color_planes_pixels (const xcb_alloc_color_planes_reply_t *R); int -xcb_alloc_color_planes_pixels_length (const xcb_alloc_color_planes_reply_t *R /**< */); +xcb_alloc_color_planes_pixels_length (const xcb_alloc_color_planes_reply_t *R); xcb_generic_iterator_t -xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R /**< */); +xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R); /** * Return the reply @@ -10312,13 +11044,13 @@ xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R /**< * The returned value must be freed by the caller using free(). */ xcb_alloc_color_planes_reply_t * -xcb_alloc_color_planes_reply (xcb_connection_t *c /**< */, +xcb_alloc_color_planes_reply (xcb_connection_t *c, xcb_alloc_color_planes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_free_colors_sizeof (const void *_buffer /**< */, - uint32_t pixels_len /**< */); +xcb_free_colors_sizeof (const void *_buffer, + uint32_t pixels_len); /** * @@ -10332,11 +11064,11 @@ xcb_free_colors_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_free_colors_checked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t plane_mask /**< */, - uint32_t pixels_len /**< */, - const uint32_t *pixels /**< */); +xcb_free_colors_checked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t plane_mask, + uint32_t pixels_len, + const uint32_t *pixels); /** * @@ -10347,11 +11079,20 @@ xcb_free_colors_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_free_colors (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t plane_mask /**< */, - uint32_t pixels_len /**< */, - const uint32_t *pixels /**< */); +xcb_free_colors (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t plane_mask, + uint32_t pixels_len, + const uint32_t *pixels); + +uint32_t * +xcb_free_colors_pixels (const xcb_free_colors_request_t *R); + +int +xcb_free_colors_pixels_length (const xcb_free_colors_request_t *R); + +xcb_generic_iterator_t +xcb_free_colors_pixels_end (const xcb_free_colors_request_t *R); /** * Get the next element of the iterator @@ -10362,7 +11103,7 @@ xcb_free_colors (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_coloritem_t) */ void -xcb_coloritem_next (xcb_coloritem_iterator_t *i /**< */); +xcb_coloritem_next (xcb_coloritem_iterator_t *i); /** * Return the iterator pointing to the last element @@ -10374,11 +11115,11 @@ xcb_coloritem_next (xcb_coloritem_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_coloritem_end (xcb_coloritem_iterator_t i /**< */); +xcb_coloritem_end (xcb_coloritem_iterator_t i); int -xcb_store_colors_sizeof (const void *_buffer /**< */, - uint32_t items_len /**< */); +xcb_store_colors_sizeof (const void *_buffer, + uint32_t items_len); /** * @@ -10392,10 +11133,10 @@ xcb_store_colors_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_store_colors_checked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t items_len /**< */, - const xcb_coloritem_t *items /**< */); +xcb_store_colors_checked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t items_len, + const xcb_coloritem_t *items); /** * @@ -10406,13 +11147,22 @@ xcb_store_colors_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_store_colors (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t items_len /**< */, - const xcb_coloritem_t *items /**< */); +xcb_store_colors (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t items_len, + const xcb_coloritem_t *items); + +xcb_coloritem_t * +xcb_store_colors_items (const xcb_store_colors_request_t *R); int -xcb_store_named_color_sizeof (const void *_buffer /**< */); +xcb_store_colors_items_length (const xcb_store_colors_request_t *R); + +xcb_coloritem_iterator_t +xcb_store_colors_items_iterator (const xcb_store_colors_request_t *R); + +int +xcb_store_named_color_sizeof (const void *_buffer); /** * @@ -10426,12 +11176,12 @@ xcb_store_named_color_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_store_named_color_checked (xcb_connection_t *c /**< */, - uint8_t flags /**< */, - xcb_colormap_t cmap /**< */, - uint32_t pixel /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_store_named_color_checked (xcb_connection_t *c, + uint8_t flags, + xcb_colormap_t cmap, + uint32_t pixel, + uint16_t name_len, + const char *name); /** * @@ -10442,12 +11192,21 @@ xcb_store_named_color_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_store_named_color (xcb_connection_t *c /**< */, - uint8_t flags /**< */, - xcb_colormap_t cmap /**< */, - uint32_t pixel /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_store_named_color (xcb_connection_t *c, + uint8_t flags, + xcb_colormap_t cmap, + uint32_t pixel, + uint16_t name_len, + const char *name); + +char * +xcb_store_named_color_name (const xcb_store_named_color_request_t *R); + +int +xcb_store_named_color_name_length (const xcb_store_named_color_request_t *R); + +xcb_generic_iterator_t +xcb_store_named_color_name_end (const xcb_store_named_color_request_t *R); /** * Get the next element of the iterator @@ -10458,7 +11217,7 @@ xcb_store_named_color (xcb_connection_t *c /**< */, * element. The member index is increased by sizeof(xcb_rgb_t) */ void -xcb_rgb_next (xcb_rgb_iterator_t *i /**< */); +xcb_rgb_next (xcb_rgb_iterator_t *i); /** * Return the iterator pointing to the last element @@ -10470,11 +11229,11 @@ xcb_rgb_next (xcb_rgb_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_rgb_end (xcb_rgb_iterator_t i /**< */); +xcb_rgb_end (xcb_rgb_iterator_t i); int -xcb_query_colors_sizeof (const void *_buffer /**< */, - uint32_t pixels_len /**< */); +xcb_query_colors_sizeof (const void *_buffer, + uint32_t pixels_len); /** * @@ -10485,10 +11244,10 @@ xcb_query_colors_sizeof (const void *_buffer /**< */, * */ xcb_query_colors_cookie_t -xcb_query_colors (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t pixels_len /**< */, - const uint32_t *pixels /**< */); +xcb_query_colors (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t pixels_len, + const uint32_t *pixels); /** * @@ -10502,19 +11261,19 @@ xcb_query_colors (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_query_colors_cookie_t -xcb_query_colors_unchecked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint32_t pixels_len /**< */, - const uint32_t *pixels /**< */); +xcb_query_colors_unchecked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint32_t pixels_len, + const uint32_t *pixels); xcb_rgb_t * -xcb_query_colors_colors (const xcb_query_colors_reply_t *R /**< */); +xcb_query_colors_colors (const xcb_query_colors_reply_t *R); int -xcb_query_colors_colors_length (const xcb_query_colors_reply_t *R /**< */); +xcb_query_colors_colors_length (const xcb_query_colors_reply_t *R); xcb_rgb_iterator_t -xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R /**< */); +xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R); /** * Return the reply @@ -10531,12 +11290,12 @@ xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_query_colors_reply_t * -xcb_query_colors_reply (xcb_connection_t *c /**< */, +xcb_query_colors_reply (xcb_connection_t *c, xcb_query_colors_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_lookup_color_sizeof (const void *_buffer /**< */); +xcb_lookup_color_sizeof (const void *_buffer); /** * @@ -10547,10 +11306,10 @@ xcb_lookup_color_sizeof (const void *_buffer /**< */); * */ xcb_lookup_color_cookie_t -xcb_lookup_color (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_lookup_color (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t name_len, + const char *name); /** * @@ -10564,10 +11323,10 @@ xcb_lookup_color (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_lookup_color_cookie_t -xcb_lookup_color_unchecked (xcb_connection_t *c /**< */, - xcb_colormap_t cmap /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_lookup_color_unchecked (xcb_connection_t *c, + xcb_colormap_t cmap, + uint16_t name_len, + const char *name); /** * Return the reply @@ -10584,9 +11343,9 @@ xcb_lookup_color_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_lookup_color_reply_t * -xcb_lookup_color_reply (xcb_connection_t *c /**< */, +xcb_lookup_color_reply (xcb_connection_t *c, xcb_lookup_color_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -10600,18 +11359,18 @@ xcb_lookup_color_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_create_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_pixmap_t source /**< */, - xcb_pixmap_t mask /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */, - uint16_t x /**< */, - uint16_t y /**< */); +xcb_create_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_pixmap_t source, + xcb_pixmap_t mask, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue, + uint16_t x, + uint16_t y); /** * @@ -10622,18 +11381,18 @@ xcb_create_cursor_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_create_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_pixmap_t source /**< */, - xcb_pixmap_t mask /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */, - uint16_t x /**< */, - uint16_t y /**< */); +xcb_create_cursor (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_pixmap_t source, + xcb_pixmap_t mask, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue, + uint16_t x, + uint16_t y); /** * @brief create cursor @@ -10669,18 +11428,18 @@ xcb_create_cursor (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_create_glyph_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_font_t source_font /**< */, - xcb_font_t mask_font /**< */, - uint16_t source_char /**< */, - uint16_t mask_char /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */); +xcb_create_glyph_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_font_t source_font, + xcb_font_t mask_font, + uint16_t source_char, + uint16_t mask_char, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue); /** * @brief create cursor @@ -10713,18 +11472,18 @@ xcb_create_glyph_cursor_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_create_glyph_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cid /**< */, - xcb_font_t source_font /**< */, - xcb_font_t mask_font /**< */, - uint16_t source_char /**< */, - uint16_t mask_char /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */); +xcb_create_glyph_cursor (xcb_connection_t *c, + xcb_cursor_t cid, + xcb_font_t source_font, + xcb_font_t mask_font, + uint16_t source_char, + uint16_t mask_char, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue); /** * @brief Deletes a cursor @@ -10741,8 +11500,8 @@ xcb_create_glyph_cursor (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_free_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */); +xcb_free_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cursor); /** * @brief Deletes a cursor @@ -10756,8 +11515,8 @@ xcb_free_cursor_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_free_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */); +xcb_free_cursor (xcb_connection_t *c, + xcb_cursor_t cursor); /** * @@ -10771,14 +11530,14 @@ xcb_free_cursor (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_recolor_cursor_checked (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */); +xcb_recolor_cursor_checked (xcb_connection_t *c, + xcb_cursor_t cursor, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue); /** * @@ -10789,14 +11548,14 @@ xcb_recolor_cursor_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_recolor_cursor (xcb_connection_t *c /**< */, - xcb_cursor_t cursor /**< */, - uint16_t fore_red /**< */, - uint16_t fore_green /**< */, - uint16_t fore_blue /**< */, - uint16_t back_red /**< */, - uint16_t back_green /**< */, - uint16_t back_blue /**< */); +xcb_recolor_cursor (xcb_connection_t *c, + xcb_cursor_t cursor, + uint16_t fore_red, + uint16_t fore_green, + uint16_t fore_blue, + uint16_t back_red, + uint16_t back_green, + uint16_t back_blue); /** * @@ -10807,11 +11566,11 @@ xcb_recolor_cursor (xcb_connection_t *c /**< */, * */ xcb_query_best_size_cookie_t -xcb_query_best_size (xcb_connection_t *c /**< */, - uint8_t _class /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_query_best_size (xcb_connection_t *c, + uint8_t _class, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height); /** * @@ -10825,11 +11584,11 @@ xcb_query_best_size (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_query_best_size_cookie_t -xcb_query_best_size_unchecked (xcb_connection_t *c /**< */, - uint8_t _class /**< */, - xcb_drawable_t drawable /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_query_best_size_unchecked (xcb_connection_t *c, + uint8_t _class, + xcb_drawable_t drawable, + uint16_t width, + uint16_t height); /** * Return the reply @@ -10846,12 +11605,12 @@ xcb_query_best_size_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_query_best_size_reply_t * -xcb_query_best_size_reply (xcb_connection_t *c /**< */, +xcb_query_best_size_reply (xcb_connection_t *c, xcb_query_best_size_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_query_extension_sizeof (const void *_buffer /**< */); +xcb_query_extension_sizeof (const void *_buffer); /** * @brief check if extension is present @@ -10874,9 +11633,9 @@ xcb_query_extension_sizeof (const void *_buffer /**< */); * */ xcb_query_extension_cookie_t -xcb_query_extension (xcb_connection_t *c /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_query_extension (xcb_connection_t *c, + uint16_t name_len, + const char *name); /** * @brief check if extension is present @@ -10902,9 +11661,9 @@ xcb_query_extension (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_query_extension_cookie_t -xcb_query_extension_unchecked (xcb_connection_t *c /**< */, - uint16_t name_len /**< */, - const char *name /**< */); +xcb_query_extension_unchecked (xcb_connection_t *c, + uint16_t name_len, + const char *name); /** * Return the reply @@ -10921,12 +11680,12 @@ xcb_query_extension_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_query_extension_reply_t * -xcb_query_extension_reply (xcb_connection_t *c /**< */, +xcb_query_extension_reply (xcb_connection_t *c, xcb_query_extension_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_list_extensions_sizeof (const void *_buffer /**< */); +xcb_list_extensions_sizeof (const void *_buffer); /** * @@ -10937,7 +11696,7 @@ xcb_list_extensions_sizeof (const void *_buffer /**< */); * */ xcb_list_extensions_cookie_t -xcb_list_extensions (xcb_connection_t *c /**< */); +xcb_list_extensions (xcb_connection_t *c); /** * @@ -10951,13 +11710,13 @@ xcb_list_extensions (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_list_extensions_cookie_t -xcb_list_extensions_unchecked (xcb_connection_t *c /**< */); +xcb_list_extensions_unchecked (xcb_connection_t *c); int -xcb_list_extensions_names_length (const xcb_list_extensions_reply_t *R /**< */); +xcb_list_extensions_names_length (const xcb_list_extensions_reply_t *R); xcb_str_iterator_t -xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R /**< */); +xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R); /** * Return the reply @@ -10974,12 +11733,12 @@ xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R /**< * * The returned value must be freed by the caller using free(). */ xcb_list_extensions_reply_t * -xcb_list_extensions_reply (xcb_connection_t *c /**< */, +xcb_list_extensions_reply (xcb_connection_t *c, xcb_list_extensions_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_change_keyboard_mapping_sizeof (const void *_buffer /**< */); +xcb_change_keyboard_mapping_sizeof (const void *_buffer); /** * @@ -10993,11 +11752,11 @@ xcb_change_keyboard_mapping_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_change_keyboard_mapping_checked (xcb_connection_t *c /**< */, - uint8_t keycode_count /**< */, - xcb_keycode_t first_keycode /**< */, - uint8_t keysyms_per_keycode /**< */, - const xcb_keysym_t *keysyms /**< */); +xcb_change_keyboard_mapping_checked (xcb_connection_t *c, + uint8_t keycode_count, + xcb_keycode_t first_keycode, + uint8_t keysyms_per_keycode, + const xcb_keysym_t *keysyms); /** * @@ -11008,14 +11767,23 @@ xcb_change_keyboard_mapping_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_change_keyboard_mapping (xcb_connection_t *c /**< */, - uint8_t keycode_count /**< */, - xcb_keycode_t first_keycode /**< */, - uint8_t keysyms_per_keycode /**< */, - const xcb_keysym_t *keysyms /**< */); +xcb_change_keyboard_mapping (xcb_connection_t *c, + uint8_t keycode_count, + xcb_keycode_t first_keycode, + uint8_t keysyms_per_keycode, + const xcb_keysym_t *keysyms); + +xcb_keysym_t * +xcb_change_keyboard_mapping_keysyms (const xcb_change_keyboard_mapping_request_t *R); int -xcb_get_keyboard_mapping_sizeof (const void *_buffer /**< */); +xcb_change_keyboard_mapping_keysyms_length (const xcb_change_keyboard_mapping_request_t *R); + +xcb_generic_iterator_t +xcb_change_keyboard_mapping_keysyms_end (const xcb_change_keyboard_mapping_request_t *R); + +int +xcb_get_keyboard_mapping_sizeof (const void *_buffer); /** * @@ -11026,9 +11794,9 @@ xcb_get_keyboard_mapping_sizeof (const void *_buffer /**< */); * */ xcb_get_keyboard_mapping_cookie_t -xcb_get_keyboard_mapping (xcb_connection_t *c /**< */, - xcb_keycode_t first_keycode /**< */, - uint8_t count /**< */); +xcb_get_keyboard_mapping (xcb_connection_t *c, + xcb_keycode_t first_keycode, + uint8_t count); /** * @@ -11042,18 +11810,18 @@ xcb_get_keyboard_mapping (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_get_keyboard_mapping_cookie_t -xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c /**< */, - xcb_keycode_t first_keycode /**< */, - uint8_t count /**< */); +xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c, + xcb_keycode_t first_keycode, + uint8_t count); xcb_keysym_t * -xcb_get_keyboard_mapping_keysyms (const xcb_get_keyboard_mapping_reply_t *R /**< */); +xcb_get_keyboard_mapping_keysyms (const xcb_get_keyboard_mapping_reply_t *R); int -xcb_get_keyboard_mapping_keysyms_length (const xcb_get_keyboard_mapping_reply_t *R /**< */); +xcb_get_keyboard_mapping_keysyms_length (const xcb_get_keyboard_mapping_reply_t *R); xcb_generic_iterator_t -xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R /**< */); +xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R); /** * Return the reply @@ -11070,12 +11838,26 @@ xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_get_keyboard_mapping_reply_t * -xcb_get_keyboard_mapping_reply (xcb_connection_t *c /**< */, +xcb_get_keyboard_mapping_reply (xcb_connection_t *c, xcb_get_keyboard_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_change_keyboard_control_sizeof (const void *_buffer /**< */); +xcb_change_keyboard_control_value_list_serialize (void **_buffer, + uint32_t value_mask, + const xcb_change_keyboard_control_value_list_t *_aux); + +int +xcb_change_keyboard_control_value_list_unpack (const void *_buffer, + uint32_t value_mask, + xcb_change_keyboard_control_value_list_t *_aux); + +int +xcb_change_keyboard_control_value_list_sizeof (const void *_buffer, + uint32_t value_mask); + +int +xcb_change_keyboard_control_sizeof (const void *_buffer); /** * @@ -11089,9 +11871,9 @@ xcb_change_keyboard_control_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_change_keyboard_control_checked (xcb_connection_t *c /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_change_keyboard_control_checked (xcb_connection_t *c, + uint32_t value_mask, + const void *value_list); /** * @@ -11102,9 +11884,41 @@ xcb_change_keyboard_control_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_change_keyboard_control (xcb_connection_t *c /**< */, - uint32_t value_mask /**< */, - const uint32_t *value_list /**< */); +xcb_change_keyboard_control (xcb_connection_t *c, + uint32_t value_mask, + const void *value_list); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + * This form can be used only if the request will not cause + * a reply to be generated. Any returned error will be + * saved for handling by xcb_request_check(). + */ +xcb_void_cookie_t +xcb_change_keyboard_control_aux_checked (xcb_connection_t *c, + uint32_t value_mask, + const xcb_change_keyboard_control_value_list_t *value_list); + +/** + * + * @param c The connection + * @return A cookie + * + * Delivers a request to the X server. + * + */ +xcb_void_cookie_t +xcb_change_keyboard_control_aux (xcb_connection_t *c, + uint32_t value_mask, + const xcb_change_keyboard_control_value_list_t *value_list); + +void * +xcb_change_keyboard_control_value_list (const xcb_change_keyboard_control_request_t *R); /** * @@ -11115,7 +11929,7 @@ xcb_change_keyboard_control (xcb_connection_t *c /**< */, * */ xcb_get_keyboard_control_cookie_t -xcb_get_keyboard_control (xcb_connection_t *c /**< */); +xcb_get_keyboard_control (xcb_connection_t *c); /** * @@ -11129,7 +11943,7 @@ xcb_get_keyboard_control (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_get_keyboard_control_cookie_t -xcb_get_keyboard_control_unchecked (xcb_connection_t *c /**< */); +xcb_get_keyboard_control_unchecked (xcb_connection_t *c); /** * Return the reply @@ -11146,9 +11960,9 @@ xcb_get_keyboard_control_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_get_keyboard_control_reply_t * -xcb_get_keyboard_control_reply (xcb_connection_t *c /**< */, +xcb_get_keyboard_control_reply (xcb_connection_t *c, xcb_get_keyboard_control_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -11162,8 +11976,8 @@ xcb_get_keyboard_control_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_bell_checked (xcb_connection_t *c /**< */, - int8_t percent /**< */); +xcb_bell_checked (xcb_connection_t *c, + int8_t percent); /** * @@ -11174,8 +11988,8 @@ xcb_bell_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_bell (xcb_connection_t *c /**< */, - int8_t percent /**< */); +xcb_bell (xcb_connection_t *c, + int8_t percent); /** * @@ -11189,12 +12003,12 @@ xcb_bell (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_change_pointer_control_checked (xcb_connection_t *c /**< */, - int16_t acceleration_numerator /**< */, - int16_t acceleration_denominator /**< */, - int16_t threshold /**< */, - uint8_t do_acceleration /**< */, - uint8_t do_threshold /**< */); +xcb_change_pointer_control_checked (xcb_connection_t *c, + int16_t acceleration_numerator, + int16_t acceleration_denominator, + int16_t threshold, + uint8_t do_acceleration, + uint8_t do_threshold); /** * @@ -11205,12 +12019,12 @@ xcb_change_pointer_control_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_change_pointer_control (xcb_connection_t *c /**< */, - int16_t acceleration_numerator /**< */, - int16_t acceleration_denominator /**< */, - int16_t threshold /**< */, - uint8_t do_acceleration /**< */, - uint8_t do_threshold /**< */); +xcb_change_pointer_control (xcb_connection_t *c, + int16_t acceleration_numerator, + int16_t acceleration_denominator, + int16_t threshold, + uint8_t do_acceleration, + uint8_t do_threshold); /** * @@ -11221,7 +12035,7 @@ xcb_change_pointer_control (xcb_connection_t *c /**< */, * */ xcb_get_pointer_control_cookie_t -xcb_get_pointer_control (xcb_connection_t *c /**< */); +xcb_get_pointer_control (xcb_connection_t *c); /** * @@ -11235,7 +12049,7 @@ xcb_get_pointer_control (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_get_pointer_control_cookie_t -xcb_get_pointer_control_unchecked (xcb_connection_t *c /**< */); +xcb_get_pointer_control_unchecked (xcb_connection_t *c); /** * Return the reply @@ -11252,9 +12066,9 @@ xcb_get_pointer_control_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_get_pointer_control_reply_t * -xcb_get_pointer_control_reply (xcb_connection_t *c /**< */, +xcb_get_pointer_control_reply (xcb_connection_t *c, xcb_get_pointer_control_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -11268,11 +12082,11 @@ xcb_get_pointer_control_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_set_screen_saver_checked (xcb_connection_t *c /**< */, - int16_t timeout /**< */, - int16_t interval /**< */, - uint8_t prefer_blanking /**< */, - uint8_t allow_exposures /**< */); +xcb_set_screen_saver_checked (xcb_connection_t *c, + int16_t timeout, + int16_t interval, + uint8_t prefer_blanking, + uint8_t allow_exposures); /** * @@ -11283,11 +12097,11 @@ xcb_set_screen_saver_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_set_screen_saver (xcb_connection_t *c /**< */, - int16_t timeout /**< */, - int16_t interval /**< */, - uint8_t prefer_blanking /**< */, - uint8_t allow_exposures /**< */); +xcb_set_screen_saver (xcb_connection_t *c, + int16_t timeout, + int16_t interval, + uint8_t prefer_blanking, + uint8_t allow_exposures); /** * @@ -11298,7 +12112,7 @@ xcb_set_screen_saver (xcb_connection_t *c /**< */, * */ xcb_get_screen_saver_cookie_t -xcb_get_screen_saver (xcb_connection_t *c /**< */); +xcb_get_screen_saver (xcb_connection_t *c); /** * @@ -11312,7 +12126,7 @@ xcb_get_screen_saver (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_get_screen_saver_cookie_t -xcb_get_screen_saver_unchecked (xcb_connection_t *c /**< */); +xcb_get_screen_saver_unchecked (xcb_connection_t *c); /** * Return the reply @@ -11329,12 +12143,12 @@ xcb_get_screen_saver_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_get_screen_saver_reply_t * -xcb_get_screen_saver_reply (xcb_connection_t *c /**< */, +xcb_get_screen_saver_reply (xcb_connection_t *c, xcb_get_screen_saver_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_change_hosts_sizeof (const void *_buffer /**< */); +xcb_change_hosts_sizeof (const void *_buffer); /** * @@ -11348,11 +12162,11 @@ xcb_change_hosts_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_change_hosts_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - uint8_t family /**< */, - uint16_t address_len /**< */, - const uint8_t *address /**< */); +xcb_change_hosts_checked (xcb_connection_t *c, + uint8_t mode, + uint8_t family, + uint16_t address_len, + const uint8_t *address); /** * @@ -11363,23 +12177,32 @@ xcb_change_hosts_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_change_hosts (xcb_connection_t *c /**< */, - uint8_t mode /**< */, - uint8_t family /**< */, - uint16_t address_len /**< */, - const uint8_t *address /**< */); - -int -xcb_host_sizeof (const void *_buffer /**< */); +xcb_change_hosts (xcb_connection_t *c, + uint8_t mode, + uint8_t family, + uint16_t address_len, + const uint8_t *address); uint8_t * -xcb_host_address (const xcb_host_t *R /**< */); +xcb_change_hosts_address (const xcb_change_hosts_request_t *R); int -xcb_host_address_length (const xcb_host_t *R /**< */); +xcb_change_hosts_address_length (const xcb_change_hosts_request_t *R); xcb_generic_iterator_t -xcb_host_address_end (const xcb_host_t *R /**< */); +xcb_change_hosts_address_end (const xcb_change_hosts_request_t *R); + +int +xcb_host_sizeof (const void *_buffer); + +uint8_t * +xcb_host_address (const xcb_host_t *R); + +int +xcb_host_address_length (const xcb_host_t *R); + +xcb_generic_iterator_t +xcb_host_address_end (const xcb_host_t *R); /** * Get the next element of the iterator @@ -11390,7 +12213,7 @@ xcb_host_address_end (const xcb_host_t *R /**< */); * element. The member index is increased by sizeof(xcb_host_t) */ void -xcb_host_next (xcb_host_iterator_t *i /**< */); +xcb_host_next (xcb_host_iterator_t *i); /** * Return the iterator pointing to the last element @@ -11402,10 +12225,10 @@ xcb_host_next (xcb_host_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_host_end (xcb_host_iterator_t i /**< */); +xcb_host_end (xcb_host_iterator_t i); int -xcb_list_hosts_sizeof (const void *_buffer /**< */); +xcb_list_hosts_sizeof (const void *_buffer); /** * @@ -11416,7 +12239,7 @@ xcb_list_hosts_sizeof (const void *_buffer /**< */); * */ xcb_list_hosts_cookie_t -xcb_list_hosts (xcb_connection_t *c /**< */); +xcb_list_hosts (xcb_connection_t *c); /** * @@ -11430,13 +12253,13 @@ xcb_list_hosts (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_list_hosts_cookie_t -xcb_list_hosts_unchecked (xcb_connection_t *c /**< */); +xcb_list_hosts_unchecked (xcb_connection_t *c); int -xcb_list_hosts_hosts_length (const xcb_list_hosts_reply_t *R /**< */); +xcb_list_hosts_hosts_length (const xcb_list_hosts_reply_t *R); xcb_host_iterator_t -xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R /**< */); +xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R); /** * Return the reply @@ -11453,9 +12276,9 @@ xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R /**< */); * The returned value must be freed by the caller using free(). */ xcb_list_hosts_reply_t * -xcb_list_hosts_reply (xcb_connection_t *c /**< */, +xcb_list_hosts_reply (xcb_connection_t *c, xcb_list_hosts_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -11469,8 +12292,8 @@ xcb_list_hosts_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_set_access_control_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */); +xcb_set_access_control_checked (xcb_connection_t *c, + uint8_t mode); /** * @@ -11481,8 +12304,8 @@ xcb_set_access_control_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_set_access_control (xcb_connection_t *c /**< */, - uint8_t mode /**< */); +xcb_set_access_control (xcb_connection_t *c, + uint8_t mode); /** * @@ -11496,8 +12319,8 @@ xcb_set_access_control (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_set_close_down_mode_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */); +xcb_set_close_down_mode_checked (xcb_connection_t *c, + uint8_t mode); /** * @@ -11508,8 +12331,8 @@ xcb_set_close_down_mode_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_set_close_down_mode (xcb_connection_t *c /**< */, - uint8_t mode /**< */); +xcb_set_close_down_mode (xcb_connection_t *c, + uint8_t mode); /** * @brief kills a client @@ -11529,8 +12352,8 @@ xcb_set_close_down_mode (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_kill_client_checked (xcb_connection_t *c /**< */, - uint32_t resource /**< */); +xcb_kill_client_checked (xcb_connection_t *c, + uint32_t resource); /** * @brief kills a client @@ -11547,11 +12370,11 @@ xcb_kill_client_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_kill_client (xcb_connection_t *c /**< */, - uint32_t resource /**< */); +xcb_kill_client (xcb_connection_t *c, + uint32_t resource); int -xcb_rotate_properties_sizeof (const void *_buffer /**< */); +xcb_rotate_properties_sizeof (const void *_buffer); /** * @@ -11565,11 +12388,11 @@ xcb_rotate_properties_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_rotate_properties_checked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t atoms_len /**< */, - int16_t delta /**< */, - const xcb_atom_t *atoms /**< */); +xcb_rotate_properties_checked (xcb_connection_t *c, + xcb_window_t window, + uint16_t atoms_len, + int16_t delta, + const xcb_atom_t *atoms); /** * @@ -11580,11 +12403,20 @@ xcb_rotate_properties_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_rotate_properties (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - uint16_t atoms_len /**< */, - int16_t delta /**< */, - const xcb_atom_t *atoms /**< */); +xcb_rotate_properties (xcb_connection_t *c, + xcb_window_t window, + uint16_t atoms_len, + int16_t delta, + const xcb_atom_t *atoms); + +xcb_atom_t * +xcb_rotate_properties_atoms (const xcb_rotate_properties_request_t *R); + +int +xcb_rotate_properties_atoms_length (const xcb_rotate_properties_request_t *R); + +xcb_generic_iterator_t +xcb_rotate_properties_atoms_end (const xcb_rotate_properties_request_t *R); /** * @@ -11598,8 +12430,8 @@ xcb_rotate_properties (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_force_screen_saver_checked (xcb_connection_t *c /**< */, - uint8_t mode /**< */); +xcb_force_screen_saver_checked (xcb_connection_t *c, + uint8_t mode); /** * @@ -11610,11 +12442,11 @@ xcb_force_screen_saver_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_force_screen_saver (xcb_connection_t *c /**< */, - uint8_t mode /**< */); +xcb_force_screen_saver (xcb_connection_t *c, + uint8_t mode); int -xcb_set_pointer_mapping_sizeof (const void *_buffer /**< */); +xcb_set_pointer_mapping_sizeof (const void *_buffer); /** * @@ -11625,9 +12457,9 @@ xcb_set_pointer_mapping_sizeof (const void *_buffer /**< */); * */ xcb_set_pointer_mapping_cookie_t -xcb_set_pointer_mapping (xcb_connection_t *c /**< */, - uint8_t map_len /**< */, - const uint8_t *map /**< */); +xcb_set_pointer_mapping (xcb_connection_t *c, + uint8_t map_len, + const uint8_t *map); /** * @@ -11641,9 +12473,9 @@ xcb_set_pointer_mapping (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_set_pointer_mapping_cookie_t -xcb_set_pointer_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t map_len /**< */, - const uint8_t *map /**< */); +xcb_set_pointer_mapping_unchecked (xcb_connection_t *c, + uint8_t map_len, + const uint8_t *map); /** * Return the reply @@ -11660,12 +12492,12 @@ xcb_set_pointer_mapping_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_set_pointer_mapping_reply_t * -xcb_set_pointer_mapping_reply (xcb_connection_t *c /**< */, +xcb_set_pointer_mapping_reply (xcb_connection_t *c, xcb_set_pointer_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_get_pointer_mapping_sizeof (const void *_buffer /**< */); +xcb_get_pointer_mapping_sizeof (const void *_buffer); /** * @@ -11676,7 +12508,7 @@ xcb_get_pointer_mapping_sizeof (const void *_buffer /**< */); * */ xcb_get_pointer_mapping_cookie_t -xcb_get_pointer_mapping (xcb_connection_t *c /**< */); +xcb_get_pointer_mapping (xcb_connection_t *c); /** * @@ -11690,16 +12522,16 @@ xcb_get_pointer_mapping (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_get_pointer_mapping_cookie_t -xcb_get_pointer_mapping_unchecked (xcb_connection_t *c /**< */); +xcb_get_pointer_mapping_unchecked (xcb_connection_t *c); uint8_t * -xcb_get_pointer_mapping_map (const xcb_get_pointer_mapping_reply_t *R /**< */); +xcb_get_pointer_mapping_map (const xcb_get_pointer_mapping_reply_t *R); int -xcb_get_pointer_mapping_map_length (const xcb_get_pointer_mapping_reply_t *R /**< */); +xcb_get_pointer_mapping_map_length (const xcb_get_pointer_mapping_reply_t *R); xcb_generic_iterator_t -xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R /**< */); +xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R); /** * Return the reply @@ -11716,12 +12548,12 @@ xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R /**< * The returned value must be freed by the caller using free(). */ xcb_get_pointer_mapping_reply_t * -xcb_get_pointer_mapping_reply (xcb_connection_t *c /**< */, +xcb_get_pointer_mapping_reply (xcb_connection_t *c, xcb_get_pointer_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_set_modifier_mapping_sizeof (const void *_buffer /**< */); +xcb_set_modifier_mapping_sizeof (const void *_buffer); /** * @@ -11732,9 +12564,9 @@ xcb_set_modifier_mapping_sizeof (const void *_buffer /**< */); * */ xcb_set_modifier_mapping_cookie_t -xcb_set_modifier_mapping (xcb_connection_t *c /**< */, - uint8_t keycodes_per_modifier /**< */, - const xcb_keycode_t *keycodes /**< */); +xcb_set_modifier_mapping (xcb_connection_t *c, + uint8_t keycodes_per_modifier, + const xcb_keycode_t *keycodes); /** * @@ -11748,9 +12580,9 @@ xcb_set_modifier_mapping (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_set_modifier_mapping_cookie_t -xcb_set_modifier_mapping_unchecked (xcb_connection_t *c /**< */, - uint8_t keycodes_per_modifier /**< */, - const xcb_keycode_t *keycodes /**< */); +xcb_set_modifier_mapping_unchecked (xcb_connection_t *c, + uint8_t keycodes_per_modifier, + const xcb_keycode_t *keycodes); /** * Return the reply @@ -11767,12 +12599,12 @@ xcb_set_modifier_mapping_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_set_modifier_mapping_reply_t * -xcb_set_modifier_mapping_reply (xcb_connection_t *c /**< */, +xcb_set_modifier_mapping_reply (xcb_connection_t *c, xcb_set_modifier_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_get_modifier_mapping_sizeof (const void *_buffer /**< */); +xcb_get_modifier_mapping_sizeof (const void *_buffer); /** * @@ -11783,7 +12615,7 @@ xcb_get_modifier_mapping_sizeof (const void *_buffer /**< */); * */ xcb_get_modifier_mapping_cookie_t -xcb_get_modifier_mapping (xcb_connection_t *c /**< */); +xcb_get_modifier_mapping (xcb_connection_t *c); /** * @@ -11797,16 +12629,16 @@ xcb_get_modifier_mapping (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_get_modifier_mapping_cookie_t -xcb_get_modifier_mapping_unchecked (xcb_connection_t *c /**< */); +xcb_get_modifier_mapping_unchecked (xcb_connection_t *c); xcb_keycode_t * -xcb_get_modifier_mapping_keycodes (const xcb_get_modifier_mapping_reply_t *R /**< */); +xcb_get_modifier_mapping_keycodes (const xcb_get_modifier_mapping_reply_t *R); int -xcb_get_modifier_mapping_keycodes_length (const xcb_get_modifier_mapping_reply_t *R /**< */); +xcb_get_modifier_mapping_keycodes_length (const xcb_get_modifier_mapping_reply_t *R); xcb_generic_iterator_t -xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R /**< */); +xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R); /** * Return the reply @@ -11823,9 +12655,9 @@ xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_get_modifier_mapping_reply_t * -xcb_get_modifier_mapping_reply (xcb_connection_t *c /**< */, +xcb_get_modifier_mapping_reply (xcb_connection_t *c, xcb_get_modifier_mapping_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -11839,7 +12671,7 @@ xcb_get_modifier_mapping_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_no_operation_checked (xcb_connection_t *c /**< */); +xcb_no_operation_checked (xcb_connection_t *c); /** * @@ -11850,7 +12682,7 @@ xcb_no_operation_checked (xcb_connection_t *c /**< */); * */ xcb_void_cookie_t -xcb_no_operation (xcb_connection_t *c /**< */); +xcb_no_operation (xcb_connection_t *c); #ifdef __cplusplus diff --git a/lib/libxcb/src/xselinux.c b/lib/libxcb/src/xselinux.c index fc9e41b44..539dd614b 100644 --- a/lib/libxcb/src/xselinux.c +++ b/lib/libxcb/src/xselinux.c @@ -19,15 +19,15 @@ xcb_extension_t xcb_selinux_id = { "SELinux", 0 }; xcb_selinux_query_version_cookie_t -xcb_selinux_query_version (xcb_connection_t *c /**< */, - uint8_t client_major /**< */, - uint8_t client_minor /**< */) +xcb_selinux_query_version (xcb_connection_t *c, + uint8_t client_major, + uint8_t client_minor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -47,15 +47,15 @@ xcb_selinux_query_version (xcb_connection_t *c /**< */, } xcb_selinux_query_version_cookie_t -xcb_selinux_query_version_unchecked (xcb_connection_t *c /**< */, - uint8_t client_major /**< */, - uint8_t client_minor /**< */) +xcb_selinux_query_version_unchecked (xcb_connection_t *c, + uint8_t client_major, + uint8_t client_minor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -75,15 +75,15 @@ xcb_selinux_query_version_unchecked (xcb_connection_t *c /**< */, } xcb_selinux_query_version_reply_t * -xcb_selinux_query_version_reply (xcb_connection_t *c /**< */, +xcb_selinux_query_version_reply (xcb_connection_t *c, xcb_selinux_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_set_device_create_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_device_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_set_device_create_context_request_t *_aux = (xcb_selinux_set_device_create_context_request_t *)_buffer; @@ -114,15 +114,15 @@ xcb_selinux_set_device_create_context_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_selinux_set_device_create_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_device_create_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -146,15 +146,15 @@ xcb_selinux_set_device_create_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_selinux_set_device_create_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_device_create_context (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -177,8 +177,30 @@ xcb_selinux_set_device_create_context (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_selinux_set_device_create_context_context (const xcb_selinux_set_device_create_context_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_selinux_get_device_create_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_device_create_context_context_length (const xcb_selinux_set_device_create_context_request_t *R) +{ + return R->context_len; +} + +xcb_generic_iterator_t +xcb_selinux_set_device_create_context_context_end (const xcb_selinux_set_device_create_context_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->context_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_selinux_get_device_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_device_create_context_reply_t *_aux = (xcb_selinux_get_device_create_context_reply_t *)_buffer; @@ -209,13 +231,13 @@ xcb_selinux_get_device_create_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_device_create_context_cookie_t -xcb_selinux_get_device_create_context (xcb_connection_t *c /**< */) +xcb_selinux_get_device_create_context (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -233,13 +255,13 @@ xcb_selinux_get_device_create_context (xcb_connection_t *c /**< */) } xcb_selinux_get_device_create_context_cookie_t -xcb_selinux_get_device_create_context_unchecked (xcb_connection_t *c /**< */) +xcb_selinux_get_device_create_context_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -257,19 +279,19 @@ xcb_selinux_get_device_create_context_unchecked (xcb_connection_t *c /**< */) } char * -xcb_selinux_get_device_create_context_context (const xcb_selinux_get_device_create_context_reply_t *R /**< */) +xcb_selinux_get_device_create_context_context (const xcb_selinux_get_device_create_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_device_create_context_context_length (const xcb_selinux_get_device_create_context_reply_t *R /**< */) +xcb_selinux_get_device_create_context_context_length (const xcb_selinux_get_device_create_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_device_create_context_context_end (const xcb_selinux_get_device_create_context_reply_t *R /**< */) +xcb_selinux_get_device_create_context_context_end (const xcb_selinux_get_device_create_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -279,15 +301,15 @@ xcb_selinux_get_device_create_context_context_end (const xcb_selinux_get_device_ } xcb_selinux_get_device_create_context_reply_t * -xcb_selinux_get_device_create_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_device_create_context_reply (xcb_connection_t *c, xcb_selinux_get_device_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_device_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_set_device_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_device_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_set_device_context_request_t *_aux = (xcb_selinux_set_device_context_request_t *)_buffer; @@ -318,16 +340,16 @@ xcb_selinux_set_device_context_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_selinux_set_device_context_checked (xcb_connection_t *c /**< */, - uint32_t device /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_device_context_checked (xcb_connection_t *c, + uint32_t device, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_DEVICE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_DEVICE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -352,16 +374,16 @@ xcb_selinux_set_device_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_selinux_set_device_context (xcb_connection_t *c /**< */, - uint32_t device /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_device_context (xcb_connection_t *c, + uint32_t device, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_DEVICE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_DEVICE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -385,8 +407,30 @@ xcb_selinux_set_device_context (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_selinux_set_device_context_context (const xcb_selinux_set_device_context_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_selinux_get_device_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_device_context_context_length (const xcb_selinux_set_device_context_request_t *R) +{ + return R->context_len; +} + +xcb_generic_iterator_t +xcb_selinux_set_device_context_context_end (const xcb_selinux_set_device_context_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->context_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_selinux_get_device_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_device_context_reply_t *_aux = (xcb_selinux_get_device_context_reply_t *)_buffer; @@ -417,14 +461,14 @@ xcb_selinux_get_device_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_device_context_cookie_t -xcb_selinux_get_device_context (xcb_connection_t *c /**< */, - uint32_t device /**< */) +xcb_selinux_get_device_context (xcb_connection_t *c, + uint32_t device) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_DEVICE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_DEVICE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -443,14 +487,14 @@ xcb_selinux_get_device_context (xcb_connection_t *c /**< */, } xcb_selinux_get_device_context_cookie_t -xcb_selinux_get_device_context_unchecked (xcb_connection_t *c /**< */, - uint32_t device /**< */) +xcb_selinux_get_device_context_unchecked (xcb_connection_t *c, + uint32_t device) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_DEVICE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_DEVICE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -469,19 +513,19 @@ xcb_selinux_get_device_context_unchecked (xcb_connection_t *c /**< */, } char * -xcb_selinux_get_device_context_context (const xcb_selinux_get_device_context_reply_t *R /**< */) +xcb_selinux_get_device_context_context (const xcb_selinux_get_device_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_device_context_context_length (const xcb_selinux_get_device_context_reply_t *R /**< */) +xcb_selinux_get_device_context_context_length (const xcb_selinux_get_device_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_device_context_context_end (const xcb_selinux_get_device_context_reply_t *R /**< */) +xcb_selinux_get_device_context_context_end (const xcb_selinux_get_device_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -491,15 +535,15 @@ xcb_selinux_get_device_context_context_end (const xcb_selinux_get_device_context } xcb_selinux_get_device_context_reply_t * -xcb_selinux_get_device_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_device_context_reply (xcb_connection_t *c, xcb_selinux_get_device_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_device_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_set_window_create_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_window_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_set_window_create_context_request_t *_aux = (xcb_selinux_set_window_create_context_request_t *)_buffer; @@ -530,15 +574,15 @@ xcb_selinux_set_window_create_context_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_selinux_set_window_create_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_window_create_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -562,15 +606,15 @@ xcb_selinux_set_window_create_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_selinux_set_window_create_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_window_create_context (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -593,8 +637,30 @@ xcb_selinux_set_window_create_context (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_selinux_set_window_create_context_context (const xcb_selinux_set_window_create_context_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_selinux_get_window_create_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_window_create_context_context_length (const xcb_selinux_set_window_create_context_request_t *R) +{ + return R->context_len; +} + +xcb_generic_iterator_t +xcb_selinux_set_window_create_context_context_end (const xcb_selinux_set_window_create_context_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->context_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_selinux_get_window_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_window_create_context_reply_t *_aux = (xcb_selinux_get_window_create_context_reply_t *)_buffer; @@ -625,13 +691,13 @@ xcb_selinux_get_window_create_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_window_create_context_cookie_t -xcb_selinux_get_window_create_context (xcb_connection_t *c /**< */) +xcb_selinux_get_window_create_context (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -649,13 +715,13 @@ xcb_selinux_get_window_create_context (xcb_connection_t *c /**< */) } xcb_selinux_get_window_create_context_cookie_t -xcb_selinux_get_window_create_context_unchecked (xcb_connection_t *c /**< */) +xcb_selinux_get_window_create_context_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -673,19 +739,19 @@ xcb_selinux_get_window_create_context_unchecked (xcb_connection_t *c /**< */) } char * -xcb_selinux_get_window_create_context_context (const xcb_selinux_get_window_create_context_reply_t *R /**< */) +xcb_selinux_get_window_create_context_context (const xcb_selinux_get_window_create_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_window_create_context_context_length (const xcb_selinux_get_window_create_context_reply_t *R /**< */) +xcb_selinux_get_window_create_context_context_length (const xcb_selinux_get_window_create_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_window_create_context_context_end (const xcb_selinux_get_window_create_context_reply_t *R /**< */) +xcb_selinux_get_window_create_context_context_end (const xcb_selinux_get_window_create_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -695,15 +761,15 @@ xcb_selinux_get_window_create_context_context_end (const xcb_selinux_get_window_ } xcb_selinux_get_window_create_context_reply_t * -xcb_selinux_get_window_create_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_window_create_context_reply (xcb_connection_t *c, xcb_selinux_get_window_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_window_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_get_window_context_sizeof (const void *_buffer /**< */) +xcb_selinux_get_window_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_window_context_reply_t *_aux = (xcb_selinux_get_window_context_reply_t *)_buffer; @@ -734,14 +800,14 @@ xcb_selinux_get_window_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_window_context_cookie_t -xcb_selinux_get_window_context (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_selinux_get_window_context (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_WINDOW_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_WINDOW_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -760,14 +826,14 @@ xcb_selinux_get_window_context (xcb_connection_t *c /**< */, } xcb_selinux_get_window_context_cookie_t -xcb_selinux_get_window_context_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_selinux_get_window_context_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_WINDOW_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_WINDOW_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -786,19 +852,19 @@ xcb_selinux_get_window_context_unchecked (xcb_connection_t *c /**< */, } char * -xcb_selinux_get_window_context_context (const xcb_selinux_get_window_context_reply_t *R /**< */) +xcb_selinux_get_window_context_context (const xcb_selinux_get_window_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_window_context_context_length (const xcb_selinux_get_window_context_reply_t *R /**< */) +xcb_selinux_get_window_context_context_length (const xcb_selinux_get_window_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_window_context_context_end (const xcb_selinux_get_window_context_reply_t *R /**< */) +xcb_selinux_get_window_context_context_end (const xcb_selinux_get_window_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -808,15 +874,15 @@ xcb_selinux_get_window_context_context_end (const xcb_selinux_get_window_context } xcb_selinux_get_window_context_reply_t * -xcb_selinux_get_window_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_window_context_reply (xcb_connection_t *c, xcb_selinux_get_window_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_window_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_list_item_sizeof (const void *_buffer /**< */) +xcb_selinux_list_item_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_list_item_t *_aux = (xcb_selinux_list_item_t *)_buffer; @@ -834,6 +900,15 @@ xcb_selinux_list_item_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->object_context_len * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -846,6 +921,15 @@ xcb_selinux_list_item_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->data_context_len * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -859,19 +943,19 @@ xcb_selinux_list_item_sizeof (const void *_buffer /**< */) } char * -xcb_selinux_list_item_object_context (const xcb_selinux_list_item_t *R /**< */) +xcb_selinux_list_item_object_context (const xcb_selinux_list_item_t *R) { return (char *) (R + 1); } int -xcb_selinux_list_item_object_context_length (const xcb_selinux_list_item_t *R /**< */) +xcb_selinux_list_item_object_context_length (const xcb_selinux_list_item_t *R) { return R->object_context_len; } xcb_generic_iterator_t -xcb_selinux_list_item_object_context_end (const xcb_selinux_list_item_t *R /**< */) +xcb_selinux_list_item_object_context_end (const xcb_selinux_list_item_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->object_context_len); @@ -881,31 +965,31 @@ xcb_selinux_list_item_object_context_end (const xcb_selinux_list_item_t *R /**< } char * -xcb_selinux_list_item_data_context (const xcb_selinux_list_item_t *R /**< */) +xcb_selinux_list_item_data_context (const xcb_selinux_list_item_t *R) { xcb_generic_iterator_t prev = xcb_selinux_list_item_object_context_end(R); - return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); + return (char *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); } int -xcb_selinux_list_item_data_context_length (const xcb_selinux_list_item_t *R /**< */) +xcb_selinux_list_item_data_context_length (const xcb_selinux_list_item_t *R) { return R->data_context_len; } xcb_generic_iterator_t -xcb_selinux_list_item_data_context_end (const xcb_selinux_list_item_t *R /**< */) +xcb_selinux_list_item_data_context_end (const xcb_selinux_list_item_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_selinux_list_item_object_context_end(R); - i.data = ((char *) child.data) + (R->data_context_len); + xcb_generic_iterator_t prev = xcb_selinux_list_item_object_context_end(R); + i.data = ((char *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->data_context_len); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } void -xcb_selinux_list_item_next (xcb_selinux_list_item_iterator_t *i /**< */) +xcb_selinux_list_item_next (xcb_selinux_list_item_iterator_t *i) { xcb_selinux_list_item_t *R = i->data; xcb_generic_iterator_t child; @@ -916,7 +1000,7 @@ xcb_selinux_list_item_next (xcb_selinux_list_item_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_selinux_list_item_end (xcb_selinux_list_item_iterator_t i /**< */) +xcb_selinux_list_item_end (xcb_selinux_list_item_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -928,7 +1012,7 @@ xcb_selinux_list_item_end (xcb_selinux_list_item_iterator_t i /**< */) } int -xcb_selinux_set_property_create_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_property_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_set_property_create_context_request_t *_aux = (xcb_selinux_set_property_create_context_request_t *)_buffer; @@ -959,15 +1043,15 @@ xcb_selinux_set_property_create_context_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_selinux_set_property_create_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_property_create_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -991,15 +1075,15 @@ xcb_selinux_set_property_create_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_selinux_set_property_create_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_property_create_context (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1022,8 +1106,30 @@ xcb_selinux_set_property_create_context (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_selinux_set_property_create_context_context (const xcb_selinux_set_property_create_context_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_selinux_get_property_create_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_property_create_context_context_length (const xcb_selinux_set_property_create_context_request_t *R) +{ + return R->context_len; +} + +xcb_generic_iterator_t +xcb_selinux_set_property_create_context_context_end (const xcb_selinux_set_property_create_context_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->context_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_selinux_get_property_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_property_create_context_reply_t *_aux = (xcb_selinux_get_property_create_context_reply_t *)_buffer; @@ -1054,13 +1160,13 @@ xcb_selinux_get_property_create_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_property_create_context_cookie_t -xcb_selinux_get_property_create_context (xcb_connection_t *c /**< */) +xcb_selinux_get_property_create_context (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1078,13 +1184,13 @@ xcb_selinux_get_property_create_context (xcb_connection_t *c /**< */) } xcb_selinux_get_property_create_context_cookie_t -xcb_selinux_get_property_create_context_unchecked (xcb_connection_t *c /**< */) +xcb_selinux_get_property_create_context_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1102,19 +1208,19 @@ xcb_selinux_get_property_create_context_unchecked (xcb_connection_t *c /**< */) } char * -xcb_selinux_get_property_create_context_context (const xcb_selinux_get_property_create_context_reply_t *R /**< */) +xcb_selinux_get_property_create_context_context (const xcb_selinux_get_property_create_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_property_create_context_context_length (const xcb_selinux_get_property_create_context_reply_t *R /**< */) +xcb_selinux_get_property_create_context_context_length (const xcb_selinux_get_property_create_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_property_create_context_context_end (const xcb_selinux_get_property_create_context_reply_t *R /**< */) +xcb_selinux_get_property_create_context_context_end (const xcb_selinux_get_property_create_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -1124,15 +1230,15 @@ xcb_selinux_get_property_create_context_context_end (const xcb_selinux_get_prope } xcb_selinux_get_property_create_context_reply_t * -xcb_selinux_get_property_create_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_property_create_context_reply (xcb_connection_t *c, xcb_selinux_get_property_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_property_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_set_property_use_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_property_use_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_set_property_use_context_request_t *_aux = (xcb_selinux_set_property_use_context_request_t *)_buffer; @@ -1163,15 +1269,15 @@ xcb_selinux_set_property_use_context_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_selinux_set_property_use_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_property_use_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_PROPERTY_USE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_PROPERTY_USE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1195,15 +1301,15 @@ xcb_selinux_set_property_use_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_selinux_set_property_use_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_property_use_context (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_PROPERTY_USE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_PROPERTY_USE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1226,8 +1332,30 @@ xcb_selinux_set_property_use_context (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_selinux_set_property_use_context_context (const xcb_selinux_set_property_use_context_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_selinux_get_property_use_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_property_use_context_context_length (const xcb_selinux_set_property_use_context_request_t *R) +{ + return R->context_len; +} + +xcb_generic_iterator_t +xcb_selinux_set_property_use_context_context_end (const xcb_selinux_set_property_use_context_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->context_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_selinux_get_property_use_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_property_use_context_reply_t *_aux = (xcb_selinux_get_property_use_context_reply_t *)_buffer; @@ -1258,13 +1386,13 @@ xcb_selinux_get_property_use_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_property_use_context_cookie_t -xcb_selinux_get_property_use_context (xcb_connection_t *c /**< */) +xcb_selinux_get_property_use_context (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_PROPERTY_USE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_PROPERTY_USE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1282,13 +1410,13 @@ xcb_selinux_get_property_use_context (xcb_connection_t *c /**< */) } xcb_selinux_get_property_use_context_cookie_t -xcb_selinux_get_property_use_context_unchecked (xcb_connection_t *c /**< */) +xcb_selinux_get_property_use_context_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_PROPERTY_USE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_PROPERTY_USE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1306,19 +1434,19 @@ xcb_selinux_get_property_use_context_unchecked (xcb_connection_t *c /**< */) } char * -xcb_selinux_get_property_use_context_context (const xcb_selinux_get_property_use_context_reply_t *R /**< */) +xcb_selinux_get_property_use_context_context (const xcb_selinux_get_property_use_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_property_use_context_context_length (const xcb_selinux_get_property_use_context_reply_t *R /**< */) +xcb_selinux_get_property_use_context_context_length (const xcb_selinux_get_property_use_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_property_use_context_context_end (const xcb_selinux_get_property_use_context_reply_t *R /**< */) +xcb_selinux_get_property_use_context_context_end (const xcb_selinux_get_property_use_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -1328,15 +1456,15 @@ xcb_selinux_get_property_use_context_context_end (const xcb_selinux_get_property } xcb_selinux_get_property_use_context_reply_t * -xcb_selinux_get_property_use_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_property_use_context_reply (xcb_connection_t *c, xcb_selinux_get_property_use_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_property_use_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_get_property_context_sizeof (const void *_buffer /**< */) +xcb_selinux_get_property_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_property_context_reply_t *_aux = (xcb_selinux_get_property_context_reply_t *)_buffer; @@ -1367,15 +1495,15 @@ xcb_selinux_get_property_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_property_context_cookie_t -xcb_selinux_get_property_context (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */) +xcb_selinux_get_property_context (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_PROPERTY_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_PROPERTY_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1395,15 +1523,15 @@ xcb_selinux_get_property_context (xcb_connection_t *c /**< */, } xcb_selinux_get_property_context_cookie_t -xcb_selinux_get_property_context_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */) +xcb_selinux_get_property_context_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_PROPERTY_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_PROPERTY_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1423,19 +1551,19 @@ xcb_selinux_get_property_context_unchecked (xcb_connection_t *c /**< */, } char * -xcb_selinux_get_property_context_context (const xcb_selinux_get_property_context_reply_t *R /**< */) +xcb_selinux_get_property_context_context (const xcb_selinux_get_property_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_property_context_context_length (const xcb_selinux_get_property_context_reply_t *R /**< */) +xcb_selinux_get_property_context_context_length (const xcb_selinux_get_property_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_property_context_context_end (const xcb_selinux_get_property_context_reply_t *R /**< */) +xcb_selinux_get_property_context_context_end (const xcb_selinux_get_property_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -1445,15 +1573,15 @@ xcb_selinux_get_property_context_context_end (const xcb_selinux_get_property_con } xcb_selinux_get_property_context_reply_t * -xcb_selinux_get_property_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_property_context_reply (xcb_connection_t *c, xcb_selinux_get_property_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_property_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_get_property_data_context_sizeof (const void *_buffer /**< */) +xcb_selinux_get_property_data_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_property_data_context_reply_t *_aux = (xcb_selinux_get_property_data_context_reply_t *)_buffer; @@ -1484,15 +1612,15 @@ xcb_selinux_get_property_data_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_property_data_context_cookie_t -xcb_selinux_get_property_data_context (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */) +xcb_selinux_get_property_data_context (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1512,15 +1640,15 @@ xcb_selinux_get_property_data_context (xcb_connection_t *c /**< */, } xcb_selinux_get_property_data_context_cookie_t -xcb_selinux_get_property_data_context_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */) +xcb_selinux_get_property_data_context_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1540,19 +1668,19 @@ xcb_selinux_get_property_data_context_unchecked (xcb_connection_t *c /**< */, } char * -xcb_selinux_get_property_data_context_context (const xcb_selinux_get_property_data_context_reply_t *R /**< */) +xcb_selinux_get_property_data_context_context (const xcb_selinux_get_property_data_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_property_data_context_context_length (const xcb_selinux_get_property_data_context_reply_t *R /**< */) +xcb_selinux_get_property_data_context_context_length (const xcb_selinux_get_property_data_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_property_data_context_context_end (const xcb_selinux_get_property_data_context_reply_t *R /**< */) +xcb_selinux_get_property_data_context_context_end (const xcb_selinux_get_property_data_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -1562,15 +1690,15 @@ xcb_selinux_get_property_data_context_context_end (const xcb_selinux_get_propert } xcb_selinux_get_property_data_context_reply_t * -xcb_selinux_get_property_data_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_property_data_context_reply (xcb_connection_t *c, xcb_selinux_get_property_data_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_property_data_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_list_properties_sizeof (const void *_buffer /**< */) +xcb_selinux_list_properties_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_list_properties_reply_t *_aux = (xcb_selinux_list_properties_reply_t *)_buffer; @@ -1606,14 +1734,14 @@ xcb_selinux_list_properties_sizeof (const void *_buffer /**< */) } xcb_selinux_list_properties_cookie_t -xcb_selinux_list_properties (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_selinux_list_properties (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_LIST_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_LIST_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1632,14 +1760,14 @@ xcb_selinux_list_properties (xcb_connection_t *c /**< */, } xcb_selinux_list_properties_cookie_t -xcb_selinux_list_properties_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_selinux_list_properties_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_LIST_PROPERTIES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_LIST_PROPERTIES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1658,13 +1786,13 @@ xcb_selinux_list_properties_unchecked (xcb_connection_t *c /**< */, } int -xcb_selinux_list_properties_properties_length (const xcb_selinux_list_properties_reply_t *R /**< */) +xcb_selinux_list_properties_properties_length (const xcb_selinux_list_properties_reply_t *R) { return R->properties_len; } xcb_selinux_list_item_iterator_t -xcb_selinux_list_properties_properties_iterator (const xcb_selinux_list_properties_reply_t *R /**< */) +xcb_selinux_list_properties_properties_iterator (const xcb_selinux_list_properties_reply_t *R) { xcb_selinux_list_item_iterator_t i; i.data = (xcb_selinux_list_item_t *) (R + 1); @@ -1674,15 +1802,15 @@ xcb_selinux_list_properties_properties_iterator (const xcb_selinux_list_properti } xcb_selinux_list_properties_reply_t * -xcb_selinux_list_properties_reply (xcb_connection_t *c /**< */, +xcb_selinux_list_properties_reply (xcb_connection_t *c, xcb_selinux_list_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_set_selection_create_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_selection_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_set_selection_create_context_request_t *_aux = (xcb_selinux_set_selection_create_context_request_t *)_buffer; @@ -1713,15 +1841,15 @@ xcb_selinux_set_selection_create_context_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_selinux_set_selection_create_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_selection_create_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1745,15 +1873,15 @@ xcb_selinux_set_selection_create_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_selinux_set_selection_create_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_selection_create_context (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1776,8 +1904,30 @@ xcb_selinux_set_selection_create_context (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_selinux_set_selection_create_context_context (const xcb_selinux_set_selection_create_context_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_selinux_get_selection_create_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_selection_create_context_context_length (const xcb_selinux_set_selection_create_context_request_t *R) +{ + return R->context_len; +} + +xcb_generic_iterator_t +xcb_selinux_set_selection_create_context_context_end (const xcb_selinux_set_selection_create_context_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->context_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_selinux_get_selection_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_selection_create_context_reply_t *_aux = (xcb_selinux_get_selection_create_context_reply_t *)_buffer; @@ -1808,13 +1958,13 @@ xcb_selinux_get_selection_create_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_selection_create_context_cookie_t -xcb_selinux_get_selection_create_context (xcb_connection_t *c /**< */) +xcb_selinux_get_selection_create_context (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1832,13 +1982,13 @@ xcb_selinux_get_selection_create_context (xcb_connection_t *c /**< */) } xcb_selinux_get_selection_create_context_cookie_t -xcb_selinux_get_selection_create_context_unchecked (xcb_connection_t *c /**< */) +xcb_selinux_get_selection_create_context_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1856,19 +2006,19 @@ xcb_selinux_get_selection_create_context_unchecked (xcb_connection_t *c /**< */ } char * -xcb_selinux_get_selection_create_context_context (const xcb_selinux_get_selection_create_context_reply_t *R /**< */) +xcb_selinux_get_selection_create_context_context (const xcb_selinux_get_selection_create_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_selection_create_context_context_length (const xcb_selinux_get_selection_create_context_reply_t *R /**< */) +xcb_selinux_get_selection_create_context_context_length (const xcb_selinux_get_selection_create_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_selection_create_context_context_end (const xcb_selinux_get_selection_create_context_reply_t *R /**< */) +xcb_selinux_get_selection_create_context_context_end (const xcb_selinux_get_selection_create_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -1878,15 +2028,15 @@ xcb_selinux_get_selection_create_context_context_end (const xcb_selinux_get_sele } xcb_selinux_get_selection_create_context_reply_t * -xcb_selinux_get_selection_create_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_selection_create_context_reply (xcb_connection_t *c, xcb_selinux_get_selection_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_selection_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_set_selection_use_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_selection_use_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_set_selection_use_context_request_t *_aux = (xcb_selinux_set_selection_use_context_request_t *)_buffer; @@ -1917,15 +2067,15 @@ xcb_selinux_set_selection_use_context_sizeof (const void *_buffer /**< */) } xcb_void_cookie_t -xcb_selinux_set_selection_use_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_selection_use_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_SELECTION_USE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_SELECTION_USE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1949,15 +2099,15 @@ xcb_selinux_set_selection_use_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_selinux_set_selection_use_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */) +xcb_selinux_set_selection_use_context (xcb_connection_t *c, + uint32_t context_len, + const char *context) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_SET_SELECTION_USE_CONTEXT, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_SET_SELECTION_USE_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -1980,8 +2130,30 @@ xcb_selinux_set_selection_use_context (xcb_connection_t *c /**< */, return xcb_ret; } +char * +xcb_selinux_set_selection_use_context_context (const xcb_selinux_set_selection_use_context_request_t *R) +{ + return (char *) (R + 1); +} + int -xcb_selinux_get_selection_use_context_sizeof (const void *_buffer /**< */) +xcb_selinux_set_selection_use_context_context_length (const xcb_selinux_set_selection_use_context_request_t *R) +{ + return R->context_len; +} + +xcb_generic_iterator_t +xcb_selinux_set_selection_use_context_context_end (const xcb_selinux_set_selection_use_context_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->context_len); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_selinux_get_selection_use_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_selection_use_context_reply_t *_aux = (xcb_selinux_get_selection_use_context_reply_t *)_buffer; @@ -2012,13 +2184,13 @@ xcb_selinux_get_selection_use_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_selection_use_context_cookie_t -xcb_selinux_get_selection_use_context (xcb_connection_t *c /**< */) +xcb_selinux_get_selection_use_context (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_SELECTION_USE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_SELECTION_USE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2036,13 +2208,13 @@ xcb_selinux_get_selection_use_context (xcb_connection_t *c /**< */) } xcb_selinux_get_selection_use_context_cookie_t -xcb_selinux_get_selection_use_context_unchecked (xcb_connection_t *c /**< */) +xcb_selinux_get_selection_use_context_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_SELECTION_USE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_SELECTION_USE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2060,19 +2232,19 @@ xcb_selinux_get_selection_use_context_unchecked (xcb_connection_t *c /**< */) } char * -xcb_selinux_get_selection_use_context_context (const xcb_selinux_get_selection_use_context_reply_t *R /**< */) +xcb_selinux_get_selection_use_context_context (const xcb_selinux_get_selection_use_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_selection_use_context_context_length (const xcb_selinux_get_selection_use_context_reply_t *R /**< */) +xcb_selinux_get_selection_use_context_context_length (const xcb_selinux_get_selection_use_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_selection_use_context_context_end (const xcb_selinux_get_selection_use_context_reply_t *R /**< */) +xcb_selinux_get_selection_use_context_context_end (const xcb_selinux_get_selection_use_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -2082,15 +2254,15 @@ xcb_selinux_get_selection_use_context_context_end (const xcb_selinux_get_selecti } xcb_selinux_get_selection_use_context_reply_t * -xcb_selinux_get_selection_use_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_selection_use_context_reply (xcb_connection_t *c, xcb_selinux_get_selection_use_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_selection_use_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_get_selection_context_sizeof (const void *_buffer /**< */) +xcb_selinux_get_selection_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_selection_context_reply_t *_aux = (xcb_selinux_get_selection_context_reply_t *)_buffer; @@ -2121,14 +2293,14 @@ xcb_selinux_get_selection_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_selection_context_cookie_t -xcb_selinux_get_selection_context (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */) +xcb_selinux_get_selection_context (xcb_connection_t *c, + xcb_atom_t selection) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_SELECTION_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_SELECTION_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2147,14 +2319,14 @@ xcb_selinux_get_selection_context (xcb_connection_t *c /**< */, } xcb_selinux_get_selection_context_cookie_t -xcb_selinux_get_selection_context_unchecked (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */) +xcb_selinux_get_selection_context_unchecked (xcb_connection_t *c, + xcb_atom_t selection) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_SELECTION_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_SELECTION_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2173,19 +2345,19 @@ xcb_selinux_get_selection_context_unchecked (xcb_connection_t *c /**< */, } char * -xcb_selinux_get_selection_context_context (const xcb_selinux_get_selection_context_reply_t *R /**< */) +xcb_selinux_get_selection_context_context (const xcb_selinux_get_selection_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_selection_context_context_length (const xcb_selinux_get_selection_context_reply_t *R /**< */) +xcb_selinux_get_selection_context_context_length (const xcb_selinux_get_selection_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_selection_context_context_end (const xcb_selinux_get_selection_context_reply_t *R /**< */) +xcb_selinux_get_selection_context_context_end (const xcb_selinux_get_selection_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -2195,15 +2367,15 @@ xcb_selinux_get_selection_context_context_end (const xcb_selinux_get_selection_c } xcb_selinux_get_selection_context_reply_t * -xcb_selinux_get_selection_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_selection_context_reply (xcb_connection_t *c, xcb_selinux_get_selection_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_selection_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_get_selection_data_context_sizeof (const void *_buffer /**< */) +xcb_selinux_get_selection_data_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_selection_data_context_reply_t *_aux = (xcb_selinux_get_selection_data_context_reply_t *)_buffer; @@ -2234,14 +2406,14 @@ xcb_selinux_get_selection_data_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_selection_data_context_cookie_t -xcb_selinux_get_selection_data_context (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */) +xcb_selinux_get_selection_data_context (xcb_connection_t *c, + xcb_atom_t selection) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_SELECTION_DATA_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_SELECTION_DATA_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2260,14 +2432,14 @@ xcb_selinux_get_selection_data_context (xcb_connection_t *c /**< */, } xcb_selinux_get_selection_data_context_cookie_t -xcb_selinux_get_selection_data_context_unchecked (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */) +xcb_selinux_get_selection_data_context_unchecked (xcb_connection_t *c, + xcb_atom_t selection) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_SELECTION_DATA_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_SELECTION_DATA_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2286,19 +2458,19 @@ xcb_selinux_get_selection_data_context_unchecked (xcb_connection_t *c /**< */, } char * -xcb_selinux_get_selection_data_context_context (const xcb_selinux_get_selection_data_context_reply_t *R /**< */) +xcb_selinux_get_selection_data_context_context (const xcb_selinux_get_selection_data_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_selection_data_context_context_length (const xcb_selinux_get_selection_data_context_reply_t *R /**< */) +xcb_selinux_get_selection_data_context_context_length (const xcb_selinux_get_selection_data_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_selection_data_context_context_end (const xcb_selinux_get_selection_data_context_reply_t *R /**< */) +xcb_selinux_get_selection_data_context_context_end (const xcb_selinux_get_selection_data_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -2308,15 +2480,15 @@ xcb_selinux_get_selection_data_context_context_end (const xcb_selinux_get_select } xcb_selinux_get_selection_data_context_reply_t * -xcb_selinux_get_selection_data_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_selection_data_context_reply (xcb_connection_t *c, xcb_selinux_get_selection_data_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_selection_data_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_list_selections_sizeof (const void *_buffer /**< */) +xcb_selinux_list_selections_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_list_selections_reply_t *_aux = (xcb_selinux_list_selections_reply_t *)_buffer; @@ -2352,13 +2524,13 @@ xcb_selinux_list_selections_sizeof (const void *_buffer /**< */) } xcb_selinux_list_selections_cookie_t -xcb_selinux_list_selections (xcb_connection_t *c /**< */) +xcb_selinux_list_selections (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_LIST_SELECTIONS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_LIST_SELECTIONS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2376,13 +2548,13 @@ xcb_selinux_list_selections (xcb_connection_t *c /**< */) } xcb_selinux_list_selections_cookie_t -xcb_selinux_list_selections_unchecked (xcb_connection_t *c /**< */) +xcb_selinux_list_selections_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_LIST_SELECTIONS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_LIST_SELECTIONS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2400,13 +2572,13 @@ xcb_selinux_list_selections_unchecked (xcb_connection_t *c /**< */) } int -xcb_selinux_list_selections_selections_length (const xcb_selinux_list_selections_reply_t *R /**< */) +xcb_selinux_list_selections_selections_length (const xcb_selinux_list_selections_reply_t *R) { return R->selections_len; } xcb_selinux_list_item_iterator_t -xcb_selinux_list_selections_selections_iterator (const xcb_selinux_list_selections_reply_t *R /**< */) +xcb_selinux_list_selections_selections_iterator (const xcb_selinux_list_selections_reply_t *R) { xcb_selinux_list_item_iterator_t i; i.data = (xcb_selinux_list_item_t *) (R + 1); @@ -2416,15 +2588,15 @@ xcb_selinux_list_selections_selections_iterator (const xcb_selinux_list_selectio } xcb_selinux_list_selections_reply_t * -xcb_selinux_list_selections_reply (xcb_connection_t *c /**< */, +xcb_selinux_list_selections_reply (xcb_connection_t *c, xcb_selinux_list_selections_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_list_selections_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_selinux_get_client_context_sizeof (const void *_buffer /**< */) +xcb_selinux_get_client_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_selinux_get_client_context_reply_t *_aux = (xcb_selinux_get_client_context_reply_t *)_buffer; @@ -2455,14 +2627,14 @@ xcb_selinux_get_client_context_sizeof (const void *_buffer /**< */) } xcb_selinux_get_client_context_cookie_t -xcb_selinux_get_client_context (xcb_connection_t *c /**< */, - uint32_t resource /**< */) +xcb_selinux_get_client_context (xcb_connection_t *c, + uint32_t resource) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_CLIENT_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_CLIENT_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2481,14 +2653,14 @@ xcb_selinux_get_client_context (xcb_connection_t *c /**< */, } xcb_selinux_get_client_context_cookie_t -xcb_selinux_get_client_context_unchecked (xcb_connection_t *c /**< */, - uint32_t resource /**< */) +xcb_selinux_get_client_context_unchecked (xcb_connection_t *c, + uint32_t resource) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_selinux_id, - /* opcode */ XCB_SELINUX_GET_CLIENT_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_selinux_id, + .opcode = XCB_SELINUX_GET_CLIENT_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2507,19 +2679,19 @@ xcb_selinux_get_client_context_unchecked (xcb_connection_t *c /**< */, } char * -xcb_selinux_get_client_context_context (const xcb_selinux_get_client_context_reply_t *R /**< */) +xcb_selinux_get_client_context_context (const xcb_selinux_get_client_context_reply_t *R) { return (char *) (R + 1); } int -xcb_selinux_get_client_context_context_length (const xcb_selinux_get_client_context_reply_t *R /**< */) +xcb_selinux_get_client_context_context_length (const xcb_selinux_get_client_context_reply_t *R) { return R->context_len; } xcb_generic_iterator_t -xcb_selinux_get_client_context_context_end (const xcb_selinux_get_client_context_reply_t *R /**< */) +xcb_selinux_get_client_context_context_end (const xcb_selinux_get_client_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->context_len); @@ -2529,9 +2701,9 @@ xcb_selinux_get_client_context_context_end (const xcb_selinux_get_client_context } xcb_selinux_get_client_context_reply_t * -xcb_selinux_get_client_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_client_context_reply (xcb_connection_t *c, xcb_selinux_get_client_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_selinux_get_client_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/xselinux.h b/lib/libxcb/src/xselinux.h index d5e79eaa3..abcb28db1 100644 --- a/lib/libxcb/src/xselinux.h +++ b/lib/libxcb/src/xselinux.h @@ -28,7 +28,7 @@ extern xcb_extension_t xcb_selinux_id; * @brief xcb_selinux_query_version_cookie_t **/ typedef struct xcb_selinux_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_query_version_cookie_t; /** Opcode for xcb_selinux_query_version. */ @@ -38,23 +38,23 @@ typedef struct xcb_selinux_query_version_cookie_t { * @brief xcb_selinux_query_version_request_t **/ typedef struct xcb_selinux_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t client_major; /**< */ - uint8_t client_minor; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t client_major; + uint8_t client_minor; } xcb_selinux_query_version_request_t; /** * @brief xcb_selinux_query_version_reply_t **/ typedef struct xcb_selinux_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t server_major; /**< */ - uint16_t server_minor; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t server_major; + uint16_t server_minor; } xcb_selinux_query_version_reply_t; /** Opcode for xcb_selinux_set_device_create_context. */ @@ -64,17 +64,17 @@ typedef struct xcb_selinux_query_version_reply_t { * @brief xcb_selinux_set_device_create_context_request_t **/ typedef struct xcb_selinux_set_device_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t context_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t context_len; } xcb_selinux_set_device_create_context_request_t; /** * @brief xcb_selinux_get_device_create_context_cookie_t **/ typedef struct xcb_selinux_get_device_create_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_device_create_context_cookie_t; /** Opcode for xcb_selinux_get_device_create_context. */ @@ -84,21 +84,21 @@ typedef struct xcb_selinux_get_device_create_context_cookie_t { * @brief xcb_selinux_get_device_create_context_request_t **/ typedef struct xcb_selinux_get_device_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_selinux_get_device_create_context_request_t; /** * @brief xcb_selinux_get_device_create_context_reply_t **/ typedef struct xcb_selinux_get_device_create_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_device_create_context_reply_t; /** Opcode for xcb_selinux_set_device_context. */ @@ -108,18 +108,18 @@ typedef struct xcb_selinux_get_device_create_context_reply_t { * @brief xcb_selinux_set_device_context_request_t **/ typedef struct xcb_selinux_set_device_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t device; /**< */ - uint32_t context_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t device; + uint32_t context_len; } xcb_selinux_set_device_context_request_t; /** * @brief xcb_selinux_get_device_context_cookie_t **/ typedef struct xcb_selinux_get_device_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_device_context_cookie_t; /** Opcode for xcb_selinux_get_device_context. */ @@ -129,22 +129,22 @@ typedef struct xcb_selinux_get_device_context_cookie_t { * @brief xcb_selinux_get_device_context_request_t **/ typedef struct xcb_selinux_get_device_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t device; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t device; } xcb_selinux_get_device_context_request_t; /** * @brief xcb_selinux_get_device_context_reply_t **/ typedef struct xcb_selinux_get_device_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_device_context_reply_t; /** Opcode for xcb_selinux_set_window_create_context. */ @@ -154,17 +154,17 @@ typedef struct xcb_selinux_get_device_context_reply_t { * @brief xcb_selinux_set_window_create_context_request_t **/ typedef struct xcb_selinux_set_window_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t context_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t context_len; } xcb_selinux_set_window_create_context_request_t; /** * @brief xcb_selinux_get_window_create_context_cookie_t **/ typedef struct xcb_selinux_get_window_create_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_window_create_context_cookie_t; /** Opcode for xcb_selinux_get_window_create_context. */ @@ -174,28 +174,28 @@ typedef struct xcb_selinux_get_window_create_context_cookie_t { * @brief xcb_selinux_get_window_create_context_request_t **/ typedef struct xcb_selinux_get_window_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_selinux_get_window_create_context_request_t; /** * @brief xcb_selinux_get_window_create_context_reply_t **/ typedef struct xcb_selinux_get_window_create_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_window_create_context_reply_t; /** * @brief xcb_selinux_get_window_context_cookie_t **/ typedef struct xcb_selinux_get_window_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_window_context_cookie_t; /** Opcode for xcb_selinux_get_window_context. */ @@ -205,40 +205,40 @@ typedef struct xcb_selinux_get_window_context_cookie_t { * @brief xcb_selinux_get_window_context_request_t **/ typedef struct xcb_selinux_get_window_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_selinux_get_window_context_request_t; /** * @brief xcb_selinux_get_window_context_reply_t **/ typedef struct xcb_selinux_get_window_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_window_context_reply_t; /** * @brief xcb_selinux_list_item_t **/ typedef struct xcb_selinux_list_item_t { - xcb_atom_t name; /**< */ - uint32_t object_context_len; /**< */ - uint32_t data_context_len; /**< */ + xcb_atom_t name; + uint32_t object_context_len; + uint32_t data_context_len; } xcb_selinux_list_item_t; /** * @brief xcb_selinux_list_item_iterator_t **/ typedef struct xcb_selinux_list_item_iterator_t { - xcb_selinux_list_item_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_selinux_list_item_t *data; + int rem; + int index; } xcb_selinux_list_item_iterator_t; /** Opcode for xcb_selinux_set_property_create_context. */ @@ -248,17 +248,17 @@ typedef struct xcb_selinux_list_item_iterator_t { * @brief xcb_selinux_set_property_create_context_request_t **/ typedef struct xcb_selinux_set_property_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t context_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t context_len; } xcb_selinux_set_property_create_context_request_t; /** * @brief xcb_selinux_get_property_create_context_cookie_t **/ typedef struct xcb_selinux_get_property_create_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_property_create_context_cookie_t; /** Opcode for xcb_selinux_get_property_create_context. */ @@ -268,21 +268,21 @@ typedef struct xcb_selinux_get_property_create_context_cookie_t { * @brief xcb_selinux_get_property_create_context_request_t **/ typedef struct xcb_selinux_get_property_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_selinux_get_property_create_context_request_t; /** * @brief xcb_selinux_get_property_create_context_reply_t **/ typedef struct xcb_selinux_get_property_create_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_property_create_context_reply_t; /** Opcode for xcb_selinux_set_property_use_context. */ @@ -292,17 +292,17 @@ typedef struct xcb_selinux_get_property_create_context_reply_t { * @brief xcb_selinux_set_property_use_context_request_t **/ typedef struct xcb_selinux_set_property_use_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t context_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t context_len; } xcb_selinux_set_property_use_context_request_t; /** * @brief xcb_selinux_get_property_use_context_cookie_t **/ typedef struct xcb_selinux_get_property_use_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_property_use_context_cookie_t; /** Opcode for xcb_selinux_get_property_use_context. */ @@ -312,28 +312,28 @@ typedef struct xcb_selinux_get_property_use_context_cookie_t { * @brief xcb_selinux_get_property_use_context_request_t **/ typedef struct xcb_selinux_get_property_use_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_selinux_get_property_use_context_request_t; /** * @brief xcb_selinux_get_property_use_context_reply_t **/ typedef struct xcb_selinux_get_property_use_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_property_use_context_reply_t; /** * @brief xcb_selinux_get_property_context_cookie_t **/ typedef struct xcb_selinux_get_property_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_property_context_cookie_t; /** Opcode for xcb_selinux_get_property_context. */ @@ -343,30 +343,30 @@ typedef struct xcb_selinux_get_property_context_cookie_t { * @brief xcb_selinux_get_property_context_request_t **/ typedef struct xcb_selinux_get_property_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_atom_t property; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_atom_t property; } xcb_selinux_get_property_context_request_t; /** * @brief xcb_selinux_get_property_context_reply_t **/ typedef struct xcb_selinux_get_property_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_property_context_reply_t; /** * @brief xcb_selinux_get_property_data_context_cookie_t **/ typedef struct xcb_selinux_get_property_data_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_property_data_context_cookie_t; /** Opcode for xcb_selinux_get_property_data_context. */ @@ -376,30 +376,30 @@ typedef struct xcb_selinux_get_property_data_context_cookie_t { * @brief xcb_selinux_get_property_data_context_request_t **/ typedef struct xcb_selinux_get_property_data_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_atom_t property; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_atom_t property; } xcb_selinux_get_property_data_context_request_t; /** * @brief xcb_selinux_get_property_data_context_reply_t **/ typedef struct xcb_selinux_get_property_data_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_property_data_context_reply_t; /** * @brief xcb_selinux_list_properties_cookie_t **/ typedef struct xcb_selinux_list_properties_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_list_properties_cookie_t; /** Opcode for xcb_selinux_list_properties. */ @@ -409,22 +409,22 @@ typedef struct xcb_selinux_list_properties_cookie_t { * @brief xcb_selinux_list_properties_request_t **/ typedef struct xcb_selinux_list_properties_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_selinux_list_properties_request_t; /** * @brief xcb_selinux_list_properties_reply_t **/ typedef struct xcb_selinux_list_properties_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t properties_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t properties_len; + uint8_t pad1[20]; } xcb_selinux_list_properties_reply_t; /** Opcode for xcb_selinux_set_selection_create_context. */ @@ -434,17 +434,17 @@ typedef struct xcb_selinux_list_properties_reply_t { * @brief xcb_selinux_set_selection_create_context_request_t **/ typedef struct xcb_selinux_set_selection_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t context_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t context_len; } xcb_selinux_set_selection_create_context_request_t; /** * @brief xcb_selinux_get_selection_create_context_cookie_t **/ typedef struct xcb_selinux_get_selection_create_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_selection_create_context_cookie_t; /** Opcode for xcb_selinux_get_selection_create_context. */ @@ -454,21 +454,21 @@ typedef struct xcb_selinux_get_selection_create_context_cookie_t { * @brief xcb_selinux_get_selection_create_context_request_t **/ typedef struct xcb_selinux_get_selection_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_selinux_get_selection_create_context_request_t; /** * @brief xcb_selinux_get_selection_create_context_reply_t **/ typedef struct xcb_selinux_get_selection_create_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_selection_create_context_reply_t; /** Opcode for xcb_selinux_set_selection_use_context. */ @@ -478,17 +478,17 @@ typedef struct xcb_selinux_get_selection_create_context_reply_t { * @brief xcb_selinux_set_selection_use_context_request_t **/ typedef struct xcb_selinux_set_selection_use_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t context_len; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t context_len; } xcb_selinux_set_selection_use_context_request_t; /** * @brief xcb_selinux_get_selection_use_context_cookie_t **/ typedef struct xcb_selinux_get_selection_use_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_selection_use_context_cookie_t; /** Opcode for xcb_selinux_get_selection_use_context. */ @@ -498,28 +498,28 @@ typedef struct xcb_selinux_get_selection_use_context_cookie_t { * @brief xcb_selinux_get_selection_use_context_request_t **/ typedef struct xcb_selinux_get_selection_use_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_selinux_get_selection_use_context_request_t; /** * @brief xcb_selinux_get_selection_use_context_reply_t **/ typedef struct xcb_selinux_get_selection_use_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_selection_use_context_reply_t; /** * @brief xcb_selinux_get_selection_context_cookie_t **/ typedef struct xcb_selinux_get_selection_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_selection_context_cookie_t; /** Opcode for xcb_selinux_get_selection_context. */ @@ -529,29 +529,29 @@ typedef struct xcb_selinux_get_selection_context_cookie_t { * @brief xcb_selinux_get_selection_context_request_t **/ typedef struct xcb_selinux_get_selection_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_atom_t selection; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_atom_t selection; } xcb_selinux_get_selection_context_request_t; /** * @brief xcb_selinux_get_selection_context_reply_t **/ typedef struct xcb_selinux_get_selection_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_selection_context_reply_t; /** * @brief xcb_selinux_get_selection_data_context_cookie_t **/ typedef struct xcb_selinux_get_selection_data_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_selection_data_context_cookie_t; /** Opcode for xcb_selinux_get_selection_data_context. */ @@ -561,29 +561,29 @@ typedef struct xcb_selinux_get_selection_data_context_cookie_t { * @brief xcb_selinux_get_selection_data_context_request_t **/ typedef struct xcb_selinux_get_selection_data_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_atom_t selection; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_atom_t selection; } xcb_selinux_get_selection_data_context_request_t; /** * @brief xcb_selinux_get_selection_data_context_reply_t **/ typedef struct xcb_selinux_get_selection_data_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_selection_data_context_reply_t; /** * @brief xcb_selinux_list_selections_cookie_t **/ typedef struct xcb_selinux_list_selections_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_list_selections_cookie_t; /** Opcode for xcb_selinux_list_selections. */ @@ -593,28 +593,28 @@ typedef struct xcb_selinux_list_selections_cookie_t { * @brief xcb_selinux_list_selections_request_t **/ typedef struct xcb_selinux_list_selections_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_selinux_list_selections_request_t; /** * @brief xcb_selinux_list_selections_reply_t **/ typedef struct xcb_selinux_list_selections_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t selections_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t selections_len; + uint8_t pad1[20]; } xcb_selinux_list_selections_reply_t; /** * @brief xcb_selinux_get_client_context_cookie_t **/ typedef struct xcb_selinux_get_client_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_selinux_get_client_context_cookie_t; /** Opcode for xcb_selinux_get_client_context. */ @@ -624,22 +624,22 @@ typedef struct xcb_selinux_get_client_context_cookie_t { * @brief xcb_selinux_get_client_context_request_t **/ typedef struct xcb_selinux_get_client_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint32_t resource; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint32_t resource; } xcb_selinux_get_client_context_request_t; /** * @brief xcb_selinux_get_client_context_reply_t **/ typedef struct xcb_selinux_get_client_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t context_len; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t context_len; + uint8_t pad1[20]; } xcb_selinux_get_client_context_reply_t; /** @@ -651,9 +651,9 @@ typedef struct xcb_selinux_get_client_context_reply_t { * */ xcb_selinux_query_version_cookie_t -xcb_selinux_query_version (xcb_connection_t *c /**< */, - uint8_t client_major /**< */, - uint8_t client_minor /**< */); +xcb_selinux_query_version (xcb_connection_t *c, + uint8_t client_major, + uint8_t client_minor); /** * @@ -667,9 +667,9 @@ xcb_selinux_query_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_selinux_query_version_cookie_t -xcb_selinux_query_version_unchecked (xcb_connection_t *c /**< */, - uint8_t client_major /**< */, - uint8_t client_minor /**< */); +xcb_selinux_query_version_unchecked (xcb_connection_t *c, + uint8_t client_major, + uint8_t client_minor); /** * Return the reply @@ -686,12 +686,12 @@ xcb_selinux_query_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_selinux_query_version_reply_t * -xcb_selinux_query_version_reply (xcb_connection_t *c /**< */, +xcb_selinux_query_version_reply (xcb_connection_t *c, xcb_selinux_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_set_device_create_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_device_create_context_sizeof (const void *_buffer); /** * @@ -705,9 +705,9 @@ xcb_selinux_set_device_create_context_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_selinux_set_device_create_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_device_create_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context); /** * @@ -718,12 +718,21 @@ xcb_selinux_set_device_create_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_selinux_set_device_create_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_device_create_context (xcb_connection_t *c, + uint32_t context_len, + const char *context); + +char * +xcb_selinux_set_device_create_context_context (const xcb_selinux_set_device_create_context_request_t *R); int -xcb_selinux_get_device_create_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_device_create_context_context_length (const xcb_selinux_set_device_create_context_request_t *R); + +xcb_generic_iterator_t +xcb_selinux_set_device_create_context_context_end (const xcb_selinux_set_device_create_context_request_t *R); + +int +xcb_selinux_get_device_create_context_sizeof (const void *_buffer); /** * @@ -734,7 +743,7 @@ xcb_selinux_get_device_create_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_device_create_context_cookie_t -xcb_selinux_get_device_create_context (xcb_connection_t *c /**< */); +xcb_selinux_get_device_create_context (xcb_connection_t *c); /** * @@ -748,16 +757,16 @@ xcb_selinux_get_device_create_context (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_selinux_get_device_create_context_cookie_t -xcb_selinux_get_device_create_context_unchecked (xcb_connection_t *c /**< */); +xcb_selinux_get_device_create_context_unchecked (xcb_connection_t *c); char * -xcb_selinux_get_device_create_context_context (const xcb_selinux_get_device_create_context_reply_t *R /**< */); +xcb_selinux_get_device_create_context_context (const xcb_selinux_get_device_create_context_reply_t *R); int -xcb_selinux_get_device_create_context_context_length (const xcb_selinux_get_device_create_context_reply_t *R /**< */); +xcb_selinux_get_device_create_context_context_length (const xcb_selinux_get_device_create_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_device_create_context_context_end (const xcb_selinux_get_device_create_context_reply_t *R /**< */); +xcb_selinux_get_device_create_context_context_end (const xcb_selinux_get_device_create_context_reply_t *R); /** * Return the reply @@ -774,12 +783,12 @@ xcb_selinux_get_device_create_context_context_end (const xcb_selinux_get_device_ * The returned value must be freed by the caller using free(). */ xcb_selinux_get_device_create_context_reply_t * -xcb_selinux_get_device_create_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_device_create_context_reply (xcb_connection_t *c, xcb_selinux_get_device_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_set_device_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_device_context_sizeof (const void *_buffer); /** * @@ -793,10 +802,10 @@ xcb_selinux_set_device_context_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_selinux_set_device_context_checked (xcb_connection_t *c /**< */, - uint32_t device /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_device_context_checked (xcb_connection_t *c, + uint32_t device, + uint32_t context_len, + const char *context); /** * @@ -807,13 +816,22 @@ xcb_selinux_set_device_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_selinux_set_device_context (xcb_connection_t *c /**< */, - uint32_t device /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_device_context (xcb_connection_t *c, + uint32_t device, + uint32_t context_len, + const char *context); + +char * +xcb_selinux_set_device_context_context (const xcb_selinux_set_device_context_request_t *R); int -xcb_selinux_get_device_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_device_context_context_length (const xcb_selinux_set_device_context_request_t *R); + +xcb_generic_iterator_t +xcb_selinux_set_device_context_context_end (const xcb_selinux_set_device_context_request_t *R); + +int +xcb_selinux_get_device_context_sizeof (const void *_buffer); /** * @@ -824,8 +842,8 @@ xcb_selinux_get_device_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_device_context_cookie_t -xcb_selinux_get_device_context (xcb_connection_t *c /**< */, - uint32_t device /**< */); +xcb_selinux_get_device_context (xcb_connection_t *c, + uint32_t device); /** * @@ -839,17 +857,17 @@ xcb_selinux_get_device_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_selinux_get_device_context_cookie_t -xcb_selinux_get_device_context_unchecked (xcb_connection_t *c /**< */, - uint32_t device /**< */); +xcb_selinux_get_device_context_unchecked (xcb_connection_t *c, + uint32_t device); char * -xcb_selinux_get_device_context_context (const xcb_selinux_get_device_context_reply_t *R /**< */); +xcb_selinux_get_device_context_context (const xcb_selinux_get_device_context_reply_t *R); int -xcb_selinux_get_device_context_context_length (const xcb_selinux_get_device_context_reply_t *R /**< */); +xcb_selinux_get_device_context_context_length (const xcb_selinux_get_device_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_device_context_context_end (const xcb_selinux_get_device_context_reply_t *R /**< */); +xcb_selinux_get_device_context_context_end (const xcb_selinux_get_device_context_reply_t *R); /** * Return the reply @@ -866,12 +884,12 @@ xcb_selinux_get_device_context_context_end (const xcb_selinux_get_device_context * The returned value must be freed by the caller using free(). */ xcb_selinux_get_device_context_reply_t * -xcb_selinux_get_device_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_device_context_reply (xcb_connection_t *c, xcb_selinux_get_device_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_set_window_create_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_window_create_context_sizeof (const void *_buffer); /** * @@ -885,9 +903,9 @@ xcb_selinux_set_window_create_context_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_selinux_set_window_create_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_window_create_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context); /** * @@ -898,12 +916,21 @@ xcb_selinux_set_window_create_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_selinux_set_window_create_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_window_create_context (xcb_connection_t *c, + uint32_t context_len, + const char *context); + +char * +xcb_selinux_set_window_create_context_context (const xcb_selinux_set_window_create_context_request_t *R); int -xcb_selinux_get_window_create_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_window_create_context_context_length (const xcb_selinux_set_window_create_context_request_t *R); + +xcb_generic_iterator_t +xcb_selinux_set_window_create_context_context_end (const xcb_selinux_set_window_create_context_request_t *R); + +int +xcb_selinux_get_window_create_context_sizeof (const void *_buffer); /** * @@ -914,7 +941,7 @@ xcb_selinux_get_window_create_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_window_create_context_cookie_t -xcb_selinux_get_window_create_context (xcb_connection_t *c /**< */); +xcb_selinux_get_window_create_context (xcb_connection_t *c); /** * @@ -928,16 +955,16 @@ xcb_selinux_get_window_create_context (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_selinux_get_window_create_context_cookie_t -xcb_selinux_get_window_create_context_unchecked (xcb_connection_t *c /**< */); +xcb_selinux_get_window_create_context_unchecked (xcb_connection_t *c); char * -xcb_selinux_get_window_create_context_context (const xcb_selinux_get_window_create_context_reply_t *R /**< */); +xcb_selinux_get_window_create_context_context (const xcb_selinux_get_window_create_context_reply_t *R); int -xcb_selinux_get_window_create_context_context_length (const xcb_selinux_get_window_create_context_reply_t *R /**< */); +xcb_selinux_get_window_create_context_context_length (const xcb_selinux_get_window_create_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_window_create_context_context_end (const xcb_selinux_get_window_create_context_reply_t *R /**< */); +xcb_selinux_get_window_create_context_context_end (const xcb_selinux_get_window_create_context_reply_t *R); /** * Return the reply @@ -954,12 +981,12 @@ xcb_selinux_get_window_create_context_context_end (const xcb_selinux_get_window_ * The returned value must be freed by the caller using free(). */ xcb_selinux_get_window_create_context_reply_t * -xcb_selinux_get_window_create_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_window_create_context_reply (xcb_connection_t *c, xcb_selinux_get_window_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_get_window_context_sizeof (const void *_buffer /**< */); +xcb_selinux_get_window_context_sizeof (const void *_buffer); /** * @@ -970,8 +997,8 @@ xcb_selinux_get_window_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_window_context_cookie_t -xcb_selinux_get_window_context (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_selinux_get_window_context (xcb_connection_t *c, + xcb_window_t window); /** * @@ -985,17 +1012,17 @@ xcb_selinux_get_window_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_selinux_get_window_context_cookie_t -xcb_selinux_get_window_context_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_selinux_get_window_context_unchecked (xcb_connection_t *c, + xcb_window_t window); char * -xcb_selinux_get_window_context_context (const xcb_selinux_get_window_context_reply_t *R /**< */); +xcb_selinux_get_window_context_context (const xcb_selinux_get_window_context_reply_t *R); int -xcb_selinux_get_window_context_context_length (const xcb_selinux_get_window_context_reply_t *R /**< */); +xcb_selinux_get_window_context_context_length (const xcb_selinux_get_window_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_window_context_context_end (const xcb_selinux_get_window_context_reply_t *R /**< */); +xcb_selinux_get_window_context_context_end (const xcb_selinux_get_window_context_reply_t *R); /** * Return the reply @@ -1012,30 +1039,30 @@ xcb_selinux_get_window_context_context_end (const xcb_selinux_get_window_context * The returned value must be freed by the caller using free(). */ xcb_selinux_get_window_context_reply_t * -xcb_selinux_get_window_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_window_context_reply (xcb_connection_t *c, xcb_selinux_get_window_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_list_item_sizeof (const void *_buffer /**< */); +xcb_selinux_list_item_sizeof (const void *_buffer); char * -xcb_selinux_list_item_object_context (const xcb_selinux_list_item_t *R /**< */); +xcb_selinux_list_item_object_context (const xcb_selinux_list_item_t *R); int -xcb_selinux_list_item_object_context_length (const xcb_selinux_list_item_t *R /**< */); +xcb_selinux_list_item_object_context_length (const xcb_selinux_list_item_t *R); xcb_generic_iterator_t -xcb_selinux_list_item_object_context_end (const xcb_selinux_list_item_t *R /**< */); +xcb_selinux_list_item_object_context_end (const xcb_selinux_list_item_t *R); char * -xcb_selinux_list_item_data_context (const xcb_selinux_list_item_t *R /**< */); +xcb_selinux_list_item_data_context (const xcb_selinux_list_item_t *R); int -xcb_selinux_list_item_data_context_length (const xcb_selinux_list_item_t *R /**< */); +xcb_selinux_list_item_data_context_length (const xcb_selinux_list_item_t *R); xcb_generic_iterator_t -xcb_selinux_list_item_data_context_end (const xcb_selinux_list_item_t *R /**< */); +xcb_selinux_list_item_data_context_end (const xcb_selinux_list_item_t *R); /** * Get the next element of the iterator @@ -1046,7 +1073,7 @@ xcb_selinux_list_item_data_context_end (const xcb_selinux_list_item_t *R /**< * * element. The member index is increased by sizeof(xcb_selinux_list_item_t) */ void -xcb_selinux_list_item_next (xcb_selinux_list_item_iterator_t *i /**< */); +xcb_selinux_list_item_next (xcb_selinux_list_item_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1058,10 +1085,10 @@ xcb_selinux_list_item_next (xcb_selinux_list_item_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_selinux_list_item_end (xcb_selinux_list_item_iterator_t i /**< */); +xcb_selinux_list_item_end (xcb_selinux_list_item_iterator_t i); int -xcb_selinux_set_property_create_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_property_create_context_sizeof (const void *_buffer); /** * @@ -1075,9 +1102,9 @@ xcb_selinux_set_property_create_context_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_selinux_set_property_create_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_property_create_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context); /** * @@ -1088,12 +1115,21 @@ xcb_selinux_set_property_create_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_selinux_set_property_create_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_property_create_context (xcb_connection_t *c, + uint32_t context_len, + const char *context); + +char * +xcb_selinux_set_property_create_context_context (const xcb_selinux_set_property_create_context_request_t *R); int -xcb_selinux_get_property_create_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_property_create_context_context_length (const xcb_selinux_set_property_create_context_request_t *R); + +xcb_generic_iterator_t +xcb_selinux_set_property_create_context_context_end (const xcb_selinux_set_property_create_context_request_t *R); + +int +xcb_selinux_get_property_create_context_sizeof (const void *_buffer); /** * @@ -1104,7 +1140,7 @@ xcb_selinux_get_property_create_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_property_create_context_cookie_t -xcb_selinux_get_property_create_context (xcb_connection_t *c /**< */); +xcb_selinux_get_property_create_context (xcb_connection_t *c); /** * @@ -1118,16 +1154,16 @@ xcb_selinux_get_property_create_context (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_selinux_get_property_create_context_cookie_t -xcb_selinux_get_property_create_context_unchecked (xcb_connection_t *c /**< */); +xcb_selinux_get_property_create_context_unchecked (xcb_connection_t *c); char * -xcb_selinux_get_property_create_context_context (const xcb_selinux_get_property_create_context_reply_t *R /**< */); +xcb_selinux_get_property_create_context_context (const xcb_selinux_get_property_create_context_reply_t *R); int -xcb_selinux_get_property_create_context_context_length (const xcb_selinux_get_property_create_context_reply_t *R /**< */); +xcb_selinux_get_property_create_context_context_length (const xcb_selinux_get_property_create_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_property_create_context_context_end (const xcb_selinux_get_property_create_context_reply_t *R /**< */); +xcb_selinux_get_property_create_context_context_end (const xcb_selinux_get_property_create_context_reply_t *R); /** * Return the reply @@ -1144,12 +1180,12 @@ xcb_selinux_get_property_create_context_context_end (const xcb_selinux_get_prope * The returned value must be freed by the caller using free(). */ xcb_selinux_get_property_create_context_reply_t * -xcb_selinux_get_property_create_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_property_create_context_reply (xcb_connection_t *c, xcb_selinux_get_property_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_set_property_use_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_property_use_context_sizeof (const void *_buffer); /** * @@ -1163,9 +1199,9 @@ xcb_selinux_set_property_use_context_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_selinux_set_property_use_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_property_use_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context); /** * @@ -1176,12 +1212,21 @@ xcb_selinux_set_property_use_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_selinux_set_property_use_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_property_use_context (xcb_connection_t *c, + uint32_t context_len, + const char *context); + +char * +xcb_selinux_set_property_use_context_context (const xcb_selinux_set_property_use_context_request_t *R); int -xcb_selinux_get_property_use_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_property_use_context_context_length (const xcb_selinux_set_property_use_context_request_t *R); + +xcb_generic_iterator_t +xcb_selinux_set_property_use_context_context_end (const xcb_selinux_set_property_use_context_request_t *R); + +int +xcb_selinux_get_property_use_context_sizeof (const void *_buffer); /** * @@ -1192,7 +1237,7 @@ xcb_selinux_get_property_use_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_property_use_context_cookie_t -xcb_selinux_get_property_use_context (xcb_connection_t *c /**< */); +xcb_selinux_get_property_use_context (xcb_connection_t *c); /** * @@ -1206,16 +1251,16 @@ xcb_selinux_get_property_use_context (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_selinux_get_property_use_context_cookie_t -xcb_selinux_get_property_use_context_unchecked (xcb_connection_t *c /**< */); +xcb_selinux_get_property_use_context_unchecked (xcb_connection_t *c); char * -xcb_selinux_get_property_use_context_context (const xcb_selinux_get_property_use_context_reply_t *R /**< */); +xcb_selinux_get_property_use_context_context (const xcb_selinux_get_property_use_context_reply_t *R); int -xcb_selinux_get_property_use_context_context_length (const xcb_selinux_get_property_use_context_reply_t *R /**< */); +xcb_selinux_get_property_use_context_context_length (const xcb_selinux_get_property_use_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_property_use_context_context_end (const xcb_selinux_get_property_use_context_reply_t *R /**< */); +xcb_selinux_get_property_use_context_context_end (const xcb_selinux_get_property_use_context_reply_t *R); /** * Return the reply @@ -1232,12 +1277,12 @@ xcb_selinux_get_property_use_context_context_end (const xcb_selinux_get_property * The returned value must be freed by the caller using free(). */ xcb_selinux_get_property_use_context_reply_t * -xcb_selinux_get_property_use_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_property_use_context_reply (xcb_connection_t *c, xcb_selinux_get_property_use_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_get_property_context_sizeof (const void *_buffer /**< */); +xcb_selinux_get_property_context_sizeof (const void *_buffer); /** * @@ -1248,9 +1293,9 @@ xcb_selinux_get_property_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_property_context_cookie_t -xcb_selinux_get_property_context (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */); +xcb_selinux_get_property_context (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property); /** * @@ -1264,18 +1309,18 @@ xcb_selinux_get_property_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_selinux_get_property_context_cookie_t -xcb_selinux_get_property_context_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */); +xcb_selinux_get_property_context_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property); char * -xcb_selinux_get_property_context_context (const xcb_selinux_get_property_context_reply_t *R /**< */); +xcb_selinux_get_property_context_context (const xcb_selinux_get_property_context_reply_t *R); int -xcb_selinux_get_property_context_context_length (const xcb_selinux_get_property_context_reply_t *R /**< */); +xcb_selinux_get_property_context_context_length (const xcb_selinux_get_property_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_property_context_context_end (const xcb_selinux_get_property_context_reply_t *R /**< */); +xcb_selinux_get_property_context_context_end (const xcb_selinux_get_property_context_reply_t *R); /** * Return the reply @@ -1292,12 +1337,12 @@ xcb_selinux_get_property_context_context_end (const xcb_selinux_get_property_con * The returned value must be freed by the caller using free(). */ xcb_selinux_get_property_context_reply_t * -xcb_selinux_get_property_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_property_context_reply (xcb_connection_t *c, xcb_selinux_get_property_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_get_property_data_context_sizeof (const void *_buffer /**< */); +xcb_selinux_get_property_data_context_sizeof (const void *_buffer); /** * @@ -1308,9 +1353,9 @@ xcb_selinux_get_property_data_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_property_data_context_cookie_t -xcb_selinux_get_property_data_context (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */); +xcb_selinux_get_property_data_context (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property); /** * @@ -1324,18 +1369,18 @@ xcb_selinux_get_property_data_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_selinux_get_property_data_context_cookie_t -xcb_selinux_get_property_data_context_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_atom_t property /**< */); +xcb_selinux_get_property_data_context_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t property); char * -xcb_selinux_get_property_data_context_context (const xcb_selinux_get_property_data_context_reply_t *R /**< */); +xcb_selinux_get_property_data_context_context (const xcb_selinux_get_property_data_context_reply_t *R); int -xcb_selinux_get_property_data_context_context_length (const xcb_selinux_get_property_data_context_reply_t *R /**< */); +xcb_selinux_get_property_data_context_context_length (const xcb_selinux_get_property_data_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_property_data_context_context_end (const xcb_selinux_get_property_data_context_reply_t *R /**< */); +xcb_selinux_get_property_data_context_context_end (const xcb_selinux_get_property_data_context_reply_t *R); /** * Return the reply @@ -1352,12 +1397,12 @@ xcb_selinux_get_property_data_context_context_end (const xcb_selinux_get_propert * The returned value must be freed by the caller using free(). */ xcb_selinux_get_property_data_context_reply_t * -xcb_selinux_get_property_data_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_property_data_context_reply (xcb_connection_t *c, xcb_selinux_get_property_data_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_list_properties_sizeof (const void *_buffer /**< */); +xcb_selinux_list_properties_sizeof (const void *_buffer); /** * @@ -1368,8 +1413,8 @@ xcb_selinux_list_properties_sizeof (const void *_buffer /**< */); * */ xcb_selinux_list_properties_cookie_t -xcb_selinux_list_properties (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_selinux_list_properties (xcb_connection_t *c, + xcb_window_t window); /** * @@ -1383,14 +1428,14 @@ xcb_selinux_list_properties (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_selinux_list_properties_cookie_t -xcb_selinux_list_properties_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_selinux_list_properties_unchecked (xcb_connection_t *c, + xcb_window_t window); int -xcb_selinux_list_properties_properties_length (const xcb_selinux_list_properties_reply_t *R /**< */); +xcb_selinux_list_properties_properties_length (const xcb_selinux_list_properties_reply_t *R); xcb_selinux_list_item_iterator_t -xcb_selinux_list_properties_properties_iterator (const xcb_selinux_list_properties_reply_t *R /**< */); +xcb_selinux_list_properties_properties_iterator (const xcb_selinux_list_properties_reply_t *R); /** * Return the reply @@ -1407,12 +1452,12 @@ xcb_selinux_list_properties_properties_iterator (const xcb_selinux_list_properti * The returned value must be freed by the caller using free(). */ xcb_selinux_list_properties_reply_t * -xcb_selinux_list_properties_reply (xcb_connection_t *c /**< */, +xcb_selinux_list_properties_reply (xcb_connection_t *c, xcb_selinux_list_properties_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_set_selection_create_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_selection_create_context_sizeof (const void *_buffer); /** * @@ -1426,9 +1471,9 @@ xcb_selinux_set_selection_create_context_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_selinux_set_selection_create_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_selection_create_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context); /** * @@ -1439,12 +1484,21 @@ xcb_selinux_set_selection_create_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_selinux_set_selection_create_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_selection_create_context (xcb_connection_t *c, + uint32_t context_len, + const char *context); + +char * +xcb_selinux_set_selection_create_context_context (const xcb_selinux_set_selection_create_context_request_t *R); int -xcb_selinux_get_selection_create_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_selection_create_context_context_length (const xcb_selinux_set_selection_create_context_request_t *R); + +xcb_generic_iterator_t +xcb_selinux_set_selection_create_context_context_end (const xcb_selinux_set_selection_create_context_request_t *R); + +int +xcb_selinux_get_selection_create_context_sizeof (const void *_buffer); /** * @@ -1455,7 +1509,7 @@ xcb_selinux_get_selection_create_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_selection_create_context_cookie_t -xcb_selinux_get_selection_create_context (xcb_connection_t *c /**< */); +xcb_selinux_get_selection_create_context (xcb_connection_t *c); /** * @@ -1469,16 +1523,16 @@ xcb_selinux_get_selection_create_context (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_selinux_get_selection_create_context_cookie_t -xcb_selinux_get_selection_create_context_unchecked (xcb_connection_t *c /**< */); +xcb_selinux_get_selection_create_context_unchecked (xcb_connection_t *c); char * -xcb_selinux_get_selection_create_context_context (const xcb_selinux_get_selection_create_context_reply_t *R /**< */); +xcb_selinux_get_selection_create_context_context (const xcb_selinux_get_selection_create_context_reply_t *R); int -xcb_selinux_get_selection_create_context_context_length (const xcb_selinux_get_selection_create_context_reply_t *R /**< */); +xcb_selinux_get_selection_create_context_context_length (const xcb_selinux_get_selection_create_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_selection_create_context_context_end (const xcb_selinux_get_selection_create_context_reply_t *R /**< */); +xcb_selinux_get_selection_create_context_context_end (const xcb_selinux_get_selection_create_context_reply_t *R); /** * Return the reply @@ -1495,12 +1549,12 @@ xcb_selinux_get_selection_create_context_context_end (const xcb_selinux_get_sele * The returned value must be freed by the caller using free(). */ xcb_selinux_get_selection_create_context_reply_t * -xcb_selinux_get_selection_create_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_selection_create_context_reply (xcb_connection_t *c, xcb_selinux_get_selection_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_set_selection_use_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_selection_use_context_sizeof (const void *_buffer); /** * @@ -1514,9 +1568,9 @@ xcb_selinux_set_selection_use_context_sizeof (const void *_buffer /**< */); * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_selinux_set_selection_use_context_checked (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_selection_use_context_checked (xcb_connection_t *c, + uint32_t context_len, + const char *context); /** * @@ -1527,12 +1581,21 @@ xcb_selinux_set_selection_use_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_selinux_set_selection_use_context (xcb_connection_t *c /**< */, - uint32_t context_len /**< */, - const char *context /**< */); +xcb_selinux_set_selection_use_context (xcb_connection_t *c, + uint32_t context_len, + const char *context); + +char * +xcb_selinux_set_selection_use_context_context (const xcb_selinux_set_selection_use_context_request_t *R); int -xcb_selinux_get_selection_use_context_sizeof (const void *_buffer /**< */); +xcb_selinux_set_selection_use_context_context_length (const xcb_selinux_set_selection_use_context_request_t *R); + +xcb_generic_iterator_t +xcb_selinux_set_selection_use_context_context_end (const xcb_selinux_set_selection_use_context_request_t *R); + +int +xcb_selinux_get_selection_use_context_sizeof (const void *_buffer); /** * @@ -1543,7 +1606,7 @@ xcb_selinux_get_selection_use_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_selection_use_context_cookie_t -xcb_selinux_get_selection_use_context (xcb_connection_t *c /**< */); +xcb_selinux_get_selection_use_context (xcb_connection_t *c); /** * @@ -1557,16 +1620,16 @@ xcb_selinux_get_selection_use_context (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_selinux_get_selection_use_context_cookie_t -xcb_selinux_get_selection_use_context_unchecked (xcb_connection_t *c /**< */); +xcb_selinux_get_selection_use_context_unchecked (xcb_connection_t *c); char * -xcb_selinux_get_selection_use_context_context (const xcb_selinux_get_selection_use_context_reply_t *R /**< */); +xcb_selinux_get_selection_use_context_context (const xcb_selinux_get_selection_use_context_reply_t *R); int -xcb_selinux_get_selection_use_context_context_length (const xcb_selinux_get_selection_use_context_reply_t *R /**< */); +xcb_selinux_get_selection_use_context_context_length (const xcb_selinux_get_selection_use_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_selection_use_context_context_end (const xcb_selinux_get_selection_use_context_reply_t *R /**< */); +xcb_selinux_get_selection_use_context_context_end (const xcb_selinux_get_selection_use_context_reply_t *R); /** * Return the reply @@ -1583,12 +1646,12 @@ xcb_selinux_get_selection_use_context_context_end (const xcb_selinux_get_selecti * The returned value must be freed by the caller using free(). */ xcb_selinux_get_selection_use_context_reply_t * -xcb_selinux_get_selection_use_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_selection_use_context_reply (xcb_connection_t *c, xcb_selinux_get_selection_use_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_get_selection_context_sizeof (const void *_buffer /**< */); +xcb_selinux_get_selection_context_sizeof (const void *_buffer); /** * @@ -1599,8 +1662,8 @@ xcb_selinux_get_selection_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_selection_context_cookie_t -xcb_selinux_get_selection_context (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */); +xcb_selinux_get_selection_context (xcb_connection_t *c, + xcb_atom_t selection); /** * @@ -1614,17 +1677,17 @@ xcb_selinux_get_selection_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_selinux_get_selection_context_cookie_t -xcb_selinux_get_selection_context_unchecked (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */); +xcb_selinux_get_selection_context_unchecked (xcb_connection_t *c, + xcb_atom_t selection); char * -xcb_selinux_get_selection_context_context (const xcb_selinux_get_selection_context_reply_t *R /**< */); +xcb_selinux_get_selection_context_context (const xcb_selinux_get_selection_context_reply_t *R); int -xcb_selinux_get_selection_context_context_length (const xcb_selinux_get_selection_context_reply_t *R /**< */); +xcb_selinux_get_selection_context_context_length (const xcb_selinux_get_selection_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_selection_context_context_end (const xcb_selinux_get_selection_context_reply_t *R /**< */); +xcb_selinux_get_selection_context_context_end (const xcb_selinux_get_selection_context_reply_t *R); /** * Return the reply @@ -1641,12 +1704,12 @@ xcb_selinux_get_selection_context_context_end (const xcb_selinux_get_selection_c * The returned value must be freed by the caller using free(). */ xcb_selinux_get_selection_context_reply_t * -xcb_selinux_get_selection_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_selection_context_reply (xcb_connection_t *c, xcb_selinux_get_selection_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_get_selection_data_context_sizeof (const void *_buffer /**< */); +xcb_selinux_get_selection_data_context_sizeof (const void *_buffer); /** * @@ -1657,8 +1720,8 @@ xcb_selinux_get_selection_data_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_selection_data_context_cookie_t -xcb_selinux_get_selection_data_context (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */); +xcb_selinux_get_selection_data_context (xcb_connection_t *c, + xcb_atom_t selection); /** * @@ -1672,17 +1735,17 @@ xcb_selinux_get_selection_data_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_selinux_get_selection_data_context_cookie_t -xcb_selinux_get_selection_data_context_unchecked (xcb_connection_t *c /**< */, - xcb_atom_t selection /**< */); +xcb_selinux_get_selection_data_context_unchecked (xcb_connection_t *c, + xcb_atom_t selection); char * -xcb_selinux_get_selection_data_context_context (const xcb_selinux_get_selection_data_context_reply_t *R /**< */); +xcb_selinux_get_selection_data_context_context (const xcb_selinux_get_selection_data_context_reply_t *R); int -xcb_selinux_get_selection_data_context_context_length (const xcb_selinux_get_selection_data_context_reply_t *R /**< */); +xcb_selinux_get_selection_data_context_context_length (const xcb_selinux_get_selection_data_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_selection_data_context_context_end (const xcb_selinux_get_selection_data_context_reply_t *R /**< */); +xcb_selinux_get_selection_data_context_context_end (const xcb_selinux_get_selection_data_context_reply_t *R); /** * Return the reply @@ -1699,12 +1762,12 @@ xcb_selinux_get_selection_data_context_context_end (const xcb_selinux_get_select * The returned value must be freed by the caller using free(). */ xcb_selinux_get_selection_data_context_reply_t * -xcb_selinux_get_selection_data_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_selection_data_context_reply (xcb_connection_t *c, xcb_selinux_get_selection_data_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_list_selections_sizeof (const void *_buffer /**< */); +xcb_selinux_list_selections_sizeof (const void *_buffer); /** * @@ -1715,7 +1778,7 @@ xcb_selinux_list_selections_sizeof (const void *_buffer /**< */); * */ xcb_selinux_list_selections_cookie_t -xcb_selinux_list_selections (xcb_connection_t *c /**< */); +xcb_selinux_list_selections (xcb_connection_t *c); /** * @@ -1729,13 +1792,13 @@ xcb_selinux_list_selections (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_selinux_list_selections_cookie_t -xcb_selinux_list_selections_unchecked (xcb_connection_t *c /**< */); +xcb_selinux_list_selections_unchecked (xcb_connection_t *c); int -xcb_selinux_list_selections_selections_length (const xcb_selinux_list_selections_reply_t *R /**< */); +xcb_selinux_list_selections_selections_length (const xcb_selinux_list_selections_reply_t *R); xcb_selinux_list_item_iterator_t -xcb_selinux_list_selections_selections_iterator (const xcb_selinux_list_selections_reply_t *R /**< */); +xcb_selinux_list_selections_selections_iterator (const xcb_selinux_list_selections_reply_t *R); /** * Return the reply @@ -1752,12 +1815,12 @@ xcb_selinux_list_selections_selections_iterator (const xcb_selinux_list_selectio * The returned value must be freed by the caller using free(). */ xcb_selinux_list_selections_reply_t * -xcb_selinux_list_selections_reply (xcb_connection_t *c /**< */, +xcb_selinux_list_selections_reply (xcb_connection_t *c, xcb_selinux_list_selections_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_selinux_get_client_context_sizeof (const void *_buffer /**< */); +xcb_selinux_get_client_context_sizeof (const void *_buffer); /** * @@ -1768,8 +1831,8 @@ xcb_selinux_get_client_context_sizeof (const void *_buffer /**< */); * */ xcb_selinux_get_client_context_cookie_t -xcb_selinux_get_client_context (xcb_connection_t *c /**< */, - uint32_t resource /**< */); +xcb_selinux_get_client_context (xcb_connection_t *c, + uint32_t resource); /** * @@ -1783,17 +1846,17 @@ xcb_selinux_get_client_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_selinux_get_client_context_cookie_t -xcb_selinux_get_client_context_unchecked (xcb_connection_t *c /**< */, - uint32_t resource /**< */); +xcb_selinux_get_client_context_unchecked (xcb_connection_t *c, + uint32_t resource); char * -xcb_selinux_get_client_context_context (const xcb_selinux_get_client_context_reply_t *R /**< */); +xcb_selinux_get_client_context_context (const xcb_selinux_get_client_context_reply_t *R); int -xcb_selinux_get_client_context_context_length (const xcb_selinux_get_client_context_reply_t *R /**< */); +xcb_selinux_get_client_context_context_length (const xcb_selinux_get_client_context_reply_t *R); xcb_generic_iterator_t -xcb_selinux_get_client_context_context_end (const xcb_selinux_get_client_context_reply_t *R /**< */); +xcb_selinux_get_client_context_context_end (const xcb_selinux_get_client_context_reply_t *R); /** * Return the reply @@ -1810,9 +1873,9 @@ xcb_selinux_get_client_context_context_end (const xcb_selinux_get_client_context * The returned value must be freed by the caller using free(). */ xcb_selinux_get_client_context_reply_t * -xcb_selinux_get_client_context_reply (xcb_connection_t *c /**< */, +xcb_selinux_get_client_context_reply (xcb_connection_t *c, xcb_selinux_get_client_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/lib/libxcb/src/xtest.c b/lib/libxcb/src/xtest.c index 215ae658f..1dd5ff6d6 100644 --- a/lib/libxcb/src/xtest.c +++ b/lib/libxcb/src/xtest.c @@ -19,15 +19,15 @@ xcb_extension_t xcb_test_id = { "XTEST", 0 }; xcb_test_get_version_cookie_t -xcb_test_get_version (xcb_connection_t *c /**< */, - uint8_t major_version /**< */, - uint16_t minor_version /**< */) +xcb_test_get_version (xcb_connection_t *c, + uint8_t major_version, + uint16_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_test_id, - /* opcode */ XCB_TEST_GET_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_test_id, + .opcode = XCB_TEST_GET_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -48,15 +48,15 @@ xcb_test_get_version (xcb_connection_t *c /**< */, } xcb_test_get_version_cookie_t -xcb_test_get_version_unchecked (xcb_connection_t *c /**< */, - uint8_t major_version /**< */, - uint16_t minor_version /**< */) +xcb_test_get_version_unchecked (xcb_connection_t *c, + uint8_t major_version, + uint16_t minor_version) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_test_id, - /* opcode */ XCB_TEST_GET_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_test_id, + .opcode = XCB_TEST_GET_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -77,23 +77,23 @@ xcb_test_get_version_unchecked (xcb_connection_t *c /**< */, } xcb_test_get_version_reply_t * -xcb_test_get_version_reply (xcb_connection_t *c /**< */, +xcb_test_get_version_reply (xcb_connection_t *c, xcb_test_get_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_test_get_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_test_compare_cursor_cookie_t -xcb_test_compare_cursor (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_cursor_t cursor /**< */) +xcb_test_compare_cursor (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_test_id, - /* opcode */ XCB_TEST_COMPARE_CURSOR, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_test_id, + .opcode = XCB_TEST_COMPARE_CURSOR, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -113,15 +113,15 @@ xcb_test_compare_cursor (xcb_connection_t *c /**< */, } xcb_test_compare_cursor_cookie_t -xcb_test_compare_cursor_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_cursor_t cursor /**< */) +xcb_test_compare_cursor_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_test_id, - /* opcode */ XCB_TEST_COMPARE_CURSOR, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_test_id, + .opcode = XCB_TEST_COMPARE_CURSOR, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -141,28 +141,28 @@ xcb_test_compare_cursor_unchecked (xcb_connection_t *c /**< */, } xcb_test_compare_cursor_reply_t * -xcb_test_compare_cursor_reply (xcb_connection_t *c /**< */, +xcb_test_compare_cursor_reply (xcb_connection_t *c, xcb_test_compare_cursor_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_test_compare_cursor_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_test_fake_input_checked (xcb_connection_t *c /**< */, - uint8_t type /**< */, - uint8_t detail /**< */, - uint32_t time /**< */, - xcb_window_t root /**< */, - int16_t rootX /**< */, - int16_t rootY /**< */, - uint8_t deviceid /**< */) +xcb_test_fake_input_checked (xcb_connection_t *c, + uint8_t type, + uint8_t detail, + uint32_t time, + xcb_window_t root, + int16_t rootX, + int16_t rootY, + uint8_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_test_id, - /* opcode */ XCB_TEST_FAKE_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_test_id, + .opcode = XCB_TEST_FAKE_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -190,20 +190,20 @@ xcb_test_fake_input_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_test_fake_input (xcb_connection_t *c /**< */, - uint8_t type /**< */, - uint8_t detail /**< */, - uint32_t time /**< */, - xcb_window_t root /**< */, - int16_t rootX /**< */, - int16_t rootY /**< */, - uint8_t deviceid /**< */) +xcb_test_fake_input (xcb_connection_t *c, + uint8_t type, + uint8_t detail, + uint32_t time, + xcb_window_t root, + int16_t rootX, + int16_t rootY, + uint8_t deviceid) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_test_id, - /* opcode */ XCB_TEST_FAKE_INPUT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_test_id, + .opcode = XCB_TEST_FAKE_INPUT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -231,14 +231,14 @@ xcb_test_fake_input (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_test_grab_control_checked (xcb_connection_t *c /**< */, - uint8_t impervious /**< */) +xcb_test_grab_control_checked (xcb_connection_t *c, + uint8_t impervious) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_test_id, - /* opcode */ XCB_TEST_GRAB_CONTROL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_test_id, + .opcode = XCB_TEST_GRAB_CONTROL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -258,14 +258,14 @@ xcb_test_grab_control_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_test_grab_control (xcb_connection_t *c /**< */, - uint8_t impervious /**< */) +xcb_test_grab_control (xcb_connection_t *c, + uint8_t impervious) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_test_id, - /* opcode */ XCB_TEST_GRAB_CONTROL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_test_id, + .opcode = XCB_TEST_GRAB_CONTROL, + .isvoid = 1 }; struct iovec xcb_parts[4]; diff --git a/lib/libxcb/src/xtest.h b/lib/libxcb/src/xtest.h index d51e4ec49..e97733e4f 100644 --- a/lib/libxcb/src/xtest.h +++ b/lib/libxcb/src/xtest.h @@ -28,7 +28,7 @@ extern xcb_extension_t xcb_test_id; * @brief xcb_test_get_version_cookie_t **/ typedef struct xcb_test_get_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_test_get_version_cookie_t; /** Opcode for xcb_test_get_version. */ @@ -38,23 +38,23 @@ typedef struct xcb_test_get_version_cookie_t { * @brief xcb_test_get_version_request_t **/ typedef struct xcb_test_get_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t major_version; /**< */ - uint8_t pad0; /**< */ - uint16_t minor_version; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t major_version; + uint8_t pad0; + uint16_t minor_version; } xcb_test_get_version_request_t; /** * @brief xcb_test_get_version_reply_t **/ typedef struct xcb_test_get_version_reply_t { - uint8_t response_type; /**< */ - uint8_t major_version; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t minor_version; /**< */ + uint8_t response_type; + uint8_t major_version; + uint16_t sequence; + uint32_t length; + uint16_t minor_version; } xcb_test_get_version_reply_t; typedef enum xcb_test_cursor_t { @@ -66,7 +66,7 @@ typedef enum xcb_test_cursor_t { * @brief xcb_test_compare_cursor_cookie_t **/ typedef struct xcb_test_compare_cursor_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_test_compare_cursor_cookie_t; /** Opcode for xcb_test_compare_cursor. */ @@ -76,21 +76,21 @@ typedef struct xcb_test_compare_cursor_cookie_t { * @brief xcb_test_compare_cursor_request_t **/ typedef struct xcb_test_compare_cursor_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ - xcb_cursor_t cursor; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; + xcb_cursor_t cursor; } xcb_test_compare_cursor_request_t; /** * @brief xcb_test_compare_cursor_reply_t **/ typedef struct xcb_test_compare_cursor_reply_t { - uint8_t response_type; /**< */ - uint8_t same; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ + uint8_t response_type; + uint8_t same; + uint16_t sequence; + uint32_t length; } xcb_test_compare_cursor_reply_t; /** Opcode for xcb_test_fake_input. */ @@ -100,19 +100,19 @@ typedef struct xcb_test_compare_cursor_reply_t { * @brief xcb_test_fake_input_request_t **/ typedef struct xcb_test_fake_input_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t type; /**< */ - uint8_t detail; /**< */ - uint8_t pad0[2]; /**< */ - uint32_t time; /**< */ - xcb_window_t root; /**< */ - uint8_t pad1[8]; /**< */ - int16_t rootX; /**< */ - int16_t rootY; /**< */ - uint8_t pad2[7]; /**< */ - uint8_t deviceid; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t type; + uint8_t detail; + uint8_t pad0[2]; + uint32_t time; + xcb_window_t root; + uint8_t pad1[8]; + int16_t rootX; + int16_t rootY; + uint8_t pad2[7]; + uint8_t deviceid; } xcb_test_fake_input_request_t; /** Opcode for xcb_test_grab_control. */ @@ -122,11 +122,11 @@ typedef struct xcb_test_fake_input_request_t { * @brief xcb_test_grab_control_request_t **/ typedef struct xcb_test_grab_control_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - uint8_t impervious; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + uint8_t impervious; + uint8_t pad0[3]; } xcb_test_grab_control_request_t; /** @@ -138,9 +138,9 @@ typedef struct xcb_test_grab_control_request_t { * */ xcb_test_get_version_cookie_t -xcb_test_get_version (xcb_connection_t *c /**< */, - uint8_t major_version /**< */, - uint16_t minor_version /**< */); +xcb_test_get_version (xcb_connection_t *c, + uint8_t major_version, + uint16_t minor_version); /** * @@ -154,9 +154,9 @@ xcb_test_get_version (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_test_get_version_cookie_t -xcb_test_get_version_unchecked (xcb_connection_t *c /**< */, - uint8_t major_version /**< */, - uint16_t minor_version /**< */); +xcb_test_get_version_unchecked (xcb_connection_t *c, + uint8_t major_version, + uint16_t minor_version); /** * Return the reply @@ -173,9 +173,9 @@ xcb_test_get_version_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_test_get_version_reply_t * -xcb_test_get_version_reply (xcb_connection_t *c /**< */, +xcb_test_get_version_reply (xcb_connection_t *c, xcb_test_get_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -186,9 +186,9 @@ xcb_test_get_version_reply (xcb_connection_t *c /**< */, * */ xcb_test_compare_cursor_cookie_t -xcb_test_compare_cursor (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_cursor_t cursor /**< */); +xcb_test_compare_cursor (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor); /** * @@ -202,9 +202,9 @@ xcb_test_compare_cursor (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_test_compare_cursor_cookie_t -xcb_test_compare_cursor_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */, - xcb_cursor_t cursor /**< */); +xcb_test_compare_cursor_unchecked (xcb_connection_t *c, + xcb_window_t window, + xcb_cursor_t cursor); /** * Return the reply @@ -221,9 +221,9 @@ xcb_test_compare_cursor_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_test_compare_cursor_reply_t * -xcb_test_compare_cursor_reply (xcb_connection_t *c /**< */, +xcb_test_compare_cursor_reply (xcb_connection_t *c, xcb_test_compare_cursor_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -237,14 +237,14 @@ xcb_test_compare_cursor_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_test_fake_input_checked (xcb_connection_t *c /**< */, - uint8_t type /**< */, - uint8_t detail /**< */, - uint32_t time /**< */, - xcb_window_t root /**< */, - int16_t rootX /**< */, - int16_t rootY /**< */, - uint8_t deviceid /**< */); +xcb_test_fake_input_checked (xcb_connection_t *c, + uint8_t type, + uint8_t detail, + uint32_t time, + xcb_window_t root, + int16_t rootX, + int16_t rootY, + uint8_t deviceid); /** * @@ -255,14 +255,14 @@ xcb_test_fake_input_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_test_fake_input (xcb_connection_t *c /**< */, - uint8_t type /**< */, - uint8_t detail /**< */, - uint32_t time /**< */, - xcb_window_t root /**< */, - int16_t rootX /**< */, - int16_t rootY /**< */, - uint8_t deviceid /**< */); +xcb_test_fake_input (xcb_connection_t *c, + uint8_t type, + uint8_t detail, + uint32_t time, + xcb_window_t root, + int16_t rootX, + int16_t rootY, + uint8_t deviceid); /** * @@ -276,8 +276,8 @@ xcb_test_fake_input (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_test_grab_control_checked (xcb_connection_t *c /**< */, - uint8_t impervious /**< */); +xcb_test_grab_control_checked (xcb_connection_t *c, + uint8_t impervious); /** * @@ -288,8 +288,8 @@ xcb_test_grab_control_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_test_grab_control (xcb_connection_t *c /**< */, - uint8_t impervious /**< */); +xcb_test_grab_control (xcb_connection_t *c, + uint8_t impervious); #ifdef __cplusplus diff --git a/lib/libxcb/src/xv.c b/lib/libxcb/src/xv.c index b8302fbd9..82138032f 100644 --- a/lib/libxcb/src/xv.c +++ b/lib/libxcb/src/xv.c @@ -20,7 +20,7 @@ xcb_extension_t xcb_xv_id = { "XVideo", 0 }; void -xcb_xv_port_next (xcb_xv_port_iterator_t *i /**< */) +xcb_xv_port_next (xcb_xv_port_iterator_t *i) { --i->rem; ++i->data; @@ -28,7 +28,7 @@ xcb_xv_port_next (xcb_xv_port_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xv_port_end (xcb_xv_port_iterator_t i /**< */) +xcb_xv_port_end (xcb_xv_port_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -38,7 +38,7 @@ xcb_xv_port_end (xcb_xv_port_iterator_t i /**< */) } void -xcb_xv_encoding_next (xcb_xv_encoding_iterator_t *i /**< */) +xcb_xv_encoding_next (xcb_xv_encoding_iterator_t *i) { --i->rem; ++i->data; @@ -46,7 +46,7 @@ xcb_xv_encoding_next (xcb_xv_encoding_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xv_encoding_end (xcb_xv_encoding_iterator_t i /**< */) +xcb_xv_encoding_end (xcb_xv_encoding_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -56,7 +56,7 @@ xcb_xv_encoding_end (xcb_xv_encoding_iterator_t i /**< */) } void -xcb_xv_rational_next (xcb_xv_rational_iterator_t *i /**< */) +xcb_xv_rational_next (xcb_xv_rational_iterator_t *i) { --i->rem; ++i->data; @@ -64,7 +64,7 @@ xcb_xv_rational_next (xcb_xv_rational_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xv_rational_end (xcb_xv_rational_iterator_t i /**< */) +xcb_xv_rational_end (xcb_xv_rational_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -74,7 +74,7 @@ xcb_xv_rational_end (xcb_xv_rational_iterator_t i /**< */) } void -xcb_xv_format_next (xcb_xv_format_iterator_t *i /**< */) +xcb_xv_format_next (xcb_xv_format_iterator_t *i) { --i->rem; ++i->data; @@ -82,7 +82,7 @@ xcb_xv_format_next (xcb_xv_format_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xv_format_end (xcb_xv_format_iterator_t i /**< */) +xcb_xv_format_end (xcb_xv_format_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -92,7 +92,7 @@ xcb_xv_format_end (xcb_xv_format_iterator_t i /**< */) } int -xcb_xv_adaptor_info_sizeof (const void *_buffer /**< */) +xcb_xv_adaptor_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xv_adaptor_info_t *_aux = (xcb_xv_adaptor_info_t *)_buffer; @@ -144,19 +144,19 @@ xcb_xv_adaptor_info_sizeof (const void *_buffer /**< */) } char * -xcb_xv_adaptor_info_name (const xcb_xv_adaptor_info_t *R /**< */) +xcb_xv_adaptor_info_name (const xcb_xv_adaptor_info_t *R) { return (char *) (R + 1); } int -xcb_xv_adaptor_info_name_length (const xcb_xv_adaptor_info_t *R /**< */) +xcb_xv_adaptor_info_name_length (const xcb_xv_adaptor_info_t *R) { return R->name_size; } xcb_generic_iterator_t -xcb_xv_adaptor_info_name_end (const xcb_xv_adaptor_info_t *R /**< */) +xcb_xv_adaptor_info_name_end (const xcb_xv_adaptor_info_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->name_size); @@ -166,20 +166,20 @@ xcb_xv_adaptor_info_name_end (const xcb_xv_adaptor_info_t *R /**< */) } xcb_xv_format_t * -xcb_xv_adaptor_info_formats (const xcb_xv_adaptor_info_t *R /**< */) +xcb_xv_adaptor_info_formats (const xcb_xv_adaptor_info_t *R) { xcb_generic_iterator_t prev = xcb_xv_adaptor_info_name_end(R); return (xcb_xv_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0); } int -xcb_xv_adaptor_info_formats_length (const xcb_xv_adaptor_info_t *R /**< */) +xcb_xv_adaptor_info_formats_length (const xcb_xv_adaptor_info_t *R) { return R->num_formats; } xcb_xv_format_iterator_t -xcb_xv_adaptor_info_formats_iterator (const xcb_xv_adaptor_info_t *R /**< */) +xcb_xv_adaptor_info_formats_iterator (const xcb_xv_adaptor_info_t *R) { xcb_xv_format_iterator_t i; xcb_generic_iterator_t prev = xcb_xv_adaptor_info_name_end(R); @@ -190,7 +190,7 @@ xcb_xv_adaptor_info_formats_iterator (const xcb_xv_adaptor_info_t *R /**< */) } void -xcb_xv_adaptor_info_next (xcb_xv_adaptor_info_iterator_t *i /**< */) +xcb_xv_adaptor_info_next (xcb_xv_adaptor_info_iterator_t *i) { xcb_xv_adaptor_info_t *R = i->data; xcb_generic_iterator_t child; @@ -201,7 +201,7 @@ xcb_xv_adaptor_info_next (xcb_xv_adaptor_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xv_adaptor_info_end (xcb_xv_adaptor_info_iterator_t i /**< */) +xcb_xv_adaptor_info_end (xcb_xv_adaptor_info_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -213,7 +213,7 @@ xcb_xv_adaptor_info_end (xcb_xv_adaptor_info_iterator_t i /**< */) } int -xcb_xv_encoding_info_sizeof (const void *_buffer /**< */) +xcb_xv_encoding_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xv_encoding_info_t *_aux = (xcb_xv_encoding_info_t *)_buffer; @@ -231,6 +231,15 @@ xcb_xv_encoding_info_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->name_size * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -244,19 +253,19 @@ xcb_xv_encoding_info_sizeof (const void *_buffer /**< */) } char * -xcb_xv_encoding_info_name (const xcb_xv_encoding_info_t *R /**< */) +xcb_xv_encoding_info_name (const xcb_xv_encoding_info_t *R) { return (char *) (R + 1); } int -xcb_xv_encoding_info_name_length (const xcb_xv_encoding_info_t *R /**< */) +xcb_xv_encoding_info_name_length (const xcb_xv_encoding_info_t *R) { return R->name_size; } xcb_generic_iterator_t -xcb_xv_encoding_info_name_end (const xcb_xv_encoding_info_t *R /**< */) +xcb_xv_encoding_info_name_end (const xcb_xv_encoding_info_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->name_size); @@ -266,7 +275,7 @@ xcb_xv_encoding_info_name_end (const xcb_xv_encoding_info_t *R /**< */) } void -xcb_xv_encoding_info_next (xcb_xv_encoding_info_iterator_t *i /**< */) +xcb_xv_encoding_info_next (xcb_xv_encoding_info_iterator_t *i) { xcb_xv_encoding_info_t *R = i->data; xcb_generic_iterator_t child; @@ -277,7 +286,7 @@ xcb_xv_encoding_info_next (xcb_xv_encoding_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xv_encoding_info_end (xcb_xv_encoding_info_iterator_t i /**< */) +xcb_xv_encoding_info_end (xcb_xv_encoding_info_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -289,7 +298,7 @@ xcb_xv_encoding_info_end (xcb_xv_encoding_info_iterator_t i /**< */) } int -xcb_xv_image_sizeof (const void *_buffer /**< */) +xcb_xv_image_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xv_image_t *_aux = (xcb_xv_image_t *)_buffer; @@ -344,19 +353,19 @@ xcb_xv_image_sizeof (const void *_buffer /**< */) } uint32_t * -xcb_xv_image_pitches (const xcb_xv_image_t *R /**< */) +xcb_xv_image_pitches (const xcb_xv_image_t *R) { return (uint32_t *) (R + 1); } int -xcb_xv_image_pitches_length (const xcb_xv_image_t *R /**< */) +xcb_xv_image_pitches_length (const xcb_xv_image_t *R) { return R->num_planes; } xcb_generic_iterator_t -xcb_xv_image_pitches_end (const xcb_xv_image_t *R /**< */) +xcb_xv_image_pitches_end (const xcb_xv_image_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->num_planes); @@ -366,55 +375,55 @@ xcb_xv_image_pitches_end (const xcb_xv_image_t *R /**< */) } uint32_t * -xcb_xv_image_offsets (const xcb_xv_image_t *R /**< */) +xcb_xv_image_offsets (const xcb_xv_image_t *R) { xcb_generic_iterator_t prev = xcb_xv_image_pitches_end(R); return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); } int -xcb_xv_image_offsets_length (const xcb_xv_image_t *R /**< */) +xcb_xv_image_offsets_length (const xcb_xv_image_t *R) { return R->num_planes; } xcb_generic_iterator_t -xcb_xv_image_offsets_end (const xcb_xv_image_t *R /**< */) +xcb_xv_image_offsets_end (const xcb_xv_image_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_xv_image_pitches_end(R); - i.data = ((uint32_t *) child.data) + (R->num_planes); + xcb_generic_iterator_t prev = xcb_xv_image_pitches_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_planes); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } uint8_t * -xcb_xv_image_data (const xcb_xv_image_t *R /**< */) +xcb_xv_image_data (const xcb_xv_image_t *R) { xcb_generic_iterator_t prev = xcb_xv_image_offsets_end(R); return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0); } int -xcb_xv_image_data_length (const xcb_xv_image_t *R /**< */) +xcb_xv_image_data_length (const xcb_xv_image_t *R) { return R->data_size; } xcb_generic_iterator_t -xcb_xv_image_data_end (const xcb_xv_image_t *R /**< */) +xcb_xv_image_data_end (const xcb_xv_image_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_xv_image_offsets_end(R); - i.data = ((uint8_t *) child.data) + (R->data_size); + xcb_generic_iterator_t prev = xcb_xv_image_offsets_end(R); + i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (R->data_size); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } void -xcb_xv_image_next (xcb_xv_image_iterator_t *i /**< */) +xcb_xv_image_next (xcb_xv_image_iterator_t *i) { xcb_xv_image_t *R = i->data; xcb_generic_iterator_t child; @@ -425,7 +434,7 @@ xcb_xv_image_next (xcb_xv_image_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xv_image_end (xcb_xv_image_iterator_t i /**< */) +xcb_xv_image_end (xcb_xv_image_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -437,7 +446,7 @@ xcb_xv_image_end (xcb_xv_image_iterator_t i /**< */) } int -xcb_xv_attribute_info_sizeof (const void *_buffer /**< */) +xcb_xv_attribute_info_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xv_attribute_info_t *_aux = (xcb_xv_attribute_info_t *)_buffer; @@ -455,6 +464,15 @@ xcb_xv_attribute_info_sizeof (const void *_buffer /**< */) xcb_block_len += _aux->size * sizeof(char); xcb_tmp += xcb_block_len; xcb_align_to = ALIGNOF(char); + xcb_align_to = 4; + /* insert padding */ + xcb_pad = -xcb_block_len & (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; /* insert padding */ xcb_pad = -xcb_block_len & (xcb_align_to - 1); xcb_buffer_len += xcb_block_len + xcb_pad; @@ -468,19 +486,19 @@ xcb_xv_attribute_info_sizeof (const void *_buffer /**< */) } char * -xcb_xv_attribute_info_name (const xcb_xv_attribute_info_t *R /**< */) +xcb_xv_attribute_info_name (const xcb_xv_attribute_info_t *R) { return (char *) (R + 1); } int -xcb_xv_attribute_info_name_length (const xcb_xv_attribute_info_t *R /**< */) +xcb_xv_attribute_info_name_length (const xcb_xv_attribute_info_t *R) { return R->size; } xcb_generic_iterator_t -xcb_xv_attribute_info_name_end (const xcb_xv_attribute_info_t *R /**< */) +xcb_xv_attribute_info_name_end (const xcb_xv_attribute_info_t *R) { xcb_generic_iterator_t i; i.data = ((char *) (R + 1)) + (R->size); @@ -490,7 +508,7 @@ xcb_xv_attribute_info_name_end (const xcb_xv_attribute_info_t *R /**< */) } void -xcb_xv_attribute_info_next (xcb_xv_attribute_info_iterator_t *i /**< */) +xcb_xv_attribute_info_next (xcb_xv_attribute_info_iterator_t *i) { xcb_xv_attribute_info_t *R = i->data; xcb_generic_iterator_t child; @@ -501,7 +519,7 @@ xcb_xv_attribute_info_next (xcb_xv_attribute_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xv_attribute_info_end (xcb_xv_attribute_info_iterator_t i /**< */) +xcb_xv_attribute_info_end (xcb_xv_attribute_info_iterator_t i) { xcb_generic_iterator_t ret; while(i.rem > 0) @@ -513,7 +531,7 @@ xcb_xv_attribute_info_end (xcb_xv_attribute_info_iterator_t i /**< */) } void -xcb_xv_image_format_info_next (xcb_xv_image_format_info_iterator_t *i /**< */) +xcb_xv_image_format_info_next (xcb_xv_image_format_info_iterator_t *i) { --i->rem; ++i->data; @@ -521,7 +539,7 @@ xcb_xv_image_format_info_next (xcb_xv_image_format_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xv_image_format_info_end (xcb_xv_image_format_info_iterator_t i /**< */) +xcb_xv_image_format_info_end (xcb_xv_image_format_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -531,13 +549,13 @@ xcb_xv_image_format_info_end (xcb_xv_image_format_info_iterator_t i /**< */) } xcb_xv_query_extension_cookie_t -xcb_xv_query_extension (xcb_connection_t *c /**< */) +xcb_xv_query_extension (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_EXTENSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_EXTENSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -555,13 +573,13 @@ xcb_xv_query_extension (xcb_connection_t *c /**< */) } xcb_xv_query_extension_cookie_t -xcb_xv_query_extension_unchecked (xcb_connection_t *c /**< */) +xcb_xv_query_extension_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_EXTENSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_EXTENSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -579,15 +597,15 @@ xcb_xv_query_extension_unchecked (xcb_connection_t *c /**< */) } xcb_xv_query_extension_reply_t * -xcb_xv_query_extension_reply (xcb_connection_t *c /**< */, +xcb_xv_query_extension_reply (xcb_connection_t *c, xcb_xv_query_extension_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xv_query_extension_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xv_query_adaptors_sizeof (const void *_buffer /**< */) +xcb_xv_query_adaptors_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xv_query_adaptors_reply_t *_aux = (xcb_xv_query_adaptors_reply_t *)_buffer; @@ -623,14 +641,14 @@ xcb_xv_query_adaptors_sizeof (const void *_buffer /**< */) } xcb_xv_query_adaptors_cookie_t -xcb_xv_query_adaptors (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_xv_query_adaptors (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_ADAPTORS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_ADAPTORS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -649,14 +667,14 @@ xcb_xv_query_adaptors (xcb_connection_t *c /**< */, } xcb_xv_query_adaptors_cookie_t -xcb_xv_query_adaptors_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */) +xcb_xv_query_adaptors_unchecked (xcb_connection_t *c, + xcb_window_t window) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_ADAPTORS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_ADAPTORS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -675,13 +693,13 @@ xcb_xv_query_adaptors_unchecked (xcb_connection_t *c /**< */, } int -xcb_xv_query_adaptors_info_length (const xcb_xv_query_adaptors_reply_t *R /**< */) +xcb_xv_query_adaptors_info_length (const xcb_xv_query_adaptors_reply_t *R) { return R->num_adaptors; } xcb_xv_adaptor_info_iterator_t -xcb_xv_query_adaptors_info_iterator (const xcb_xv_query_adaptors_reply_t *R /**< */) +xcb_xv_query_adaptors_info_iterator (const xcb_xv_query_adaptors_reply_t *R) { xcb_xv_adaptor_info_iterator_t i; i.data = (xcb_xv_adaptor_info_t *) (R + 1); @@ -691,15 +709,15 @@ xcb_xv_query_adaptors_info_iterator (const xcb_xv_query_adaptors_reply_t *R /** } xcb_xv_query_adaptors_reply_t * -xcb_xv_query_adaptors_reply (xcb_connection_t *c /**< */, +xcb_xv_query_adaptors_reply (xcb_connection_t *c, xcb_xv_query_adaptors_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xv_query_adaptors_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xv_query_encodings_sizeof (const void *_buffer /**< */) +xcb_xv_query_encodings_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xv_query_encodings_reply_t *_aux = (xcb_xv_query_encodings_reply_t *)_buffer; @@ -735,14 +753,14 @@ xcb_xv_query_encodings_sizeof (const void *_buffer /**< */) } xcb_xv_query_encodings_cookie_t -xcb_xv_query_encodings (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */) +xcb_xv_query_encodings (xcb_connection_t *c, + xcb_xv_port_t port) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_ENCODINGS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_ENCODINGS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -761,14 +779,14 @@ xcb_xv_query_encodings (xcb_connection_t *c /**< */, } xcb_xv_query_encodings_cookie_t -xcb_xv_query_encodings_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */) +xcb_xv_query_encodings_unchecked (xcb_connection_t *c, + xcb_xv_port_t port) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_ENCODINGS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_ENCODINGS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -787,13 +805,13 @@ xcb_xv_query_encodings_unchecked (xcb_connection_t *c /**< */, } int -xcb_xv_query_encodings_info_length (const xcb_xv_query_encodings_reply_t *R /**< */) +xcb_xv_query_encodings_info_length (const xcb_xv_query_encodings_reply_t *R) { return R->num_encodings; } xcb_xv_encoding_info_iterator_t -xcb_xv_query_encodings_info_iterator (const xcb_xv_query_encodings_reply_t *R /**< */) +xcb_xv_query_encodings_info_iterator (const xcb_xv_query_encodings_reply_t *R) { xcb_xv_encoding_info_iterator_t i; i.data = (xcb_xv_encoding_info_t *) (R + 1); @@ -803,23 +821,23 @@ xcb_xv_query_encodings_info_iterator (const xcb_xv_query_encodings_reply_t *R / } xcb_xv_query_encodings_reply_t * -xcb_xv_query_encodings_reply (xcb_connection_t *c /**< */, +xcb_xv_query_encodings_reply (xcb_connection_t *c, xcb_xv_query_encodings_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xv_query_encodings_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_xv_grab_port_cookie_t -xcb_xv_grab_port (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_timestamp_t time /**< */) +xcb_xv_grab_port (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_GRAB_PORT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_GRAB_PORT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -839,15 +857,15 @@ xcb_xv_grab_port (xcb_connection_t *c /**< */, } xcb_xv_grab_port_cookie_t -xcb_xv_grab_port_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_timestamp_t time /**< */) +xcb_xv_grab_port_unchecked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_GRAB_PORT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_GRAB_PORT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -867,23 +885,23 @@ xcb_xv_grab_port_unchecked (xcb_connection_t *c /**< */, } xcb_xv_grab_port_reply_t * -xcb_xv_grab_port_reply (xcb_connection_t *c /**< */, +xcb_xv_grab_port_reply (xcb_connection_t *c, xcb_xv_grab_port_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xv_grab_port_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xv_ungrab_port_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_timestamp_t time /**< */) +xcb_xv_ungrab_port_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_UNGRAB_PORT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_UNGRAB_PORT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -903,15 +921,15 @@ xcb_xv_ungrab_port_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_ungrab_port (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_timestamp_t time /**< */) +xcb_xv_ungrab_port (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_timestamp_t time) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_UNGRAB_PORT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_UNGRAB_PORT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -931,24 +949,24 @@ xcb_xv_ungrab_port (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_put_video_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */) +xcb_xv_put_video_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_PUT_VIDEO, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_PUT_VIDEO, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -977,24 +995,24 @@ xcb_xv_put_video_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_put_video (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */) +xcb_xv_put_video (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_PUT_VIDEO, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_PUT_VIDEO, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1023,24 +1041,24 @@ xcb_xv_put_video (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_put_still_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */) +xcb_xv_put_still_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_PUT_STILL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_PUT_STILL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1069,24 +1087,24 @@ xcb_xv_put_still_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_put_still (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */) +xcb_xv_put_still (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_PUT_STILL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_PUT_STILL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1115,24 +1133,24 @@ xcb_xv_put_still (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_get_video_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */) +xcb_xv_get_video_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_GET_VIDEO, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_GET_VIDEO, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1161,24 +1179,24 @@ xcb_xv_get_video_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_get_video (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */) +xcb_xv_get_video (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_GET_VIDEO, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_GET_VIDEO, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1207,24 +1225,24 @@ xcb_xv_get_video (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_get_still_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */) +xcb_xv_get_still_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_GET_STILL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_GET_STILL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1253,24 +1271,24 @@ xcb_xv_get_still_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_get_still (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */) +xcb_xv_get_still (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_GET_STILL, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_GET_STILL, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1299,15 +1317,15 @@ xcb_xv_get_still (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_stop_video_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */) +xcb_xv_stop_video_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_STOP_VIDEO, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_STOP_VIDEO, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1327,15 +1345,15 @@ xcb_xv_stop_video_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_stop_video (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */) +xcb_xv_stop_video (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_STOP_VIDEO, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_STOP_VIDEO, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1355,15 +1373,15 @@ xcb_xv_stop_video (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_select_video_notify_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint8_t onoff /**< */) +xcb_xv_select_video_notify_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint8_t onoff) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_SELECT_VIDEO_NOTIFY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_SELECT_VIDEO_NOTIFY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1384,15 +1402,15 @@ xcb_xv_select_video_notify_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_select_video_notify (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint8_t onoff /**< */) +xcb_xv_select_video_notify (xcb_connection_t *c, + xcb_drawable_t drawable, + uint8_t onoff) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_SELECT_VIDEO_NOTIFY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_SELECT_VIDEO_NOTIFY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1413,15 +1431,15 @@ xcb_xv_select_video_notify (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_select_port_notify_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint8_t onoff /**< */) +xcb_xv_select_port_notify_checked (xcb_connection_t *c, + xcb_xv_port_t port, + uint8_t onoff) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_SELECT_PORT_NOTIFY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_SELECT_PORT_NOTIFY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1442,15 +1460,15 @@ xcb_xv_select_port_notify_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_select_port_notify (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint8_t onoff /**< */) +xcb_xv_select_port_notify (xcb_connection_t *c, + xcb_xv_port_t port, + uint8_t onoff) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_SELECT_PORT_NOTIFY, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_SELECT_PORT_NOTIFY, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1471,19 +1489,19 @@ xcb_xv_select_port_notify (xcb_connection_t *c /**< */, } xcb_xv_query_best_size_cookie_t -xcb_xv_query_best_size (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint8_t motion /**< */) +xcb_xv_query_best_size (xcb_connection_t *c, + xcb_xv_port_t port, + uint16_t vid_w, + uint16_t vid_h, + uint16_t drw_w, + uint16_t drw_h, + uint8_t motion) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_BEST_SIZE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_BEST_SIZE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1508,19 +1526,19 @@ xcb_xv_query_best_size (xcb_connection_t *c /**< */, } xcb_xv_query_best_size_cookie_t -xcb_xv_query_best_size_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint8_t motion /**< */) +xcb_xv_query_best_size_unchecked (xcb_connection_t *c, + xcb_xv_port_t port, + uint16_t vid_w, + uint16_t vid_h, + uint16_t drw_w, + uint16_t drw_h, + uint8_t motion) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_BEST_SIZE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_BEST_SIZE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1545,24 +1563,24 @@ xcb_xv_query_best_size_unchecked (xcb_connection_t *c /**< */, } xcb_xv_query_best_size_reply_t * -xcb_xv_query_best_size_reply (xcb_connection_t *c /**< */, +xcb_xv_query_best_size_reply (xcb_connection_t *c, xcb_xv_query_best_size_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xv_query_best_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xv_set_port_attribute_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_atom_t attribute /**< */, - int32_t value /**< */) +xcb_xv_set_port_attribute_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_atom_t attribute, + int32_t value) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_SET_PORT_ATTRIBUTE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_SET_PORT_ATTRIBUTE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1583,16 +1601,16 @@ xcb_xv_set_port_attribute_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_set_port_attribute (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_atom_t attribute /**< */, - int32_t value /**< */) +xcb_xv_set_port_attribute (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_atom_t attribute, + int32_t value) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_SET_PORT_ATTRIBUTE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_SET_PORT_ATTRIBUTE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -1613,15 +1631,15 @@ xcb_xv_set_port_attribute (xcb_connection_t *c /**< */, } xcb_xv_get_port_attribute_cookie_t -xcb_xv_get_port_attribute (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_atom_t attribute /**< */) +xcb_xv_get_port_attribute (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_atom_t attribute) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_GET_PORT_ATTRIBUTE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_GET_PORT_ATTRIBUTE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1641,15 +1659,15 @@ xcb_xv_get_port_attribute (xcb_connection_t *c /**< */, } xcb_xv_get_port_attribute_cookie_t -xcb_xv_get_port_attribute_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_atom_t attribute /**< */) +xcb_xv_get_port_attribute_unchecked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_atom_t attribute) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_GET_PORT_ATTRIBUTE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_GET_PORT_ATTRIBUTE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1669,15 +1687,15 @@ xcb_xv_get_port_attribute_unchecked (xcb_connection_t *c /**< */, } xcb_xv_get_port_attribute_reply_t * -xcb_xv_get_port_attribute_reply (xcb_connection_t *c /**< */, +xcb_xv_get_port_attribute_reply (xcb_connection_t *c, xcb_xv_get_port_attribute_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xv_get_port_attribute_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xv_query_port_attributes_sizeof (const void *_buffer /**< */) +xcb_xv_query_port_attributes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xv_query_port_attributes_reply_t *_aux = (xcb_xv_query_port_attributes_reply_t *)_buffer; @@ -1713,14 +1731,14 @@ xcb_xv_query_port_attributes_sizeof (const void *_buffer /**< */) } xcb_xv_query_port_attributes_cookie_t -xcb_xv_query_port_attributes (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */) +xcb_xv_query_port_attributes (xcb_connection_t *c, + xcb_xv_port_t port) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_PORT_ATTRIBUTES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_PORT_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1739,14 +1757,14 @@ xcb_xv_query_port_attributes (xcb_connection_t *c /**< */, } xcb_xv_query_port_attributes_cookie_t -xcb_xv_query_port_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */) +xcb_xv_query_port_attributes_unchecked (xcb_connection_t *c, + xcb_xv_port_t port) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_PORT_ATTRIBUTES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_PORT_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1765,13 +1783,13 @@ xcb_xv_query_port_attributes_unchecked (xcb_connection_t *c /**< */, } int -xcb_xv_query_port_attributes_attributes_length (const xcb_xv_query_port_attributes_reply_t *R /**< */) +xcb_xv_query_port_attributes_attributes_length (const xcb_xv_query_port_attributes_reply_t *R) { return R->num_attributes; } xcb_xv_attribute_info_iterator_t -xcb_xv_query_port_attributes_attributes_iterator (const xcb_xv_query_port_attributes_reply_t *R /**< */) +xcb_xv_query_port_attributes_attributes_iterator (const xcb_xv_query_port_attributes_reply_t *R) { xcb_xv_attribute_info_iterator_t i; i.data = (xcb_xv_attribute_info_t *) (R + 1); @@ -1781,15 +1799,15 @@ xcb_xv_query_port_attributes_attributes_iterator (const xcb_xv_query_port_attrib } xcb_xv_query_port_attributes_reply_t * -xcb_xv_query_port_attributes_reply (xcb_connection_t *c /**< */, +xcb_xv_query_port_attributes_reply (xcb_connection_t *c, xcb_xv_query_port_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xv_query_port_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xv_list_image_formats_sizeof (const void *_buffer /**< */) +xcb_xv_list_image_formats_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xv_list_image_formats_reply_t *_aux = (xcb_xv_list_image_formats_reply_t *)_buffer; @@ -1820,14 +1838,14 @@ xcb_xv_list_image_formats_sizeof (const void *_buffer /**< */) } xcb_xv_list_image_formats_cookie_t -xcb_xv_list_image_formats (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */) +xcb_xv_list_image_formats (xcb_connection_t *c, + xcb_xv_port_t port) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_LIST_IMAGE_FORMATS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_LIST_IMAGE_FORMATS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1846,14 +1864,14 @@ xcb_xv_list_image_formats (xcb_connection_t *c /**< */, } xcb_xv_list_image_formats_cookie_t -xcb_xv_list_image_formats_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */) +xcb_xv_list_image_formats_unchecked (xcb_connection_t *c, + xcb_xv_port_t port) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_LIST_IMAGE_FORMATS, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_LIST_IMAGE_FORMATS, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1872,19 +1890,19 @@ xcb_xv_list_image_formats_unchecked (xcb_connection_t *c /**< */, } xcb_xv_image_format_info_t * -xcb_xv_list_image_formats_format (const xcb_xv_list_image_formats_reply_t *R /**< */) +xcb_xv_list_image_formats_format (const xcb_xv_list_image_formats_reply_t *R) { return (xcb_xv_image_format_info_t *) (R + 1); } int -xcb_xv_list_image_formats_format_length (const xcb_xv_list_image_formats_reply_t *R /**< */) +xcb_xv_list_image_formats_format_length (const xcb_xv_list_image_formats_reply_t *R) { return R->num_formats; } xcb_xv_image_format_info_iterator_t -xcb_xv_list_image_formats_format_iterator (const xcb_xv_list_image_formats_reply_t *R /**< */) +xcb_xv_list_image_formats_format_iterator (const xcb_xv_list_image_formats_reply_t *R) { xcb_xv_image_format_info_iterator_t i; i.data = (xcb_xv_image_format_info_t *) (R + 1); @@ -1894,15 +1912,15 @@ xcb_xv_list_image_formats_format_iterator (const xcb_xv_list_image_formats_reply } xcb_xv_list_image_formats_reply_t * -xcb_xv_list_image_formats_reply (xcb_connection_t *c /**< */, +xcb_xv_list_image_formats_reply (xcb_connection_t *c, xcb_xv_list_image_formats_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xv_list_image_formats_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xv_query_image_attributes_sizeof (const void *_buffer /**< */) +xcb_xv_query_image_attributes_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xv_query_image_attributes_reply_t *_aux = (xcb_xv_query_image_attributes_reply_t *)_buffer; @@ -1945,17 +1963,17 @@ xcb_xv_query_image_attributes_sizeof (const void *_buffer /**< */) } xcb_xv_query_image_attributes_cookie_t -xcb_xv_query_image_attributes (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint32_t id /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_xv_query_image_attributes (xcb_connection_t *c, + xcb_xv_port_t port, + uint32_t id, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_IMAGE_ATTRIBUTES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_IMAGE_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -1977,17 +1995,17 @@ xcb_xv_query_image_attributes (xcb_connection_t *c /**< */, } xcb_xv_query_image_attributes_cookie_t -xcb_xv_query_image_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint32_t id /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_xv_query_image_attributes_unchecked (xcb_connection_t *c, + xcb_xv_port_t port, + uint32_t id, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_QUERY_IMAGE_ATTRIBUTES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_QUERY_IMAGE_ATTRIBUTES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -2009,19 +2027,19 @@ xcb_xv_query_image_attributes_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_xv_query_image_attributes_pitches (const xcb_xv_query_image_attributes_reply_t *R /**< */) +xcb_xv_query_image_attributes_pitches (const xcb_xv_query_image_attributes_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_xv_query_image_attributes_pitches_length (const xcb_xv_query_image_attributes_reply_t *R /**< */) +xcb_xv_query_image_attributes_pitches_length (const xcb_xv_query_image_attributes_reply_t *R) { return R->num_planes; } xcb_generic_iterator_t -xcb_xv_query_image_attributes_pitches_end (const xcb_xv_query_image_attributes_reply_t *R /**< */) +xcb_xv_query_image_attributes_pitches_end (const xcb_xv_query_image_attributes_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->num_planes); @@ -2031,40 +2049,40 @@ xcb_xv_query_image_attributes_pitches_end (const xcb_xv_query_image_attributes_r } uint32_t * -xcb_xv_query_image_attributes_offsets (const xcb_xv_query_image_attributes_reply_t *R /**< */) +xcb_xv_query_image_attributes_offsets (const xcb_xv_query_image_attributes_reply_t *R) { xcb_generic_iterator_t prev = xcb_xv_query_image_attributes_pitches_end(R); return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); } int -xcb_xv_query_image_attributes_offsets_length (const xcb_xv_query_image_attributes_reply_t *R /**< */) +xcb_xv_query_image_attributes_offsets_length (const xcb_xv_query_image_attributes_reply_t *R) { return R->num_planes; } xcb_generic_iterator_t -xcb_xv_query_image_attributes_offsets_end (const xcb_xv_query_image_attributes_reply_t *R /**< */) +xcb_xv_query_image_attributes_offsets_end (const xcb_xv_query_image_attributes_reply_t *R) { xcb_generic_iterator_t i; - xcb_generic_iterator_t child = xcb_xv_query_image_attributes_pitches_end(R); - i.data = ((uint32_t *) child.data) + (R->num_planes); + xcb_generic_iterator_t prev = xcb_xv_query_image_attributes_pitches_end(R); + i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_planes); i.rem = 0; i.index = (char *) i.data - (char *) R; return i; } xcb_xv_query_image_attributes_reply_t * -xcb_xv_query_image_attributes_reply (xcb_connection_t *c /**< */, +xcb_xv_query_image_attributes_reply (xcb_connection_t *c, xcb_xv_query_image_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xv_query_image_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xv_put_image_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */) +xcb_xv_put_image_sizeof (const void *_buffer, + uint32_t data_len) { char *xcb_tmp = (char *)_buffer; unsigned int xcb_buffer_len = 0; @@ -2094,29 +2112,29 @@ xcb_xv_put_image_sizeof (const void *_buffer /**< */, } xcb_void_cookie_t -xcb_xv_put_image_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t id /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_w /**< */, - uint16_t src_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_xv_put_image_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t id, + int16_t src_x, + int16_t src_y, + uint16_t src_w, + uint16_t src_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h, + uint16_t width, + uint16_t height, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_PUT_IMAGE, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xv_id, + .opcode = XCB_XV_PUT_IMAGE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2153,29 +2171,29 @@ xcb_xv_put_image_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_put_image (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t id /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_w /**< */, - uint16_t src_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */) +xcb_xv_put_image (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t id, + int16_t src_x, + int16_t src_y, + uint16_t src_w, + uint16_t src_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h, + uint16_t width, + uint16_t height, + uint32_t data_len, + const uint8_t *data) { static const xcb_protocol_request_t xcb_req = { - /* count */ 4, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_PUT_IMAGE, - /* isvoid */ 1 + .count = 4, + .ext = &xcb_xv_id, + .opcode = XCB_XV_PUT_IMAGE, + .isvoid = 1 }; struct iovec xcb_parts[6]; @@ -2211,31 +2229,53 @@ xcb_xv_put_image (xcb_connection_t *c /**< */, return xcb_ret; } +uint8_t * +xcb_xv_put_image_data (const xcb_xv_put_image_request_t *R) +{ + return (uint8_t *) (R + 1); +} + +int +xcb_xv_put_image_data_length (const xcb_xv_put_image_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_xv_put_image_request_t))/sizeof(uint8_t)); +} + +xcb_generic_iterator_t +xcb_xv_put_image_data_end (const xcb_xv_put_image_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_xv_put_image_request_t))/sizeof(uint8_t))); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + xcb_void_cookie_t -xcb_xv_shm_put_image_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t id /**< */, - uint32_t offset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_w /**< */, - uint16_t src_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint8_t send_event /**< */) +xcb_xv_shm_put_image_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + xcb_shm_seg_t shmseg, + uint32_t id, + uint32_t offset, + int16_t src_x, + int16_t src_y, + uint16_t src_w, + uint16_t src_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h, + uint16_t width, + uint16_t height, + uint8_t send_event) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_SHM_PUT_IMAGE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_SHM_PUT_IMAGE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -2271,30 +2311,30 @@ xcb_xv_shm_put_image_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xv_shm_put_image (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t id /**< */, - uint32_t offset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_w /**< */, - uint16_t src_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint8_t send_event /**< */) +xcb_xv_shm_put_image (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + xcb_shm_seg_t shmseg, + uint32_t id, + uint32_t offset, + int16_t src_x, + int16_t src_y, + uint16_t src_w, + uint16_t src_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h, + uint16_t width, + uint16_t height, + uint8_t send_event) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xv_id, - /* opcode */ XCB_XV_SHM_PUT_IMAGE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xv_id, + .opcode = XCB_XV_SHM_PUT_IMAGE, + .isvoid = 1 }; struct iovec xcb_parts[4]; diff --git a/lib/libxcb/src/xv.h b/lib/libxcb/src/xv.h index d8772df9f..c0bcfe887 100644 --- a/lib/libxcb/src/xv.h +++ b/lib/libxcb/src/xv.h @@ -31,9 +31,9 @@ typedef uint32_t xcb_xv_port_t; * @brief xcb_xv_port_iterator_t **/ typedef struct xcb_xv_port_iterator_t { - xcb_xv_port_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xv_port_t *data; + int rem; + int index; } xcb_xv_port_iterator_t; typedef uint32_t xcb_xv_encoding_t; @@ -42,9 +42,9 @@ typedef uint32_t xcb_xv_encoding_t; * @brief xcb_xv_encoding_iterator_t **/ typedef struct xcb_xv_encoding_iterator_t { - xcb_xv_encoding_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xv_encoding_t *data; + int rem; + int index; } xcb_xv_encoding_iterator_t; typedef enum xcb_xv_type_t { @@ -96,158 +96,158 @@ typedef enum xcb_xv_grab_port_status_t { * @brief xcb_xv_rational_t **/ typedef struct xcb_xv_rational_t { - int32_t numerator; /**< */ - int32_t denominator; /**< */ + int32_t numerator; + int32_t denominator; } xcb_xv_rational_t; /** * @brief xcb_xv_rational_iterator_t **/ typedef struct xcb_xv_rational_iterator_t { - xcb_xv_rational_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xv_rational_t *data; + int rem; + int index; } xcb_xv_rational_iterator_t; /** * @brief xcb_xv_format_t **/ typedef struct xcb_xv_format_t { - xcb_visualid_t visual; /**< */ - uint8_t depth; /**< */ - uint8_t pad0[3]; /**< */ + xcb_visualid_t visual; + uint8_t depth; + uint8_t pad0[3]; } xcb_xv_format_t; /** * @brief xcb_xv_format_iterator_t **/ typedef struct xcb_xv_format_iterator_t { - xcb_xv_format_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xv_format_t *data; + int rem; + int index; } xcb_xv_format_iterator_t; /** * @brief xcb_xv_adaptor_info_t **/ typedef struct xcb_xv_adaptor_info_t { - xcb_xv_port_t base_id; /**< */ - uint16_t name_size; /**< */ - uint16_t num_ports; /**< */ - uint16_t num_formats; /**< */ - uint8_t type; /**< */ - uint8_t pad0; /**< */ + xcb_xv_port_t base_id; + uint16_t name_size; + uint16_t num_ports; + uint16_t num_formats; + uint8_t type; + uint8_t pad0; } xcb_xv_adaptor_info_t; /** * @brief xcb_xv_adaptor_info_iterator_t **/ typedef struct xcb_xv_adaptor_info_iterator_t { - xcb_xv_adaptor_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xv_adaptor_info_t *data; + int rem; + int index; } xcb_xv_adaptor_info_iterator_t; /** * @brief xcb_xv_encoding_info_t **/ typedef struct xcb_xv_encoding_info_t { - xcb_xv_encoding_t encoding; /**< */ - uint16_t name_size; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint8_t pad0[2]; /**< */ - xcb_xv_rational_t rate; /**< */ + xcb_xv_encoding_t encoding; + uint16_t name_size; + uint16_t width; + uint16_t height; + uint8_t pad0[2]; + xcb_xv_rational_t rate; } xcb_xv_encoding_info_t; /** * @brief xcb_xv_encoding_info_iterator_t **/ typedef struct xcb_xv_encoding_info_iterator_t { - xcb_xv_encoding_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xv_encoding_info_t *data; + int rem; + int index; } xcb_xv_encoding_info_iterator_t; /** * @brief xcb_xv_image_t **/ typedef struct xcb_xv_image_t { - uint32_t id; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint32_t data_size; /**< */ - uint32_t num_planes; /**< */ + uint32_t id; + uint16_t width; + uint16_t height; + uint32_t data_size; + uint32_t num_planes; } xcb_xv_image_t; /** * @brief xcb_xv_image_iterator_t **/ typedef struct xcb_xv_image_iterator_t { - xcb_xv_image_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xv_image_t *data; + int rem; + int index; } xcb_xv_image_iterator_t; /** * @brief xcb_xv_attribute_info_t **/ typedef struct xcb_xv_attribute_info_t { - uint32_t flags; /**< */ - int32_t min; /**< */ - int32_t max; /**< */ - uint32_t size; /**< */ + uint32_t flags; + int32_t min; + int32_t max; + uint32_t size; } xcb_xv_attribute_info_t; /** * @brief xcb_xv_attribute_info_iterator_t **/ typedef struct xcb_xv_attribute_info_iterator_t { - xcb_xv_attribute_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xv_attribute_info_t *data; + int rem; + int index; } xcb_xv_attribute_info_iterator_t; /** * @brief xcb_xv_image_format_info_t **/ typedef struct xcb_xv_image_format_info_t { - uint32_t id; /**< */ - uint8_t type; /**< */ - uint8_t byte_order; /**< */ - uint8_t pad0[2]; /**< */ - uint8_t guid[16]; /**< */ - uint8_t bpp; /**< */ - uint8_t num_planes; /**< */ - uint8_t pad1[2]; /**< */ - uint8_t depth; /**< */ - uint8_t pad2[3]; /**< */ - uint32_t red_mask; /**< */ - uint32_t green_mask; /**< */ - uint32_t blue_mask; /**< */ - uint8_t format; /**< */ - uint8_t pad3[3]; /**< */ - uint32_t y_sample_bits; /**< */ - uint32_t u_sample_bits; /**< */ - uint32_t v_sample_bits; /**< */ - uint32_t vhorz_y_period; /**< */ - uint32_t vhorz_u_period; /**< */ - uint32_t vhorz_v_period; /**< */ - uint32_t vvert_y_period; /**< */ - uint32_t vvert_u_period; /**< */ - uint32_t vvert_v_period; /**< */ - uint8_t vcomp_order[32]; /**< */ - uint8_t vscanline_order; /**< */ - uint8_t pad4[11]; /**< */ + uint32_t id; + uint8_t type; + uint8_t byte_order; + uint8_t pad0[2]; + uint8_t guid[16]; + uint8_t bpp; + uint8_t num_planes; + uint8_t pad1[2]; + uint8_t depth; + uint8_t pad2[3]; + uint32_t red_mask; + uint32_t green_mask; + uint32_t blue_mask; + uint8_t format; + uint8_t pad3[3]; + uint32_t y_sample_bits; + uint32_t u_sample_bits; + uint32_t v_sample_bits; + uint32_t vhorz_y_period; + uint32_t vhorz_u_period; + uint32_t vhorz_v_period; + uint32_t vvert_y_period; + uint32_t vvert_u_period; + uint32_t vvert_v_period; + uint8_t vcomp_order[32]; + uint8_t vscanline_order; + uint8_t pad4[11]; } xcb_xv_image_format_info_t; /** * @brief xcb_xv_image_format_info_iterator_t **/ typedef struct xcb_xv_image_format_info_iterator_t { - xcb_xv_image_format_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xv_image_format_info_t *data; + int rem; + int index; } xcb_xv_image_format_info_iterator_t; /** Opcode for xcb_xv_bad_port. */ @@ -257,9 +257,9 @@ typedef struct xcb_xv_image_format_info_iterator_t { * @brief xcb_xv_bad_port_error_t **/ typedef struct xcb_xv_bad_port_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_xv_bad_port_error_t; /** Opcode for xcb_xv_bad_encoding. */ @@ -269,9 +269,9 @@ typedef struct xcb_xv_bad_port_error_t { * @brief xcb_xv_bad_encoding_error_t **/ typedef struct xcb_xv_bad_encoding_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_xv_bad_encoding_error_t; /** Opcode for xcb_xv_bad_control. */ @@ -281,9 +281,9 @@ typedef struct xcb_xv_bad_encoding_error_t { * @brief xcb_xv_bad_control_error_t **/ typedef struct xcb_xv_bad_control_error_t { - uint8_t response_type; /**< */ - uint8_t error_code; /**< */ - uint16_t sequence; /**< */ + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; } xcb_xv_bad_control_error_t; /** Opcode for xcb_xv_video_notify. */ @@ -293,12 +293,12 @@ typedef struct xcb_xv_bad_control_error_t { * @brief xcb_xv_video_notify_event_t **/ typedef struct xcb_xv_video_notify_event_t { - uint8_t response_type; /**< */ - uint8_t reason; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_xv_port_t port; /**< */ + uint8_t response_type; + uint8_t reason; + uint16_t sequence; + xcb_timestamp_t time; + xcb_drawable_t drawable; + xcb_xv_port_t port; } xcb_xv_video_notify_event_t; /** Opcode for xcb_xv_port_notify. */ @@ -308,20 +308,20 @@ typedef struct xcb_xv_video_notify_event_t { * @brief xcb_xv_port_notify_event_t **/ typedef struct xcb_xv_port_notify_event_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - xcb_timestamp_t time; /**< */ - xcb_xv_port_t port; /**< */ - xcb_atom_t attribute; /**< */ - int32_t value; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_timestamp_t time; + xcb_xv_port_t port; + xcb_atom_t attribute; + int32_t value; } xcb_xv_port_notify_event_t; /** * @brief xcb_xv_query_extension_cookie_t **/ typedef struct xcb_xv_query_extension_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xv_query_extension_cookie_t; /** Opcode for xcb_xv_query_extension. */ @@ -331,28 +331,28 @@ typedef struct xcb_xv_query_extension_cookie_t { * @brief xcb_xv_query_extension_request_t **/ typedef struct xcb_xv_query_extension_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_xv_query_extension_request_t; /** * @brief xcb_xv_query_extension_reply_t **/ typedef struct xcb_xv_query_extension_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t major; /**< */ - uint16_t minor; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t major; + uint16_t minor; } xcb_xv_query_extension_reply_t; /** * @brief xcb_xv_query_adaptors_cookie_t **/ typedef struct xcb_xv_query_adaptors_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xv_query_adaptors_cookie_t; /** Opcode for xcb_xv_query_adaptors. */ @@ -362,29 +362,29 @@ typedef struct xcb_xv_query_adaptors_cookie_t { * @brief xcb_xv_query_adaptors_request_t **/ typedef struct xcb_xv_query_adaptors_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_window_t window; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_window_t window; } xcb_xv_query_adaptors_request_t; /** * @brief xcb_xv_query_adaptors_reply_t **/ typedef struct xcb_xv_query_adaptors_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_adaptors; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_adaptors; + uint8_t pad1[22]; } xcb_xv_query_adaptors_reply_t; /** * @brief xcb_xv_query_encodings_cookie_t **/ typedef struct xcb_xv_query_encodings_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xv_query_encodings_cookie_t; /** Opcode for xcb_xv_query_encodings. */ @@ -394,29 +394,29 @@ typedef struct xcb_xv_query_encodings_cookie_t { * @brief xcb_xv_query_encodings_request_t **/ typedef struct xcb_xv_query_encodings_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; } xcb_xv_query_encodings_request_t; /** * @brief xcb_xv_query_encodings_reply_t **/ typedef struct xcb_xv_query_encodings_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t num_encodings; /**< */ - uint8_t pad1[22]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t num_encodings; + uint8_t pad1[22]; } xcb_xv_query_encodings_reply_t; /** * @brief xcb_xv_grab_port_cookie_t **/ typedef struct xcb_xv_grab_port_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xv_grab_port_cookie_t; /** Opcode for xcb_xv_grab_port. */ @@ -426,21 +426,21 @@ typedef struct xcb_xv_grab_port_cookie_t { * @brief xcb_xv_grab_port_request_t **/ typedef struct xcb_xv_grab_port_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_timestamp_t time; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_timestamp_t time; } xcb_xv_grab_port_request_t; /** * @brief xcb_xv_grab_port_reply_t **/ typedef struct xcb_xv_grab_port_reply_t { - uint8_t response_type; /**< */ - uint8_t result; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ + uint8_t response_type; + uint8_t result; + uint16_t sequence; + uint32_t length; } xcb_xv_grab_port_reply_t; /** Opcode for xcb_xv_ungrab_port. */ @@ -450,11 +450,11 @@ typedef struct xcb_xv_grab_port_reply_t { * @brief xcb_xv_ungrab_port_request_t **/ typedef struct xcb_xv_ungrab_port_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_timestamp_t time; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_timestamp_t time; } xcb_xv_ungrab_port_request_t; /** Opcode for xcb_xv_put_video. */ @@ -464,20 +464,20 @@ typedef struct xcb_xv_ungrab_port_request_t { * @brief xcb_xv_put_video_request_t **/ typedef struct xcb_xv_put_video_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t vid_x; /**< */ - int16_t vid_y; /**< */ - uint16_t vid_w; /**< */ - uint16_t vid_h; /**< */ - int16_t drw_x; /**< */ - int16_t drw_y; /**< */ - uint16_t drw_w; /**< */ - uint16_t drw_h; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t vid_x; + int16_t vid_y; + uint16_t vid_w; + uint16_t vid_h; + int16_t drw_x; + int16_t drw_y; + uint16_t drw_w; + uint16_t drw_h; } xcb_xv_put_video_request_t; /** Opcode for xcb_xv_put_still. */ @@ -487,20 +487,20 @@ typedef struct xcb_xv_put_video_request_t { * @brief xcb_xv_put_still_request_t **/ typedef struct xcb_xv_put_still_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t vid_x; /**< */ - int16_t vid_y; /**< */ - uint16_t vid_w; /**< */ - uint16_t vid_h; /**< */ - int16_t drw_x; /**< */ - int16_t drw_y; /**< */ - uint16_t drw_w; /**< */ - uint16_t drw_h; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t vid_x; + int16_t vid_y; + uint16_t vid_w; + uint16_t vid_h; + int16_t drw_x; + int16_t drw_y; + uint16_t drw_w; + uint16_t drw_h; } xcb_xv_put_still_request_t; /** Opcode for xcb_xv_get_video. */ @@ -510,20 +510,20 @@ typedef struct xcb_xv_put_still_request_t { * @brief xcb_xv_get_video_request_t **/ typedef struct xcb_xv_get_video_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t vid_x; /**< */ - int16_t vid_y; /**< */ - uint16_t vid_w; /**< */ - uint16_t vid_h; /**< */ - int16_t drw_x; /**< */ - int16_t drw_y; /**< */ - uint16_t drw_w; /**< */ - uint16_t drw_h; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t vid_x; + int16_t vid_y; + uint16_t vid_w; + uint16_t vid_h; + int16_t drw_x; + int16_t drw_y; + uint16_t drw_w; + uint16_t drw_h; } xcb_xv_get_video_request_t; /** Opcode for xcb_xv_get_still. */ @@ -533,20 +533,20 @@ typedef struct xcb_xv_get_video_request_t { * @brief xcb_xv_get_still_request_t **/ typedef struct xcb_xv_get_still_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - int16_t vid_x; /**< */ - int16_t vid_y; /**< */ - uint16_t vid_w; /**< */ - uint16_t vid_h; /**< */ - int16_t drw_x; /**< */ - int16_t drw_y; /**< */ - uint16_t drw_w; /**< */ - uint16_t drw_h; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t vid_x; + int16_t vid_y; + uint16_t vid_w; + uint16_t vid_h; + int16_t drw_x; + int16_t drw_y; + uint16_t drw_w; + uint16_t drw_h; } xcb_xv_get_still_request_t; /** Opcode for xcb_xv_stop_video. */ @@ -556,11 +556,11 @@ typedef struct xcb_xv_get_still_request_t { * @brief xcb_xv_stop_video_request_t **/ typedef struct xcb_xv_stop_video_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_drawable_t drawable; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_drawable_t drawable; } xcb_xv_stop_video_request_t; /** Opcode for xcb_xv_select_video_notify. */ @@ -570,12 +570,12 @@ typedef struct xcb_xv_stop_video_request_t { * @brief xcb_xv_select_video_notify_request_t **/ typedef struct xcb_xv_select_video_notify_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_drawable_t drawable; /**< */ - uint8_t onoff; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_drawable_t drawable; + uint8_t onoff; + uint8_t pad0[3]; } xcb_xv_select_video_notify_request_t; /** Opcode for xcb_xv_select_port_notify. */ @@ -585,19 +585,19 @@ typedef struct xcb_xv_select_video_notify_request_t { * @brief xcb_xv_select_port_notify_request_t **/ typedef struct xcb_xv_select_port_notify_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - uint8_t onoff; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + uint8_t onoff; + uint8_t pad0[3]; } xcb_xv_select_port_notify_request_t; /** * @brief xcb_xv_query_best_size_cookie_t **/ typedef struct xcb_xv_query_best_size_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xv_query_best_size_cookie_t; /** Opcode for xcb_xv_query_best_size. */ @@ -607,28 +607,28 @@ typedef struct xcb_xv_query_best_size_cookie_t { * @brief xcb_xv_query_best_size_request_t **/ typedef struct xcb_xv_query_best_size_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - uint16_t vid_w; /**< */ - uint16_t vid_h; /**< */ - uint16_t drw_w; /**< */ - uint16_t drw_h; /**< */ - uint8_t motion; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + uint16_t vid_w; + uint16_t vid_h; + uint16_t drw_w; + uint16_t drw_h; + uint8_t motion; + uint8_t pad0[3]; } xcb_xv_query_best_size_request_t; /** * @brief xcb_xv_query_best_size_reply_t **/ typedef struct xcb_xv_query_best_size_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t actual_width; /**< */ - uint16_t actual_height; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t actual_width; + uint16_t actual_height; } xcb_xv_query_best_size_reply_t; /** Opcode for xcb_xv_set_port_attribute. */ @@ -638,19 +638,19 @@ typedef struct xcb_xv_query_best_size_reply_t { * @brief xcb_xv_set_port_attribute_request_t **/ typedef struct xcb_xv_set_port_attribute_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_atom_t attribute; /**< */ - int32_t value; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_atom_t attribute; + int32_t value; } xcb_xv_set_port_attribute_request_t; /** * @brief xcb_xv_get_port_attribute_cookie_t **/ typedef struct xcb_xv_get_port_attribute_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xv_get_port_attribute_cookie_t; /** Opcode for xcb_xv_get_port_attribute. */ @@ -660,29 +660,29 @@ typedef struct xcb_xv_get_port_attribute_cookie_t { * @brief xcb_xv_get_port_attribute_request_t **/ typedef struct xcb_xv_get_port_attribute_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_atom_t attribute; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_atom_t attribute; } xcb_xv_get_port_attribute_request_t; /** * @brief xcb_xv_get_port_attribute_reply_t **/ typedef struct xcb_xv_get_port_attribute_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - int32_t value; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + int32_t value; } xcb_xv_get_port_attribute_reply_t; /** * @brief xcb_xv_query_port_attributes_cookie_t **/ typedef struct xcb_xv_query_port_attributes_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xv_query_port_attributes_cookie_t; /** Opcode for xcb_xv_query_port_attributes. */ @@ -692,30 +692,30 @@ typedef struct xcb_xv_query_port_attributes_cookie_t { * @brief xcb_xv_query_port_attributes_request_t **/ typedef struct xcb_xv_query_port_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; } xcb_xv_query_port_attributes_request_t; /** * @brief xcb_xv_query_port_attributes_reply_t **/ typedef struct xcb_xv_query_port_attributes_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_attributes; /**< */ - uint32_t text_size; /**< */ - uint8_t pad1[16]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_attributes; + uint32_t text_size; + uint8_t pad1[16]; } xcb_xv_query_port_attributes_reply_t; /** * @brief xcb_xv_list_image_formats_cookie_t **/ typedef struct xcb_xv_list_image_formats_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xv_list_image_formats_cookie_t; /** Opcode for xcb_xv_list_image_formats. */ @@ -725,29 +725,29 @@ typedef struct xcb_xv_list_image_formats_cookie_t { * @brief xcb_xv_list_image_formats_request_t **/ typedef struct xcb_xv_list_image_formats_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; } xcb_xv_list_image_formats_request_t; /** * @brief xcb_xv_list_image_formats_reply_t **/ typedef struct xcb_xv_list_image_formats_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_formats; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_formats; + uint8_t pad1[20]; } xcb_xv_list_image_formats_reply_t; /** * @brief xcb_xv_query_image_attributes_cookie_t **/ typedef struct xcb_xv_query_image_attributes_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xv_query_image_attributes_cookie_t; /** Opcode for xcb_xv_query_image_attributes. */ @@ -757,28 +757,28 @@ typedef struct xcb_xv_query_image_attributes_cookie_t { * @brief xcb_xv_query_image_attributes_request_t **/ typedef struct xcb_xv_query_image_attributes_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - uint32_t id; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + uint32_t id; + uint16_t width; + uint16_t height; } xcb_xv_query_image_attributes_request_t; /** * @brief xcb_xv_query_image_attributes_reply_t **/ typedef struct xcb_xv_query_image_attributes_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num_planes; /**< */ - uint32_t data_size; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint8_t pad1[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num_planes; + uint32_t data_size; + uint16_t width; + uint16_t height; + uint8_t pad1[12]; } xcb_xv_query_image_attributes_reply_t; /** Opcode for xcb_xv_put_image. */ @@ -788,23 +788,23 @@ typedef struct xcb_xv_query_image_attributes_reply_t { * @brief xcb_xv_put_image_request_t **/ typedef struct xcb_xv_put_image_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - uint32_t id; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ - uint16_t src_w; /**< */ - uint16_t src_h; /**< */ - int16_t drw_x; /**< */ - int16_t drw_y; /**< */ - uint16_t drw_w; /**< */ - uint16_t drw_h; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + uint32_t id; + int16_t src_x; + int16_t src_y; + uint16_t src_w; + uint16_t src_h; + int16_t drw_x; + int16_t drw_y; + uint16_t drw_w; + uint16_t drw_h; + uint16_t width; + uint16_t height; } xcb_xv_put_image_request_t; /** Opcode for xcb_xv_shm_put_image. */ @@ -814,27 +814,27 @@ typedef struct xcb_xv_put_image_request_t { * @brief xcb_xv_shm_put_image_request_t **/ typedef struct xcb_xv_shm_put_image_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port; /**< */ - xcb_drawable_t drawable; /**< */ - xcb_gcontext_t gc; /**< */ - xcb_shm_seg_t shmseg; /**< */ - uint32_t id; /**< */ - uint32_t offset; /**< */ - int16_t src_x; /**< */ - int16_t src_y; /**< */ - uint16_t src_w; /**< */ - uint16_t src_h; /**< */ - int16_t drw_x; /**< */ - int16_t drw_y; /**< */ - uint16_t drw_w; /**< */ - uint16_t drw_h; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint8_t send_event; /**< */ - uint8_t pad0[3]; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + xcb_shm_seg_t shmseg; + uint32_t id; + uint32_t offset; + int16_t src_x; + int16_t src_y; + uint16_t src_w; + uint16_t src_h; + int16_t drw_x; + int16_t drw_y; + uint16_t drw_w; + uint16_t drw_h; + uint16_t width; + uint16_t height; + uint8_t send_event; + uint8_t pad0[3]; } xcb_xv_shm_put_image_request_t; /** @@ -846,7 +846,7 @@ typedef struct xcb_xv_shm_put_image_request_t { * element. The member index is increased by sizeof(xcb_xv_port_t) */ void -xcb_xv_port_next (xcb_xv_port_iterator_t *i /**< */); +xcb_xv_port_next (xcb_xv_port_iterator_t *i); /** * Return the iterator pointing to the last element @@ -858,7 +858,7 @@ xcb_xv_port_next (xcb_xv_port_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xv_port_end (xcb_xv_port_iterator_t i /**< */); +xcb_xv_port_end (xcb_xv_port_iterator_t i); /** * Get the next element of the iterator @@ -869,7 +869,7 @@ xcb_xv_port_end (xcb_xv_port_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xv_encoding_t) */ void -xcb_xv_encoding_next (xcb_xv_encoding_iterator_t *i /**< */); +xcb_xv_encoding_next (xcb_xv_encoding_iterator_t *i); /** * Return the iterator pointing to the last element @@ -881,7 +881,7 @@ xcb_xv_encoding_next (xcb_xv_encoding_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xv_encoding_end (xcb_xv_encoding_iterator_t i /**< */); +xcb_xv_encoding_end (xcb_xv_encoding_iterator_t i); /** * Get the next element of the iterator @@ -892,7 +892,7 @@ xcb_xv_encoding_end (xcb_xv_encoding_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xv_rational_t) */ void -xcb_xv_rational_next (xcb_xv_rational_iterator_t *i /**< */); +xcb_xv_rational_next (xcb_xv_rational_iterator_t *i); /** * Return the iterator pointing to the last element @@ -904,7 +904,7 @@ xcb_xv_rational_next (xcb_xv_rational_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xv_rational_end (xcb_xv_rational_iterator_t i /**< */); +xcb_xv_rational_end (xcb_xv_rational_iterator_t i); /** * Get the next element of the iterator @@ -915,7 +915,7 @@ xcb_xv_rational_end (xcb_xv_rational_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xv_format_t) */ void -xcb_xv_format_next (xcb_xv_format_iterator_t *i /**< */); +xcb_xv_format_next (xcb_xv_format_iterator_t *i); /** * Return the iterator pointing to the last element @@ -927,28 +927,28 @@ xcb_xv_format_next (xcb_xv_format_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xv_format_end (xcb_xv_format_iterator_t i /**< */); +xcb_xv_format_end (xcb_xv_format_iterator_t i); int -xcb_xv_adaptor_info_sizeof (const void *_buffer /**< */); +xcb_xv_adaptor_info_sizeof (const void *_buffer); char * -xcb_xv_adaptor_info_name (const xcb_xv_adaptor_info_t *R /**< */); +xcb_xv_adaptor_info_name (const xcb_xv_adaptor_info_t *R); int -xcb_xv_adaptor_info_name_length (const xcb_xv_adaptor_info_t *R /**< */); +xcb_xv_adaptor_info_name_length (const xcb_xv_adaptor_info_t *R); xcb_generic_iterator_t -xcb_xv_adaptor_info_name_end (const xcb_xv_adaptor_info_t *R /**< */); +xcb_xv_adaptor_info_name_end (const xcb_xv_adaptor_info_t *R); xcb_xv_format_t * -xcb_xv_adaptor_info_formats (const xcb_xv_adaptor_info_t *R /**< */); +xcb_xv_adaptor_info_formats (const xcb_xv_adaptor_info_t *R); int -xcb_xv_adaptor_info_formats_length (const xcb_xv_adaptor_info_t *R /**< */); +xcb_xv_adaptor_info_formats_length (const xcb_xv_adaptor_info_t *R); xcb_xv_format_iterator_t -xcb_xv_adaptor_info_formats_iterator (const xcb_xv_adaptor_info_t *R /**< */); +xcb_xv_adaptor_info_formats_iterator (const xcb_xv_adaptor_info_t *R); /** * Get the next element of the iterator @@ -959,7 +959,7 @@ xcb_xv_adaptor_info_formats_iterator (const xcb_xv_adaptor_info_t *R /**< */); * element. The member index is increased by sizeof(xcb_xv_adaptor_info_t) */ void -xcb_xv_adaptor_info_next (xcb_xv_adaptor_info_iterator_t *i /**< */); +xcb_xv_adaptor_info_next (xcb_xv_adaptor_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -971,19 +971,19 @@ xcb_xv_adaptor_info_next (xcb_xv_adaptor_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xv_adaptor_info_end (xcb_xv_adaptor_info_iterator_t i /**< */); +xcb_xv_adaptor_info_end (xcb_xv_adaptor_info_iterator_t i); int -xcb_xv_encoding_info_sizeof (const void *_buffer /**< */); +xcb_xv_encoding_info_sizeof (const void *_buffer); char * -xcb_xv_encoding_info_name (const xcb_xv_encoding_info_t *R /**< */); +xcb_xv_encoding_info_name (const xcb_xv_encoding_info_t *R); int -xcb_xv_encoding_info_name_length (const xcb_xv_encoding_info_t *R /**< */); +xcb_xv_encoding_info_name_length (const xcb_xv_encoding_info_t *R); xcb_generic_iterator_t -xcb_xv_encoding_info_name_end (const xcb_xv_encoding_info_t *R /**< */); +xcb_xv_encoding_info_name_end (const xcb_xv_encoding_info_t *R); /** * Get the next element of the iterator @@ -994,7 +994,7 @@ xcb_xv_encoding_info_name_end (const xcb_xv_encoding_info_t *R /**< */); * element. The member index is increased by sizeof(xcb_xv_encoding_info_t) */ void -xcb_xv_encoding_info_next (xcb_xv_encoding_info_iterator_t *i /**< */); +xcb_xv_encoding_info_next (xcb_xv_encoding_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1006,37 +1006,37 @@ xcb_xv_encoding_info_next (xcb_xv_encoding_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xv_encoding_info_end (xcb_xv_encoding_info_iterator_t i /**< */); +xcb_xv_encoding_info_end (xcb_xv_encoding_info_iterator_t i); int -xcb_xv_image_sizeof (const void *_buffer /**< */); +xcb_xv_image_sizeof (const void *_buffer); uint32_t * -xcb_xv_image_pitches (const xcb_xv_image_t *R /**< */); +xcb_xv_image_pitches (const xcb_xv_image_t *R); int -xcb_xv_image_pitches_length (const xcb_xv_image_t *R /**< */); +xcb_xv_image_pitches_length (const xcb_xv_image_t *R); xcb_generic_iterator_t -xcb_xv_image_pitches_end (const xcb_xv_image_t *R /**< */); +xcb_xv_image_pitches_end (const xcb_xv_image_t *R); uint32_t * -xcb_xv_image_offsets (const xcb_xv_image_t *R /**< */); +xcb_xv_image_offsets (const xcb_xv_image_t *R); int -xcb_xv_image_offsets_length (const xcb_xv_image_t *R /**< */); +xcb_xv_image_offsets_length (const xcb_xv_image_t *R); xcb_generic_iterator_t -xcb_xv_image_offsets_end (const xcb_xv_image_t *R /**< */); +xcb_xv_image_offsets_end (const xcb_xv_image_t *R); uint8_t * -xcb_xv_image_data (const xcb_xv_image_t *R /**< */); +xcb_xv_image_data (const xcb_xv_image_t *R); int -xcb_xv_image_data_length (const xcb_xv_image_t *R /**< */); +xcb_xv_image_data_length (const xcb_xv_image_t *R); xcb_generic_iterator_t -xcb_xv_image_data_end (const xcb_xv_image_t *R /**< */); +xcb_xv_image_data_end (const xcb_xv_image_t *R); /** * Get the next element of the iterator @@ -1047,7 +1047,7 @@ xcb_xv_image_data_end (const xcb_xv_image_t *R /**< */); * element. The member index is increased by sizeof(xcb_xv_image_t) */ void -xcb_xv_image_next (xcb_xv_image_iterator_t *i /**< */); +xcb_xv_image_next (xcb_xv_image_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1059,19 +1059,19 @@ xcb_xv_image_next (xcb_xv_image_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xv_image_end (xcb_xv_image_iterator_t i /**< */); +xcb_xv_image_end (xcb_xv_image_iterator_t i); int -xcb_xv_attribute_info_sizeof (const void *_buffer /**< */); +xcb_xv_attribute_info_sizeof (const void *_buffer); char * -xcb_xv_attribute_info_name (const xcb_xv_attribute_info_t *R /**< */); +xcb_xv_attribute_info_name (const xcb_xv_attribute_info_t *R); int -xcb_xv_attribute_info_name_length (const xcb_xv_attribute_info_t *R /**< */); +xcb_xv_attribute_info_name_length (const xcb_xv_attribute_info_t *R); xcb_generic_iterator_t -xcb_xv_attribute_info_name_end (const xcb_xv_attribute_info_t *R /**< */); +xcb_xv_attribute_info_name_end (const xcb_xv_attribute_info_t *R); /** * Get the next element of the iterator @@ -1082,7 +1082,7 @@ xcb_xv_attribute_info_name_end (const xcb_xv_attribute_info_t *R /**< */); * element. The member index is increased by sizeof(xcb_xv_attribute_info_t) */ void -xcb_xv_attribute_info_next (xcb_xv_attribute_info_iterator_t *i /**< */); +xcb_xv_attribute_info_next (xcb_xv_attribute_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1094,7 +1094,7 @@ xcb_xv_attribute_info_next (xcb_xv_attribute_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xv_attribute_info_end (xcb_xv_attribute_info_iterator_t i /**< */); +xcb_xv_attribute_info_end (xcb_xv_attribute_info_iterator_t i); /** * Get the next element of the iterator @@ -1105,7 +1105,7 @@ xcb_xv_attribute_info_end (xcb_xv_attribute_info_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xv_image_format_info_t) */ void -xcb_xv_image_format_info_next (xcb_xv_image_format_info_iterator_t *i /**< */); +xcb_xv_image_format_info_next (xcb_xv_image_format_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -1117,7 +1117,7 @@ xcb_xv_image_format_info_next (xcb_xv_image_format_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xv_image_format_info_end (xcb_xv_image_format_info_iterator_t i /**< */); +xcb_xv_image_format_info_end (xcb_xv_image_format_info_iterator_t i); /** * @@ -1128,7 +1128,7 @@ xcb_xv_image_format_info_end (xcb_xv_image_format_info_iterator_t i /**< */); * */ xcb_xv_query_extension_cookie_t -xcb_xv_query_extension (xcb_connection_t *c /**< */); +xcb_xv_query_extension (xcb_connection_t *c); /** * @@ -1142,7 +1142,7 @@ xcb_xv_query_extension (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_xv_query_extension_cookie_t -xcb_xv_query_extension_unchecked (xcb_connection_t *c /**< */); +xcb_xv_query_extension_unchecked (xcb_connection_t *c); /** * Return the reply @@ -1159,12 +1159,12 @@ xcb_xv_query_extension_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_xv_query_extension_reply_t * -xcb_xv_query_extension_reply (xcb_connection_t *c /**< */, +xcb_xv_query_extension_reply (xcb_connection_t *c, xcb_xv_query_extension_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xv_query_adaptors_sizeof (const void *_buffer /**< */); +xcb_xv_query_adaptors_sizeof (const void *_buffer); /** * @@ -1175,8 +1175,8 @@ xcb_xv_query_adaptors_sizeof (const void *_buffer /**< */); * */ xcb_xv_query_adaptors_cookie_t -xcb_xv_query_adaptors (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_xv_query_adaptors (xcb_connection_t *c, + xcb_window_t window); /** * @@ -1190,14 +1190,14 @@ xcb_xv_query_adaptors (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xv_query_adaptors_cookie_t -xcb_xv_query_adaptors_unchecked (xcb_connection_t *c /**< */, - xcb_window_t window /**< */); +xcb_xv_query_adaptors_unchecked (xcb_connection_t *c, + xcb_window_t window); int -xcb_xv_query_adaptors_info_length (const xcb_xv_query_adaptors_reply_t *R /**< */); +xcb_xv_query_adaptors_info_length (const xcb_xv_query_adaptors_reply_t *R); xcb_xv_adaptor_info_iterator_t -xcb_xv_query_adaptors_info_iterator (const xcb_xv_query_adaptors_reply_t *R /**< */); +xcb_xv_query_adaptors_info_iterator (const xcb_xv_query_adaptors_reply_t *R); /** * Return the reply @@ -1214,12 +1214,12 @@ xcb_xv_query_adaptors_info_iterator (const xcb_xv_query_adaptors_reply_t *R /** * The returned value must be freed by the caller using free(). */ xcb_xv_query_adaptors_reply_t * -xcb_xv_query_adaptors_reply (xcb_connection_t *c /**< */, +xcb_xv_query_adaptors_reply (xcb_connection_t *c, xcb_xv_query_adaptors_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xv_query_encodings_sizeof (const void *_buffer /**< */); +xcb_xv_query_encodings_sizeof (const void *_buffer); /** * @@ -1230,8 +1230,8 @@ xcb_xv_query_encodings_sizeof (const void *_buffer /**< */); * */ xcb_xv_query_encodings_cookie_t -xcb_xv_query_encodings (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */); +xcb_xv_query_encodings (xcb_connection_t *c, + xcb_xv_port_t port); /** * @@ -1245,14 +1245,14 @@ xcb_xv_query_encodings (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xv_query_encodings_cookie_t -xcb_xv_query_encodings_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */); +xcb_xv_query_encodings_unchecked (xcb_connection_t *c, + xcb_xv_port_t port); int -xcb_xv_query_encodings_info_length (const xcb_xv_query_encodings_reply_t *R /**< */); +xcb_xv_query_encodings_info_length (const xcb_xv_query_encodings_reply_t *R); xcb_xv_encoding_info_iterator_t -xcb_xv_query_encodings_info_iterator (const xcb_xv_query_encodings_reply_t *R /**< */); +xcb_xv_query_encodings_info_iterator (const xcb_xv_query_encodings_reply_t *R); /** * Return the reply @@ -1269,9 +1269,9 @@ xcb_xv_query_encodings_info_iterator (const xcb_xv_query_encodings_reply_t *R / * The returned value must be freed by the caller using free(). */ xcb_xv_query_encodings_reply_t * -xcb_xv_query_encodings_reply (xcb_connection_t *c /**< */, +xcb_xv_query_encodings_reply (xcb_connection_t *c, xcb_xv_query_encodings_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1282,9 +1282,9 @@ xcb_xv_query_encodings_reply (xcb_connection_t *c /**< */, * */ xcb_xv_grab_port_cookie_t -xcb_xv_grab_port (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_timestamp_t time /**< */); +xcb_xv_grab_port (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_timestamp_t time); /** * @@ -1298,9 +1298,9 @@ xcb_xv_grab_port (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xv_grab_port_cookie_t -xcb_xv_grab_port_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_timestamp_t time /**< */); +xcb_xv_grab_port_unchecked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_timestamp_t time); /** * Return the reply @@ -1317,9 +1317,9 @@ xcb_xv_grab_port_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xv_grab_port_reply_t * -xcb_xv_grab_port_reply (xcb_connection_t *c /**< */, +xcb_xv_grab_port_reply (xcb_connection_t *c, xcb_xv_grab_port_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1333,9 +1333,9 @@ xcb_xv_grab_port_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_ungrab_port_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_timestamp_t time /**< */); +xcb_xv_ungrab_port_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_timestamp_t time); /** * @@ -1346,9 +1346,9 @@ xcb_xv_ungrab_port_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_ungrab_port (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_timestamp_t time /**< */); +xcb_xv_ungrab_port (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_timestamp_t time); /** * @@ -1362,18 +1362,18 @@ xcb_xv_ungrab_port (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_put_video_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */); +xcb_xv_put_video_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h); /** * @@ -1384,18 +1384,18 @@ xcb_xv_put_video_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_put_video (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */); +xcb_xv_put_video (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h); /** * @@ -1409,18 +1409,18 @@ xcb_xv_put_video (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_put_still_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */); +xcb_xv_put_still_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h); /** * @@ -1431,18 +1431,18 @@ xcb_xv_put_still_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_put_still (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */); +xcb_xv_put_still (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h); /** * @@ -1456,18 +1456,18 @@ xcb_xv_put_still (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_get_video_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */); +xcb_xv_get_video_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h); /** * @@ -1478,18 +1478,18 @@ xcb_xv_get_video_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_get_video (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */); +xcb_xv_get_video (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h); /** * @@ -1503,18 +1503,18 @@ xcb_xv_get_video (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_get_still_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */); +xcb_xv_get_still_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h); /** * @@ -1525,18 +1525,18 @@ xcb_xv_get_still_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_get_still (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - int16_t vid_x /**< */, - int16_t vid_y /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */); +xcb_xv_get_still (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + int16_t vid_x, + int16_t vid_y, + uint16_t vid_w, + uint16_t vid_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h); /** * @@ -1550,9 +1550,9 @@ xcb_xv_get_still (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_stop_video_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */); +xcb_xv_stop_video_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable); /** * @@ -1563,9 +1563,9 @@ xcb_xv_stop_video_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_stop_video (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */); +xcb_xv_stop_video (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable); /** * @@ -1579,9 +1579,9 @@ xcb_xv_stop_video (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_select_video_notify_checked (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint8_t onoff /**< */); +xcb_xv_select_video_notify_checked (xcb_connection_t *c, + xcb_drawable_t drawable, + uint8_t onoff); /** * @@ -1592,9 +1592,9 @@ xcb_xv_select_video_notify_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_select_video_notify (xcb_connection_t *c /**< */, - xcb_drawable_t drawable /**< */, - uint8_t onoff /**< */); +xcb_xv_select_video_notify (xcb_connection_t *c, + xcb_drawable_t drawable, + uint8_t onoff); /** * @@ -1608,9 +1608,9 @@ xcb_xv_select_video_notify (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_select_port_notify_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint8_t onoff /**< */); +xcb_xv_select_port_notify_checked (xcb_connection_t *c, + xcb_xv_port_t port, + uint8_t onoff); /** * @@ -1621,9 +1621,9 @@ xcb_xv_select_port_notify_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_select_port_notify (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint8_t onoff /**< */); +xcb_xv_select_port_notify (xcb_connection_t *c, + xcb_xv_port_t port, + uint8_t onoff); /** * @@ -1634,13 +1634,13 @@ xcb_xv_select_port_notify (xcb_connection_t *c /**< */, * */ xcb_xv_query_best_size_cookie_t -xcb_xv_query_best_size (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint8_t motion /**< */); +xcb_xv_query_best_size (xcb_connection_t *c, + xcb_xv_port_t port, + uint16_t vid_w, + uint16_t vid_h, + uint16_t drw_w, + uint16_t drw_h, + uint8_t motion); /** * @@ -1654,13 +1654,13 @@ xcb_xv_query_best_size (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xv_query_best_size_cookie_t -xcb_xv_query_best_size_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint16_t vid_w /**< */, - uint16_t vid_h /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint8_t motion /**< */); +xcb_xv_query_best_size_unchecked (xcb_connection_t *c, + xcb_xv_port_t port, + uint16_t vid_w, + uint16_t vid_h, + uint16_t drw_w, + uint16_t drw_h, + uint8_t motion); /** * Return the reply @@ -1677,9 +1677,9 @@ xcb_xv_query_best_size_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xv_query_best_size_reply_t * -xcb_xv_query_best_size_reply (xcb_connection_t *c /**< */, +xcb_xv_query_best_size_reply (xcb_connection_t *c, xcb_xv_query_best_size_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -1693,10 +1693,10 @@ xcb_xv_query_best_size_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_set_port_attribute_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_atom_t attribute /**< */, - int32_t value /**< */); +xcb_xv_set_port_attribute_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_atom_t attribute, + int32_t value); /** * @@ -1707,10 +1707,10 @@ xcb_xv_set_port_attribute_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_set_port_attribute (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_atom_t attribute /**< */, - int32_t value /**< */); +xcb_xv_set_port_attribute (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_atom_t attribute, + int32_t value); /** * @@ -1721,9 +1721,9 @@ xcb_xv_set_port_attribute (xcb_connection_t *c /**< */, * */ xcb_xv_get_port_attribute_cookie_t -xcb_xv_get_port_attribute (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_atom_t attribute /**< */); +xcb_xv_get_port_attribute (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_atom_t attribute); /** * @@ -1737,9 +1737,9 @@ xcb_xv_get_port_attribute (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xv_get_port_attribute_cookie_t -xcb_xv_get_port_attribute_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_atom_t attribute /**< */); +xcb_xv_get_port_attribute_unchecked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_atom_t attribute); /** * Return the reply @@ -1756,12 +1756,12 @@ xcb_xv_get_port_attribute_unchecked (xcb_connection_t *c /**< */, * The returned value must be freed by the caller using free(). */ xcb_xv_get_port_attribute_reply_t * -xcb_xv_get_port_attribute_reply (xcb_connection_t *c /**< */, +xcb_xv_get_port_attribute_reply (xcb_connection_t *c, xcb_xv_get_port_attribute_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xv_query_port_attributes_sizeof (const void *_buffer /**< */); +xcb_xv_query_port_attributes_sizeof (const void *_buffer); /** * @@ -1772,8 +1772,8 @@ xcb_xv_query_port_attributes_sizeof (const void *_buffer /**< */); * */ xcb_xv_query_port_attributes_cookie_t -xcb_xv_query_port_attributes (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */); +xcb_xv_query_port_attributes (xcb_connection_t *c, + xcb_xv_port_t port); /** * @@ -1787,14 +1787,14 @@ xcb_xv_query_port_attributes (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xv_query_port_attributes_cookie_t -xcb_xv_query_port_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */); +xcb_xv_query_port_attributes_unchecked (xcb_connection_t *c, + xcb_xv_port_t port); int -xcb_xv_query_port_attributes_attributes_length (const xcb_xv_query_port_attributes_reply_t *R /**< */); +xcb_xv_query_port_attributes_attributes_length (const xcb_xv_query_port_attributes_reply_t *R); xcb_xv_attribute_info_iterator_t -xcb_xv_query_port_attributes_attributes_iterator (const xcb_xv_query_port_attributes_reply_t *R /**< */); +xcb_xv_query_port_attributes_attributes_iterator (const xcb_xv_query_port_attributes_reply_t *R); /** * Return the reply @@ -1811,12 +1811,12 @@ xcb_xv_query_port_attributes_attributes_iterator (const xcb_xv_query_port_attrib * The returned value must be freed by the caller using free(). */ xcb_xv_query_port_attributes_reply_t * -xcb_xv_query_port_attributes_reply (xcb_connection_t *c /**< */, +xcb_xv_query_port_attributes_reply (xcb_connection_t *c, xcb_xv_query_port_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xv_list_image_formats_sizeof (const void *_buffer /**< */); +xcb_xv_list_image_formats_sizeof (const void *_buffer); /** * @@ -1827,8 +1827,8 @@ xcb_xv_list_image_formats_sizeof (const void *_buffer /**< */); * */ xcb_xv_list_image_formats_cookie_t -xcb_xv_list_image_formats (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */); +xcb_xv_list_image_formats (xcb_connection_t *c, + xcb_xv_port_t port); /** * @@ -1842,17 +1842,17 @@ xcb_xv_list_image_formats (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xv_list_image_formats_cookie_t -xcb_xv_list_image_formats_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */); +xcb_xv_list_image_formats_unchecked (xcb_connection_t *c, + xcb_xv_port_t port); xcb_xv_image_format_info_t * -xcb_xv_list_image_formats_format (const xcb_xv_list_image_formats_reply_t *R /**< */); +xcb_xv_list_image_formats_format (const xcb_xv_list_image_formats_reply_t *R); int -xcb_xv_list_image_formats_format_length (const xcb_xv_list_image_formats_reply_t *R /**< */); +xcb_xv_list_image_formats_format_length (const xcb_xv_list_image_formats_reply_t *R); xcb_xv_image_format_info_iterator_t -xcb_xv_list_image_formats_format_iterator (const xcb_xv_list_image_formats_reply_t *R /**< */); +xcb_xv_list_image_formats_format_iterator (const xcb_xv_list_image_formats_reply_t *R); /** * Return the reply @@ -1869,12 +1869,12 @@ xcb_xv_list_image_formats_format_iterator (const xcb_xv_list_image_formats_reply * The returned value must be freed by the caller using free(). */ xcb_xv_list_image_formats_reply_t * -xcb_xv_list_image_formats_reply (xcb_connection_t *c /**< */, +xcb_xv_list_image_formats_reply (xcb_connection_t *c, xcb_xv_list_image_formats_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xv_query_image_attributes_sizeof (const void *_buffer /**< */); +xcb_xv_query_image_attributes_sizeof (const void *_buffer); /** * @@ -1885,11 +1885,11 @@ xcb_xv_query_image_attributes_sizeof (const void *_buffer /**< */); * */ xcb_xv_query_image_attributes_cookie_t -xcb_xv_query_image_attributes (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint32_t id /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_xv_query_image_attributes (xcb_connection_t *c, + xcb_xv_port_t port, + uint32_t id, + uint16_t width, + uint16_t height); /** * @@ -1903,29 +1903,29 @@ xcb_xv_query_image_attributes (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xv_query_image_attributes_cookie_t -xcb_xv_query_image_attributes_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - uint32_t id /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_xv_query_image_attributes_unchecked (xcb_connection_t *c, + xcb_xv_port_t port, + uint32_t id, + uint16_t width, + uint16_t height); uint32_t * -xcb_xv_query_image_attributes_pitches (const xcb_xv_query_image_attributes_reply_t *R /**< */); +xcb_xv_query_image_attributes_pitches (const xcb_xv_query_image_attributes_reply_t *R); int -xcb_xv_query_image_attributes_pitches_length (const xcb_xv_query_image_attributes_reply_t *R /**< */); +xcb_xv_query_image_attributes_pitches_length (const xcb_xv_query_image_attributes_reply_t *R); xcb_generic_iterator_t -xcb_xv_query_image_attributes_pitches_end (const xcb_xv_query_image_attributes_reply_t *R /**< */); +xcb_xv_query_image_attributes_pitches_end (const xcb_xv_query_image_attributes_reply_t *R); uint32_t * -xcb_xv_query_image_attributes_offsets (const xcb_xv_query_image_attributes_reply_t *R /**< */); +xcb_xv_query_image_attributes_offsets (const xcb_xv_query_image_attributes_reply_t *R); int -xcb_xv_query_image_attributes_offsets_length (const xcb_xv_query_image_attributes_reply_t *R /**< */); +xcb_xv_query_image_attributes_offsets_length (const xcb_xv_query_image_attributes_reply_t *R); xcb_generic_iterator_t -xcb_xv_query_image_attributes_offsets_end (const xcb_xv_query_image_attributes_reply_t *R /**< */); +xcb_xv_query_image_attributes_offsets_end (const xcb_xv_query_image_attributes_reply_t *R); /** * Return the reply @@ -1942,13 +1942,13 @@ xcb_xv_query_image_attributes_offsets_end (const xcb_xv_query_image_attributes_r * The returned value must be freed by the caller using free(). */ xcb_xv_query_image_attributes_reply_t * -xcb_xv_query_image_attributes_reply (xcb_connection_t *c /**< */, +xcb_xv_query_image_attributes_reply (xcb_connection_t *c, xcb_xv_query_image_attributes_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xv_put_image_sizeof (const void *_buffer /**< */, - uint32_t data_len /**< */); +xcb_xv_put_image_sizeof (const void *_buffer, + uint32_t data_len); /** * @@ -1962,23 +1962,23 @@ xcb_xv_put_image_sizeof (const void *_buffer /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_put_image_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t id /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_w /**< */, - uint16_t src_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_xv_put_image_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t id, + int16_t src_x, + int16_t src_y, + uint16_t src_w, + uint16_t src_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h, + uint16_t width, + uint16_t height, + uint32_t data_len, + const uint8_t *data); /** * @@ -1989,23 +1989,32 @@ xcb_xv_put_image_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_put_image (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - uint32_t id /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_w /**< */, - uint16_t src_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t data_len /**< */, - const uint8_t *data /**< */); +xcb_xv_put_image (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + uint32_t id, + int16_t src_x, + int16_t src_y, + uint16_t src_w, + uint16_t src_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h, + uint16_t width, + uint16_t height, + uint32_t data_len, + const uint8_t *data); + +uint8_t * +xcb_xv_put_image_data (const xcb_xv_put_image_request_t *R); + +int +xcb_xv_put_image_data_length (const xcb_xv_put_image_request_t *R); + +xcb_generic_iterator_t +xcb_xv_put_image_data_end (const xcb_xv_put_image_request_t *R); /** * @@ -2019,24 +2028,24 @@ xcb_xv_put_image (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xv_shm_put_image_checked (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t id /**< */, - uint32_t offset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_w /**< */, - uint16_t src_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint8_t send_event /**< */); +xcb_xv_shm_put_image_checked (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + xcb_shm_seg_t shmseg, + uint32_t id, + uint32_t offset, + int16_t src_x, + int16_t src_y, + uint16_t src_w, + uint16_t src_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h, + uint16_t width, + uint16_t height, + uint8_t send_event); /** * @@ -2047,24 +2056,24 @@ xcb_xv_shm_put_image_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xv_shm_put_image (xcb_connection_t *c /**< */, - xcb_xv_port_t port /**< */, - xcb_drawable_t drawable /**< */, - xcb_gcontext_t gc /**< */, - xcb_shm_seg_t shmseg /**< */, - uint32_t id /**< */, - uint32_t offset /**< */, - int16_t src_x /**< */, - int16_t src_y /**< */, - uint16_t src_w /**< */, - uint16_t src_h /**< */, - int16_t drw_x /**< */, - int16_t drw_y /**< */, - uint16_t drw_w /**< */, - uint16_t drw_h /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint8_t send_event /**< */); +xcb_xv_shm_put_image (xcb_connection_t *c, + xcb_xv_port_t port, + xcb_drawable_t drawable, + xcb_gcontext_t gc, + xcb_shm_seg_t shmseg, + uint32_t id, + uint32_t offset, + int16_t src_x, + int16_t src_y, + uint16_t src_w, + uint16_t src_h, + int16_t drw_x, + int16_t drw_y, + uint16_t drw_w, + uint16_t drw_h, + uint16_t width, + uint16_t height, + uint8_t send_event); #ifdef __cplusplus diff --git a/lib/libxcb/src/xvmc.c b/lib/libxcb/src/xvmc.c index e309689c4..d0f6923d3 100644 --- a/lib/libxcb/src/xvmc.c +++ b/lib/libxcb/src/xvmc.c @@ -19,7 +19,7 @@ xcb_extension_t xcb_xvmc_id = { "XVideo-MotionCompensation", 0 }; void -xcb_xvmc_context_next (xcb_xvmc_context_iterator_t *i /**< */) +xcb_xvmc_context_next (xcb_xvmc_context_iterator_t *i) { --i->rem; ++i->data; @@ -27,7 +27,7 @@ xcb_xvmc_context_next (xcb_xvmc_context_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xvmc_context_end (xcb_xvmc_context_iterator_t i /**< */) +xcb_xvmc_context_end (xcb_xvmc_context_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -37,7 +37,7 @@ xcb_xvmc_context_end (xcb_xvmc_context_iterator_t i /**< */) } void -xcb_xvmc_surface_next (xcb_xvmc_surface_iterator_t *i /**< */) +xcb_xvmc_surface_next (xcb_xvmc_surface_iterator_t *i) { --i->rem; ++i->data; @@ -45,7 +45,7 @@ xcb_xvmc_surface_next (xcb_xvmc_surface_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xvmc_surface_end (xcb_xvmc_surface_iterator_t i /**< */) +xcb_xvmc_surface_end (xcb_xvmc_surface_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -55,7 +55,7 @@ xcb_xvmc_surface_end (xcb_xvmc_surface_iterator_t i /**< */) } void -xcb_xvmc_subpicture_next (xcb_xvmc_subpicture_iterator_t *i /**< */) +xcb_xvmc_subpicture_next (xcb_xvmc_subpicture_iterator_t *i) { --i->rem; ++i->data; @@ -63,7 +63,7 @@ xcb_xvmc_subpicture_next (xcb_xvmc_subpicture_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xvmc_subpicture_end (xcb_xvmc_subpicture_iterator_t i /**< */) +xcb_xvmc_subpicture_end (xcb_xvmc_subpicture_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -73,7 +73,7 @@ xcb_xvmc_subpicture_end (xcb_xvmc_subpicture_iterator_t i /**< */) } void -xcb_xvmc_surface_info_next (xcb_xvmc_surface_info_iterator_t *i /**< */) +xcb_xvmc_surface_info_next (xcb_xvmc_surface_info_iterator_t *i) { --i->rem; ++i->data; @@ -81,7 +81,7 @@ xcb_xvmc_surface_info_next (xcb_xvmc_surface_info_iterator_t *i /**< */) } xcb_generic_iterator_t -xcb_xvmc_surface_info_end (xcb_xvmc_surface_info_iterator_t i /**< */) +xcb_xvmc_surface_info_end (xcb_xvmc_surface_info_iterator_t i) { xcb_generic_iterator_t ret; ret.data = i.data + i.rem; @@ -91,13 +91,13 @@ xcb_xvmc_surface_info_end (xcb_xvmc_surface_info_iterator_t i /**< */) } xcb_xvmc_query_version_cookie_t -xcb_xvmc_query_version (xcb_connection_t *c /**< */) +xcb_xvmc_query_version (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -115,13 +115,13 @@ xcb_xvmc_query_version (xcb_connection_t *c /**< */) } xcb_xvmc_query_version_cookie_t -xcb_xvmc_query_version_unchecked (xcb_connection_t *c /**< */) +xcb_xvmc_query_version_unchecked (xcb_connection_t *c) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_QUERY_VERSION, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_QUERY_VERSION, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -139,15 +139,15 @@ xcb_xvmc_query_version_unchecked (xcb_connection_t *c /**< */) } xcb_xvmc_query_version_reply_t * -xcb_xvmc_query_version_reply (xcb_connection_t *c /**< */, +xcb_xvmc_query_version_reply (xcb_connection_t *c, xcb_xvmc_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xvmc_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xvmc_list_surface_types_sizeof (const void *_buffer /**< */) +xcb_xvmc_list_surface_types_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xvmc_list_surface_types_reply_t *_aux = (xcb_xvmc_list_surface_types_reply_t *)_buffer; @@ -178,14 +178,14 @@ xcb_xvmc_list_surface_types_sizeof (const void *_buffer /**< */) } xcb_xvmc_list_surface_types_cookie_t -xcb_xvmc_list_surface_types (xcb_connection_t *c /**< */, - xcb_xv_port_t port_id /**< */) +xcb_xvmc_list_surface_types (xcb_connection_t *c, + xcb_xv_port_t port_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_LIST_SURFACE_TYPES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_LIST_SURFACE_TYPES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -204,14 +204,14 @@ xcb_xvmc_list_surface_types (xcb_connection_t *c /**< */, } xcb_xvmc_list_surface_types_cookie_t -xcb_xvmc_list_surface_types_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port_id /**< */) +xcb_xvmc_list_surface_types_unchecked (xcb_connection_t *c, + xcb_xv_port_t port_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_LIST_SURFACE_TYPES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_LIST_SURFACE_TYPES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -230,19 +230,19 @@ xcb_xvmc_list_surface_types_unchecked (xcb_connection_t *c /**< */, } xcb_xvmc_surface_info_t * -xcb_xvmc_list_surface_types_surfaces (const xcb_xvmc_list_surface_types_reply_t *R /**< */) +xcb_xvmc_list_surface_types_surfaces (const xcb_xvmc_list_surface_types_reply_t *R) { return (xcb_xvmc_surface_info_t *) (R + 1); } int -xcb_xvmc_list_surface_types_surfaces_length (const xcb_xvmc_list_surface_types_reply_t *R /**< */) +xcb_xvmc_list_surface_types_surfaces_length (const xcb_xvmc_list_surface_types_reply_t *R) { return R->num; } xcb_xvmc_surface_info_iterator_t -xcb_xvmc_list_surface_types_surfaces_iterator (const xcb_xvmc_list_surface_types_reply_t *R /**< */) +xcb_xvmc_list_surface_types_surfaces_iterator (const xcb_xvmc_list_surface_types_reply_t *R) { xcb_xvmc_surface_info_iterator_t i; i.data = (xcb_xvmc_surface_info_t *) (R + 1); @@ -252,15 +252,15 @@ xcb_xvmc_list_surface_types_surfaces_iterator (const xcb_xvmc_list_surface_types } xcb_xvmc_list_surface_types_reply_t * -xcb_xvmc_list_surface_types_reply (xcb_connection_t *c /**< */, +xcb_xvmc_list_surface_types_reply (xcb_connection_t *c, xcb_xvmc_list_surface_types_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xvmc_list_surface_types_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } int -xcb_xvmc_create_context_sizeof (const void *_buffer /**< */) +xcb_xvmc_create_context_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xvmc_create_context_reply_t *_aux = (xcb_xvmc_create_context_reply_t *)_buffer; @@ -291,19 +291,19 @@ xcb_xvmc_create_context_sizeof (const void *_buffer /**< */) } xcb_xvmc_create_context_cookie_t -xcb_xvmc_create_context (xcb_connection_t *c /**< */, - xcb_xvmc_context_t context_id /**< */, - xcb_xv_port_t port_id /**< */, - xcb_xvmc_surface_t surface_id /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t flags /**< */) +xcb_xvmc_create_context (xcb_connection_t *c, + xcb_xvmc_context_t context_id, + xcb_xv_port_t port_id, + xcb_xvmc_surface_t surface_id, + uint16_t width, + uint16_t height, + uint32_t flags) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -327,19 +327,19 @@ xcb_xvmc_create_context (xcb_connection_t *c /**< */, } xcb_xvmc_create_context_cookie_t -xcb_xvmc_create_context_unchecked (xcb_connection_t *c /**< */, - xcb_xvmc_context_t context_id /**< */, - xcb_xv_port_t port_id /**< */, - xcb_xvmc_surface_t surface_id /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t flags /**< */) +xcb_xvmc_create_context_unchecked (xcb_connection_t *c, + xcb_xvmc_context_t context_id, + xcb_xv_port_t port_id, + xcb_xvmc_surface_t surface_id, + uint16_t width, + uint16_t height, + uint32_t flags) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_CREATE_CONTEXT, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_CREATE_CONTEXT, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -363,19 +363,19 @@ xcb_xvmc_create_context_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_xvmc_create_context_priv_data (const xcb_xvmc_create_context_reply_t *R /**< */) +xcb_xvmc_create_context_priv_data (const xcb_xvmc_create_context_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_xvmc_create_context_priv_data_length (const xcb_xvmc_create_context_reply_t *R /**< */) +xcb_xvmc_create_context_priv_data_length (const xcb_xvmc_create_context_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_xvmc_create_context_priv_data_end (const xcb_xvmc_create_context_reply_t *R /**< */) +xcb_xvmc_create_context_priv_data_end (const xcb_xvmc_create_context_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->length); @@ -385,22 +385,22 @@ xcb_xvmc_create_context_priv_data_end (const xcb_xvmc_create_context_reply_t *R } xcb_xvmc_create_context_reply_t * -xcb_xvmc_create_context_reply (xcb_connection_t *c /**< */, +xcb_xvmc_create_context_reply (xcb_connection_t *c, xcb_xvmc_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xvmc_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xvmc_destroy_context_checked (xcb_connection_t *c /**< */, - xcb_xvmc_context_t context_id /**< */) +xcb_xvmc_destroy_context_checked (xcb_connection_t *c, + xcb_xvmc_context_t context_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_DESTROY_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_DESTROY_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -419,14 +419,14 @@ xcb_xvmc_destroy_context_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xvmc_destroy_context (xcb_connection_t *c /**< */, - xcb_xvmc_context_t context_id /**< */) +xcb_xvmc_destroy_context (xcb_connection_t *c, + xcb_xvmc_context_t context_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_DESTROY_CONTEXT, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_DESTROY_CONTEXT, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -445,7 +445,7 @@ xcb_xvmc_destroy_context (xcb_connection_t *c /**< */, } int -xcb_xvmc_create_surface_sizeof (const void *_buffer /**< */) +xcb_xvmc_create_surface_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xvmc_create_surface_reply_t *_aux = (xcb_xvmc_create_surface_reply_t *)_buffer; @@ -476,15 +476,15 @@ xcb_xvmc_create_surface_sizeof (const void *_buffer /**< */) } xcb_xvmc_create_surface_cookie_t -xcb_xvmc_create_surface (xcb_connection_t *c /**< */, - xcb_xvmc_surface_t surface_id /**< */, - xcb_xvmc_context_t context_id /**< */) +xcb_xvmc_create_surface (xcb_connection_t *c, + xcb_xvmc_surface_t surface_id, + xcb_xvmc_context_t context_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_CREATE_SURFACE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_CREATE_SURFACE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -504,15 +504,15 @@ xcb_xvmc_create_surface (xcb_connection_t *c /**< */, } xcb_xvmc_create_surface_cookie_t -xcb_xvmc_create_surface_unchecked (xcb_connection_t *c /**< */, - xcb_xvmc_surface_t surface_id /**< */, - xcb_xvmc_context_t context_id /**< */) +xcb_xvmc_create_surface_unchecked (xcb_connection_t *c, + xcb_xvmc_surface_t surface_id, + xcb_xvmc_context_t context_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_CREATE_SURFACE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_CREATE_SURFACE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -532,19 +532,19 @@ xcb_xvmc_create_surface_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_xvmc_create_surface_priv_data (const xcb_xvmc_create_surface_reply_t *R /**< */) +xcb_xvmc_create_surface_priv_data (const xcb_xvmc_create_surface_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_xvmc_create_surface_priv_data_length (const xcb_xvmc_create_surface_reply_t *R /**< */) +xcb_xvmc_create_surface_priv_data_length (const xcb_xvmc_create_surface_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_xvmc_create_surface_priv_data_end (const xcb_xvmc_create_surface_reply_t *R /**< */) +xcb_xvmc_create_surface_priv_data_end (const xcb_xvmc_create_surface_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->length); @@ -554,22 +554,22 @@ xcb_xvmc_create_surface_priv_data_end (const xcb_xvmc_create_surface_reply_t *R } xcb_xvmc_create_surface_reply_t * -xcb_xvmc_create_surface_reply (xcb_connection_t *c /**< */, +xcb_xvmc_create_surface_reply (xcb_connection_t *c, xcb_xvmc_create_surface_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xvmc_create_surface_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xvmc_destroy_surface_checked (xcb_connection_t *c /**< */, - xcb_xvmc_surface_t surface_id /**< */) +xcb_xvmc_destroy_surface_checked (xcb_connection_t *c, + xcb_xvmc_surface_t surface_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_DESTROY_SURFACE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_DESTROY_SURFACE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -588,14 +588,14 @@ xcb_xvmc_destroy_surface_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xvmc_destroy_surface (xcb_connection_t *c /**< */, - xcb_xvmc_surface_t surface_id /**< */) +xcb_xvmc_destroy_surface (xcb_connection_t *c, + xcb_xvmc_surface_t surface_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_DESTROY_SURFACE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_DESTROY_SURFACE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -614,7 +614,7 @@ xcb_xvmc_destroy_surface (xcb_connection_t *c /**< */, } int -xcb_xvmc_create_subpicture_sizeof (const void *_buffer /**< */) +xcb_xvmc_create_subpicture_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xvmc_create_subpicture_reply_t *_aux = (xcb_xvmc_create_subpicture_reply_t *)_buffer; @@ -645,18 +645,18 @@ xcb_xvmc_create_subpicture_sizeof (const void *_buffer /**< */) } xcb_xvmc_create_subpicture_cookie_t -xcb_xvmc_create_subpicture (xcb_connection_t *c /**< */, - xcb_xvmc_subpicture_t subpicture_id /**< */, - xcb_xvmc_context_t context /**< */, - uint32_t xvimage_id /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_xvmc_create_subpicture (xcb_connection_t *c, + xcb_xvmc_subpicture_t subpicture_id, + xcb_xvmc_context_t context, + uint32_t xvimage_id, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_CREATE_SUBPICTURE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_CREATE_SUBPICTURE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -679,18 +679,18 @@ xcb_xvmc_create_subpicture (xcb_connection_t *c /**< */, } xcb_xvmc_create_subpicture_cookie_t -xcb_xvmc_create_subpicture_unchecked (xcb_connection_t *c /**< */, - xcb_xvmc_subpicture_t subpicture_id /**< */, - xcb_xvmc_context_t context /**< */, - uint32_t xvimage_id /**< */, - uint16_t width /**< */, - uint16_t height /**< */) +xcb_xvmc_create_subpicture_unchecked (xcb_connection_t *c, + xcb_xvmc_subpicture_t subpicture_id, + xcb_xvmc_context_t context, + uint32_t xvimage_id, + uint16_t width, + uint16_t height) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_CREATE_SUBPICTURE, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_CREATE_SUBPICTURE, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -713,19 +713,19 @@ xcb_xvmc_create_subpicture_unchecked (xcb_connection_t *c /**< */, } uint32_t * -xcb_xvmc_create_subpicture_priv_data (const xcb_xvmc_create_subpicture_reply_t *R /**< */) +xcb_xvmc_create_subpicture_priv_data (const xcb_xvmc_create_subpicture_reply_t *R) { return (uint32_t *) (R + 1); } int -xcb_xvmc_create_subpicture_priv_data_length (const xcb_xvmc_create_subpicture_reply_t *R /**< */) +xcb_xvmc_create_subpicture_priv_data_length (const xcb_xvmc_create_subpicture_reply_t *R) { return R->length; } xcb_generic_iterator_t -xcb_xvmc_create_subpicture_priv_data_end (const xcb_xvmc_create_subpicture_reply_t *R /**< */) +xcb_xvmc_create_subpicture_priv_data_end (const xcb_xvmc_create_subpicture_reply_t *R) { xcb_generic_iterator_t i; i.data = ((uint32_t *) (R + 1)) + (R->length); @@ -735,22 +735,22 @@ xcb_xvmc_create_subpicture_priv_data_end (const xcb_xvmc_create_subpicture_reply } xcb_xvmc_create_subpicture_reply_t * -xcb_xvmc_create_subpicture_reply (xcb_connection_t *c /**< */, +xcb_xvmc_create_subpicture_reply (xcb_connection_t *c, xcb_xvmc_create_subpicture_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xvmc_create_subpicture_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } xcb_void_cookie_t -xcb_xvmc_destroy_subpicture_checked (xcb_connection_t *c /**< */, - xcb_xvmc_subpicture_t subpicture_id /**< */) +xcb_xvmc_destroy_subpicture_checked (xcb_connection_t *c, + xcb_xvmc_subpicture_t subpicture_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_DESTROY_SUBPICTURE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_DESTROY_SUBPICTURE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -769,14 +769,14 @@ xcb_xvmc_destroy_subpicture_checked (xcb_connection_t *c /**< */, } xcb_void_cookie_t -xcb_xvmc_destroy_subpicture (xcb_connection_t *c /**< */, - xcb_xvmc_subpicture_t subpicture_id /**< */) +xcb_xvmc_destroy_subpicture (xcb_connection_t *c, + xcb_xvmc_subpicture_t subpicture_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_DESTROY_SUBPICTURE, - /* isvoid */ 1 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_DESTROY_SUBPICTURE, + .isvoid = 1 }; struct iovec xcb_parts[4]; @@ -795,7 +795,7 @@ xcb_xvmc_destroy_subpicture (xcb_connection_t *c /**< */, } int -xcb_xvmc_list_subpicture_types_sizeof (const void *_buffer /**< */) +xcb_xvmc_list_subpicture_types_sizeof (const void *_buffer) { char *xcb_tmp = (char *)_buffer; const xcb_xvmc_list_subpicture_types_reply_t *_aux = (xcb_xvmc_list_subpicture_types_reply_t *)_buffer; @@ -826,15 +826,15 @@ xcb_xvmc_list_subpicture_types_sizeof (const void *_buffer /**< */) } xcb_xvmc_list_subpicture_types_cookie_t -xcb_xvmc_list_subpicture_types (xcb_connection_t *c /**< */, - xcb_xv_port_t port_id /**< */, - xcb_xvmc_surface_t surface_id /**< */) +xcb_xvmc_list_subpicture_types (xcb_connection_t *c, + xcb_xv_port_t port_id, + xcb_xvmc_surface_t surface_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_LIST_SUBPICTURE_TYPES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_LIST_SUBPICTURE_TYPES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -854,15 +854,15 @@ xcb_xvmc_list_subpicture_types (xcb_connection_t *c /**< */, } xcb_xvmc_list_subpicture_types_cookie_t -xcb_xvmc_list_subpicture_types_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port_id /**< */, - xcb_xvmc_surface_t surface_id /**< */) +xcb_xvmc_list_subpicture_types_unchecked (xcb_connection_t *c, + xcb_xv_port_t port_id, + xcb_xvmc_surface_t surface_id) { static const xcb_protocol_request_t xcb_req = { - /* count */ 2, - /* ext */ &xcb_xvmc_id, - /* opcode */ XCB_XVMC_LIST_SUBPICTURE_TYPES, - /* isvoid */ 0 + .count = 2, + .ext = &xcb_xvmc_id, + .opcode = XCB_XVMC_LIST_SUBPICTURE_TYPES, + .isvoid = 0 }; struct iovec xcb_parts[4]; @@ -882,19 +882,19 @@ xcb_xvmc_list_subpicture_types_unchecked (xcb_connection_t *c /**< */, } xcb_xv_image_format_info_t * -xcb_xvmc_list_subpicture_types_types (const xcb_xvmc_list_subpicture_types_reply_t *R /**< */) +xcb_xvmc_list_subpicture_types_types (const xcb_xvmc_list_subpicture_types_reply_t *R) { return (xcb_xv_image_format_info_t *) (R + 1); } int -xcb_xvmc_list_subpicture_types_types_length (const xcb_xvmc_list_subpicture_types_reply_t *R /**< */) +xcb_xvmc_list_subpicture_types_types_length (const xcb_xvmc_list_subpicture_types_reply_t *R) { return R->num; } xcb_xv_image_format_info_iterator_t -xcb_xvmc_list_subpicture_types_types_iterator (const xcb_xvmc_list_subpicture_types_reply_t *R /**< */) +xcb_xvmc_list_subpicture_types_types_iterator (const xcb_xvmc_list_subpicture_types_reply_t *R) { xcb_xv_image_format_info_iterator_t i; i.data = (xcb_xv_image_format_info_t *) (R + 1); @@ -904,9 +904,9 @@ xcb_xvmc_list_subpicture_types_types_iterator (const xcb_xvmc_list_subpicture_ty } xcb_xvmc_list_subpicture_types_reply_t * -xcb_xvmc_list_subpicture_types_reply (xcb_connection_t *c /**< */, +xcb_xvmc_list_subpicture_types_reply (xcb_connection_t *c, xcb_xvmc_list_subpicture_types_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */) + xcb_generic_error_t **e) { return (xcb_xvmc_list_subpicture_types_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); } diff --git a/lib/libxcb/src/xvmc.h b/lib/libxcb/src/xvmc.h index c276c7d09..6305416f1 100644 --- a/lib/libxcb/src/xvmc.h +++ b/lib/libxcb/src/xvmc.h @@ -30,9 +30,9 @@ typedef uint32_t xcb_xvmc_context_t; * @brief xcb_xvmc_context_iterator_t **/ typedef struct xcb_xvmc_context_iterator_t { - xcb_xvmc_context_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xvmc_context_t *data; + int rem; + int index; } xcb_xvmc_context_iterator_t; typedef uint32_t xcb_xvmc_surface_t; @@ -41,9 +41,9 @@ typedef uint32_t xcb_xvmc_surface_t; * @brief xcb_xvmc_surface_iterator_t **/ typedef struct xcb_xvmc_surface_iterator_t { - xcb_xvmc_surface_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xvmc_surface_t *data; + int rem; + int index; } xcb_xvmc_surface_iterator_t; typedef uint32_t xcb_xvmc_subpicture_t; @@ -52,40 +52,40 @@ typedef uint32_t xcb_xvmc_subpicture_t; * @brief xcb_xvmc_subpicture_iterator_t **/ typedef struct xcb_xvmc_subpicture_iterator_t { - xcb_xvmc_subpicture_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xvmc_subpicture_t *data; + int rem; + int index; } xcb_xvmc_subpicture_iterator_t; /** * @brief xcb_xvmc_surface_info_t **/ typedef struct xcb_xvmc_surface_info_t { - xcb_xvmc_surface_t id; /**< */ - uint16_t chroma_format; /**< */ - uint16_t pad0; /**< */ - uint16_t max_width; /**< */ - uint16_t max_height; /**< */ - uint16_t subpicture_max_width; /**< */ - uint16_t subpicture_max_height; /**< */ - uint32_t mc_type; /**< */ - uint32_t flags; /**< */ + xcb_xvmc_surface_t id; + uint16_t chroma_format; + uint16_t pad0; + uint16_t max_width; + uint16_t max_height; + uint16_t subpicture_max_width; + uint16_t subpicture_max_height; + uint32_t mc_type; + uint32_t flags; } xcb_xvmc_surface_info_t; /** * @brief xcb_xvmc_surface_info_iterator_t **/ typedef struct xcb_xvmc_surface_info_iterator_t { - xcb_xvmc_surface_info_t *data; /**< */ - int rem; /**< */ - int index; /**< */ + xcb_xvmc_surface_info_t *data; + int rem; + int index; } xcb_xvmc_surface_info_iterator_t; /** * @brief xcb_xvmc_query_version_cookie_t **/ typedef struct xcb_xvmc_query_version_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xvmc_query_version_cookie_t; /** Opcode for xcb_xvmc_query_version. */ @@ -95,28 +95,28 @@ typedef struct xcb_xvmc_query_version_cookie_t { * @brief xcb_xvmc_query_version_request_t **/ typedef struct xcb_xvmc_query_version_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; } xcb_xvmc_query_version_request_t; /** * @brief xcb_xvmc_query_version_reply_t **/ typedef struct xcb_xvmc_query_version_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t major; /**< */ - uint32_t minor; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t major; + uint32_t minor; } xcb_xvmc_query_version_reply_t; /** * @brief xcb_xvmc_list_surface_types_cookie_t **/ typedef struct xcb_xvmc_list_surface_types_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xvmc_list_surface_types_cookie_t; /** Opcode for xcb_xvmc_list_surface_types. */ @@ -126,29 +126,29 @@ typedef struct xcb_xvmc_list_surface_types_cookie_t { * @brief xcb_xvmc_list_surface_types_request_t **/ typedef struct xcb_xvmc_list_surface_types_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port_id; } xcb_xvmc_list_surface_types_request_t; /** * @brief xcb_xvmc_list_surface_types_reply_t **/ typedef struct xcb_xvmc_list_surface_types_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num; + uint8_t pad1[20]; } xcb_xvmc_list_surface_types_reply_t; /** * @brief xcb_xvmc_create_context_cookie_t **/ typedef struct xcb_xvmc_create_context_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xvmc_create_context_cookie_t; /** Opcode for xcb_xvmc_create_context. */ @@ -158,29 +158,29 @@ typedef struct xcb_xvmc_create_context_cookie_t { * @brief xcb_xvmc_create_context_request_t **/ typedef struct xcb_xvmc_create_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xvmc_context_t context_id; /**< */ - xcb_xv_port_t port_id; /**< */ - xcb_xvmc_surface_t surface_id; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ - uint32_t flags; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xvmc_context_t context_id; + xcb_xv_port_t port_id; + xcb_xvmc_surface_t surface_id; + uint16_t width; + uint16_t height; + uint32_t flags; } xcb_xvmc_create_context_request_t; /** * @brief xcb_xvmc_create_context_reply_t **/ typedef struct xcb_xvmc_create_context_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t width_actual; /**< */ - uint16_t height_actual; /**< */ - uint32_t flags_return; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t width_actual; + uint16_t height_actual; + uint32_t flags_return; + uint8_t pad1[20]; } xcb_xvmc_create_context_reply_t; /** Opcode for xcb_xvmc_destroy_context. */ @@ -190,17 +190,17 @@ typedef struct xcb_xvmc_create_context_reply_t { * @brief xcb_xvmc_destroy_context_request_t **/ typedef struct xcb_xvmc_destroy_context_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xvmc_context_t context_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xvmc_context_t context_id; } xcb_xvmc_destroy_context_request_t; /** * @brief xcb_xvmc_create_surface_cookie_t **/ typedef struct xcb_xvmc_create_surface_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xvmc_create_surface_cookie_t; /** Opcode for xcb_xvmc_create_surface. */ @@ -210,22 +210,22 @@ typedef struct xcb_xvmc_create_surface_cookie_t { * @brief xcb_xvmc_create_surface_request_t **/ typedef struct xcb_xvmc_create_surface_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xvmc_surface_t surface_id; /**< */ - xcb_xvmc_context_t context_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xvmc_surface_t surface_id; + xcb_xvmc_context_t context_id; } xcb_xvmc_create_surface_request_t; /** * @brief xcb_xvmc_create_surface_reply_t **/ typedef struct xcb_xvmc_create_surface_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint8_t pad1[24]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t pad1[24]; } xcb_xvmc_create_surface_reply_t; /** Opcode for xcb_xvmc_destroy_surface. */ @@ -235,17 +235,17 @@ typedef struct xcb_xvmc_create_surface_reply_t { * @brief xcb_xvmc_destroy_surface_request_t **/ typedef struct xcb_xvmc_destroy_surface_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xvmc_surface_t surface_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xvmc_surface_t surface_id; } xcb_xvmc_destroy_surface_request_t; /** * @brief xcb_xvmc_create_subpicture_cookie_t **/ typedef struct xcb_xvmc_create_subpicture_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xvmc_create_subpicture_cookie_t; /** Opcode for xcb_xvmc_create_subpicture. */ @@ -255,30 +255,30 @@ typedef struct xcb_xvmc_create_subpicture_cookie_t { * @brief xcb_xvmc_create_subpicture_request_t **/ typedef struct xcb_xvmc_create_subpicture_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xvmc_subpicture_t subpicture_id; /**< */ - xcb_xvmc_context_t context; /**< */ - uint32_t xvimage_id; /**< */ - uint16_t width; /**< */ - uint16_t height; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xvmc_subpicture_t subpicture_id; + xcb_xvmc_context_t context; + uint32_t xvimage_id; + uint16_t width; + uint16_t height; } xcb_xvmc_create_subpicture_request_t; /** * @brief xcb_xvmc_create_subpicture_reply_t **/ typedef struct xcb_xvmc_create_subpicture_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint16_t width_actual; /**< */ - uint16_t height_actual; /**< */ - uint16_t num_palette_entries; /**< */ - uint16_t entry_bytes; /**< */ - uint8_t component_order[4]; /**< */ - uint8_t pad1[12]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t width_actual; + uint16_t height_actual; + uint16_t num_palette_entries; + uint16_t entry_bytes; + uint8_t component_order[4]; + uint8_t pad1[12]; } xcb_xvmc_create_subpicture_reply_t; /** Opcode for xcb_xvmc_destroy_subpicture. */ @@ -288,17 +288,17 @@ typedef struct xcb_xvmc_create_subpicture_reply_t { * @brief xcb_xvmc_destroy_subpicture_request_t **/ typedef struct xcb_xvmc_destroy_subpicture_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xvmc_subpicture_t subpicture_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xvmc_subpicture_t subpicture_id; } xcb_xvmc_destroy_subpicture_request_t; /** * @brief xcb_xvmc_list_subpicture_types_cookie_t **/ typedef struct xcb_xvmc_list_subpicture_types_cookie_t { - unsigned int sequence; /**< */ + unsigned int sequence; } xcb_xvmc_list_subpicture_types_cookie_t; /** Opcode for xcb_xvmc_list_subpicture_types. */ @@ -308,23 +308,23 @@ typedef struct xcb_xvmc_list_subpicture_types_cookie_t { * @brief xcb_xvmc_list_subpicture_types_request_t **/ typedef struct xcb_xvmc_list_subpicture_types_request_t { - uint8_t major_opcode; /**< */ - uint8_t minor_opcode; /**< */ - uint16_t length; /**< */ - xcb_xv_port_t port_id; /**< */ - xcb_xvmc_surface_t surface_id; /**< */ + uint8_t major_opcode; + uint8_t minor_opcode; + uint16_t length; + xcb_xv_port_t port_id; + xcb_xvmc_surface_t surface_id; } xcb_xvmc_list_subpicture_types_request_t; /** * @brief xcb_xvmc_list_subpicture_types_reply_t **/ typedef struct xcb_xvmc_list_subpicture_types_reply_t { - uint8_t response_type; /**< */ - uint8_t pad0; /**< */ - uint16_t sequence; /**< */ - uint32_t length; /**< */ - uint32_t num; /**< */ - uint8_t pad1[20]; /**< */ + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t num; + uint8_t pad1[20]; } xcb_xvmc_list_subpicture_types_reply_t; /** @@ -336,7 +336,7 @@ typedef struct xcb_xvmc_list_subpicture_types_reply_t { * element. The member index is increased by sizeof(xcb_xvmc_context_t) */ void -xcb_xvmc_context_next (xcb_xvmc_context_iterator_t *i /**< */); +xcb_xvmc_context_next (xcb_xvmc_context_iterator_t *i); /** * Return the iterator pointing to the last element @@ -348,7 +348,7 @@ xcb_xvmc_context_next (xcb_xvmc_context_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xvmc_context_end (xcb_xvmc_context_iterator_t i /**< */); +xcb_xvmc_context_end (xcb_xvmc_context_iterator_t i); /** * Get the next element of the iterator @@ -359,7 +359,7 @@ xcb_xvmc_context_end (xcb_xvmc_context_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xvmc_surface_t) */ void -xcb_xvmc_surface_next (xcb_xvmc_surface_iterator_t *i /**< */); +xcb_xvmc_surface_next (xcb_xvmc_surface_iterator_t *i); /** * Return the iterator pointing to the last element @@ -371,7 +371,7 @@ xcb_xvmc_surface_next (xcb_xvmc_surface_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xvmc_surface_end (xcb_xvmc_surface_iterator_t i /**< */); +xcb_xvmc_surface_end (xcb_xvmc_surface_iterator_t i); /** * Get the next element of the iterator @@ -382,7 +382,7 @@ xcb_xvmc_surface_end (xcb_xvmc_surface_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xvmc_subpicture_t) */ void -xcb_xvmc_subpicture_next (xcb_xvmc_subpicture_iterator_t *i /**< */); +xcb_xvmc_subpicture_next (xcb_xvmc_subpicture_iterator_t *i); /** * Return the iterator pointing to the last element @@ -394,7 +394,7 @@ xcb_xvmc_subpicture_next (xcb_xvmc_subpicture_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xvmc_subpicture_end (xcb_xvmc_subpicture_iterator_t i /**< */); +xcb_xvmc_subpicture_end (xcb_xvmc_subpicture_iterator_t i); /** * Get the next element of the iterator @@ -405,7 +405,7 @@ xcb_xvmc_subpicture_end (xcb_xvmc_subpicture_iterator_t i /**< */); * element. The member index is increased by sizeof(xcb_xvmc_surface_info_t) */ void -xcb_xvmc_surface_info_next (xcb_xvmc_surface_info_iterator_t *i /**< */); +xcb_xvmc_surface_info_next (xcb_xvmc_surface_info_iterator_t *i); /** * Return the iterator pointing to the last element @@ -417,7 +417,7 @@ xcb_xvmc_surface_info_next (xcb_xvmc_surface_info_iterator_t *i /**< */); * last element. */ xcb_generic_iterator_t -xcb_xvmc_surface_info_end (xcb_xvmc_surface_info_iterator_t i /**< */); +xcb_xvmc_surface_info_end (xcb_xvmc_surface_info_iterator_t i); /** * @@ -428,7 +428,7 @@ xcb_xvmc_surface_info_end (xcb_xvmc_surface_info_iterator_t i /**< */); * */ xcb_xvmc_query_version_cookie_t -xcb_xvmc_query_version (xcb_connection_t *c /**< */); +xcb_xvmc_query_version (xcb_connection_t *c); /** * @@ -442,7 +442,7 @@ xcb_xvmc_query_version (xcb_connection_t *c /**< */); * placed in the event queue. */ xcb_xvmc_query_version_cookie_t -xcb_xvmc_query_version_unchecked (xcb_connection_t *c /**< */); +xcb_xvmc_query_version_unchecked (xcb_connection_t *c); /** * Return the reply @@ -459,12 +459,12 @@ xcb_xvmc_query_version_unchecked (xcb_connection_t *c /**< */); * The returned value must be freed by the caller using free(). */ xcb_xvmc_query_version_reply_t * -xcb_xvmc_query_version_reply (xcb_connection_t *c /**< */, +xcb_xvmc_query_version_reply (xcb_connection_t *c, xcb_xvmc_query_version_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xvmc_list_surface_types_sizeof (const void *_buffer /**< */); +xcb_xvmc_list_surface_types_sizeof (const void *_buffer); /** * @@ -475,8 +475,8 @@ xcb_xvmc_list_surface_types_sizeof (const void *_buffer /**< */); * */ xcb_xvmc_list_surface_types_cookie_t -xcb_xvmc_list_surface_types (xcb_connection_t *c /**< */, - xcb_xv_port_t port_id /**< */); +xcb_xvmc_list_surface_types (xcb_connection_t *c, + xcb_xv_port_t port_id); /** * @@ -490,17 +490,17 @@ xcb_xvmc_list_surface_types (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xvmc_list_surface_types_cookie_t -xcb_xvmc_list_surface_types_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port_id /**< */); +xcb_xvmc_list_surface_types_unchecked (xcb_connection_t *c, + xcb_xv_port_t port_id); xcb_xvmc_surface_info_t * -xcb_xvmc_list_surface_types_surfaces (const xcb_xvmc_list_surface_types_reply_t *R /**< */); +xcb_xvmc_list_surface_types_surfaces (const xcb_xvmc_list_surface_types_reply_t *R); int -xcb_xvmc_list_surface_types_surfaces_length (const xcb_xvmc_list_surface_types_reply_t *R /**< */); +xcb_xvmc_list_surface_types_surfaces_length (const xcb_xvmc_list_surface_types_reply_t *R); xcb_xvmc_surface_info_iterator_t -xcb_xvmc_list_surface_types_surfaces_iterator (const xcb_xvmc_list_surface_types_reply_t *R /**< */); +xcb_xvmc_list_surface_types_surfaces_iterator (const xcb_xvmc_list_surface_types_reply_t *R); /** * Return the reply @@ -517,12 +517,12 @@ xcb_xvmc_list_surface_types_surfaces_iterator (const xcb_xvmc_list_surface_types * The returned value must be freed by the caller using free(). */ xcb_xvmc_list_surface_types_reply_t * -xcb_xvmc_list_surface_types_reply (xcb_connection_t *c /**< */, +xcb_xvmc_list_surface_types_reply (xcb_connection_t *c, xcb_xvmc_list_surface_types_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); int -xcb_xvmc_create_context_sizeof (const void *_buffer /**< */); +xcb_xvmc_create_context_sizeof (const void *_buffer); /** * @@ -533,13 +533,13 @@ xcb_xvmc_create_context_sizeof (const void *_buffer /**< */); * */ xcb_xvmc_create_context_cookie_t -xcb_xvmc_create_context (xcb_connection_t *c /**< */, - xcb_xvmc_context_t context_id /**< */, - xcb_xv_port_t port_id /**< */, - xcb_xvmc_surface_t surface_id /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t flags /**< */); +xcb_xvmc_create_context (xcb_connection_t *c, + xcb_xvmc_context_t context_id, + xcb_xv_port_t port_id, + xcb_xvmc_surface_t surface_id, + uint16_t width, + uint16_t height, + uint32_t flags); /** * @@ -553,22 +553,22 @@ xcb_xvmc_create_context (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xvmc_create_context_cookie_t -xcb_xvmc_create_context_unchecked (xcb_connection_t *c /**< */, - xcb_xvmc_context_t context_id /**< */, - xcb_xv_port_t port_id /**< */, - xcb_xvmc_surface_t surface_id /**< */, - uint16_t width /**< */, - uint16_t height /**< */, - uint32_t flags /**< */); +xcb_xvmc_create_context_unchecked (xcb_connection_t *c, + xcb_xvmc_context_t context_id, + xcb_xv_port_t port_id, + xcb_xvmc_surface_t surface_id, + uint16_t width, + uint16_t height, + uint32_t flags); uint32_t * -xcb_xvmc_create_context_priv_data (const xcb_xvmc_create_context_reply_t *R /**< */); +xcb_xvmc_create_context_priv_data (const xcb_xvmc_create_context_reply_t *R); int -xcb_xvmc_create_context_priv_data_length (const xcb_xvmc_create_context_reply_t *R /**< */); +xcb_xvmc_create_context_priv_data_length (const xcb_xvmc_create_context_reply_t *R); xcb_generic_iterator_t -xcb_xvmc_create_context_priv_data_end (const xcb_xvmc_create_context_reply_t *R /**< */); +xcb_xvmc_create_context_priv_data_end (const xcb_xvmc_create_context_reply_t *R); /** * Return the reply @@ -585,9 +585,9 @@ xcb_xvmc_create_context_priv_data_end (const xcb_xvmc_create_context_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_xvmc_create_context_reply_t * -xcb_xvmc_create_context_reply (xcb_connection_t *c /**< */, +xcb_xvmc_create_context_reply (xcb_connection_t *c, xcb_xvmc_create_context_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -601,8 +601,8 @@ xcb_xvmc_create_context_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xvmc_destroy_context_checked (xcb_connection_t *c /**< */, - xcb_xvmc_context_t context_id /**< */); +xcb_xvmc_destroy_context_checked (xcb_connection_t *c, + xcb_xvmc_context_t context_id); /** * @@ -613,11 +613,11 @@ xcb_xvmc_destroy_context_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xvmc_destroy_context (xcb_connection_t *c /**< */, - xcb_xvmc_context_t context_id /**< */); +xcb_xvmc_destroy_context (xcb_connection_t *c, + xcb_xvmc_context_t context_id); int -xcb_xvmc_create_surface_sizeof (const void *_buffer /**< */); +xcb_xvmc_create_surface_sizeof (const void *_buffer); /** * @@ -628,9 +628,9 @@ xcb_xvmc_create_surface_sizeof (const void *_buffer /**< */); * */ xcb_xvmc_create_surface_cookie_t -xcb_xvmc_create_surface (xcb_connection_t *c /**< */, - xcb_xvmc_surface_t surface_id /**< */, - xcb_xvmc_context_t context_id /**< */); +xcb_xvmc_create_surface (xcb_connection_t *c, + xcb_xvmc_surface_t surface_id, + xcb_xvmc_context_t context_id); /** * @@ -644,18 +644,18 @@ xcb_xvmc_create_surface (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xvmc_create_surface_cookie_t -xcb_xvmc_create_surface_unchecked (xcb_connection_t *c /**< */, - xcb_xvmc_surface_t surface_id /**< */, - xcb_xvmc_context_t context_id /**< */); +xcb_xvmc_create_surface_unchecked (xcb_connection_t *c, + xcb_xvmc_surface_t surface_id, + xcb_xvmc_context_t context_id); uint32_t * -xcb_xvmc_create_surface_priv_data (const xcb_xvmc_create_surface_reply_t *R /**< */); +xcb_xvmc_create_surface_priv_data (const xcb_xvmc_create_surface_reply_t *R); int -xcb_xvmc_create_surface_priv_data_length (const xcb_xvmc_create_surface_reply_t *R /**< */); +xcb_xvmc_create_surface_priv_data_length (const xcb_xvmc_create_surface_reply_t *R); xcb_generic_iterator_t -xcb_xvmc_create_surface_priv_data_end (const xcb_xvmc_create_surface_reply_t *R /**< */); +xcb_xvmc_create_surface_priv_data_end (const xcb_xvmc_create_surface_reply_t *R); /** * Return the reply @@ -672,9 +672,9 @@ xcb_xvmc_create_surface_priv_data_end (const xcb_xvmc_create_surface_reply_t *R * The returned value must be freed by the caller using free(). */ xcb_xvmc_create_surface_reply_t * -xcb_xvmc_create_surface_reply (xcb_connection_t *c /**< */, +xcb_xvmc_create_surface_reply (xcb_connection_t *c, xcb_xvmc_create_surface_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -688,8 +688,8 @@ xcb_xvmc_create_surface_reply (xcb_connection_t *c /**< */, * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xvmc_destroy_surface_checked (xcb_connection_t *c /**< */, - xcb_xvmc_surface_t surface_id /**< */); +xcb_xvmc_destroy_surface_checked (xcb_connection_t *c, + xcb_xvmc_surface_t surface_id); /** * @@ -700,11 +700,11 @@ xcb_xvmc_destroy_surface_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xvmc_destroy_surface (xcb_connection_t *c /**< */, - xcb_xvmc_surface_t surface_id /**< */); +xcb_xvmc_destroy_surface (xcb_connection_t *c, + xcb_xvmc_surface_t surface_id); int -xcb_xvmc_create_subpicture_sizeof (const void *_buffer /**< */); +xcb_xvmc_create_subpicture_sizeof (const void *_buffer); /** * @@ -715,12 +715,12 @@ xcb_xvmc_create_subpicture_sizeof (const void *_buffer /**< */); * */ xcb_xvmc_create_subpicture_cookie_t -xcb_xvmc_create_subpicture (xcb_connection_t *c /**< */, - xcb_xvmc_subpicture_t subpicture_id /**< */, - xcb_xvmc_context_t context /**< */, - uint32_t xvimage_id /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_xvmc_create_subpicture (xcb_connection_t *c, + xcb_xvmc_subpicture_t subpicture_id, + xcb_xvmc_context_t context, + uint32_t xvimage_id, + uint16_t width, + uint16_t height); /** * @@ -734,21 +734,21 @@ xcb_xvmc_create_subpicture (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xvmc_create_subpicture_cookie_t -xcb_xvmc_create_subpicture_unchecked (xcb_connection_t *c /**< */, - xcb_xvmc_subpicture_t subpicture_id /**< */, - xcb_xvmc_context_t context /**< */, - uint32_t xvimage_id /**< */, - uint16_t width /**< */, - uint16_t height /**< */); +xcb_xvmc_create_subpicture_unchecked (xcb_connection_t *c, + xcb_xvmc_subpicture_t subpicture_id, + xcb_xvmc_context_t context, + uint32_t xvimage_id, + uint16_t width, + uint16_t height); uint32_t * -xcb_xvmc_create_subpicture_priv_data (const xcb_xvmc_create_subpicture_reply_t *R /**< */); +xcb_xvmc_create_subpicture_priv_data (const xcb_xvmc_create_subpicture_reply_t *R); int -xcb_xvmc_create_subpicture_priv_data_length (const xcb_xvmc_create_subpicture_reply_t *R /**< */); +xcb_xvmc_create_subpicture_priv_data_length (const xcb_xvmc_create_subpicture_reply_t *R); xcb_generic_iterator_t -xcb_xvmc_create_subpicture_priv_data_end (const xcb_xvmc_create_subpicture_reply_t *R /**< */); +xcb_xvmc_create_subpicture_priv_data_end (const xcb_xvmc_create_subpicture_reply_t *R); /** * Return the reply @@ -765,9 +765,9 @@ xcb_xvmc_create_subpicture_priv_data_end (const xcb_xvmc_create_subpicture_reply * The returned value must be freed by the caller using free(). */ xcb_xvmc_create_subpicture_reply_t * -xcb_xvmc_create_subpicture_reply (xcb_connection_t *c /**< */, +xcb_xvmc_create_subpicture_reply (xcb_connection_t *c, xcb_xvmc_create_subpicture_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); /** * @@ -781,8 +781,8 @@ xcb_xvmc_create_subpicture_reply (xcb_connection_t *c /**< * saved for handling by xcb_request_check(). */ xcb_void_cookie_t -xcb_xvmc_destroy_subpicture_checked (xcb_connection_t *c /**< */, - xcb_xvmc_subpicture_t subpicture_id /**< */); +xcb_xvmc_destroy_subpicture_checked (xcb_connection_t *c, + xcb_xvmc_subpicture_t subpicture_id); /** * @@ -793,11 +793,11 @@ xcb_xvmc_destroy_subpicture_checked (xcb_connection_t *c /**< */, * */ xcb_void_cookie_t -xcb_xvmc_destroy_subpicture (xcb_connection_t *c /**< */, - xcb_xvmc_subpicture_t subpicture_id /**< */); +xcb_xvmc_destroy_subpicture (xcb_connection_t *c, + xcb_xvmc_subpicture_t subpicture_id); int -xcb_xvmc_list_subpicture_types_sizeof (const void *_buffer /**< */); +xcb_xvmc_list_subpicture_types_sizeof (const void *_buffer); /** * @@ -808,9 +808,9 @@ xcb_xvmc_list_subpicture_types_sizeof (const void *_buffer /**< */); * */ xcb_xvmc_list_subpicture_types_cookie_t -xcb_xvmc_list_subpicture_types (xcb_connection_t *c /**< */, - xcb_xv_port_t port_id /**< */, - xcb_xvmc_surface_t surface_id /**< */); +xcb_xvmc_list_subpicture_types (xcb_connection_t *c, + xcb_xv_port_t port_id, + xcb_xvmc_surface_t surface_id); /** * @@ -824,18 +824,18 @@ xcb_xvmc_list_subpicture_types (xcb_connection_t *c /**< */, * placed in the event queue. */ xcb_xvmc_list_subpicture_types_cookie_t -xcb_xvmc_list_subpicture_types_unchecked (xcb_connection_t *c /**< */, - xcb_xv_port_t port_id /**< */, - xcb_xvmc_surface_t surface_id /**< */); +xcb_xvmc_list_subpicture_types_unchecked (xcb_connection_t *c, + xcb_xv_port_t port_id, + xcb_xvmc_surface_t surface_id); xcb_xv_image_format_info_t * -xcb_xvmc_list_subpicture_types_types (const xcb_xvmc_list_subpicture_types_reply_t *R /**< */); +xcb_xvmc_list_subpicture_types_types (const xcb_xvmc_list_subpicture_types_reply_t *R); int -xcb_xvmc_list_subpicture_types_types_length (const xcb_xvmc_list_subpicture_types_reply_t *R /**< */); +xcb_xvmc_list_subpicture_types_types_length (const xcb_xvmc_list_subpicture_types_reply_t *R); xcb_xv_image_format_info_iterator_t -xcb_xvmc_list_subpicture_types_types_iterator (const xcb_xvmc_list_subpicture_types_reply_t *R /**< */); +xcb_xvmc_list_subpicture_types_types_iterator (const xcb_xvmc_list_subpicture_types_reply_t *R); /** * Return the reply @@ -852,9 +852,9 @@ xcb_xvmc_list_subpicture_types_types_iterator (const xcb_xvmc_list_subpicture_ty * The returned value must be freed by the caller using free(). */ xcb_xvmc_list_subpicture_types_reply_t * -xcb_xvmc_list_subpicture_types_reply (xcb_connection_t *c /**< */, +xcb_xvmc_list_subpicture_types_reply (xcb_connection_t *c, xcb_xvmc_list_subpicture_types_cookie_t cookie /**< */, - xcb_generic_error_t **e /**< */); + xcb_generic_error_t **e); #ifdef __cplusplus diff --git a/proto/xcb-proto/Makefile b/proto/xcb-proto/Makefile index effaebc07..4b5516276 100644 --- a/proto/xcb-proto/Makefile +++ b/proto/xcb-proto/Makefile @@ -1,4 +1,4 @@ -# $OpenBSD: Makefile,v 1.6 2014/03/15 17:24:19 matthieu Exp $ +# $OpenBSD: Makefile,v 1.7 2016/09/02 10:09:44 matthieu Exp $ PKGCONFIG= xcb-proto.pc @@ -55,6 +55,7 @@ realinstall: XCBGEN_SRCS= \ __init__.py \ + align.py \ error.py \ expr.py \ matcher.py \ diff --git a/proto/xcb-proto/NEWS b/proto/xcb-proto/NEWS index 3ab5cc096..caf1ffad4 100644 --- a/proto/xcb-proto/NEWS +++ b/proto/xcb-proto/NEWS @@ -1,3 +1,30 @@ +Release 1.12 (2016-05-18) +========================= +* xinput: Various padding-related additions and fixes +* xinput: Various type fixes +* xinput: Various mask fixes +* xinput: Various additions of enums +* Define new "altmask" attribute +* Define new switch-case construct +* xinput: Convert various construct from bitcase to case +* xinput: Add full support for various requests +* Define new sumof with nested expressions +* present: Specify length of RedirectNotify.notifies +* Define new listelement-ref construct +* xinput: Support list axisvalues in events +* Define new paramref construct +* xfixes: Fix GetCursorImageAndName cursor image support +* Replace valueparam with other construct in various extensions +* Remove support for the valueparam construct +* xprint: Fix some list definitions +* randr: Add RandR 1.5 requests and data types +* shm: Mark PutImage.send_event field as boolean +* glx: Add IsEnabled request +* Make padding explicit in various places +* Fix typos in some documentation examples +* Add an automatic alignment checker +* Optionally enforce serilization of pads for ABI compatibility + Release 1.11 (2014-08-01) ========================= * Add support for diff --git a/proto/xcb-proto/configure.ac b/proto/xcb-proto/configure.ac index d140bfe70..540a8dd17 100644 --- a/proto/xcb-proto/configure.ac +++ b/proto/xcb-proto/configure.ac @@ -3,7 +3,7 @@ AC_PREREQ(2.57) AC_INIT([XCB Proto], - 1.11, + 1.12, [xcb@lists.freedesktop.org]) AC_CONFIG_SRCDIR([xcb-proto.pc.in]) AM_INIT_AUTOMAKE([foreign dist-bzip2]) diff --git a/proto/xcb-proto/doc/xml-xcb.txt b/proto/xcb-proto/doc/xml-xcb.txt index 97ce5bf8e..9cef1de11 100644 --- a/proto/xcb-proto/doc/xml-xcb.txt +++ b/proto/xcb-proto/doc/xml-xcb.txt @@ -184,17 +184,25 @@ separated by a single colon. For example, to refer to the PIXMAP type defined in glx rather than the one defined in xproto, use type="glx:PIXMAP" rather than type="PIXMAP". -Note: Most of the below may optionally contain an enum, altenum, or mask +Note: Most of the below may optionally contain an enum, altenum, mask or altmask attribute, which follows the above rules for "type". "enum" is an exhaustive enum; the value is restricted to one of the constants named in the enum. "altenum" may be one of the values contained in the enum, but it need not be. -"mask" refers to an enum to be used as a bitmask. +"mask" refers to an exhaustive enum to be used as a bitmask. +"altmask" may be a mask from the referred enum, but it need not be. - + This element declares some padding in a data structure. The bytes attribute declares the number of bytes of padding. + If serialize="true", then the pad will be serialized/deserialized. + This is only needed for ABI compatibility with legacy. + Newly added pads should not be defined with serialize="true". + + The serialize attribute may be omitted. + Default is serialize="false". + This element represents a field in a data structure. The type attribute @@ -217,13 +225,6 @@ enum; the value is restricted to one of the constants named in the enum. of the list in terms of other fields in the structure. See the section "Expressions" for details on the expression representation. - - - This element represents a parameter in a request that is not sent over the - wire. The field can be referenced in the length expressions of lists or in - an exprfield. The type attribute declares the data type of the field, and - the name attribute gives the name of the field. - expression This element represents a field in a request that is calculated rather than @@ -243,18 +244,40 @@ enum; the value is restricted to one of the constants named in the enum. instead for new protocol definitions. switch expression - bitcase expression(s), fields + bitcase expression(s), fields + case expression(s), fields + This element represents conditional inclusion of fields. It can be viewed - as sequence of multiple ifs: if ( switch expression & bitcase expression ) - is non-zero, bitcase fields are included in structure. It can be used only - as the last field of a structure. + as sequence of multiple ifs: - When a bitcase includes multiple clauses, the contents of the - bitcase are only present once regardless of the number of bitcase expressions - that match. + : + if ( switch expression & bitcase expression ) is non-zero, + bitcase fields are included in structure. + + : + if ( switch expression == case expression ) is true, + then case fields are included in structure. + + It can be used only as the last field of a structure. + + When a bitcase or case includes multiple clauses, the contents + of the bitcase or case are only present once regardless of the number of + bitcase or case expressions that match. + + inside can only refer to an enum's members. + inside can only refer to an enum's members. + + A switch may contain multiple or elements. + Usually it will only contain elements + or only contain elements. + That is, mixing of and usually doesn't make any sense. + + The same value may appear in multiple or elements. + + New protocol definitions should prefer to use this instead of + and instead of . - New protocol definitions should prefer to use this instead of . Expressions ----------- @@ -275,6 +298,23 @@ Expressions the structure containing this expression. The identifier is the value of the "name" attribute on the referenced field. +identifier + + A paramref is similar to a fieldref, but it refers to the value of + a field in the context which refers to the struct which contains the paramref. + + So, it refers to a field outside of the structure where it is defined. + This has the following consequences: + * The generator cannot deduce its type. + So, it is mandatory to specify its type. + * The identifier-name must not be used as a field in the structure + which contaons the paramref. + + For an example, see struct "DeviceTimeCoord" and request/reply + "GetDeviceMotionEvents" in xinput.xml, where paramref "num_axes" + in struct DeviceTimeCoord refers to field "num_axes" in + the DeviceTimeCoord reply. + integer The value element represents a literal integer value in an expression. The @@ -299,10 +339,26 @@ Expressions This element represents a sumation of the elements of the referenced list. +expression + + The expression is evaluated for each element of the referenced list, + in the context of this element. + This sumof element then represents a sumation of the results of these + evaluations. + + expression will usually be a fieldref which references a field of + a list-element or an expression containing a fieldref, + such as popcount of a fieldref. + expression This element represents the number of bits set in the expression. + + + This element represents the current list-element when used inside + a list-iteration expression such as . + Documentation ------------- diff --git a/proto/xcb-proto/py-compile b/proto/xcb-proto/py-compile index 46ea866a7..bc2039140 100644 --- a/proto/xcb-proto/py-compile +++ b/proto/xcb-proto/py-compile @@ -3,7 +3,7 @@ scriptversion=2011-06-08.12; # UTC -# Copyright (C) 2000-2013 Free Software Foundation, Inc. +# Copyright (C) 2000-2014 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by diff --git a/proto/xcb-proto/src/glx.xml b/proto/xcb-proto/src/glx.xml index 2a36daadd..2e50aeaa1 100644 --- a/proto/xcb-proto/src/glx.xml +++ b/proto/xcb-proto/src/glx.xml @@ -665,6 +665,7 @@ The patch that fixed this server bug in X.org CVS is here: + @@ -680,6 +681,7 @@ The patch that fixed this server bug in X.org CVS is here: + @@ -766,6 +768,7 @@ The patch that fixed this server bug in X.org CVS is here: + @@ -953,6 +956,7 @@ The patch that fixed this server bug in X.org CVS is here: + @@ -1086,6 +1090,15 @@ The patch that fixed this server bug in X.org CVS is here: + + + + + + + + + diff --git a/proto/xcb-proto/src/present.xml b/proto/xcb-proto/src/present.xml index a9adc2ba8..a648ad77c 100644 --- a/proto/xcb-proto/src/present.xml +++ b/proto/xcb-proto/src/present.xml @@ -88,6 +88,7 @@ OF THIS SOFTWARE. + @@ -107,6 +108,7 @@ OF THIS SOFTWARE. + @@ -157,6 +159,7 @@ OF THIS SOFTWARE. + @@ -176,6 +179,7 @@ OF THIS SOFTWARE. + @@ -199,7 +203,7 @@ OF THIS SOFTWARE. - + diff --git a/proto/xcb-proto/src/randr.xml b/proto/xcb-proto/src/randr.xml index d9192b216..722f715bf 100644 --- a/proto/xcb-proto/src/randr.xml +++ b/proto/xcb-proto/src/randr.xml @@ -27,7 +27,7 @@ authorization from the authors. --> + major-version="1" minor-version="5"> xproto render @@ -528,6 +528,7 @@ authorization from the authors. filter_len + @@ -547,12 +548,14 @@ authorization from the authors. pending_len + pending_nparams current_len + current_nparams @@ -868,4 +871,47 @@ authorization from the authors. + + + + + + + + + + + + + + + + nOutput + + + + + + + + + + + + + + nMonitors + + + + + + + + + + + + + diff --git a/proto/xcb-proto/src/render.xml b/proto/xcb-proto/src/render.xml index 55b73f7b8..935fdcc81 100644 --- a/proto/xcb-proto/src/render.xml +++ b/proto/xcb-proto/src/render.xml @@ -280,16 +280,122 @@ for licensing information. - + + + value_mask + + Repeat + + + + AlphaMap + + + + AlphaXOrigin + + + + AlphaYOrigin + + + + ClipXOrigin + + + + ClipYOrigin + + + + ClipMask + + + + GraphicsExposure + + + + SubwindowMode + + + + PolyEdge + + + + PolyMode + + + + Dither + + + + ComponentAlpha + + + - + + + value_mask + + Repeat + + + + AlphaMap + + + + AlphaXOrigin + + + + AlphaYOrigin + + + + ClipXOrigin + + + + ClipYOrigin + + + + ClipMask + + + + GraphicsExposure + + + + SubwindowMode + + + + PolyEdge + + + + PolyMode + + + + Dither + + + + ComponentAlpha + + + @@ -501,6 +607,7 @@ for licensing information. filter_len + diff --git a/proto/xcb-proto/src/screensaver.xml b/proto/xcb-proto/src/screensaver.xml index 491869e81..8d5abb43d 100644 --- a/proto/xcb-proto/src/screensaver.xml +++ b/proto/xcb-proto/src/screensaver.xml @@ -95,9 +95,71 @@ Draft Standard Version 1.1 - + + + value_mask + + BackPixmap + + + + BackPixel + + + + BorderPixmap + + + + BorderPixel + + + + BitGravity + + + + WinGravity + + + + BackingStore + + + + BackingPlanes + + + + BackingPixel + + + + OverrideRedirect + + + + SaveUnder + + + + EventMask + + + + DontPropagate + + + + Colormap + + + + Cursor + + + + diff --git a/proto/xcb-proto/src/shm.xml b/proto/xcb-proto/src/shm.xml index 71fce14fa..c2605da0e 100644 --- a/proto/xcb-proto/src/shm.xml +++ b/proto/xcb-proto/src/shm.xml @@ -79,7 +79,7 @@ authorization from the authors. - + diff --git a/proto/xcb-proto/src/sync.xml b/proto/xcb-proto/src/sync.xml index 23175cb35..33ce17871 100644 --- a/proto/xcb-proto/src/sync.xml +++ b/proto/xcb-proto/src/sync.xml @@ -53,6 +53,7 @@ for licensing information. name_len + diff --git a/proto/xcb-proto/src/xcb.xsd b/proto/xcb-proto/src/xcb.xsd index 59bb9a883..c1dce3e1e 100644 --- a/proto/xcb-proto/src/xcb.xsd +++ b/proto/xcb-proto/src/xcb.xsd @@ -54,6 +54,7 @@ authorization from the authors. + @@ -77,7 +78,9 @@ authorization from the authors. - + + + @@ -143,6 +146,15 @@ authorization from the authors. + + + + + + + + + @@ -159,9 +171,13 @@ authorization from the authors. + + + + @@ -179,15 +195,6 @@ authorization from the authors. - - - - - - - - - @@ -293,7 +300,6 @@ authorization from the authors. - @@ -303,7 +309,6 @@ authorization from the authors. - diff --git a/proto/xcb-proto/src/xfixes.xml b/proto/xcb-proto/src/xfixes.xml index c5cba352a..0a3d5ffee 100644 --- a/proto/xcb-proto/src/xfixes.xml +++ b/proto/xcb-proto/src/xfixes.xml @@ -291,13 +291,13 @@ authorization from the authors. - nbytes width height + nbytes diff --git a/proto/xcb-proto/src/xinput.xml b/proto/xcb-proto/src/xinput.xml index 86350dea0..94855bac8 100644 --- a/proto/xcb-proto/src/xinput.xml +++ b/proto/xcb-proto/src/xinput.xml @@ -32,6 +32,27 @@ authorization from the authors. http://cgit.freedesktop.org/xorg/proto/inputproto/tree/specs/XI2proto.txt --> + + + xfixes @@ -63,7 +84,7 @@ authorization from the authors. name_len - + @@ -89,6 +110,17 @@ authorization from the authors. 4 5 6 + @@ -139,6 +171,31 @@ authorization from the authors. + + class_id + + + Key + + + + + + + Button + + + + Valuator + + + + + + axes_len + + + @@ -150,15 +207,21 @@ authorization from the authors. - + devices_len - - + + + num_class_info + + + + devices_len + + @@ -173,12 +236,13 @@ authorization from the authors. - + num_classes + @@ -196,8 +260,9 @@ authorization from the authors. - - + + + @@ -218,7 +283,7 @@ authorization from the authors. - + @@ -253,7 +318,7 @@ authorization from the authors. - + @@ -266,21 +331,25 @@ authorization from the authors. - + + num_axes + + - + - + + num_events + @@ -290,8 +359,11 @@ authorization from the authors. - - + + + @@ -304,8 +376,11 @@ authorization from the authors. - - + + + @@ -325,7 +400,7 @@ authorization from the authors. num_classes - + @@ -336,15 +411,20 @@ authorization from the authors. + + + 255 + + - + @@ -361,7 +441,7 @@ authorization from the authors. - + @@ -371,13 +451,13 @@ authorization from the authors. - + - + num_classes @@ -389,9 +469,10 @@ authorization from the authors. - + + @@ -409,6 +490,7 @@ authorization from the authors. + @@ -417,7 +499,7 @@ authorization from the authors. - + @@ -432,6 +514,7 @@ authorization from the authors. + @@ -514,19 +597,63 @@ authorization from the authors. - - - len - 4 - - + + class_id + + Keyboard + + + + + + + + + + 32 + + + + Pointer + + + + + + + String + + + + num_keysyms + + + + Integer + + + + + + Led + + + + + Bell + + + + + + - + @@ -601,18 +728,74 @@ authorization from the authors. - - - len - 4 - - + + class_id + + Keyboard + + + + + + + + + + + Pointer + + + + + + + String + + + + num_keysyms + + + + Integer + + + + Led + + + + + Bell + + + + + + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 0 + 0 + 0 + 1 + 2 + + - + + @@ -622,8 +805,9 @@ authorization from the authors. + - + @@ -654,7 +838,7 @@ authorization from the authors. - + @@ -671,7 +855,7 @@ authorization from the authors. - + keycodes_per_modifier @@ -679,7 +863,7 @@ authorization from the authors. - + @@ -691,12 +875,13 @@ authorization from the authors. - + map_size + @@ -710,7 +895,7 @@ authorization from the authors. map_size - + @@ -738,12 +923,17 @@ authorization from the authors. + + 0 + 1 + + - - + + num_valuators @@ -751,21 +941,43 @@ authorization from the authors. - - - - - len - 4 - - + + class_id + + + Key + + + + + 32 + + + + Button + + + + 32 + + + + Valuator + + + + + num_valuators + + + - + @@ -814,7 +1026,7 @@ authorization from the authors. num_valuators - + @@ -887,12 +1099,53 @@ authorization from the authors. - - - len - 4 - - + + control_id + + resolution + + + num_valuators + + + num_valuators + + + num_valuators + + + + abs_calib + + + + + + + + + + + core + + + + + + enable + + + + + abs_area + + + + + + + + @@ -900,7 +1153,7 @@ authorization from the authors. - + @@ -961,12 +1214,48 @@ authorization from the authors. - - - len - 4 - - + + control_id + + resolution + + + + + num_valuators + + + + abs_calib + + + + + + + + + + + core + + + + + enable + + + + + abs_area + + + + + + + + @@ -975,7 +1264,7 @@ authorization from the authors. - + @@ -989,7 +1278,7 @@ authorization from the authors. - + @@ -1016,28 +1305,26 @@ authorization from the authors. format - - + 8Bits num_items - - + + + 16Bits num_items - - + + + 32Bits num_items - + @@ -1060,7 +1347,7 @@ authorization from the authors. - + @@ -1069,28 +1356,26 @@ authorization from the authors. format - - + 8Bits num_items - - + + + 16Bits num_items - - + + + 32Bits num_items - + @@ -1130,7 +1415,7 @@ authorization from the authors. - + @@ -1183,11 +1468,12 @@ authorization from the authors. - - + + name_len + @@ -1217,15 +1503,37 @@ authorization from the authors. - - - - len - 4 - - 4 - - + + type + + AddMaster + + + + + name_len + + + + + RemoveMaster + + + + + + + + AttachSlave + + + + + DetachSlave + + + + @@ -1391,7 +1699,7 @@ authorization from the authors. - + @@ -1421,40 +1729,75 @@ authorization from the authors. - - - - - len - 4 - - 8 - - + + type + + + Key + + + + num_keys + + + + Button + + + + + + num_buttons + 31 + + 32 + + + + num_buttons + + + + Valuator + + + + + + + + + + + + Scroll + + + + + + + + + Touch + + + + - + - - - - - name_len - 3 - - 4 - - 4 - + name_len + num_classes @@ -1578,6 +1921,7 @@ authorization from the authors. + @@ -1646,28 +1990,26 @@ authorization from the authors. format - - + 8Bits num_items - - + + + 16Bits num_items - - + + + 32Bits num_items - + @@ -1698,28 +2040,26 @@ authorization from the authors. format - - + 8Bits num_items - - + + + 16Bits num_items - - + + + 32Bits num_items - + @@ -1771,6 +2111,12 @@ authorization from the authors. + + + 7 + + @@ -1781,9 +2127,9 @@ authorization from the authors. - + - + @@ -1804,13 +2150,25 @@ authorization from the authors. + + 7 + + + 6 + + + 2 + 1 + 0 + + - + - + 4 @@ -1824,7 +2182,7 @@ authorization from the authors. - + @@ -1832,22 +2190,27 @@ authorization from the authors. + + 0 + 1 + + - + - + 28 - + 28 @@ -1937,8 +2300,13 @@ authorization from the authors. valuators_len - + + + + + + + @@ -1973,8 +2341,13 @@ authorization from the authors. valuators_len - + + + + + + + @@ -2015,8 +2388,8 @@ authorization from the authors. - - + + @@ -2093,10 +2466,20 @@ authorization from the authors. valuators_len - - + + + + + + + + + + + + + + @@ -2114,10 +2497,20 @@ authorization from the authors. valuators_len - - + + + + + + + + + + + + + + @@ -2156,8 +2549,13 @@ authorization from the authors. valuators_len - + + + + + + + @@ -2196,10 +2594,20 @@ authorization from the authors. valuators_len - - + + + + + + + + + + + + + + @@ -2207,6 +2615,11 @@ authorization from the authors. + + 0 + 1 + + @@ -2217,7 +2630,7 @@ authorization from the authors. - + diff --git a/proto/xcb-proto/src/xkb.xml b/proto/xcb-proto/src/xkb.xml index ad52ea2a4..8778c073f 100644 --- a/proto/xcb-proto/src/xkb.xml +++ b/proto/xcb-proto/src/xkb.xml @@ -745,6 +745,7 @@ authorization from the authors. length + @@ -1355,7 +1356,7 @@ authorization from the authors. nKeyActions - + totalActions @@ -1371,21 +1372,21 @@ authorization from the authors. virtualMods - + ExplicitComponents totalKeyExplicit - + ModifierMap totalModMapKeys - + VirtualModMap @@ -1443,6 +1444,7 @@ authorization from the authors. nKeyActions + totalActions @@ -1458,6 +1460,7 @@ authorization from the authors. virtualMods + ExplicitComponents @@ -1667,20 +1670,7 @@ authorization from the authors. nKTLevels --> nTypes - - - - - nTypes - 3 - - - 3 - - - nTypes - - + @@ -1784,6 +1774,7 @@ authorization from the authors. nTypes + @@ -2092,6 +2083,7 @@ authorization from the authors. nKeyActions + totalActions @@ -2107,18 +2099,21 @@ authorization from the authors. virtualMods + ExplicitComponents totalKeyExplicit + ModifierMap totalModMapKeys + VirtualModMap @@ -2226,6 +2221,7 @@ authorization from the authors. nTypes + @@ -2352,6 +2348,7 @@ authorization from the authors. nameLen + nBtnsRtrn diff --git a/proto/xcb-proto/src/xprint.xml b/proto/xcb-proto/src/xprint.xml index e32293f3b..f9af65fa6 100644 --- a/proto/xcb-proto/src/xprint.xml +++ b/proto/xcb-proto/src/xprint.xml @@ -41,12 +41,12 @@ authorization from the authors. nameLen - + descLen - + @@ -178,9 +178,13 @@ authorization from the authors. len_data - + + len_fmt + - + + len_options + @@ -209,21 +213,15 @@ authorization from the authors. - + - - - + + + diff --git a/proto/xcb-proto/src/xproto.xml b/proto/xcb-proto/src/xproto.xml index bfb8a4cff..437dc30af 100644 --- a/proto/xcb-proto/src/xproto.xml +++ b/proto/xcb-proto/src/xproto.xml @@ -57,6 +57,7 @@ authorization from the authors. GCONTEXT + @@ -64,6 +65,8 @@ authorization from the authors. + + @@ -252,6 +255,7 @@ authorization from the authors. vendor_len + pixmap_formats_len @@ -1293,9 +1297,71 @@ parent's cursor will cause an immediate change in the displayed cursor. - + + + value_mask + + BackPixmap + + + + BackPixel + + + + BorderPixmap + + + + BorderPixel + + + + BitGravity + + + + WinGravity + + + + BackingStore + + + + BackingPlanes + + + + BackingPixel + + + + OverrideRedirect + + + + SaveUnder + + + + EventMask + + + + DontPropagate + + + + Colormap + + + + Cursor + + + + Creates a window - + + + value_mask + + BackPixmap + + + + BackPixel + + + + BorderPixmap + + + + BorderPixel + + + + BitGravity + + + + WinGravity + + + + BackingStore + + + + BackingPlanes + + + + BackingPixel + + + + OverrideRedirect + + + + SaveUnder + + + + EventMask + + + + DontPropagate + + + + Colormap + + + + Cursor + + + + change window attributes - + - + + value_mask + + X + + + + Y + + + + Width + + + + Height + + + + BorderWidth + + + + Sibling + + + + StackMode + + + + Configures window attributes - + + + value_mask + + Function + + + + PlaneMask + + + + Foreground + + + + Background + + + + LineWidth + + + + LineStyle + + + + CapStyle + + + + JoinStyle + + + + FillStyle + + + + FillRule + + + + Tile + + + + Stipple + + + + TileStippleOriginX + + + + TileStippleOriginY + + + + Font + + + + SubwindowMode + + + + GraphicsExposures + + + + ClipOriginX + + + + ClipOriginY + + + + ClipMask + + + + DashOffset + + + + DashList + + + + ArcMode + + + Creates a graphics context - + + + value_mask + + Function + + + + PlaneMask + + + + Foreground + + + + Background + + + + LineWidth + + + + LineStyle + + + + CapStyle + + + + JoinStyle + + + + FillStyle + + + + FillRule + + + + Tile + + + + Stipple + + + + TileStippleOriginX + + + + TileStippleOriginY + + + + Font + + + + SubwindowMode + + + + GraphicsExposures + + + + ClipOriginX + + + + ClipOriginY + + + + ClipMask + + + + DashOffset + + + + DashList + + + + ArcMode + + + change graphics context components - + + + value_mask + + KeyClickPercent + + + + BellPercent + + + + BellPitch + + + + BellDuration + + + + Led + + + + LedMode + + + + Key + + + + AutoRepeatMode + + + + @@ -5088,6 +5465,7 @@ sensitive! address_len + diff --git a/proto/xcb-proto/src/xselinux.xml b/proto/xcb-proto/src/xselinux.xml index 7751470ca..a97a14684 100644 --- a/proto/xcb-proto/src/xselinux.xml +++ b/proto/xcb-proto/src/xselinux.xml @@ -111,9 +111,11 @@ authorization from the authors. object_context_len + data_context_len + diff --git a/proto/xcb-proto/src/xv.xml b/proto/xcb-proto/src/xv.xml index 47a05d04d..6db133fa6 100644 --- a/proto/xcb-proto/src/xv.xml +++ b/proto/xcb-proto/src/xv.xml @@ -118,6 +118,7 @@ authorization from the authors. name_size + @@ -146,6 +147,7 @@ authorization from the authors. size + diff --git a/proto/xcb-proto/xcbgen/Makefile.am b/proto/xcb-proto/xcbgen/Makefile.am index 110a992f1..d6c7adc7d 100644 --- a/proto/xcb-proto/xcbgen/Makefile.am +++ b/proto/xcb-proto/xcbgen/Makefile.am @@ -1,3 +1,3 @@ pkgpythondir = $(pythondir)/xcbgen -pkgpython_PYTHON = __init__.py error.py expr.py matcher.py state.py xtypes.py +pkgpython_PYTHON = __init__.py error.py expr.py align.py matcher.py state.py xtypes.py diff --git a/proto/xcb-proto/xcbgen/align.py b/proto/xcb-proto/xcbgen/align.py new file mode 100644 index 000000000..5e3183801 --- /dev/null +++ b/proto/xcb-proto/xcbgen/align.py @@ -0,0 +1,177 @@ +''' +This module contains helper classes for alignment arithmetic and checks +''' + +from fractions import gcd + +class Alignment(object): + + def __init__(self, align=4, offset=0): + self.align = align + # normalize the offset (just in case) + self.offset = offset % align + + + def __eq__(self, other): + return self.align == other.align and self.offset == other.offset + + def __str__(self): + return "(align=%d, offset=%d)" % (self.align, self.offset) + + @staticmethod + def for_primitive_type(size): + # compute the required start_alignment based on the size of the type + if size % 8 == 0: + # do 8-byte primitives require 8-byte alignment in X11? + return Alignment(8,0) + elif size % 4 == 0: + return Alignment(4,0) + elif size % 2 == 0: + return Alignment(2,0) + else: + return Alignment(1,0) + + + def align_after_fixed_size(self, size): + new_offset = (self.offset + size) % self.align + return Alignment(self.align, new_offset) + + + def is_guaranteed_at(self, external_align): + ''' + Assuming the given external_align, checks whether + self is fulfilled for all cases. + Returns True if yes, False otherwise. + ''' + if self.align == 1 and self.offset == 0: + # alignment 1 with offset 0 is always fulfilled + return True + + if external_align is None: + # there is no external align -> fail + return False + + if external_align.align < self.align: + # the external align guarantees less alignment -> not guaranteed + return False + + if external_align.align % self.align != 0: + # the external align cannot be divided by our align + # -> not guaranteed + # (this can only happen if there are alignments that are not + # a power of 2, which is highly discouraged. But better be + # safe and check for it) + return False + + if external_align.offset % self.align != self.offset: + # offsets do not match + return False + + return True + + + def combine_with(self, other): + # returns the alignment that is guaranteed when + # both, self or other, can happen + new_align = gcd(self.align, other.align) + new_offset_candidate1 = self.offset % new_align + new_offset_candidate2 = other.offset % new_align + if new_offset_candidate1 == new_offset_candidate2: + new_offset = new_offset_candidate1 + else: + offset_diff = abs(new_offset_candidate2 - new_offset_candidate1) + new_align = gcd(new_align, offset_diff) + new_offset_candidate1 = self.offset % new_align + new_offset_candidate2 = other.offset % new_align + assert new_offset_candidate1 == new_offset_candidate2 + new_offset = new_offset_candidate1 + # return the result + return Alignment(new_align, new_offset) + + +class AlignmentLog(object): + + def __init__(self): + self.ok_list = [] + self.fail_list = [] + self.verbosity = 1 + + def __str__(self): + result = "" + + # output the OK-list + for (align_before, field_name, type_obj, callstack, align_after) in self.ok_list: + stacksize = len(callstack) + indent = ' ' * stacksize + if self.ok_callstack_is_relevant(callstack): + if field_name is None or field_name == "": + result += (" %sok: %s:\n\t%sbefore: %s, after: %s\n" + % (indent, str(type_obj), indent, str(align_before), str(align_after))) + else: + result += (" %sok: field \"%s\" in %s:\n\t%sbefore: %s, after: %s\n" + % (indent, str(field_name), str(type_obj), + indent, str(align_before), str(align_after))) + if self.verbosity >= 1: + result += self.callstack_to_str(indent, callstack) + + # output the fail-list + for (align_before, field_name, type_obj, callstack, reason) in self.fail_list: + stacksize = len(callstack) + indent = ' ' * stacksize + if field_name is None or field_name == "": + result += (" %sfail: align %s is incompatible with\n\t%s%s\n\t%sReason: %s\n" + % (indent, str(align_before), indent, str(type_obj), indent, reason)) + else: + result += (" %sfail: align %s is incompatible with\n\t%sfield \"%s\" in %s\n\t%sReason: %s\n" + % (indent, str(align_before), indent, str(field_name), str(type_obj), indent, reason)) + + if self.verbosity >= 1: + result += self.callstack_to_str(indent, callstack) + + + return result + + + def callstack_to_str(self, indent, callstack): + result = "\t%scallstack: [\n" % indent + for stack_elem in callstack: + result += "\t %s%s\n" % (indent, str(stack_elem)) + result += "\t%s]\n" % indent + return result + + + def ok_callstack_is_relevant(self, ok_callstack): + # determine whether an ok callstack is relevant for logging + if self.verbosity >= 2: + return True + + # empty callstacks are always relevant + if len(ok_callstack) == 0: + return True + + # check whether the ok_callstack is a subset or equal to a fail_callstack + for (align_before, field_name, type_obj, fail_callstack, reason) in self.fail_list: + if len(ok_callstack) <= len(fail_callstack): + zipped = zip(ok_callstack, fail_callstack[:len(ok_callstack)]) + is_subset = all([i == j for i, j in zipped]) + if is_subset: + return True + + return False + + + def ok(self, align_before, field_name, type_obj, callstack, align_after): + self.ok_list.append((align_before, field_name, type_obj, callstack, align_after)) + + def fail(self, align_before, field_name, type_obj, callstack, reason): + self.fail_list.append((align_before, field_name, type_obj, callstack, reason)) + + def append(self, other): + self.ok_list.extend(other.ok_list) + self.fail_list.extend(other.fail_list) + + def ok_count(self): + return len(self.ok_list) + + + diff --git a/proto/xcb-proto/xcbgen/expr.py b/proto/xcb-proto/xcbgen/expr.py index f9d5179f0..a716d3443 100644 --- a/proto/xcb-proto/xcbgen/expr.py +++ b/proto/xcb-proto/xcbgen/expr.py @@ -22,7 +22,19 @@ class Field(object): self.wire = wire self.auto = auto self.isfd = isfd + self.parent = None + def __str__(self): + field_string = "Field" + if self.field_name is None: + if self.field_type is not None: + field_string += " with type " + str(self.type) + else: + field_string += " \"" + self.field_name + "\"" + if self.parent is not None: + field_string += " in " + str(self.parent) + + return field_string class Expression(object): ''' @@ -52,6 +64,8 @@ class Expression(object): self.lhs = None self.rhs = None + self.contains_listelement_ref = False + if elt.tag == 'list': # List going into a request, which has no length field (inferred by server) self.lenfield_name = elt.get('name') + '_len' @@ -61,12 +75,9 @@ class Expression(object): # Standard list with a fieldref self.lenfield_name = elt.text - elif elt.tag == 'valueparam': - # Value-mask. The length bitmask is described by attributes. - self.lenfield_name = elt.get('value-mask-name') - self.lenfield_type = elt.get('value-mask-type') - self.lenwire = True - self.bitfield = True + elif elt.tag == 'paramref': + self.lenfield_name = elt.text + self.lenfield_type = elt.get('type') elif elt.tag == 'op': # Op field. Need to recurse. @@ -103,6 +114,17 @@ class Expression(object): elif elt.tag == 'sumof': self.op = 'sumof' self.lenfield_name = elt.get('ref') + subexpressions = list(elt) + if len(subexpressions) > 0: + # sumof with a nested expression which is to be evaluated + # for each list-element in the context of that list-element. + # sumof then returns the sum of the results of these evaluations + self.rhs = Expression(subexpressions[0], parent) + + elif elt.tag == 'listelement-ref': + # current list element inside iterating expressions such as sumof + self.op = 'listelement-ref' + self.contains_listelement_ref = True else: # Notreached @@ -111,6 +133,27 @@ class Expression(object): def fixed_size(self): return self.nmemb != None + def get_value(self): + return self.nmemb + + # if the value of the expression is a guaranteed multiple of a number + # return this number, else return 1 (which is trivially guaranteed for integers) + def get_multiple(self): + multiple = 1 + if self.op == '*': + if self.lhs.fixed_size(): + multiple *= self.lhs.get_value() + if self.rhs.fixed_size(): + multiple *= self.rhs.get_value() + + return multiple + + def recursive_resolve_tasks(self, module, parents): + for subexpr in (self.lhs, self.rhs): + if subexpr != None: + subexpr.recursive_resolve_tasks(module, parents) + self.contains_listelement_ref |= subexpr.contains_listelement_ref + def resolve(self, module, parents): if self.op == 'enumref': self.lenfield_type = module.get_type(self.lenfield_name[0]) @@ -120,11 +163,13 @@ class Expression(object): for p in reversed(parents): fields = dict([(f.field_name, f) for f in p.fields]) if self.lenfield_name in fields.keys(): - if p.is_bitcase: + if p.is_case_or_bitcase: # switch is the anchestor self.lenfield_parent = p.parents[-1] else: self.lenfield_parent = p self.lenfield_type = fields[self.lenfield_name].field_type break + + self.recursive_resolve_tasks(module, parents) diff --git a/proto/xcb-proto/xcbgen/xtypes.py b/proto/xcb-proto/xcbgen/xtypes.py index 3cd90320e..c3b57583d 100644 --- a/proto/xcb-proto/xcbgen/xtypes.py +++ b/proto/xcb-proto/xcbgen/xtypes.py @@ -2,8 +2,12 @@ This module contains the classes which represent XCB data types. ''' from xcbgen.expr import Field, Expression +from xcbgen.align import Alignment, AlignmentLog import __main__ +verbose_align_log = False +true_values = ['true', '1', 'yes'] + class Type(object): ''' Abstract base class for all XCB data types. @@ -33,7 +37,13 @@ class Type(object): self.is_union = False self.is_pad = False self.is_switch = False + self.is_case_or_bitcase = False self.is_bitcase = False + self.is_case = False + self.required_start_align = Alignment() + + # the biggest align value of an align-pad contained in this type + self.max_align_pad = 1 def resolve(self, module): ''' @@ -74,6 +84,7 @@ class Type(object): return complex_type.fields.append(new_field) + new_field.parent = complex_type def make_fd_of(self, module, complex_type, fd_name): ''' @@ -88,7 +99,91 @@ class Type(object): complex_type.fields.append(new_fd) -class SimpleType(Type): + + def get_total_size(self): + ''' + get the total size of this type if it is fixed-size, otherwise None + ''' + if self.fixed_size(): + if self.nmemb is None: + return self.size + else: + return self.size * self.nmemb + else: + return None + + def get_align_offset(self): + if self.required_start_align is None: + return 0 + else: + return self.required_start_align.offset + + def is_acceptable_start_align(self, start_align, callstack, log): + return self.get_alignment_after(start_align, callstack, log) is not None + + def get_alignment_after(self, start_align, callstack, log): + ''' + get the alignment after this type based on the given start_align. + the start_align is checked for compatibility with the + internal start align. If it is not compatible, then None is returned + ''' + if self.required_start_align is None or self.required_start_align.is_guaranteed_at(start_align): + return self.unchecked_get_alignment_after(start_align, callstack, log) + else: + if log is not None: + log.fail(start_align, "", self, callstack + [self], + "start_align is incompatible with required_start_align %s" + % (str(self.required_start_align))) + return None + + def unchecked_get_alignment_after(self, start_align, callstack, log): + ''' + Abstract method for geting the alignment after this type + when the alignment at the start is given, and when this type + has variable size. + ''' + raise Exception('abstract unchecked_get_alignment_after method not overridden!') + + + @staticmethod + def type_name_to_str(type_name): + if isinstance(type_name, str): + #already a string + return type_name + else: + return ".".join(type_name) + + + def __str__(self): + return type(self).__name__ + " \"" + Type.type_name_to_str(self.name) + "\"" + +class PrimitiveType(Type): + + def __init__(self, name, size): + Type.__init__(self, name) + self.size = size + self.nmemb = 1 + + # compute the required start_alignment based on the size of the type + self.required_start_align = Alignment.for_primitive_type(self.size) + + def unchecked_get_alignment_after(self, start_align, callstack, log): + my_callstack = callstack + [self]; + after_align = start_align.align_after_fixed_size(self.size) + + if log is not None: + if after_align is None: + log.fail(start_align, "", self, my_callstack, + "align after fixed size %d failed" % self.size) + else: + log.ok(start_align, "", self, my_callstack, after_align) + + return after_align + + def fixed_size(self): + return True + +class SimpleType(PrimitiveType): ''' Derived class which represents a cardinal type like CARD32 or char. Any type which is typedef'ed to cardinal will be one of these. @@ -97,17 +192,13 @@ class SimpleType(Type): none ''' def __init__(self, name, size): - Type.__init__(self, name) + PrimitiveType.__init__(self, name, size) self.is_simple = True - self.size = size - self.nmemb = 1 + def resolve(self, module): self.resolved = True - def fixed_size(self): - return True - out = __main__.output['simple'] @@ -178,16 +269,23 @@ class ListType(Type): self.is_list = True self.member = member self.parents = list(parent) + lenfield_name = False if elt.tag == 'list': elts = list(elt) self.expr = Expression(elts[0] if len(elts) else elt, self) - elif elt.tag == 'valueparam': - self.expr = Expression(elt, self) + is_list_in_parent = self.parents[0].elt.tag in ('request', 'event', 'reply', 'error') + if not len(elts) and is_list_in_parent: + self.expr = Expression(elt,self) + self.expr.op = 'calculate_len' + else: + self.expr = Expression(elts[0] if len(elts) else elt, self) self.size = member.size if member.fixed_size() else None self.nmemb = self.expr.nmemb if self.expr.fixed_size() else None + self.required_start_align = self.member.required_start_align + def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto, enum=None): if not self.fixed_size(): # We need a length field. @@ -218,6 +316,8 @@ class ListType(Type): self.member.resolve(module) self.expr.resolve(module, self.parents) + self.required_start_align = self.member.required_start_align + # Find my length field again. We need the actual Field object in the expr. # This is needed because we might have added it ourself above. if not self.fixed_size(): @@ -232,7 +332,70 @@ class ListType(Type): def fixed_size(self): return self.member.fixed_size() and self.expr.fixed_size() -class ExprType(Type): + def unchecked_get_alignment_after(self, start_align, callstack, log): + my_callstack = callstack[:] + my_callstack.append(self) + if start_align is None: + log.fail(start_align, "", self, my_callstack, "start_align is None") + return None + if self.expr.fixed_size(): + # fixed number of elements + num_elements = self.nmemb + prev_alignment = None + alignment = start_align + while num_elements > 0: + if alignment is None: + if log is not None: + log.fail(start_align, "", self, my_callstack, + ("fixed size list with size %d after %d iterations" + + ", at transition from alignment \"%s\"") + % (self.nmemb, + (self.nmemb - num_elements), + str(prev_alignment))) + return None + prev_alignment = alignment + alignment = self.member.get_alignment_after(prev_alignment, my_callstack, log) + num_elements -= 1 + if log is not None: + log.ok(start_align, "", self, my_callstack, alignment) + return alignment + else: + # variable number of elements + # check whether the number of elements is a multiple + multiple = self.expr.get_multiple() + assert multiple > 0 + + # iterate until the combined alignment does not change anymore + alignment = start_align + while True: + prev_multiple_alignment = alignment + # apply "multiple" amount of changes sequentially + prev_alignment = alignment + for multiple_count in range(0, multiple): + + after_alignment = self.member.get_alignment_after(prev_alignment, my_callstack, log) + if after_alignment is None: + if log is not None: + log.fail(start_align, "", self, my_callstack, + ("variable size list " + + "at transition from alignment \"%s\"") + % (str(prev_alignment))) + return None + + prev_alignment = after_alignment + + # combine with the cumulatively combined alignment + # (to model the variable number of entries) + alignment = prev_multiple_alignment.combine_with(after_alignment) + + if alignment == prev_multiple_alignment: + # does not change anymore by adding more potential elements + # -> finished + if log is not None: + log.ok(start_align, "", self, my_callstack, alignment) + return alignment + +class ExprType(PrimitiveType): ''' Derived class which represents an exprfield. Fixed size. @@ -240,24 +403,19 @@ class ExprType(Type): expr is an Expression object containing the value of the field. ''' def __init__(self, elt, member, *parents): - Type.__init__(self, member.name) + PrimitiveType.__init__(self, member.name, member.size) self.is_expr = True self.member = member self.parents = parents self.expr = Expression(list(elt)[0], self) - self.size = member.size - self.nmemb = 1 - def resolve(self, module): if self.resolved: return self.member.resolve(module) self.resolved = True - def fixed_size(self): - return True class PadType(Type): ''' @@ -272,6 +430,10 @@ class PadType(Type): if elt != None: self.nmemb = int(elt.get('bytes', "1"), 0) self.align = int(elt.get('align', "1"), 0) + self.serialize = elt.get('serialize', "false").lower() in true_values + + # pads don't require any alignment at their start + self.required_start_align = Alignment(1,0) def resolve(self, module): self.resolved = True @@ -279,6 +441,38 @@ class PadType(Type): def fixed_size(self): return self.align <= 1 + def unchecked_get_alignment_after(self, start_align, callstack, log): + if self.align <= 1: + # fixed size pad + after_align = start_align.align_after_fixed_size(self.get_total_size()) + if log is not None: + if after_align is None: + log.fail(start_align, "", self, callstack, + "align after fixed size pad of size %d failed" % self.size) + else: + log.ok(start_align, "", self, callstack, after_align) + + return after_align + + # align-pad + assert self.align > 1 + assert self.size == 1 + assert self.nmemb == 1 + if (start_align.offset == 0 + and self.align <= start_align.align + and start_align.align % self.align == 0): + # the alignment pad is size 0 because the start_align + # is already sufficiently aligned -> return the start_align + after_align = start_align + else: + # the alignment pad has nonzero size -> return the alignment + # that is guaranteed by it, independently of the start_align + after_align = Alignment(self.align, 0) + + if log is not None: + log.ok(start_align, "", self, callstack, after_align) + + return after_align class ComplexType(Type): ''' @@ -297,6 +491,18 @@ class ComplexType(Type): self.lenfield_parent = [self] self.fds = [] + # get required_start_alignment + required_start_align_element = elt.find("required_start_align") + if required_start_align_element is None: + # unknown -> mark for autocompute + self.required_start_align = None + else: + self.required_start_align = Alignment( + int(required_start_align_element.get('align', "4"), 0), + int(required_start_align_element.get('offset', "0"), 0)) + if verbose_align_log: + print "Explicit start-align for %s: %s\n" % (self, self.required_start_align) + def resolve(self, module): if self.resolved: return @@ -326,11 +532,6 @@ class ComplexType(Type): fkey = child.get('type') type = ListType(child, module.get_type(fkey), *self.lenfield_parent) visible = True - elif child.tag == 'valueparam': - field_name = child.get('value-list-name') - fkey = 'CARD32' - type = ListType(child, module.get_type(fkey), *self.lenfield_parent) - visible = True elif child.tag == 'switch': field_name = child.get('name') # construct the switch type name from the parent type and the field name @@ -356,7 +557,15 @@ class ComplexType(Type): # Recursively resolve the type (could be another structure, list) type.resolve(module) + # Compute the size of the maximally contain align-pad + if type.max_align_pad > self.max_align_pad: + self.max_align_pad = type.max_align_pad + + self.check_implicit_fixed_size_part_aligns(); + self.calc_size() # Figure out how big we are + self.calc_or_check_required_start_align() + self.resolved = True def calc_size(self): @@ -365,17 +574,155 @@ class ComplexType(Type): if not m.wire: continue if m.type.fixed_size(): - self.size = self.size + (m.type.size * m.type.nmemb) + self.size = self.size + m.type.get_total_size() else: self.size = None break + def calc_or_check_required_start_align(self): + if self.required_start_align is None: + # no required-start-align configured -> calculate it + log = AlignmentLog() + callstack = [] + self.required_start_align = self.calc_minimally_required_start_align(callstack, log) + if self.required_start_align is None: + print ("ERROR: could not calc required_start_align of %s\nDetails:\n%s" + % (str(self), str(log))) + else: + if verbose_align_log: + print ("calc_required_start_align: %s has start-align %s" + % (str(self), str(self.required_start_align))) + print "Details:\n" + str(log) + if self.required_start_align.offset != 0: + print (("WARNING: %s\n\thas start-align with non-zero offset: %s" + + "\n\tsuggest to add explicit definition with:" + + "\n\t\t" + + "\n\tor to fix the xml so that zero offset is ok\n") + % (str(self), self.required_start_align, + self.required_start_align.align, + self.required_start_align.offset)) + else: + # required-start-align configured -> check it + log = AlignmentLog() + callstack = [] + if not self.is_possible_start_align(self.required_start_align, callstack, log): + print ("ERROR: required_start_align %s of %s causes problems\nDetails:\n%s" + % (str(self.required_start_align), str(self), str(log))) + + + def calc_minimally_required_start_align(self, callstack, log): + # calculate the minimally required start_align that causes no + # align errors + best_log = None + best_failed_align = None + for align in [1,2,4,8]: + for offset in range(0,align): + align_candidate = Alignment(align, offset) + if verbose_align_log: + print "trying %s for %s" % (str(align_candidate), str(self)) + my_log = AlignmentLog() + if self.is_possible_start_align(align_candidate, callstack, my_log): + log.append(my_log) + if verbose_align_log: + print "found start-align %s for %s" % (str(align_candidate), str(self)) + return align_candidate + else: + my_ok_count = my_log.ok_count() + if (best_log is None + or my_ok_count > best_log.ok_count() + or (my_ok_count == best_log.ok_count() + and align_candidate.align > best_failed_align.align) + and align_candidate.align != 8): + best_log = my_log + best_failed_align = align_candidate + + + + # none of the candidates applies + # this type has illegal internal aligns for all possible start_aligns + if verbose_align_log: + print "didn't find start-align for %s" % str(self) + log.append(best_log) + return None + + def is_possible_start_align(self, align, callstack, log): + if align is None: + return False + if (self.max_align_pad > align.align + or align.align % self.max_align_pad != 0): + # our align pad implementation depends on known alignment + # at the start of our type + return False + + return self.get_alignment_after(align, callstack, log) is not None + def fixed_size(self): for m in self.fields: if not m.type.fixed_size(): return False return True + + # default impls of polymorphic methods which assume sequential layout of fields + # (like Struct or CaseOrBitcaseType) + def check_implicit_fixed_size_part_aligns(self): + # find places where the implementation of the C-binding would + # create code that makes the compiler add implicit alignment. + # make these places explicit, so we have + # consistent behaviour for all bindings + size = 0 + for field in self.fields: + if not field.wire: + continue + if not field.type.fixed_size(): + # end of fixed-size part + break + required_field_align = field.type.required_start_align + if required_field_align is None: + raise Exception( + "field \"%s\" in \"%s\" has not required_start_align" + % (field.field_name, self.name) + ) + mis_align = (size + required_field_align.offset) % required_field_align.align + if mis_align != 0: + # implicit align pad is required + padsize = required_field_align.align - mis_align + raise Exception( + "C-compiler would insert implicit alignpad of size %d before field \"%s\" in \"%s\"" + % (padsize, field.field_name, self.name) + ) + + def unchecked_get_alignment_after(self, start_align, callstack, log): + # default impl assumes sequential layout of fields + # (like Struct or CaseOrBitcaseType) + my_align = start_align + if my_align is None: + return None + + for field in self.fields: + if not field.wire: + continue + my_callstack = callstack[:] + my_callstack.extend([self, field]) + + prev_align = my_align + my_align = field.type.get_alignment_after(my_align, my_callstack, log) + if my_align is None: + if log is not None: + log.fail(prev_align, field.field_name, self, my_callstack, + "alignment is incompatible with this field") + return None + else: + if log is not None: + log.ok(prev_align, field.field_name, self, my_callstack, my_align) + + if log is not None: + my_callstack = callstack[:] + my_callstack.append(self) + log.ok(start_align, "", self, my_callstack, my_align) + return my_align + + class SwitchType(ComplexType): ''' Derived class which represents a List of Items. @@ -405,16 +752,20 @@ class SwitchType(ComplexType): # Resolve all of our field datatypes. for index, child in enumerate(list(self.elt)): - if child.tag == 'bitcase': + if child.tag == 'bitcase' or child.tag == 'case': field_name = child.get('name') if field_name is None: - field_type = self.name + ('bitcase%d' % index,) + field_type = self.name + ('%s%d' % ( child.tag, index ),) else: field_type = self.name + (field_name,) # use self.parent to indicate anchestor, # as switch does not contain named fields itself - type = BitcaseType(index, field_type, child, *parents) + if child.tag == 'bitcase': + type = BitcaseType(index, field_type, child, *parents) + else: + type = CaseType(index, field_type, child, *parents) + # construct the switch type name from the parent type and the field name if field_name is None: type.has_name = False @@ -439,6 +790,7 @@ class SwitchType(ComplexType): self.fields.append(new_field) self.calc_size() # Figure out how big we are + self.calc_or_check_required_start_align() self.resolved = True def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto, enum=None): @@ -479,6 +831,123 @@ class SwitchType(ComplexType): # return True + + def check_implicit_fixed_size_part_aligns(self): + # this is done for the CaseType or BitCaseType + return + + def unchecked_get_alignment_after(self, start_align, callstack, log): + # we assume that BitCases can appear in any combination, + # and that at most one Case can appear + # (assuming that Cases are mutually exclusive) + + # get all Cases (we assume that at least one case is selected if there are cases) + case_fields = [] + for field in self.bitcases: + if field.type.is_case: + case_fields.append(field) + + if not case_fields: + # there are no case-fields -> check without case-fields + case_fields = [None] + + my_callstack = callstack[:] + my_callstack.append(self) + # + total_align = None + first = True + for case_field in case_fields: + my2_callstack = my_callstack[:] + if case_field is not None: + my2_callstack.append(case_field) + + case_align = self.get_align_for_selected_case_field( + case_field, start_align, my2_callstack, log) + + + if case_align is None: + if log is not None: + if case_field is None: + log.fail(start_align, "", self, my2_callstack, + "alignment without cases (only bitcases) failed") + else: + log.fail(start_align, "", self, my2_callstack + [case_field], + "alignment for selected case %s failed" + % case_field.field_name) + return None + if first: + total_align = case_align + else: + total_align = total_align.combine_with(case_align) + + if log is not None: + if case_field is None: + log.ok( + start_align, + "without cases (only arbitrary bitcases)", + self, my2_callstack, case_align) + else: + log.ok( + start_align, + "case %s and arbitrary bitcases" % case_field.field_name, + self, my2_callstack, case_align) + + + if log is not None: + log.ok(start_align, "", self, my_callstack, total_align) + return total_align + + # aux function for unchecked_get_alignment_after + def get_align_for_selected_case_field(self, case_field, start_align, callstack, log): + if verbose_align_log: + print "get_align_for_selected_case_field: %s, case_field = %s" % (str(self), str(case_field)) + total_align = start_align + for field in self.bitcases: + my_callstack = callstack[:] + my_callstack.append(field) + + if not field.wire: + continue + if field is case_field: + # assume that this field is active -> no combine_with to emulate optional + after_field_align = field.type.get_alignment_after(total_align, my_callstack, log) + + if log is not None: + if after_field_align is None: + log.fail(total_align, field.field_name, field.type, my_callstack, + "invalid aligment for this case branch") + else: + log.ok(total_align, field.field_name, field.type, my_callstack, + after_field_align) + + total_align = after_field_align + elif field.type.is_bitcase: + after_field_align = field.type.get_alignment_after(total_align, my_callstack, log) + # we assume that this field is optional, therefore combine + # alignment after the field with the alignment before the field. + if after_field_align is None: + if log is not None: + log.fail(total_align, field.field_name, field.type, my_callstack, + "invalid aligment for this bitcase branch") + total_align = None + else: + if log is not None: + log.ok(total_align, field.field_name, field.type, my_callstack, + after_field_align) + + # combine with the align before the field because + # the field is optional + total_align = total_align.combine_with(after_field_align) + else: + # ignore other fields as they are irrelevant for alignment + continue + + if total_align is None: + break + + return total_align + + class Struct(ComplexType): ''' Derived class representing a struct data type. @@ -497,25 +966,83 @@ class Union(ComplexType): out = __main__.output['union'] -class BitcaseType(ComplexType): + def calc_size(self): + self.size = 0 + for m in self.fields: + if not m.wire: + continue + if m.type.fixed_size(): + self.size = max(self.size, m.type.get_total_size()) + else: + self.size = None + break + + + def check_implicit_fixed_size_part_aligns(self): + # a union does not have implicit aligns because all fields start + # at the start of the union + return + + + def unchecked_get_alignment_after(self, start_align, callstack, log): + my_callstack = callstack[:] + my_callstack.append(self) + + after_align = None + if self.fixed_size(): + + #check proper alignment for all members + start_align_ok = all( + [field.type.is_acceptable_start_align(start_align, my_callstack + [field], log) + for field in self.fields]) + + if start_align_ok: + #compute the after align from the start_align + after_align = start_align.align_after_fixed_size(self.get_total_size()) + else: + after_align = None + + if log is not None and after_align is not None: + log.ok(start_align, "fixed sized union", self, my_callstack, after_align) + + else: + if start_align is None: + if log is not None: + log.fail(start_align, "", self, my_callstack, + "missing start_align for union") + return None + + after_align = reduce( + lambda x, y: None if x is None or y is None else x.combine_with(y), + [field.type.get_alignment_after(start_align, my_callstack + [field], log) + for field in self.fields]) + + if log is not None and after_align is not None: + log.ok(start_align, "var sized union", self, my_callstack, after_align) + + + if after_align is None and log is not None: + log.fail(start_align, "", self, my_callstack, "start_align is not ok for all members") + + return after_align + +class CaseOrBitcaseType(ComplexType): ''' - Derived class representing a struct data type. + Derived class representing a case or bitcase. ''' def __init__(self, index, name, elt, *parent): elts = list(elt) self.expr = [] - fields = [] - for elt in elts: - if elt.tag == 'enumref': - self.expr.append(Expression(elt, self)) - else: - fields.append(elt) - ComplexType.__init__(self, name, fields) + for sub_elt in elts: + if sub_elt.tag == 'enumref': + self.expr.append(Expression(sub_elt, self)) + elt.remove(sub_elt) + ComplexType.__init__(self, name, elt) self.has_name = True self.index = 1 self.lenfield_parent = list(parent) + [self] self.parents = list(parent) - self.is_bitcase = True + self.is_case_or_bitcase = True def make_member_of(self, module, switch_type, field_type, field_name, visible, wire, auto, enum=None): ''' @@ -545,6 +1072,26 @@ class BitcaseType(ComplexType): # Resolve the bitcase expression ComplexType.resolve(self, module) + #calculate alignment + self.calc_or_check_required_start_align() + + +class BitcaseType(CaseOrBitcaseType): + ''' + Derived class representing a bitcase. + ''' + def __init__(self, index, name, elt, *parent): + CaseOrBitcaseType.__init__(self, index, name, elt, *parent) + self.is_bitcase = True + +class CaseType(CaseOrBitcaseType): + ''' + Derived class representing a case. + ''' + def __init__(self, index, name, elt, *parent): + CaseOrBitcaseType.__init__(self, index, name, elt, *parent) + self.is_case = True + class Reply(ComplexType): ''' @@ -554,6 +1101,8 @@ class Reply(ComplexType): ComplexType.__init__(self, name, elt) self.is_reply = True self.doc = None + if self.required_start_align is None: + self.required_start_align = Alignment(4,0) for child in list(elt): if child.tag == 'doc': @@ -585,6 +1134,8 @@ class Request(ComplexType): self.reply = None self.doc = None self.opcode = elt.get('opcode') + if self.required_start_align is None: + self.required_start_align = Alignment(4,0) for child in list(elt): if child.tag == 'reply': @@ -622,6 +1173,10 @@ class Event(ComplexType): ''' def __init__(self, name, elt): ComplexType.__init__(self, name, elt) + + if self.required_start_align is None: + self.required_start_align = Alignment(4,0) + self.opcodes = {} self.has_seq = not bool(elt.get('no-sequence-number')) @@ -676,6 +1231,8 @@ class Error(ComplexType): def __init__(self, name, elt): ComplexType.__init__(self, name, elt) self.opcodes = {} + if self.required_start_align is None: + self.required_start_align = Alignment(4,0) def add_opcode(self, opcode, name, main): self.opcodes[name] = opcode