From 47ceed78612d48dcda62cc2686fc527d61abe38b Mon Sep 17 00:00:00 2001 From: Josh Triplett Date: Sat, 18 Feb 2006 16:49:41 -0800 Subject: [PATCH 1/1] Remove xcl and CVSROOT. --- .cvsignore | 17 + COPYING | 30 + ChangeLog | 610 ++++++ INSTALL | 229 +++ Makefile.am | 6 + autogen.sh | 3 + configure.ac | 84 + debian/.cvsignore | 6 + debian/changelog | 41 + debian/control | 56 + debian/copyright.debian | 12 + debian/libxcb0-dev.dirs | 2 + debian/libxcb0-dev.install | 5 + debian/libxcb0.dirs | 1 + debian/libxcb0.install | 1 + debian/rules | 22 + doc/tutorial/index.html | 3772 ++++++++++++++++++++++++++++++++++++ doc/tutorial/xcb.css | 82 + src/.cvsignore | 17 + src/Makefile.am | 83 + src/c-client.xsl | 1301 +++++++++++++ src/xcb.h | 165 ++ src/xcb_auth.c | 296 +++ src/xcb_conn.c | 239 +++ src/xcb_ext.c | 122 ++ src/xcb_in.c | 319 +++ src/xcb_list.c | 215 ++ src/xcb_out.c | 272 +++ src/xcb_util.c | 279 +++ src/xcb_xid.c | 70 + src/xcb_xlib.c | 41 + src/xcbext.h | 75 + src/xcbint.h | 183 ++ src/xcbxlib.h | 38 + tests/.cvsignore | 2 + tests/CheckLog.xsl | 104 + tests/Makefile.am | 32 + tests/check_all.c | 20 + tests/check_public.c | 129 ++ tests/check_suites.h | 4 + xcb.pc.in | 10 + 41 files changed, 8995 insertions(+) create mode 100644 .cvsignore create mode 100644 COPYING create mode 100644 ChangeLog create mode 100644 INSTALL create mode 100644 Makefile.am create mode 100755 autogen.sh create mode 100644 configure.ac create mode 100644 debian/.cvsignore create mode 100644 debian/changelog create mode 100644 debian/control create mode 100644 debian/copyright.debian create mode 100644 debian/libxcb0-dev.dirs create mode 100644 debian/libxcb0-dev.install create mode 100644 debian/libxcb0.dirs create mode 100644 debian/libxcb0.install create mode 100755 debian/rules create mode 100755 doc/tutorial/index.html create mode 100755 doc/tutorial/xcb.css create mode 100644 src/.cvsignore create mode 100644 src/Makefile.am create mode 100644 src/c-client.xsl create mode 100644 src/xcb.h create mode 100644 src/xcb_auth.c create mode 100644 src/xcb_conn.c create mode 100644 src/xcb_ext.c create mode 100644 src/xcb_in.c create mode 100644 src/xcb_list.c create mode 100644 src/xcb_out.c create mode 100644 src/xcb_util.c create mode 100644 src/xcb_xid.c create mode 100644 src/xcb_xlib.c create mode 100644 src/xcbext.h create mode 100644 src/xcbint.h create mode 100644 src/xcbxlib.h create mode 100644 tests/.cvsignore create mode 100644 tests/CheckLog.xsl create mode 100644 tests/Makefile.am create mode 100644 tests/check_all.c create mode 100644 tests/check_public.c create mode 100644 tests/check_suites.h create mode 100644 xcb.pc.in diff --git a/.cvsignore b/.cvsignore new file mode 100644 index 0000000..3d5e104 --- /dev/null +++ b/.cvsignore @@ -0,0 +1,17 @@ +Makefile +Makefile.in +aclocal.m4 +autom4te.cache +compile +config.guess +config.log +config.status +config.sub +configure +depcomp +install-sh +libtool +ltmain.sh +missing +mkinstalldirs +*.pc diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..8c328d3 --- /dev/null +++ b/COPYING @@ -0,0 +1,30 @@ +Copyright (C) 2001-2004 Bart Massey, Jamey Sharp, and Josh Triplett. +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall +be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS +BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the names of the authors +or their institutions shall not be used in advertising or +otherwise to promote the sale, use or other dealings in this +Software without prior written authorization from the +authors. diff --git a/ChangeLog b/ChangeLog new file mode 100644 index 0000000..7ba7263 --- /dev/null +++ b/ChangeLog @@ -0,0 +1,610 @@ +2005-12-28 Jamey Sharp + + * configure.ac: + Replace obsolete AC_OUTPUT(...) call with AC_CONFIG_FILES(...) + and the no-argument AC_OUTPUT macro. + +2005-12-24 Jamey Sharp + + * src/xcb_xlib.c, src/xcbxlib.h, src/Makefile.am: + New header and two functions specifically for Xlib's use, so + we can quit installing xcbint.h. + + * src/xcb_out.c, src/xcbint.h: + Now that Xlib uses entirely public API, force_sequence_wrap is + purely internal to xcb_out. + +2005-12-20 Jamey Sharp + + * src/xcb_util.c: + Use AF_UNIX instead of PF_UNIX, because they're interchangeable + on Linux (and 4.x BSD?) but on MacOS X the latter is not + available. Thanks to Ian Osgood for testing. + +2005-12-12 Jamey Sharp + + * src/xcb_util.c: + Rewrite XCBParseDisplay to handle all error cases correctly. + Thanks to Travis Spencer for pointing out a problem with + the previous sscanf call; turns out that sscanf won't do what + I want anyway, so this version just uses strtoul. + +2005-12-12 Jamey Sharp + + * tests/check_public.c: + Fix segfault in fail_unless calls and provide more useful error + messages. Also remove DISPLAY from the environment and test + ParseDisplay on a null pointer. + +2005-12-07 Jamey Sharp + + * src/xcb.h, src/xcb_in.c: + Use GCC attribute extension, if available, to mark some + functions deprecated; and rename XCBWaitEvent to + XCBWaitForEvent, with a deprecated backwards compatibility + function. + +2005-12-07 Jamey Sharp + + * src/xcb.h, src/xcb_conn.c, src/xcb_util.c: + Rename XCBConnect to XCBConnectToFD, and implement XCBConnect + and XCBConnectToDisplayWithAuthInfo, as specified by the XcbApi + documentation. Provide a trivial implementation of deprecated + XCBConnectBasic for backwards compatibility. Fix XCBParseDisplay + to accept a null screen pointer. + +2005-09-30 Trevor Woerner + + reviewer: Jamey Sharp + + * Makefile.am, configure.ac, src/Makefile.am, tests/Makefile.am, + src/check_all.c, src/check_public.c, src/check_suites.h: + Created a new directory called "tests" where the unit tests + will reside, separate from other files. Moved the unit + test files from the "src" directory into the new "tests" + directory. + + * configure.ac, tests/CheckLog.xsl, tests/.cvsignore, + tests/Makefile.am, tests/check_all.c: + Added an XSLT transform to post-process the XML log file which + is generated by the unit test suite into an HTML page. Added + the necessary hooks into the build system to have this + translation occur when necessary as part of the build process. + +2005-08-15 Trevor Woerner + + reviewer: Jamey Sharp + + * src/Makefile.am: + Make builds work when the source and build directories + are different. + +2005-08-03 Trevor Woerner + + reviewer: Jamey Sharp + + * configure.ac: + Allow people to not have check as long as they have at + least automake version 1.9. Older versions of automake + still work as long as check is installed or the NoCheck + instructions are followed. + +2005-07-21 Jamey Sharp + + * src/xcb_conn.c: + Fix one uninitialized memory warning from Valgrind. + More will have to wait. + +2005-07-21 Jamey Sharp + + * src/xcb_ext.c: + Fix memory leak reported by Carl Worth (thanks Carl!). + +2005-05-22 Josh Triplett + + * src/c-client.xsl: + Permit unions to have fixed-length list fields. + +2005-05-21 Josh Triplett + + * src/c-client.xsl: + In function parameters and structure fields, line up field names in + the same starting column. + +2005-05-17 Josh Triplett + + * src/c-client.xsl: + Make header files self-sufficient, by including xcb.h in the + generated headers rather than the generated sources. + + * src/xcbext.h: + Make xcbext.h self-sufficient, by including xcb.h. + +2005-05-17 Josh Triplett + + * src/c-client.xsl: + Line up function parameters with opening parenthesis. + +2005-05-17 Jamey Sharp + + * src/c-client.xsl: + Improve whitespace output on function declarations. + +2005-04-23 Jeremy Kolb + * src/c-client.xsl: + Added list support for typedefs. + GLX now compiles. + +2005-04-23 Josh Triplett + + * src/c-client.xsl: + Allow protocol descriptions to explicitly qualify types with a + namespace, which should be the value of the header attribute from + the protocol description containing the desired type. + +2005-04-10 Jamey Sharp + + * src/xcb.h, src/xcb_in.c: + New public function XCBGetRequestRead: returns the last sequence + number that the server is known to have processed. This function + enables apps to determine whether forcing a cookie is going to + block. + +2005-04-09 Jamey Sharp + + * src/xcb_ext.c: + Implement XCBPrefetchExtensionData. An extension can now be in + one of three states in a particular connection's cache: not + queried; query cookie available; and query reply available. + +2005-04-09 Jamey Sharp + + * src/xcb_ext.c, src/xcbint.h: + Assign a display-independent unique integer to each XCBExtension + structure. Use a map instead of a list for the extension cache. + Key the map on the assigned integer. + +2005-04-06 Jeremy Kolb + + * src/c-client.xsl: + Added support for c types float and double. + Needed for GLX extension. + +2005-04-02 Jamey Sharp + + * src/c-client.xsl: + Workaround for XSLT processors that can't understand attribute + values of the form '{{ "{...}" }}'. (What? That looks completely + clear to me. *grin*) + +2005-04-01 Jamey Sharp + + * src/xcb_list.c: + Make the _destroy operations no-op on null pointers. + +2005-03-31 Jamey Sharp + + * src/xcb.h, src/xcb_conn.c, src/xcb_out.c, src/xcbint.h: + Lazily check for BIG-REQUESTS support. The first call to + XCBGetMaximumRequestLength takes the two-round-trip penalty for + discovering BIG-REQUESTS support, and caches the result for + subsequent calls. Also XCBSendRequest is now careful to only ask + for the true maximum request length if the length from the + connection setup data isn't sufficient for the current request. + +2005-03-31 Jamey Sharp + + * src/xcb_in.c: + Fix X error handling to, uh, not hang. + +2005-03-30 Jamey Sharp + + * src/xcb_in.c, src/xcbint.h: + Accept zero or more replies to any request. Eliminates, for the + moment, nearly all run-time error checking regarding the number + of replies expected for a particular request. Also breaks the + unexpected reply callback, which is OK because I was going to + remove it anyway, and now I've done so. + +2005-03-30 Jamey Sharp + + * src/xcb_list.c, src/xcbint.h: + Add a map ADT implemented using the list ADT. + +2005-03-28 Vincent Torri + + * doc/tutorial/index.html, doc/tutorial/xcb.css: + Add a tutorial + +2005-03-27 Jeremy Kolb + + * src/Makefile.am: + Added xf86dri (xcb-proto/src/extensions/xf86dri.h). + Removed compilation of record as it's broken. + +2005-03-25 Jamey Sharp + + * src/xcb_in.c: + Instead of storing a pending flag per reply record, look in the + readers list to find out whether there's a reader waiting for + the reply we've just been asked to wait for. + +2005-03-25 Jamey Sharp + + * src/xcb_list.c, src/xcbint.h: + Add _xcb_queue_is_empty. + +2005-03-25 Jamey Sharp + + * src/xcb_in.c, src/xcb_list.c, src/xcbint.h: + Add a queue ADT. Currently implemented using the list ADT, but + analysis will probably suggest a better data structure. The + split is intended to help that analysis. + +2005-03-25 Jamey Sharp + + * src/xcb_in.c, src/xcb_list.c, src/xcbint.h: + Remove _xcb_list_length. (Two callers in xcb_in didn't actually + care about the returned value beyond "empty" or "non-empty", + which they can get other ways.) _xcb_in_events_length became + obsolete in the process, and I took _xcb_list_clear out of + xcbint.h while I was at it because only _xcb_list_delete calls + it these days. + +2005-03-25 Jamey Sharp + + * src/xcb.h, src/xcb_in.c: + Remove XCBEventQueueLength and XCBEventQueueClear: they're not + part of the new API, and they interfere with analysis of the + _xcb_list implementation. + +2005-03-24 Josh Triplett + + * configure.ac: + Change pdx.freedesktop.org to lists.freedesktop.org in package + email address. + +2005-03-23 Jamey Sharp + + * src/xcb_conn.c, src/xcb_in.c: + avn@daemon.hole.ru pointed out two memory leaks in XCB, which + this update fixes. I also introduced a third a couple of days + ago, which this fixes as well. + +2005-03-23 Jamey Sharp + + * src/xcb_in.c: + Quit storing an "error" flag: it's redundant with the contents + of the packet that it was stored with. + +2005-03-22 Jamey Sharp + + * src/xcb_in.c, src/xcbint.h: + My recent Xlib patch stressed XCB's pending reply queue in ways + it has never been stressed before, with thousands of entries. + Profiling revealed that wake_up_next_reader was taking most of + the cycles of my test app with its linear search of the reply + queue. So I gave it its own 'readers' queue, which can have at + most one entry per thread, and which can be no more than the + number of pending replies. In the current implementation the + readers queue uses only constant-time operations, too. + +2005-03-20 Jamey Sharp + + * src/xcb_in.c: + Wait for the last known read sequence number to pass the request + we're waiting for, instead of checking whether data has arrived + for the current request. Causes null to be returned if somebody + screwed up by expecting a reply when none can come; relied on by + new Xlib/XCB bits that intentionally and routinely screw up this + way because the API doesn't give them enough information. + + * src/xcb_list.c, src/xcbint.h: + Add _xcb_list_peek_head so Xlib doesn't have to repeatedly + remove and re-insert the item at the head of its new + pending_requests queue. Profiling showed that was a significant + performance hit for the above-mentioned patch and with this + three-line function apps are actually usable again. + +2004-11-26 Josh Triplett + + * src/c-client.xsl: + In do-request processing, use the existing num-parts variable + rather than recalculating the same expression. + +2004-11-26 Josh Triplett + + * src/c-client.xsl: + * Add a list of known core types, and don't search all the + protocol descriptions for types in that list. This + significantly shortens the processing time. + * Search for all definitions of a non-core type, not just the + first, in order to check for duplicate definitions. + * Add an error message for non-core types with no definitions + found. + +2004-11-10 Josh Triplett + + * src/c-client.xsl: + Don't create a separate local variable for exprfields, and change + an explicit xsl:for-each to an xsl:apply-templates. + +2004-11-10 Josh Triplett + + * src/c-client.xsl: + Prefix variables in request functions with "xcb_" to avoid + collisions with field names. + +2004-11-09 Josh Triplett + + * src/c-client.xsl: + * src/xcb_out.c: + * src/xcbext.h: + More API changes: Put constant request-specific data into a static + const structure in each request function. + +2004-11-09 Josh Triplett + + * src/c-client.xsl: + Add support for an tag in a function body, which indents + the s it contains. + + * debian/.cvsignore: + debian/copyright is a generated file, so add it to + debian/.cvsignore + +2004-11-08 Jamey Sharp + + * src/xcb_conn.c: + Make the __thread-based assertion a compile-time + option, defaulting to off. It breaks on many systems + and isn't critical to XCB's functionality. + +2004-11-07 Josh Triplett + + * c-client.xsl: + Update XSLT to deal with change from extension element to + extension-name and extension-xname attributes on xcb element. + +2004-11-06 Josh Triplett + + * xcb.h: + * xcb_auth.c: + * xcb_conn.c: + * xcb_ext.c: + * xcb_in.c: + * xcb_list.c: + * xcb_out.c: + * xcb_util.c: + * xcb_xid.c: + * xcbext.h: + * xcbint.h: + Include license in every file rather than referencing COPYING. + Update copyright notices to 2004. + + * COPYING: + Remove non-applicable licenses from COPYING file. + +2004-11-06 Josh Triplett + + * configure.ac: + * src/.cvsignore: + * src/Makefile.am: + * src/xcb.h: + Merged changes for XML-XCB project. + + * src/c-client.xsl: + * src/xcb.h: + Add XSLT binding generator and non-M4 version of xcb.h. + + * src/client-c.xcb: + * src/xcb.h.m4: + Remove M4 binding generator and M4 version of xcb.h. + + * debian/changelog: + * debian/control: + * debian/copyright.debian: + * debian/rules: + Updated Debian packaging. + +2004-09-30 Jamey Sharp + + * src/xcbext.h: + * src/xcb_in.c: + * src/client-c.xcb: + Renamed XCBWaitReply to XCBWaitForReply for new API. + +2004-09-30 Jamey Sharp + + * src/Makefile.am: + Fix build failure when compiling tests. + +2004-09-29 Jamey Sharp + + * src/xcb.h.m4: + * src/xcb_in.c: + Added XCBPollForEvent function from new API. + +2004-09-29 Jamey Sharp + + * src/xcb.h.m4: + * src/xcbext.h: + * src/client-c.xcb: + * src/xcb_ext.c: + Update the extension cache for its new API. The + optimizations that this API enables are not yet + implemented, but the current implementation should + at least function correctly. + +2004-09-29 Jamey Sharp + + * src/xcb_util.c: + * src/xcbext.h: + Oops, XCBPopcount was supposed to change argument + types too. + +2004-09-29 Jamey Sharp + + * src/client-c.xcb: + * src/xcb_util.c: + * src/xcbext.h: + Renamed XCBOnes to XCBPopcount as per new API spec. + +2004-09-29 Jamey Sharp + + * src/xcbext.h: + * src/xcb.h.m4: + * src/Makefile.am: + * src/client-c.xcb: + * src/xcb_in.c: + * src/xcb_out.c: + * src/xcb_util.c: + * src/xcb_xid.c: + Moved declarations that are only useful to protocol + implementations into a separate header file, + xcbext.h. + +2004-09-28 Jamey Sharp + + * src/xcbint.h: + * src/xcb_conn.c: + Add internal sanity check macros for sequence + numbers, and invoke them every time _xcb_conn_wait + is entered. + +2004-09-28 Jamey Sharp + + * src/client-c.xcb: + Allow LISTPARAMs to omit the length argument. When + generating C code, a LOCALPARAM is automatically + generated for the length if the length argument is + omitted. + +2004-08-13 Jamey Sharp + + * configure.ac: + * src/Makefile.am: + * src/.cvsignore: + * src/check_all.c: + * src/check_suites.h: + * src/check_public.c: + Add the first unit tests for XCB. This adds a build + dependency on 'check'; I hope somebody will make it + more of a build recommendation. + +2004-08-13 Jamey Sharp + + * src/xcb_conn.c: + Add a sanity check: assert() that _xcb_conn_wait + will not be re-entered within the same thread. This + turns out not to be true in some current buggy code. + Xlib re-enters from _XAsyncReplyHandler in + src/xcl/display.c; and the X Test Suite seems to + catch SIGABRT and continue running. + +2004-08-10 Jamey Sharp + + * src/xcb_out.c: + I misread the BIG-REQUESTS specification. The long + length field needs to count itself too. + +2004-07-24 Jamey Sharp + + * src/client-c.xcb: + Renamed functions that return new iterators to + *Iter, to avoid conflict with similar functions that + return arrays. + + Deprecating ARRAYFIELD in favor of LISTFIELD, which + now generates both array and iterator accessors. You + get an array accessor as long as the element type is + fixed length; you get an interator accessor as long + as the base type has an iterator. You always get a + 'Length' function. + +2004-07-24 Jamey Sharp + + * src/xcb_auth.c: + Bart cleaned up some code that I made ugly, and + I'm fixing a warning that resulted from a static + function being created but not necessarily used. + +2004-07-07 Jamey Sharp + + * src/xcb_xid.c: + OK, it might be a good idea to commit something + that compiles. I thought I'd tested this change... + +2004-07-06 Jamey Sharp + + * src/xcbint.h: + * src/xcb_xid.c: + Added support for the XC-Misc extension's ability + to request more XIDs from the server when the + client runs out of them. + +2004-07-06 Jamey Sharp + + * src/xcb.h.m4: + * src/xcb_auth.c: + * src/xcb_util.c: + Removed XCBNextNonce, and the nonce parameter of + XCBGetAuthInfo, from the API. XCB can compute + that just fine without help from the application. + +2004-07-06 Jamey Sharp + + * src/Makefile.am: + Importing part of patches, adding SYNC, by + Mikko Markus Torni . + This needed better padding computation in XCB + before it could be implemented cleanly. + +2004-07-02 Jamey Sharp + + * src/Makefile.am: + Importing part of patches, adding XC-MISC, by + Mikko Markus Torni . + +2004-07-02 Jamey Sharp + + * src/xcb.h.m4: + * src/xcb_in.c: + Remove XCBEventQueueRemove and XCBEventQueueFind. + Their existence in the API constrains the + implementation, and they're not useful for real + code, like toolkits, anyway. + +2004-07-02 Jamey Sharp + + * src/client-c.xcb: + * src/xcb.h.m4: + XCB headers are now compatible with C++ source. + +2004-07-02 Jamey Sharp + + * src/client-c.xcb: + * src/xcb.h.m4: + Keith's fix for padding didn't quite work, despite + looking quite sensible at the time. Replaced + XCB_TYPE_CEIL with XCB_TYPE_PAD and made all the + iterators, lists, and arrays count the number of + bytes from the beginning of the current request. + +2004-07-02 Jamey Sharp + + * src/xcb_out.c: + * src/xcbint.h: + Force a response from the server if we haven't seen + one in 65530 requests. If you don't do this, XCB + gets confused the next time it waits for a reply. + +2004-06-16 Keith Packard + + * src/client-c.xcb: + * src/xcb.h.m4: + Must round datatype lengths to 4-byte boundary for + NEXTFIELD and End macros. Created new XCB_TYPE_CEIL + macro for this purpose and used it in a couple of + places. It is to be hoped that this represents all + of the locations that need changing... diff --git a/INSTALL b/INSTALL new file mode 100644 index 0000000..54caf7c --- /dev/null +++ b/INSTALL @@ -0,0 +1,229 @@ +Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software +Foundation, Inc. + + This file is free documentation; the Free Software Foundation gives +unlimited permission to copy, distribute and modify it. + +Basic Installation +================== + + These are generic installation instructions. + + The `configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation. It uses +those values to create a `Makefile' in each directory of the package. +It may also create one or more `.h' files containing system-dependent +definitions. Finally, it creates a shell script `config.status' that +you can run in the future to recreate the current configuration, and a +file `config.log' containing compiler output (useful mainly for +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 +disabled by default to prevent problems with accidental use of stale +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 +diffs or instructions to the address given in the `README' so they can +be considered for the next release. If you are using the cache, and at +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'. + +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. + + Running `configure' takes awhile. 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. + + 4. Type `make install' to install the programs and any data files and + documentation. + + 5. 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 + also a `make maintainer-clean' target, but that is intended mainly + for the package's developers. If you use it, you may have to get + all sorts of other programs in order to regenerate files that came + with the distribution. + +Compilers and Options +===================== + + Some systems require unusual options for compilation or linking that +the `configure' script does not know about. Run `./configure --help' +for details on some of the pertinent environment variables. + + You can give `configure' initial values for configuration parameters +by setting variables in the command line or in the environment. Here +is an example: + + ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix + + *Note Defining Variables::, for more details. + +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 +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 `..'. + + 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. + +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'. + + 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. + + In addition, if you use an unusual directory layout you can give +options like `--bindir=PATH' 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. + + 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 +is something like `gnu-as' or `x' (for the X Window System). The +`README' should mention any `--enable-' and `--with-' options that the +package recognizes. + + For packages that use the X Window System, `configure' can usually +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. + +Specifying the System Type +========================== + + There may be some features `configure' cannot figure out +automatically, but needs to determine by the type of machine the package +will run on. Usually, assuming the package is built to be run on the +_same_ architectures, `configure' can figure that out, but if it prints +a message saying it cannot guess the machine type, give it the +`--build=TYPE' option. TYPE can either be a short name for the system +type, such as `sun4', or a canonical name which has the form: + + CPU-COMPANY-SYSTEM + +where SYSTEM can have one of these forms: + + 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 +produce code for. + + If you want to _use_ a cross compiler, that generates code for a +platform different from the build platform, you should specify the +"host" platform (i.e., that on which the generated programs will +eventually be run) with `--host=TYPE'. + +Sharing Defaults +================ + + If you want to set default values for `configure' scripts to share, +you can create a site shell script called `config.site' that gives +default values for variables like `CC', `cache_file', and `prefix'. +`configure' looks for `PREFIX/share/config.site' if it exists, then +`PREFIX/etc/config.site' if it exists. Or, you can set the +`CONFIG_SITE' environment variable to the location of the site script. +A warning: not all `configure' scripts look for a site script. + +Defining Variables +================== + + Variables not defined in a site shell script can be set in the +environment passed to `configure'. However, some packages may run +configure again during the build, and the customized values of these +variables may be lost. In order to avoid this problem, you should set +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 +overridden in the site shell script). + +`configure' Invocation +====================== + + `configure' recognizes the following options to control how it +operates. + +`--help' +`-h' + Print a summary of the options to `configure', and exit. + +`--version' +`-V' + Print the version of Autoconf used to generate the `configure' + script, and exit. + +`--cache-file=FILE' + Enable the cache: use and save the results of the tests in FILE, + traditionally `config.cache'. FILE defaults to `/dev/null' to + disable caching. + +`--config-cache' +`-C' + Alias for `--cache-file=config.cache'. + +`--quiet' +`--silent' +`-q' + Do not print messages saying which checks are being made. To + suppress all normal output, redirect it to `/dev/null' (any error + messages will still be shown). + +`--srcdir=DIR' + Look for the package's source code in directory DIR. Usually + `configure' can determine that directory automatically. + +`configure' also accepts some other, not widely useful, options. Run +`configure --help' for more details. + diff --git a/Makefile.am b/Makefile.am new file mode 100644 index 0000000..df93163 --- /dev/null +++ b/Makefile.am @@ -0,0 +1,6 @@ +SUBDIRS=src tests + +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = xcb.pc + +EXTRA_DIST=xcb.pc.in diff --git a/autogen.sh b/autogen.sh new file mode 100755 index 0000000..d68a142 --- /dev/null +++ b/autogen.sh @@ -0,0 +1,3 @@ +#! /bin/sh +autoreconf -v --install || exit 1 +./configure "$@" diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000..903eeed --- /dev/null +++ b/configure.ac @@ -0,0 +1,84 @@ +# -*- Autoconf -*- +# Process this file with autoconf to produce a configure script. + +AC_PREREQ(2.57) +AC_INIT([libXCB], + 0.9, + [xcb@lists.freedesktop.org]) +AC_CONFIG_SRCDIR([xcb.pc.in]) +AM_INIT_AUTOMAKE([foreign dist-bzip2]) + +dnl This ifdef has no useful effect prior to automake 1.9, but in 1.9 +dnl it allows the user to not have check.m4 installed. +m4_ifdef([AM_PATH_CHECK],[ +AM_PATH_CHECK(0.8.2, [HAVE_CHECK=true], [HAVE_CHECK=false]) +]) +AM_CONDITIONAL(HAVE_CHECK, test x$HAVE_CHECK = xtrue) + +AC_CONFIG_HEADERS([src/config.h]) + +AC_PROG_LIBTOOL +AC_PROG_CC + +AC_PATH_PROG(XSLTPROC, xsltproc, no) +if test "$XSLTPROC" = "no"; then + AC_MSG_ERROR([XCB requires xsltproc.]) +fi + +HTML_CHECK_RESULT=false +if test x"$HAVE_CHECK" = xtrue; then + if test x"$XSLTPROC" != xno; then + HTML_CHECK_RESULT=true + fi +fi +AC_SUBST(HTML_CHECK_RESULT) + +# Checks for pkg-config packages +PKG_CHECK_MODULES(XCBPROTO, xcb-proto >= 0.9) +PKG_CHECK_MODULES(XPROTO, xproto) +PKG_CHECK_MODULES(XAU, xau) + +# Find the xcb-proto protocol descriptions +AC_MSG_CHECKING(XCBPROTO_XCBINCLUDEDIR) +XCBPROTO_XCBINCLUDEDIR=`$PKG_CONFIG --variable=xcbincludedir xcb-proto` +AC_MSG_RESULT($XCBPROTO_XCBINCLUDEDIR) +AC_SUBST(XCBPROTO_XCBINCLUDEDIR) + +AC_HEADER_STDC +AC_SEARCH_LIBS(gethostbyname, nsl) +AC_SEARCH_LIBS(connect, socket) + +xcbincludedir='${includedir}/X11/XCB' +AC_SUBST(xcbincludedir) + +AC_ARG_WITH(opt, +AC_HELP_STRING([--with-opt], [compile with reasonable optimizations]) +AC_HELP_STRING([--with-opt=FLAGS], [compile with specified FLAGS]) +AC_HELP_STRING([--with-opt=small], [compile for smallest code]) +AC_HELP_STRING([--with-opt=debug], [compile for debugging (default)]), +[ + case "$withval" in + yes) + optflags="-O3" + ;; + small) + optflags="-Os -fomit-frame-pointer -DNDEBUG" + ;; + no|debug) + optflags="-g" + ;; + *) + optflags="$withval" + ;; + esac +]) +AC_CACHE_CHECK([what compiler optimizations to apply], [optflags], [optflags="-g"]) +AC_DEFINE(_XOPEN_SOURCE, 500, [Conform to Single Unix Specification.]) +CDEBUGFLAGS="$optflags -Wall -pedantic -Wpointer-arith \ + -Wstrict-prototypes -Wmissing-declarations -Wnested-externs" +AC_SUBST(CDEBUGFLAGS) + +AC_CONFIG_FILES([Makefile src/Makefile tests/Makefile]) +AC_CONFIG_FILES([xcb.pc]) + +AC_OUTPUT diff --git a/debian/.cvsignore b/debian/.cvsignore new file mode 100644 index 0000000..cad8b05 --- /dev/null +++ b/debian/.cvsignore @@ -0,0 +1,6 @@ +compat +copyright +fd.o-* +stamp-* +tmp +files diff --git a/debian/changelog b/debian/changelog new file mode 100644 index 0000000..148dd94 --- /dev/null +++ b/debian/changelog @@ -0,0 +1,41 @@ +libxcb0 (0.9-1pre2v4) unstable; urgency=low + + pre2v1: + * Split into libxcb0 and libxcb0-dev. + * Change control file for new packages. + * Add install and dirs files for new packages. + * Update Build-Depends for renaming of fd.o-xau, fd.o-xproto, and + fd.o-xcb-proto. + * Remove fd.o prefix from package name. + * Change Maintainer to xcb@lists.freedesktop.org, move myself to + Uploaders, and add Jamey Sharp to Uploaders. Update copyright.debian + accordingly. + * Add Bugs field pointing to xcb@lists.freedesktop.org. + * Update homepage URL in description and copyright.debian to + http://xcb.freedesktop.org, and put it in a Homepage: field in the + description. + + pre2v2: + * Add libxcb0-dbg package. + + pre2v3: + * New upstream snapshot. + + pre2v4: + * New upstream snapshot. + + -- Josh Triplett Tue, 17 May 2005 12:53:53 -0700 + +fd.o-xcb (0.9-1) unstable; urgency=low + + * New version using XSLT; works with XML descriptions in xcb-proto 0.9. + * Updated Debian packaging. + + -- Josh Triplett Fri, 29 Oct 2004 15:11:09 -0700 + +fd.o-xcb (0.8-1) unstable; urgency=low + + * Initial Release. + + -- Jamey Sharp Thu, 18 Mar 2004 00:09:03 -0800 + diff --git a/debian/control b/debian/control new file mode 100644 index 0000000..33c61c0 --- /dev/null +++ b/debian/control @@ -0,0 +1,56 @@ +Source: libxcb0 +Priority: optional +Maintainer: XCB Developers +Uploaders: Jamey Sharp , Josh Triplett +Build-Depends: x-dev, libxau-dev, xcb-proto, cdbs, debhelper (>= 4.1.76), pkg-config, autoconf, automake1.9 | automaken, libtool, xsltproc, check, binutils (>= 2.12.90.0.9) +Build-Conflicts: automake1.4, automake1.5, automake1.6 +Standards-Version: 3.6.1 +Bugs: mailto:xcb@lists.freedesktop.org + +Package: libxcb0 +Section: libs +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends} +Description: X C Binding + Xlib has been the standard C binding for the X Window System protocol for + many years now. It is an excellent piece of work, but there are applications + for which it is not ideal. XCB builds on nearly two decades of experience + with X specifically and software engineering in general in an effort to + replace the aging Xlib code base. + . + This package contains the library files needed to run software using + XCB. + . + Homepage: http://xcb.freedesktop.org + +Package: libxcb0-dev +Section: libdevel +Architecture: any +Depends: libxcb0 (= ${Source-Version}), x-dev +Description: X C Binding, development files + Xlib has been the standard C binding for the X Window System protocol for + many years now. It is an excellent piece of work, but there are applications + for which it is not ideal. XCB builds on nearly two decades of experience + with X specifically and software engineering in general in an effort to + replace the aging Xlib code base. + . + This package contains the header and library files needed to build software + using XCB. + . + Homepage: http://xcb.freedesktop.org + +Package: libxcb0-dbg +Section: libdevel +Architecture: any +Depends: libxcb0 (= ${Source-Version}) +Description: X C Binding, debugging symbols + Xlib has been the standard C binding for the X Window System protocol for + many years now. It is an excellent piece of work, but there are applications + for which it is not ideal. XCB builds on nearly two decades of experience + with X specifically and software engineering in general in an effort to + replace the aging Xlib code base. + . + This package contains the debugging symbols associated with libxcb0. gdb will + automatically use these symbols when debugging libxcb0. + . + Homepage: http://xcb.freedesktop.org diff --git a/debian/copyright.debian b/debian/copyright.debian new file mode 100644 index 0000000..7cd330a --- /dev/null +++ b/debian/copyright.debian @@ -0,0 +1,12 @@ +This package was debianized by Jamey Sharp on +Thu, 18 Mar 2004 00:48:42 -0800, and later updated by Josh Triplett +. The package is co-maintained by the XCB developers +via the XCB mailing list . + +It was downloaded from http://xcb.freedesktop.org. + +Upstream Authors: Jamey Sharp + Josh Triplett + +Copyright: + diff --git a/debian/libxcb0-dev.dirs b/debian/libxcb0-dev.dirs new file mode 100644 index 0000000..4418816 --- /dev/null +++ b/debian/libxcb0-dev.dirs @@ -0,0 +1,2 @@ +usr/lib +usr/include diff --git a/debian/libxcb0-dev.install b/debian/libxcb0-dev.install new file mode 100644 index 0000000..5ab44bc --- /dev/null +++ b/debian/libxcb0-dev.install @@ -0,0 +1,5 @@ +usr/X11R6/include/X11/* +usr/lib/lib*.a +usr/lib/lib*.so +usr/lib/pkgconfig/* +usr/lib/*.la diff --git a/debian/libxcb0.dirs b/debian/libxcb0.dirs new file mode 100644 index 0000000..6845771 --- /dev/null +++ b/debian/libxcb0.dirs @@ -0,0 +1 @@ +usr/lib diff --git a/debian/libxcb0.install b/debian/libxcb0.install new file mode 100644 index 0000000..d0dbfd1 --- /dev/null +++ b/debian/libxcb0.install @@ -0,0 +1 @@ +usr/lib/lib*.so.* diff --git a/debian/rules b/debian/rules new file mode 100755 index 0000000..e81cbea --- /dev/null +++ b/debian/rules @@ -0,0 +1,22 @@ +#!/usr/bin/make -f + +DEB_DH_INSTALL_SOURCEDIR=debian/tmp + +include /usr/share/cdbs/1/rules/debhelper.mk +include /usr/share/cdbs/1/class/autotools.mk + +DEB_CONFIGURE_EXTRA_FLAGS = --with-opt +DEB_CONFIGURE_INCLUDEDIR = "\$${prefix}/X11R6/include" +DEB_DH_STRIP_ARGS=--dbg-package=libxcb0 + +debian/stamp-autotools-files: + autoreconf -v --install + touch debian/stamp-autotools-files + +debian/copyright: debian/copyright.debian COPYING + cat $+ > $@ + +clean:: + -rm -f debian/copyright + +common-install-prehook-arch common-install-prehook-indep:: debian/copyright diff --git a/doc/tutorial/index.html b/doc/tutorial/index.html new file mode 100755 index 0000000..ac6e502 --- /dev/null +++ b/doc/tutorial/index.html @@ -0,0 +1,3772 @@ + + + + + + Basic Graphics Programming With The XCB Library + + + + +
+ Basic Graphics Programming With The XCB Library +
+
+
    +
  1. Introduction
    2. +
  2. The client and server model of the X window system
    3. +
  3. GUI programming: the asynchronous model
    4. +
  4. Basic XCB notions
    5. +
      +
    1. The X Connection
      2. +
    2. Requests and replies: the Xlib killers
      3. +
    3. The Graphics Context
      4. +
    4. Object handles
      5. +
    5. Memory allocation for XCB structures
      6. +
    6. Events
      7. +
    +
  5. Using XCB-based programs
    6. +
      +
    1. Installation of XCB
      2. +
    2. Compiling XCB-based programs
      3. +
    +
  6. Opening and closing the connection to an X server
    7. +
  7. Checking basic information about a connection
    8. +
  8. Creating a basic window - the "hello world" program
    9. +
  9. Drawing in a window
    10. +
      +
    1. Allocating a Graphics Context
      2. +
    2. Changing the attributes of a Graphics Context
      3. +
    3. Drawing primitives: point, line, box, circle,...
      4. +
    +
  10. X Events
    11. +
      +
    1. Registering for event types using event masks
      2. +
    2. Receiving events: writing the events loop
      3. +
    3. Expose events
      4. +
    4. Getting user input
      5. +
        +
      1. Mouse button press and release events
        2. +
      2. Mouse movement events
        3. +
      3. Mouse pointer enter and leave events
        4. +
      4. The keyboard focus
        5. +
      5. Keyboard press and release events
        6. +
      +
    5. X events: a complete example
      6. +
    +
  11. Handling text and fonts
    12. +
      +
    1. The Font structure
      2. +
    2. Loading a Font
      3. +
    3. Assigning a Font to a Graphic Context
      4. +
    4. Drawing text in a window
      5. +
    +
  12. Windows hierarchy
    13. +
      +
    1. Root, parent and child windows
      2. +
    2. Events propagation
      3. +
    +
  13. Interacting with the window manager
    14. +
      +
    1. Window properties
      2. +
    2. Setting the window name and icon name
      3. +
    3. Setting preferred window size(s)
      4. +
    4. Setting miscellaneous window manager hints
      5. +
    5. Setting an application's icon
      6. +
    +
  14. Simple window operations
    15. +
      +
    1. Mapping and un-mapping a window
      2. +
    2. Configuring a window
      3. +
    3. Moving a window around the screen
      4. +
    4. Resizing a window
      5. +
    5. Changing windows stacking order: raise and lower
      6. +
    6. Iconifying and de-iconifying a window
      7. +
    7. Getting informations about a window
      8. +
    +
  15. Using colors to paint the rainbow
    16. +
      +
    1. Color maps
      2. +
    2. Allocating and freeing Color Maps
      3. +
    3. Allocating and freeing a color entry
      4. +
    4. Drawing with a color
      5. +
    +
  16. X Bitmaps and Pixmaps
    17. +
      +
    1. What is a X Bitmap ? An X Pixmap ?
      2. +
    2. Loading a bitmap from a file
      3. +
    3. Drawing a bitmap in a window
      4. +
    4. Creating a pixmap
      5. +
    5. Drawing a pixmap in a window
      6. +
    6. Freeing a pixmap
      7. +
    +
  17. Messing with the mouse cursor
    18. +
      +
    1. Creating and destroying a mouse cursor
      2. +
    2. Setting a window's mouse cursor
      3. +
    +
  18. Translation of basic Xlib functions and macros
    19. +
      +
    1. Members of the Display structure
      2. +
        +
      1. ConnectionNumber
        2. +
      2. DefaultScreen
        3. +
      3. QLength
        4. +
      4. ScreenCount
        5. +
      5. ServerVendor
        6. +
      6. ProtocolVersion
        7. +
      7. ProtocolRevision
        8. +
      8. VendorRelease
        9. +
      9. DisplayString
        10. +
      10. BitmapUnit
        11. +
      11. BitmapBitOrder
        12. +
      12. BitmapPad
        13. +
      13. ImageByteOrder
        14. +
      +
    2. ScreenOfDisplay related functions
      3. +
        +
      1. ScreenOfDisplay
        2. +
      2. DefaultScreenOfDisplay
        3. +
      3. RootWindow / RootWindowOfScreen
        4. +
      4. DefaultRootWindow
        5. +
      5. DefaultVisual / DefaultVisualOfScreen
        6. +
      6. DefaultGC / DefaultGCOfScreen
        7. +
      7. BlackPixel / BlackPixelOfScreen
        8. +
      8. WhitePixel / WhitePixelOfScreen
        9. +
      9. DisplayWidth / WidthOfScreen
        10. +
      10. DisplayHeight / HeightOfScreen
        11. +
      11. DisplayWidthMM / WidthMMOfScreen
        12. +
      12. DisplayHeightMM / HeightMMOfScreen
        13. +
      13. DisplayPlanes / DefaultDepth / DefaultDepthOfScreen / PlanesOfScreen
        14. +
      14. DefaultColormap / DefaultColormapOfScreen
        15. +
      15. MinCmapsOfScreen
        16. +
      16. MaxCmapsOfScreen
        17. +
      17. DoesSaveUnders
        18. +
      18. DoesBackingStore
        19. +
      19. EventMaskOfScreen
        20. +
      +
    3. Miscellaneaous macros
      4. +
        +
      1. DisplayOfScreen
        2. +
      2. DisplayCells / CellsOfScreen
        3. +
      +
    +
+
+
+
    +
  1. Introduction
    2. +

    + This tutorial is based on the + Xlib Tutorial + written by Guy Keren. The + author allowed me to take some parts of his text, mainly the text which + deals with the X Windows generality. +

    +

    + This tutorial is intended to people who want to start to program + with the XCB + library. As for the Xlib + library, it is useless and a real X + programmer should use a much higher level of abstraction, such + as using Motif, + LessTiff, + GTK, + QT or + EWL. However, + we need to start somewhere. More than this, knowing how things + work down below is never a bad idea. +

    +

    + After reading this tutorial, one should be able to write very + simple graphical programs, but not programs with a descent user + interface. For such programs, one of the previously mentioned + library should be used. +

    +

    + But what is XCB ? Xlib has been + the standard C binding for the X + Window System protocol for many years now. It is an + excellent piece of work, but there are applications for which it + is not ideal, for example +

      +
    • Small platforms: Xlib is a large piece of code, and + it's difficult to make it smaller
      • +
    • Latency hiding: Xlib requests requiring a reply are + effectively synchronous: they block until the reply appears, + whether the result is needed immediately or not.
      • +
    • Direct access to the protocol: Xlib does quite a + bit of caching, layering, and similar optimizations. While this + is normally a feature, it makes it difficult to simply emit + specified X protocol requests and process specific + responses.
      • +
    • Threaded applications: While Xlib does attempt to + support multithreading, the API makes this difficult and + error-prone.
      • +
    • New extensions: The Xlib infrastructure provides + limited support for the new creation of X extension client side + code.
      • +
    +

    +

    + For these reasons, among others, XCB, an X C binding, has been + designed to solve the above problems and thus provide a base for +

      +
    • Toolkit implementation.
      • +
    • Direct protocol-level programming.
      • +
    • Lightweight emulation of commonly used portions of the + Xlib API (in progress)
      • +
    +

    +

    +
  2. The client and server model of the X window system
    3. +

    + The X Window System was developed with one major goal: + flexibility. The idea was that the way things look is one thing, + but the way things work is another matter. Thus, the lower + levels provide the tools required to draw windows, handle user + input, allow drawing graphics using colors (or black and white + screens), etc. To this point, a decision was made to separate + the system into two parts. A client that decides what to do, and + a server that actually draws on the screen and reads user input + in order to send it to the client for processing. +

    +

    + This model is the complete opposite of what is used to when + dealing with clients and servers. In our case, the user seats + near the machine controlled by the server, while the client + might be running on a remote machine. The server controls the + screens, mouse and keyboard. A client may connect to the server, + request that it draws a window (or several windows), and ask the + server to send it any input the user sends to these + windows. Thus, several clients may connect to a single X server + (one might be running an mail software, one running a WWW + browser, etc). When input is sent by the user to some window, + the server sends a message to the client controlling this window + for processing. The client decides what to do with this input, + and sends the server requests for drawing in the window. +

    +

    + The whole session is carried out using the X message + protocol. This protocol was originally carried over the TCP/IP + protocol suite, allowing the client to run on any machine + connected to the same network that the server is. Later on, the + X servers were extended to allow clients running on the local + machine with more optimized access to the server (note that an X + protocol message may be several hundreds of KB in size), such as + using shred memory, or using Unix domain sockets (a method for + creating a logical channel on a Unix system between two processors). +

    +
  3. GUI programming: the asynchronous model
    4. +

    + Unlike conventional computer programs, that carry some serial + nature, a GUI program usually uses an asynchronous programming + model, also known as "event-driven programming". This means that + that program mostly sits idle, waiting for events sent by the X + server, and then acts upon these events. An event may say "The + user pressed the 1st button mouse in spot (x,y)", or "The window + you control needs to be redrawn". In order for the program to e + responsive to the user input, as well as to refresh requests, it + needs to handle each event in a rather short period of time + (e.g. less that 200 milliseconds, as a rule of thumb). +

    +

    + This also implies that the program may not perform operations + that might take a long time while handling an event (such as + opening a network connection to some remote server, or + connecting to a database server, or even performing a long file + copy operation). Instead, it needs to perform all these + operations in an asynchronous manner. This may be done by using + various asynchronous models to perform the longish operations, + or by performing them in a different process or thread. +

    +

    + So the way a GUI program looks is something like that: +

      +
    1. Perform initialization routines.
      2. +
    2. Connect to the X server.
      3. +
    3. Perform X-related initialization.
      4. +
    4. While not finished:
      5. +
        +
      1. Receive the next event from the X server.
        2. +
      2. Handle the event, possibly sending various drawing + requests to the X server.
        3. +
      3. If the event was a quit message, exit the loop.
        4. +
      +
    5. Close down the connection to the X server.
      6. +
    6. Perform cleanup operations.
      7. +
    +

    +

    +
  4. Basic XCB notions
    5. +

    + XCB has been created to eliminate the needs of + programs to actually implement the X protocol layer. This + library gives a program a very low-level access to any X + server. Since the protocol is standardized, a client using any + implementation of XCB may talk with any X server (the same + occurs for Xlib, of course). We now give a brief description of + the basic XCB notions. They will be detailed later. +

    +
      +
    1. The X Connection
      2. +

      + The major notion of using XCB is the X Connection. This is a + structure representing the connection we have open with a + given X server. It hides a queue of messages coming from the + server, and a queue of pending requests that our client + intends to send to the server. In XCB, this structure is named + 'XCBConnection'. When we open a connection to an X server, the + library returns a pointer to such a structure. Later, we + supply this pointer to any XCB function that should send + messages to the X server or receive messages from this server. +

      +
    2. Requests and + replies: the Xlib killers
      3. +

      + To ask informations to the X server, we have to make a request + and ask for a reply. With Xlib, these two tasks are + automatically done: Xlib locks the system, sends a request, + waits for a reply from the X server and unlocks. This is + annoying, especially if one makes a lot of requests to the X + server. Indeed, Xlib has to wait for the end of a reply + before asking for the next request (because of the locks that + Xlib sends). For example, here is a time-line of N=4 + requests/replies with Xlib, with a round-trip latency + T_round_trip that is 5 times long as the time required + to write or read a request/reply (T_write/T_read): +

      + 
      +  W-----RW-----RW-----RW-----R
+
      +
        +
      • W: Writing request
        • +
      • -: Stalled, waiting for data
        • +
      • R: Reading reply
        • +
      +

      + The total time is N * (T_write + T_round_trip + T_read). +

      +

      + With XCB, we can suppress most of the round-trips as the + requests and the replies are not locked. We usually send a + request, then XCB returns to us a cookie, which is an + identifier. Then, later, we ask for a reply using this + cookie and XCB returns a + pointer to that reply. Hence, with XCB, we can send a lot of + requests, and later in the program, ask for all the replies + when we need them. Here is the time-line for 4 + requests/replies when we use this property of XCB: +

      + 
      +  WWWW--RRRR
+
      +

      + The total time is N * T_write + max (0, T_round_trip - (N-1) * + T_write) + N * T_read. Which can be considerably faster than + all those Xlib round-trips. +

      +

      + Here is a program that computes the time to create 500 atoms + with Xlib and XCB. It shows the Xlib way, the bad XCB way + (which is similar to Xlib) and the good XCB way. On my + computer, XCB is 25 times faster than Xlib. +

      + 
      +#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+
+#include <X11/XCB/xcb.h>
+
+#include <X11/Xlib.h>
+
+double
+get_time(void)
+{
+  struct timeval timev;
+  
+  gettimeofday(&timev, NULL);
+
+  return (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
+}
+
+int
+main ()
+{
+  XCBConnection       *c;
+  XCBATOM             *atoms;
+  XCBInternAtomCookie *cs;
+  char               **names;
+  int                  count;
+  int                  i;
+  double               start;
+  double               end;
+  double               diff;
+
+  /* Xlib */
+  Display *disp;
+  Atom    *atoms_x;
+  double   diff_x;
+
+  c = XCBConnectBasic ();
+
+  count = 500;
+  atoms = (XCBATOM *)malloc (count * sizeof (atoms));
+  names = (char **)malloc (count * sizeof (char *));
+
+  /* init names */
+  for (i = 0; i < count; ++i)
+    {
+      char buf[100];
+
+      sprintf (buf, "NAME%d", i);
+      names[i] = strdup (buf);
+    }
+
+  /* bad use */
+  start = get_time ();
+
+  for (i = 0; i < count; ++i)
+    atoms[i] = XCBInternAtomReply (c, 
+                                   XCBInternAtom (c,
+                                                  0,
+                                                  strlen(names[i]),
+                                                  names[i]),
+                                   NULL)->atom;
+
+  end = get_time ();
+  diff = end - start;
+  printf ("bad use time  : %f\n", diff);
+
+  /* good use */
+  start = get_time ();
+
+  cs = (XCBInternAtomCookie *) malloc (count * sizeof(XCBInternAtomCookie));
+  for(i = 0; i < count; ++i)
+    cs[i] = XCBInternAtom (c, 0, strlen(names[i]), names[i]);
+
+  for(i = 0; i < count; ++i)
+    {
+      XCBInternAtomRep *r;
+
+      r = XCBInternAtomReply(c, cs[i], 0);
+      if(r)
+        atoms[i] = r->atom;
+      free(r);
+    }
+
+  end = get_time ();
+  printf ("good use time : %f\n", end - start);
+  printf ("ratio         : %f\n", diff / (end - start));
+  diff = end - start;
+
+  /* free var */
+  for (i = 0; i < count; ++i)
+    {
+      free (names[i]);
+    }
+  free (atoms);
+  free (cs);
+
+  XCBDisconnect (c);
+
+  /* Xlib */
+  disp = XOpenDisplay (getenv("DISPLAY"));
+
+  atoms_x = (Atom *)malloc (count * sizeof (atoms_x));
+
+  start = get_time ();
+
+  for (i = 0; i < count; ++i)
+    atoms_x[i] = XInternAtom(disp, names[i], 0);
+
+  end = get_time ();
+  diff_x = end - start;
+  printf ("Xlib use time : %f\n", diff_x);
+  printf ("ratio         : %f\n", diff_x / diff);
+
+  free (atoms_x);
+  free (names);
+
+  XCloseDisplay (disp);
+  
+  return 1;
+}
+
      +
    3. The Graphic Context
      4. +

      + When we perform various drawing operations (graphics, text, + etc), we may specify various options for controlling how the + data will be drawn (what foreground and background colors to + use, how line edges will be connected, what font to use when + drawing some text, etc). In order to avoid the need to supply + hundreds of parameters to each drawing function, a graphical + context structure is used. We set the various drawing options + in this structure, and then, we pass a pointer to this + structure to any drawing routines. This is rather handy, as we + often need to perform several drawing requests with the same + options. Thus, we would initialize a graphical context, set + the desired options, and pass this structure to all drawing + functions. +

      +

      + Note that graphic contexts have no client-side structure in + XCB, they're just XIDs. Xlib has a client-side structure + because it caches the GC contents so it can avoid making + redundant requests, but of course XCB doesn't do that. +

      +
    4. Events
      5. +

      + A structure is used to pass events received from the X + server. XCB supports exactly the events specified in the + protocol (33 events). This structure contains the type + of event received, as well as the data associated with the + event (e.g. position on the screen where the event was + generated, mouse button associated with the event, region of + the screen associated with a "redraw" event, etc). The way to + read the event's data epends on the event type. +

      +
    +

    +
  5. Using XCB-based programs
    6. +

    +
      +
    1. Installation of XCB
      2. +

      + To build XCB from source, you need to have installed at + least: +

      +
        +
      • pkgconfig 0.15.0
        • +
      • automake 1.7
        • +
      • autoconf 2.50
        • +
      • check
        • +
      • xsltproc
        • +
      +

      + You have to checkout in CVS the following modules: +

      +
        +
      • Xproto from xlibs
        • +
      • Xau from xlibs
        • +
      • xcb-proto
        • +
      • xcb
        • +
      +

      + Note that Xproto and xcb-proto exist only to install header + files, so typing 'make' or 'make all' will produce the message + "Nothing to be done for 'all'". That's normal. +

      +
    2. Compiling XCB-based programs
      3. +

      + Compiling XCB-based programs requires linking them with the XCB + library. This is easily done thanks to pkgconfig: +

      + 
      +gcc -Wall prog.c -o prog `pkg-config --cflags --libs xcb`
+
      +
    +
  6. Opening and closing the connection to an X server
    7. +

    + An X program first needs to open the connection to the X + server. There is a function that opens a connection. It requires + the display name, or NULL. In the latter case, the display name + will be the one in the environment variable DISPLAY. +

    + 
    +XCBConnection *XCBConnect (const char *displayname,
+                           int        *screenp);
+
    +

    + The second parameter returns the screen number used for the + connection. The returned structure describes an XCB connection + and is opaque. Here is how the connection can be opened: +

    + 
    +#include <X11/XCB/xcb.h>
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection *c;
+  
+  /* Open the connection to the X server. use the DISPLAY environment variable as the default display name */
+  c = XCBConnect (NULL, NULL);
+
+  return 1;
+}
+
    +

    + To close a connection, it suffices to use: +

    + 
    +void XCBDisconnect (XCBConnection *c);
+
    +
    +
    + Comparison Xlib/XCB +
    +
    +
      +
    • XOpenDisplay ()
      • +
    +
    +
    +
      +
    • XCBConnect ()
      • +
    +
    +
    +
      +
    • XCloseDisplay ()
      • +
    +
    +
    +
      +
    • XCBDisconnect ()
      • +
    +
    +
    +

    +

    +
  7. Checking basic information about a connection
    8. +

    + Once we opened a connection to an X server, we should check some + basic informations about it: what screens it has, what is the + size (width and height) of the screen, how many colors it + supports (black and white ? grey scale ?, 256 colors ? more ?), + and so on. We get such informations from the XCBSCREEN + structure: +

    + 
    +typedef struct {
+    XCBWINDOW root;
+    XCBCOLORMAP default_colormap;
+    CARD32 white_pixel;
+    CARD32 black_pixel;
+    CARD32 current_input_masks;
+    CARD16 width_in_pixels;
+    CARD16 height_in_pixels;
+    CARD16 width_in_millimeters;
+    CARD16 height_in_millimeters;
+    CARD16 min_installed_maps;
+    CARD16 max_installed_maps;
+    XCBVISUALID root_visual;
+    BYTE backing_stores;
+    BOOL save_unders;
+    CARD8 root_depth;
+    CARD8 allowed_depths_len;
+} XCBSCREEN;
+
    +

    + We could retrieve the first screen of the connection by using the + following function: +

    + 
    +XCBSCREENIter XCBConnSetupSuccessRepRootsIter (XCBConnSetupSuccessRep *R);
+
    +

    + Here is a small program that shows how to use this function: +

    + 
    +#include <stdio.h>
+
+#include <X11/XCB/xcb.h>
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection *c;
+  XCBSCREEN     *screen;
+  int            screen_nbr;
+  XCBSCREENIter  iter;
+  
+  /* Open the connection to the X server. Use the DISPLAY environment variable */
+  c = XCBConnect (NULL, &screen_nbr);
+  
+  /* Get the screen #screen_nbr */
+  iter = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c));
+  for (; iter.rem; --screen_nbr, XCBSCREENNext (&iter))
+    if (screen_nbr == 0)
+      {
+        screen = iter.data;
+        break;
+      }
+
+  printf ("\n");
+  printf ("Informations of screen %ld:\n", screen->root.xid);
+  printf ("  width.........: %d\n", screen->width_in_pixels);
+  printf ("  height........: %d\n", screen->height_in_pixels);
+  printf ("  white pixel...: %ld\n", screen->white_pixel);
+  printf ("  black pixel...: %ld\n", screen->black_pixel);
+  printf ("\n");
+
+  return 1;
+}
+
    +
  8. Creating a basic window - the "hello world" program
    9. +

    + After we got some basic informations about our screen, we can + create our first window. In the X Window System, a window is + characterized by an Id. So, in XCB, a window is of type: +

    + 
    +typedef struct {
+    CARD32 xid;
+} XCBWINDOW;
+
    +

    + We first ask for a new Id for our window, with this function: +

    + 
    +XCBWINDOW XCBWINDOWNew(XCBConnection *c);
+
    +

    + Then, XCB supplies the following function to create new windows: +

    + 
    +XCBVoidCookie XCBCreateWindow (XCBConnection *c,             /* Pointer to the XCBConnection structure */
+                               CARD8          depth,         /* Depth of the screen */
+                               XCBWINDOW      wid,           /* Id of the window */
+			       XCBWINDOW      parent,        /* Id of an existing window that should be the parent of the new window */
+			       INT16          x,             /* X position of the top-left corner of the window (in pixels) */
+			       INT16          y,             /* Y position of the top-left corner of the window (in pixels) */
+		       	       CARD16         width,         /* Width of the window (in pixels) */
+			       CARD16         height,        /* Height of the window (in pixels) */
+			       CARD16         border_width,  /* Width of the window's border (in pixels) */
+			       CARD16         _class,
+			       XCBVISUALID    visual,
+			       CARD32         value_mask,
+			       const CARD32  *value_list);
+
    +

    + The fact that we created the window does not mean that it will + be drawn on screen. By default, newly created windows are not + mapped on the screen (they are invisible). In order to make our + window visible, we use the function XCBMapWindow(), whose + prototype is +

    + 
    +XCBVoidCookie XCBMapWindow (XCBConnection *c, XCBWINDOW window);
+
    +

    + Finally, here is a small program to create a window of size + 150x150 pixels, positioned at the top-left corner of the screen: +

    + 
    +#include <unistd.h>
+
+#include <X11/XCB/xcb.h>
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection *c;
+  XCBSCREEN     *screen;
+  XCBDRAWABLE    win;
+  
+  /* Open the connection to the X server */
+  c = XCBConnect (NULL, NULL);
+  
+  /* Get the first screen */
+  screen = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c)).data;
+
+  /* Ask for our window's Id */
+  win.window = XCBWINDOWNew(c);
+
+  /* Create the window */
+  XCBCreateWindow (c,                        /* Connection          */
+ 		   0,                        /* depth               */
+		   win.window,               /* window Id           */
+		   screen->root,             /* parent window       */
+		   0, 0,                     /* x, y                */
+		   150, 150,                 /* width, height       */
+		   10,                       /* border_width        */
+		   InputOutput,              /* class               */
+		   screen->root_visual,      /* visual              */
+		   0, NULL);                 /* masks, not used yet */
+
+  /* Map the window on the screen */
+  XCBMapWindow (c, win.window);
+
+  XCBSync (c, 0);
+  
+  pause ();
+
+  return 1;
+}
+
    +

    + In this code, you see one more function - XCBSync(), not explained + yet. It is used to flush all the pending requests. More + precisely, there are 2 functions that do such things. The first + one is XCBFlush(): +

    + 
    +int XCBFlush (XCBConnection *c);
+
    +

    + This function flushes all pending requests to the X server (much + like the fflush() function is used to + flush standard output). The second function is + XCBSync(): +

    + 
    +int XCBSync(XCBConnection *c, XCBGenericError **e);
+
    +

    + This functions also flushes all pending requests to the X + server, and then waits until the X server finishing processing + these requests. In a normal program, this will not be necessary + (we'll see why when we get to write a normal X program), but for + now, we put it there. +

    +

    + The window that is created by the above code has a default + background (gray). This one can be set to a specific color, + thanks to the two last parameters of + XCBCreateWindow(), which are not + described yet. See the subsections + Configuring a window or + Registering for event types using event masks + for exemples on how to use these parameters. In addition, as no + events are handled, you have to make a Ctrl-C to interrupt the + program. +

    +

    + TODO: one should tell what these functions return and + about the generic error +

    +
    +
    + Comparison Xlib/XCB +
    +
    +
      +
    • XCreateWindow ()
      • +
    +
    +
    +
      +
    • XCBWINDOWNew ()
      • +
    • XCBCreateWindow ()
      • +
    +
    +
    +

    +
  9. Drawing in a window
    10. +

    + Drawing in a window can be done using various graphical + functions (drawing pixels, lines, rectangles, etc). In order to + draw in a window, we first need to define various general + drawing parameters (what line width to use, which color to draw + with, etc). This is done using a graphical context. +

    +
      +
    1. Allocating a Graphics Context
      2. +

      + As we said, a graphical context defines several attributes to + be used with the various drawing functions. For this, we + define a graphical context. We can use more than one graphical + context with a single window, in order to draw in multiple + styles (different colors, different line widths, etc). In XCB, + a Graphics Context is, as a window, characterized by an Id: +

      + 
      +typedef struct {
+    CARD32 xid;
+} XCBGCONTEXT;
+
      +

      + We first ask the X server to attribute an Id to our graphic + context with this function: +

      + 
      +XCBGCONTEXT XCBGCONTEXTNew (XCBConnection *c);
+
      +

      + Then, we set the attributes of the graphic context with this function: +

      + 
      +XCBVoidCookie XCBCreateGC (XCBConnection *c,
+                           XCBGCONTEXT    cid,
+			   XCBDRAWABLE    drawable,
+			   CARD32         value_mask,
+			   const CARD32  *value_list);
+
      +

      + We give now an example on how to allocate a graphic context + that specifies that each drawing functions that use it will + draw in foreground with a black color. +

      + 
      +#include <X11/XCB/xcb.h>
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection *c;
+  XCBSCREEN     *screen;
+  XCBDRAWABLE    win;
+  XCBGCONTEXT    black;
+  CARD32         mask;
+  CARD32         value[1];
+  
+  /* Open the connection to the X server and get the first screen */
+  c = XCBConnect (NULL, NULL);
+  screen = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c)).data;
+
+  /* Create a black graphic context for drawing in the foreground */
+  win.window = screen->root;
+  black = XCBGCONTEXTNew (c);
+  mask = GCForeground;
+  value[0] = screen->black_pixel;
+  XCBCreateGC (c, black, win, mask, value);
+
+  return 1;
+}
+
      +

      + Note should be taken regarding the role of "value_mask" and + "value_list" in the prototype of XCBCreateGC(). Since a + graphic context has many attributes, and since we often just + want to define a few of them, we need to be able to tell the + XCBCreateGC() which attributes we + want to set. This is what the "value_mask" parameter is + for. We then use the "value_list" parameter to specify actual + values for the attribute we defined in "value_mask". Thus, for + each constant used in "value_list", we will use the matching + constant in "value_mask". In this case, we define a graphic + context with one attribute: when drawing (a point, a line, + etc), the foreground color will be black. The rest of the + attributes of this graphic context will be set to their + default values. +

      +

      + See the next Subsection for more details. +

      +
      +
      + Comparison Xlib/XCB +
      +
      +
        +
      • XCreateGC ()
        • +
      +
      +
      +
        +
      • XCBGCONTEXTNew ()
        • +
      • XCBCreateGC ()
        • +
      +
      +
      +

      +
    2. Changing the attributes of a Graphics Context
      3. +

      + Once we have allocated a Graphic Context, we may need to + change its attributes (for example, changing the foreground + color we use to draw a line, or changing the attributes of the + font we use to display strings. See Subsections Drawing with a + color and Assigning a Font to a Graphic Context). This is done + by using this function: +

      + 
      +XCBVoidCookie XCBChangeGC (XCBConnection *c,           /* The XCB Connection */
+                           XCBGCONTEXT    gc,          /* The Graphic Context */
+			   CARD32         value_mask,  /* Components of the Graphic Context that have to be set */
+			   const CARD32  *value_list); /* Value as specified by value_mask */
+
      +

      + The value_mask parameter could take + these values: +

      +
        +
      • GCFunction
        • +
      • GCPlaneMask
        • +
      • GCForeground
        • +
      • GCBackground
        • +
      • GCLineWidth
        • +
      • GCLineStyle
        • +
      • GCCapStyle
        • +
      • GCJoinStyle
        • +
      • GCFillStyle
        • +
      • GCFillRule
        • +
      • GCTile
        • +
      • GCStipple
        • +
      • GCTileStipXOrigin
        • +
      • GCTileStipYOrigin
        • +
      • GCFont
        • +
      • GCSubwindowMode
        • +
      • GCGraphicsExposures
        • +
      • GCClipXOrigin
        • +
      • GCClipYOrigin
        • +
      • GCClipMask
        • +
      • GCDashOffset
        • +
      • GCDashList
        • +
      • GCArcMode
        • +
      +

      + It is possible to set several attributes at the same + time (for example setting the attributes of a font and the + color which will be used to display a string), by OR'ing these + values in value_mask. Then + value_list has to be an array which + lists the value for the respective attributes. See Subsection + Drawing with a color to have an example. +

      +

      + TODO: set the links of the 3 subsections, once they will + be written :) +

      +

      + TODO: give an example which sets several attributes. +

      +
    3. Drawing primitives: point, line, box, circle,...
      4. +

      + After we have created a Graphic Context, we can draw on a + window using this Graphic Context, with a set of XCB + functions, collectively called "drawing primitive". Let see + how they are used. +

      +

      + To draw a point, or several points, we use +

      + 
      +XCBVoidCookie XCBPolyPoint (XCBConnection  *c,               /* The connection to the X server */
+                            BYTE            coordinate_mode, /* Coordinate mode, usually set to CoordModeOrigin */
+			    XCBDRAWABLE     drawable,        /* The drawable on which we want to draw the point(s) */
+			    XCBGCONTEXT     gc,              /* The Graphic Context we use to draw the point(s) */
+			    CARD32          points_len,      /* The number of points */
+			    const XCBPOINT *points);         /* An array of points */
+
      +

      + The coordinate_mode parameter + specifies the coordinate mode. Available values are +

      +
        +
      • CoordModeOrigin
        • +
      • CoordModePrevious
        • +
      +

      + The XCBPOINT type is just a + structure with two fields (the coordinates of the point): +

      + 
      +typedef struct {
+    INT16 x;
+    INT16 y;
+} XCBPOINT;
+
      +

      + You could see an example in xpoints.c. TODO Set the link. +

      +

      + To draw a line, or a polygonal line, we use +

      + 
      +XCBVoidCookie XCBPolyLine (XCBConnection  *c,               /* The connection to the X server */
+                           BYTE            coordinate_mode, /* Coordinate mode, usually set to CoordModeOrigin */
+			   XCBDRAWABLE     drawable,        /* The drawable on which we want to draw the line(s) */
+			   XCBGCONTEXT     gc,              /* The Graphic Context we use to draw the line(s) */
+			   CARD32          points_len,      /* The number of points in the polygonal line */
+			   const XCBPOINT *points);         /* An array of points */
+
      +

      + This function will draw the line between the first and the + second points, then the line between the second and the third + points, and so on. +

      +

      + To draw a segment, or several segments, we use +

      + 
      +XCBVoidCookie XCBPolySegment (XCBConnection    *c,              /* The connection to the X server */
+                              XCBDRAWABLE       drawable,       /* The drawable on which we want to draw the segment(s) */
+			      XCBGCONTEXT       gc,             /* The Graphic Context we use to draw the segment(s) */
+			      CARD32            segments_len,   /* The number of segments */
+			      const XCBSEGMENT *segments);      /* An array of segments */
+
      +

      + The XCBSEGMENT type is just a + structure with four fields (the coordinates of the two points + that define the segment): +

      + 
      +typedef struct {
+    INT16 x1;
+    INT16 y1;
+    INT16 x2;
+    INT16 y2;
+} XCBSEGMENT;
+
      +

      + To draw a rectangle, or several rectangles, we use +

      + 
      +XCBVoidCookie XCBPolyRectangle (XCBConnection      *c,              /* The connection to the X server */
+				XCBDRAWABLE         drawable,       /* The drawable on which we want to draw the rectangle(s) */
+				XCBGCONTEXT         gc,             /* The Graphic Context we use to draw the rectangle(s) */
+				CARD32              rectangles_len, /* The number of rectangles */
+				const XCBRECTANGLE *rectangles);    /* An array of rectangles */
+
      +

      + The XCBRECTANGLE type is just a + structure with four fields (the coordinates of the top-left + corner of the rectangle, and its width and height): +

      + 
      +typedef struct {
+    INT16 x;
+    INT16 y;
+    CARD16 width;
+    CARD16 height;
+} XCBRECTANGLE;
+
      +

      + TODO: there's no coordinate_mode. Is it normal ? +

      +

      + To draw an elliptical arc, or several elliptical arcs, we use +

      + 
      +XCBVoidCookie XCBPolyArc (XCBConnection *c,          /* The connection to the X server */
+                          XCBDRAWABLE    drawable,   /* The drawable on which we want to draw the arc(s) */
+			  XCBGCONTEXT    gc,         /* The Graphic Context we use to draw the arc(s) */
+			  CARD32         arcs_len,   /* The number of arcs */
+			  const XCBARC  *arcs);      /* An array of arcs */
+
      +

      + The XCBARC type is a structure with + six fields: +

      + 
      +typedef struct {
+    INT16 x;        /* Top left x coordinate of the rectangle surrounding the ellipse */
+    INT16 y;        /* Top left y coordinate of the rectangle surrounding the ellipse */
+    CARD16 width;   /* Width of the rectangle surrounding the ellipse */
+    CARD16 height;  /* Height of the rectangle surrounding the ellipse */
+    INT16 angle1;   /* Angle at which the arc begins */
+    INT16 angle2;   /* Angle at which the arc ends */
+} XCBARC;
+
      +
      +

      + Note: the angles are expressed in units of 1/64 of a degree, + so to have an angle of 90 degrees, starting at 0, + angle1 = 0 and + angle2 = 90 << 6. Positive angles + indicate counterclockwise motion, while negative angles + indicate clockwise motion. +

      +
      +

      + TODO: there's no coordinate_mode. Is it normal ? +

      +

      + TODO: I think that (x,y) should be the center of the + ellipse, and (width, height) the radius. It's more logical. +

      +

      + The corresponding function which fill inside the geometrical + object are listed below, without further explanation, as they + are used as the above functions. +

      +

      + To Fill a polygon defined by the points given as arguments , + we use +

      + 
      +XCBVoidCookie XCBFillPoly (XCBConnection  *c,
+                           XCBDRAWABLE     drawable,
+			   XCBGCONTEXT     gc,
+			   CARD8           shape,
+			   CARD8           coordinate_mode,
+			   CARD32          points_len,
+			   const XCBPOINT *points);
+
      +

      + The shape parameter specifies a + shape that helps the server to improve performance. Available + values are +

      +
        +
      • Complex
        • +
      • Convex
        • +
      • Nonconvex
        • +
      +

      + To fill one or several rectangles, we use +

      + 
      +XCBVoidCookie XCBPolyFillRectangle (XCBConnection      *c,
+                                    XCBDRAWABLE         drawable,
+				    XCBGCONTEXT         gc,
+				    CARD32              rectangles_len,
+				    const XCBRECTANGLE *rectangles);
+
      +

      + To fill one or several arcs, we use +

      + 
      +XCBVoidCookie XCBPolyFillArc (XCBConnection *c,
+                              XCBDRAWABLE    drawable,
+			      XCBGCONTEXT    gc,
+			      CARD32         arcs_len,
+			      const XCBARC  *arcs);
+
      +

      +

      + To illustrate these functions, here is an example that draws + four points, a polygonal line, two segments, two rectangles + and two arcs. Remark that we use events for the first time, as + an introduction to the next section. +

      + 
      +#include <stdlib.h>
+#include <stdio.h>
+
+#include <X11/XCB/xcb.h>
+
+/* Get the depth of the screen. Needed in order to draw something */
+int
+get_depth(XCBConnection *c,
+	  XCBSCREEN     *root)
+{
+  XCBDRAWABLE        drawable;
+  XCBGetGeometryRep *geom;
+  int                depth;
+
+  drawable.window = root->root;
+  geom = XCBGetGeometryReply (c, XCBGetGeometry(c, drawable), 0);
+
+  if(!geom)
+    {
+      perror ("GetGeometry(root) failed");
+      exit (0);
+    }
+  
+  depth = geom->depth;
+  free (geom);
+
+  return depth;
+}
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection   *c;
+  XCBSCREEN       *screen;
+  XCBDRAWABLE      win;
+  XCBGCONTEXT      foreground;
+  XCBGenericEvent *e;
+  CARD32           mask = 0;
+  CARD32           values[2];
+
+  /* geometric objects */
+  XCBPOINT         points[] = {
+    {10, 10},
+    {10, 20},
+    {20, 10},
+    {20, 20}};
+
+  XCBPOINT         polyline[] = {
+    {50, 10},
+    {55, 30},
+    {80, 10},
+    {90, 20}};
+
+  XCBSEGMENT       segments[] = {
+    {100, 10, 140, 30},
+    {110, 25, 130, 60}};
+
+  XCBRECTANGLE     rectangles[] = {
+    { 10, 50, 40, 20},
+    { 80, 50, 10, 40}};
+
+  XCBARC           arcs[] = {
+    {10, 100, 60, 40, 0, 90 << 6},
+    {90, 100, 55, 40, 0, 270 << 6}};
+  
+  /* Open the connection to the X server */
+  c = XCBConnect (NULL, NULL);
+  
+  /* Get the first screen */
+  screen = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c)).data;
+
+  /* Create black (foregroung) graphic context */
+  win.window = screen->root;
+
+  foreground = XCBGCONTEXTNew (c);
+  mask = GCForeground | GCGraphicsExposures;
+  values[0] = screen->black_pixel;
+  values[1] = 0;
+  XCBCreateGC (c, foreground, win, mask, values);
+
+  /* Ask for our window's Id */
+  win.window = XCBWINDOWNew(c);
+
+  /* Create the window */
+  mask = XCBCWBackPixel | XCBCWEventMask;
+  values[0] = screen->white_pixel;
+  values[1] = ExposureMask;
+  XCBCreateWindow (c,                        /* Connection          */
+ 		   0,                        /* depth               */
+		   win.window,               /* window Id           */
+		   screen->root,             /* parent window       */
+		   0, 0,                     /* x, y                */
+		   150, 150,                 /* width, height       */
+		   10,                       /* border_width        */
+		   InputOutput,              /* class               */
+		   screen->root_visual,      /* visual              */
+		   mask, values);            /* masks */
+
+  /* Map the window on the screen */
+  XCBMapWindow (c, win.window);
+
+
+  /* We flush the request */
+  XCBSync (c, 0);
+
+  while ((e = XCBWaitEvent (c)))
+    {
+      switch (e->response_type)
+	{
+	case XCBExpose:
+	  {
+	    /* We draw the points */
+	    XCBPolyPoint (c, CoordModeOrigin, win, foreground, 4, points);
+	    
+	    /* We draw the polygonal line */
+	    XCBPolyLine (c, CoordModeOrigin, win, foreground, 4, polyline);
+	    
+	    /* We draw the segements */
+	    XCBPolySegment (c, win, foreground, 2, segments);
+	    
+	    /* We draw the rectangles */
+	    XCBPolyRectangle (c, win, foreground, 2, rectangles);
+	    
+	    /* We draw the arcs */
+	    XCBPolyArc (c, win, foreground, 2, arcs);
+
+	    /* We flush the request */
+	    XCBSync (c, 0);
+	    
+	    break;
+	  }
+	default:
+	  {
+	    /* Unknown event type, ignore it */
+	    break;
+	  }
+	}
+      /* Free the Generic Event */
+      free (e);
+    }
+
+  return 1;
+}
+
      +
    +
  10. X Events
    11. +

    + In an X program, everything is driven by events. Event painting + on the screen is sometimes done as a response to an event (an + Expose event). If part of a program's + window that was hidden, gets exposed (e.g. the window was raised + above other widows), the X server will send an "expose" event to + let the program know it should repaint that part of the + window. User input (key presses, mouse movement, etc) is also + received as a set of events. +

    +
      +
    1. Registering for event types using event masks
      2. +

      + During the creation of a window, you should give it what kind + of events it wishes to receive. Thus, you may register for + various mouse (also called pointer) events, keyboard events, + expose events, and so on. This is done for optimizing the + server-to-client connection (i.e. why send a program (that + might even be running at the other side of the globe) an event + it is not interested in ?) +

      +

      + In XCB, you use the "value_mask" and "value_list" data in the + XCBCreateWindow() function to + register for events. Here is how we register for + Expose event when creating a window: +

      + 
      +  mask = XCBCWEventMask;
+  valwin[0] = ExposureMask;
+  win.window = XCBWINDOWNew (c);
+  XCBCreateWindow (c, depth, win.window, root->root,
+		   0, 0, 150, 150, 10,
+		   InputOutput, root->root_visual,
+		   mask, valwin);
+
      +

      + ExposureMask is a constant defined + in the "X.h" header file. If we wanted to register to several + event types, we can logically "or" them, as follows: +

      + 
      +  mask = XCBCWEventMask;
+  valwin[0] = ExposureMask | ButtonPressMask;
+  win.window = XCBWINDOWNew (c);
+  XCBCreateWindow (c, depth, win.window, root->root,
+		   0, 0, 150, 150, 10,
+		   InputOutput, root->root_visual,
+		   mask, valwin);
+
      +

      + This registers for Expose events as + well as for mouse button presses insode the created + window. You should note that a mask may represent several + event sub-types. +

      +

      + The values that a mask could take are given + by the XCBCW enumeration: +

      + 
      +typedef enum {
+    XCBCWBackPixmap       = 1L<<0,
+    XCBCWBackPixel        = 1L<<1,
+    XCBCWBorderPixmap     = 1L<<2,
+    XCBCWBorderPixel      = 1L<<3,
+    XCBCWBitGravity       = 1L<<4,
+    XCBCWWinGravity       = 1L<<5,
+    XCBCWBackingStore     = 1L<<6,
+    XCBCWBackingPlanes    = 1L<<7,
+    XCBCWBackingPixel     = 1L<<8,
+    XCBCWOverrideRedirect = 1L<<9,
+    XCBCWSaveUnder        = 1L<<10,
+    XCBCWEventMask        = 1L<<11,
+    XCBCWDontPropagate    = 1L<<12,
+    XCBCWColormap         = 1L<<13,
+    XCBCWCursor           = 1L<<14
+} XCBCW;
+
      +
      +

      Note: we must be careful when setting the values of the valwin + parameter, as they have to follow the order the + XCBCW enumeration. Here is an + example: +

      +
      + 
      +  mask = XCBCWEventMask | XCBCWBackPixmap;
+  valwin[0] = None;                           /* for XCBCWBackPixmap (whose value is 1)    */
+  valwin[1] = ExposureMask | ButtonPressMask; /* for XCBCWEventMask, whose value (2048)    */
+                                              /* is superior to the one of XCBCWBackPixmap */
+
      +

      + If the window has already been created, we can use the + XCBConfigureWindow() function to set + the events that the window will receive. The subsection + Configuring a window shows its + prototype. As an example, here is a piece of code that + configures the window to receive the + Expose and + ButtonPressMask events: +

      + 
      +const static CARD32 values[] = { ExposureMask | ButtonPressMask };
+
+/* The connection c and the window win are supposed to be defined */
+
+XCBConfigureWindow (c, win, XCBCWEventMask, values);
+
      +
      +

      + Note: A common bug programmers do is adding code to handle new + event types in their program, while forgetting to add the + masks for these events in the creation of the window. Such a + programmer then should sit down for hours debugging his + program, wondering "Why doesn't my program notice that I + released the button?", only to find that they registered for + button press events but not for button release events. +

      +
      +
    2. Receiving events: writing the events loop
      3. +

      + After we have registered for the event types we are interested + in, we need to enter a loop of receiving events and handling + them. There are two ways to receive events: a blocking way and + a non blocking way: +

      +
        +
      • + XCBWaitEvent (XCBConnection *c) + is the blocking way. It waits (so blocks...) until an event is + queued in the X server. Then it retrieves it into a newly + allocated structure (it dequeues it from the queue) and returns + it. This structure has to be freed. The function returns + NULL if an error occurs. +
        • +
        +
      • + XCBPollForEvent (XCBConnection *c, int + *error) is the non blocking way. It looks at the event + queue and returns (and dequeues too) an existing event into + a newly allocated structure. This structure has to be + freed. It returns NULL if there is + no event. If an error occurs, the parameter error will be filled with the error + status. +
        • +
      +

      + There are various ways to write such a loop. We present two + ways to write such a loop, with the two functions above. The + first one uses XCBWaitEvent, which + is similar to an event Xlib loop using only XNextEvent: +

      + 
      +  XCBGenericEvent *e;
+
+  while ((e = XCBWaitEvent (c)))
+    {
+      switch (e->response_type)
+	{
+	case XCBExpose:
+	  {
+	    /* Handle the Expose event type */
+	    XCBExposeEvent *ev = (XCBExposeEvent *)e;
+
+	    /* ... */
+
+	    break;
+	  }
+	case XCBButtonPress: 
+	  {
+	    /* Handle the ButtonPress event type */
+	    XCBButtonPressEvent *ev = (XCBButtonPressEvent *)e;
+
+	    /* ... */
+
+	    break;
+	  }
+	default:
+	  {
+	    /* Unknown event type, ignore it */
+	    break;
+	  }
+	}
+      /* Free the Generic Event */
+      free (e);
+    }
+
      +

      + You will certainly want to use XCBPollForEvent(XCBConnection *c, int + *error) if, in Xlib, you use XPending: +

      + 
      +  while (XPending (display))
+    {
+      XEvent ev;
+
+      XNextEvent(d, &ev);
+      
+      /* Manage your event */
+    }
+
      +

      + Such a loop in XCB looks like: +

      + 
      +  XCBGenericEvent *ev;
+
+  while ((ev = XCBPollForEvent (conn, 0)))
+    {
+      /* Manage your event */
+    }
+
      +

      + The events are managed in the same way as with XCBWaitEvent. + Obviously, we will need to give the user some way of + terminating the program. This is usually done by handling a + special "quit" event, as we will soon see. +

      +
      +
      + Comparison Xlib/XCB +
      +
      +
        +
      • XNextEvent ()
        • +
      +
      +
      +
        +
      • XCBWaitEvent ()
        • +
      +
      +
      +
        +
      • XPending ()
        • +
      • XNextEvent ()
        • +
      +
      +
      +
        +
      • XCBPollForEvent ()
        • +
        +
      +
      +
      +

      +

    3. Expose events
      4. +

      + The Expose event is one of the most + basic (and most used) events an application may receive. It + will be sent to us in one of several cases: +

        +
      • A window that covered part of our window has moved + away, exposing part (or all) of our window.
        • +
      • Our window was raised above other windows.
        • +
      • Our window mapped for the first time.
        • +
      • Our window was de-iconified.
        • +
      +

      +

      + You should note the implicit assumption hidden here: the + contents of our window is lost when it is being obscured + (covered) by either windows. One may wonder why the X server + does not save this contents. The answer is: to save + memory. After all, the number of windows on a display at a + given time may be very large, and storing the contents of all + of them might require a lot of memory. Actually, there is a + way to tell the X server to store the contents of a window in + special cases, as we will see later. +

      +

      + When we get an Expose event, we + should take the event's data from the members of the following + structure: +

      + 
      +typedef struct {
+    BYTE response_type;  /* The type of the event, here it is XCBExpose */
+    CARD8 pad0;
+    CARD16 sequence;
+    XCBWINDOW window;    /* The Id of the window that receives the event (in case */
+                         /* our application registered for events on several windows */
+    CARD16 x;            /* The x coordinate of the top-left part of the window that needs to be redrawn */
+    CARD16 y;            /* The y coordinate of the top-left part of the window that needs to be redrawn */
+    CARD16 width;        /* The width of the part of the window that needs to be redrawn */
+    CARD16 height;       /* The height of the part of the window that needs to be redrawn */
+    CARD16 count;
+} XCBExposeEvent;
+
      +
    4. Getting user input
      5. +

      + User input traditionally comes from two sources: the mouse + and the keyboard. Various event types exist to notify us of + user input (a key being presses on the keyboard, a key being + released on the keyboard, the mouse moving over our window, + the mouse entering (or leaving) our window, and so on. +

      +
        +
      1. Mouse button press and release events
        2. +

        + The first event type we will deal with is a mouse + button-press (or button-release) event in our window. In + order to register to such an event type, we should add one + (or more) of the following masks when we create our window: +

        +
          +
        • ButtonPressMask: notify us + of any button that was pressed in one of our windows.
          • +
        • ButtonReleaseMask: notify us + of any button that was released in one of our windows.
          • +
        +

        + The structure to be checked for in our events loop is the + same for these two events, and is the following: +

        + 
        +typedef struct {
+    BYTE response_type;  /* The type of the event, here it is XCBButtonPressEvent or XCBButtonReleaseEvent */
+    XCBBUTTON detail;
+    CARD16 sequence;
+    XCBTIMESTAMP time;   /* Time, in milliseconds the event took place in */
+    XCBWINDOW root;
+    XCBWINDOW event;
+    XCBWINDOW child;
+    INT16 root_x;
+    INT16 root_y;
+    INT16 event_x;       /* The x coordinate where the mouse has been pressed in the window */
+    INT16 event_y;       /* The y coordinate where the mouse has been pressed in the window */
+    CARD16 state;        /* A mask of the buttons (or keys) during the event */
+    BOOL same_screen;
+} XCBButtonPressEvent;
+
+typedef XCBButtonPressEvent XCBButtonReleaseEvent;
+
        +

        + The time field may be used to calculate "double-click" + situations by an application (e.g. if the mouse button was + clicked two times in a duration shorter than a given amount + of time, assume this was a double click). +

        +

        + The state field is a mask of the buttons held down during + the event. It is a bitwise OR of any of the following: +

        +
          +
        • Button1Mask
          • +
        • Button2Mask
          • +
        • Button3Mask
          • +
        • Button4Mask
          • +
        • Button5Mask
          • +
        • ShiftMask
          • +
        • LockMask
          • +
        • ControlMask
          • +
        • Mod1Mask
          • +
        • Mod2Mask
          • +
        • Mod3Mask
          • +
        • Mod4Mask
          • +
        • Mod5Mask
          • +
        +

        + Their names are self explanatory, where the first 5 refer to + the mouse buttons that are being pressed, while the rest + refer to various "special keys" that are being pressed (Mod1 + is usually the 'Alt' key or the 'Meta' key). +

        +

        + TODO: Problem: it seems that the state does not + change when clicking with various buttons. +

        +
      2. Mouse movement events
        3. +

        + Similar to mouse button press and release events, we also + can be notified of various mouse movement events. These can + be split into two families. One is of mouse pointer + movement while no buttons are pressed, and the second is a + mouse pointer motion while one (or more) of the buttons are + pressed (this is sometimes called "a mouse drag operation", + or just "dragging"). The following event masks may be added + during the creation of our window: +

        +
          +
        • PointerMotionMask: events of + the pointer moving in one of the windows controlled by our + application, while no mouse button is held pressed.
          • +
        • ButtonMotionMask: Events of + the pointer moving while one or more of the mouse buttons + is held pressed.
          • +
        • Button1MotionMask: same as + ButtonMotionMask, but only when + the 1st mouse button is held pressed.
          • +
        • Button2MotionMask, + Button3MotionMask, + Button4MotionMask, + Button5MotionMask: same as + Button1MotionMask, but + respectively for 2nd, 3rd, 4th and 5th mouse button.
          • +
        +

        + The structure to be checked for in our events loop is the + same for these events, and is the following: +

        + 
        +typedef struct {
+    BYTE response_type;  /* The type of the event */
+    BYTE detail;
+    CARD16 sequence;
+    XCBTIMESTAMP time;   /* Time, in milliseconds the event took place in */
+    XCBWINDOW root;
+    XCBWINDOW event;
+    XCBWINDOW child;
+    INT16 root_x;
+    INT16 root_y;
+    INT16 event_x;       /* The x coordinate of the mouse when the  event was generated */
+    INT16 event_y;       /* The y coordinate of the mouse when the  event was generated */
+    CARD16 state;        /* A mask of the buttons (or keys) during the event */
+    BOOL same_screen;
+} XCBMotionNotifyEvent;
+
        +
      3. Mouse pointer enter and leave events
        4. +

        + Another type of event that applications might be interested + at, is a mouse pointer entering a window the program + controls, or leaving such a window. Some programs use these + events to show the user tht the applications is now in + focus. In order to register for such an event type, we + should add one (or more) of the following masks when we + create our window: +

        +
          +
        • EnterWindowMask: notify us + when the mouse pointer enters any of our controlled + windows.
          • +
        • LeaveWindowMask: notify us + when the mouse pointer leaves any of our controlled + windows.
          • +
        +

        + The structure to be checked for in our events loop is the + same for these two events, and is the following: +

        + 
        +typedef struct {
+    BYTE response_type;  /* The type of the event */
+    BYTE detail;
+    CARD16 sequence;
+    XCBTIMESTAMP time;   /* Time, in milliseconds the event took place in */
+    XCBWINDOW root;
+    XCBWINDOW event;
+    XCBWINDOW child;
+    INT16 root_x;
+    INT16 root_y;
+    INT16 event_x;       /* The x coordinate of the mouse when the  event was generated */
+    INT16 event_y;       /* The y coordinate of the mouse when the  event was generated */
+    CARD16 state;        /* A mask of the buttons (or keys) during the event */
+    BYTE mode;           /* The number of mouse button that was clicked */
+    BYTE same_screen_focus;
+} XCBEnterNotifyEvent;
+
+typedef XCBEnterNotifyEvent XCBLeaveNotifyEvent;
+
        +
      4. The keyboard focus
        5. +

        + There may be many windows on a screen, but only a single + keyboard attached to them. How does the X server then know + which window should be sent a given keyboard input ? This is + done using the keyboard focus. Only a single window on the + screen may have the keyboard focus at a given time. There + is a XCB function that allow a program to set the keyboard + focus to a given window. The user can usually set the + keyboard ficus using the window manager (often by clicking + on the title bar of the desired window). Once our window + has the keyboard focus, every key press or key release will + cause an event to be sent to our program (if it regsitered + for these event types...). +

        +
      5. Keyboard press and release events
        6. +

        + If a window controlled by our program currently holds the + keyboard focus, it can receive key press and key release + events. So, we should add one (or more) of the following + masks when we create our window: +

        +
          +
        • KeyPressMask: notify us when + a key was pressed while any of our controlled windows had + the keyboard focus.
          • +
        • KeyReleaseMask: notify us + when a key was released while any of our controlled + windows had the keyboard focus.
          • +
        +

        + The structure to be checked for in our events loop is the + same for these two events, and is the following: +

        + 
        +typedef struct {
+    BYTE response_type;  /* The type of the event */
+    XCBKEYCODE detail;
+    CARD16 sequence;
+    XCBTIMESTAMP time;   /* Time, in milliseconds the event took place in */
+    XCBWINDOW root;
+    XCBWINDOW event;
+    XCBWINDOW child;
+    INT16 root_x;
+    INT16 root_y;
+    INT16 event_x;
+    INT16 event_y;
+    CARD16 state;
+    BOOL same_screen;
+} XCBKeyPressEvent;
+
+typedef XCBKeyPressEvent XCBKeyReleaseEvent;
+
        +

        + The detail field refer to the + physical key on the keyboard. +

        +

        + TODO: Talk about getting the ASCII code from the key code. +

        +
      +
    5. X events: a complete example
      6. +

      + As an example for handling events, we show a program that + creates a window, enter an events loop and check for all the + events described above, and write on the terminal the relevant + characteristics of the event. With this code, it should be + easy to add drawing operations, like those which have been + described above. +

      + 
      +#include <malloc.h>
+#include <stdio.h>
+
+#include <X11/XCB/xcb.h>
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection   *c;
+  XCBSCREEN       *screen;
+  XCBDRAWABLE      win;
+  XCBGenericEvent *e;
+  CARD32           mask = 0;
+  CARD32           values[2];
+  
+  /* Open the connection to the X server */
+  c = XCBConnect (NULL, NULL);
+  
+  /* Get the first screen */
+  screen = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c)).data;
+
+  /* Ask for our window's Id */
+  win.window = XCBWINDOWNew(c);
+
+  /* Create the window */
+  mask = XCBCWBackPixel | XCBCWEventMask;
+  values[0] = screen->white_pixel;
+  values[1] = ExposureMask      | ButtonPressMask  | ButtonReleaseMask |
+              PointerMotionMask | EnterWindowMask  | LeaveWindowMask   |
+               KeyPressMask     | KeyReleaseMask;
+  XCBCreateWindow (c,                        /* Connection          */
+ 		   0,                        /* depth               */
+		   win.window,               /* window Id           */
+		   screen->root,             /* parent window       */
+		   0, 0,                     /* x, y                */
+		   150, 150,                 /* width, height       */
+		   10,                       /* border_width        */
+		   InputOutput,              /* class               */
+		   screen->root_visual,      /* visual              */
+		   mask, values);            /* masks */
+
+  /* Map the window on the screen */
+  XCBMapWindow (c, win.window);
+
+  XCBSync (c, 0);
+  while ((e = XCBWaitEvent (c)))
+    {
+      switch (e->response_type)
+	{
+	case XCBExpose:
+	  {
+	    XCBExposeEvent *ev = (XCBExposeEvent *)e;
+	    
+	    printf ("Window %ld exposed. Region to be redrawn at location (%d,%d), with dimension (%d,%d)\n",
+	            ev->window.xid, ev->x, ev->y, ev->width, ev->height);
+	    break;
+	  }
+	case XCBButtonPress: 
+	  {
+	    XCBButtonPressEvent *ev = (XCBButtonPressEvent *)e;
+	    int                  button_num = 0;
+	    
+	    if ((ev->state | Button1Mask) == Button1Mask)
+	      button_num = 1;
+	    if ((ev->state | Button2Mask) == Button2Mask)
+	      button_num = 2;
+	    if ((ev->state | Button3Mask) == Button3Mask)
+	      button_num = 3;
+	    if ((ev->state | Button4Mask) == Button4Mask)
+	      button_num = 4;
+	    if ((ev->state | Button5Mask) == Button5Mask)
+	      button_num = 5;
+	      
+	    switch (ev->detail.id)
+	      {
+	      case 4:
+	        {
+		printf ("Wheel Button up in window %ld, at coordinates (%d,%d)\n",
+                        ev->event.xid, ev->event_x, ev->event_y);
+		break;
+		}
+	      case 5:
+	        {
+		printf ("Wheel Button down in window %ld, at coordinates (%d,%d)\n",
+                        ev->event.xid, ev->event_x, ev->event_y);
+		break;
+		}
+	      default:
+	        printf ("Button %d pressed in window %ld, at coordinates (%d,%d)\n",
+                        ev->detail.id, ev->event.xid, ev->event_x, ev->event_y);
+	      }
+	    break;
+	  }
+	case XCBButtonRelease: 
+	  {
+	    XCBButtonReleaseEvent *ev = (XCBButtonReleaseEvent *)e;
+	    int                  button_num = 0;
+	    
+	    if ((ev->state | Button1Mask) == Button1Mask)
+	      button_num = 1;
+	    if ((ev->state | Button2Mask) == Button2Mask)
+	      button_num = 2;
+	    if ((ev->state | Button3Mask) == Button3Mask)
+	      button_num = 3;
+	    if ((ev->state | Button4Mask) == Button4Mask)
+	      button_num = 4;
+	    if ((ev->state | Button5Mask) == Button5Mask)
+	      button_num = 5;
+	    
+	    printf ("Button %d released in window %ld, at coordinates (%d,%d)\n",
+                    ev->detail.id, ev->event.xid, ev->event_x, ev->event_y);
+	    break;
+	  }
+	case XCBMotionNotify:
+	  {
+	    XCBMotionNotifyEvent *ev = (XCBMotionNotifyEvent *)e;
+	    
+	    printf ("Mouse moved in window %ld, at coordinates (%d,%d)\n",
+                    ev->event.xid, ev->event_x, ev->event_y);
+	    break;
+	  }
+	case XCBEnterNotify:
+	  {
+	    XCBEnterNotifyEvent *ev = (XCBEnterNotifyEvent *)e;
+	    
+	    printf ("Mouse entered window %ld, at coordinates (%d,%d)\n",
+                    ev->event.xid, ev->event_x, ev->event_y);
+	    break;
+	  }
+	case XCBLeaveNotify:
+	  {
+	    XCBLeaveNotifyEvent *ev = (XCBLeaveNotifyEvent *)e;
+	    
+	    printf ("Mouse leaved window %ld, at coordinates (%d,%d)\n",
+                    ev->event.xid, ev->event_x, ev->event_y);
+	    break;
+	  }
+	case XCBKeyPress: 
+	  {
+	    XCBKeyPressEvent *ev = (XCBKeyPressEvent *)e;
+
+	    printf ("Key pressed in window %ld\n",
+                    ev->event.xid);
+	    break;
+	  }
+	case XCBKeyRelease: 
+	  {
+	    XCBKeyReleaseEvent *ev = (XCBKeyReleaseEvent *)e;
+
+	    printf ("Key releaseed in window %ld\n",
+                    ev->event.xid);
+	    break;
+	  }
+	default:
+	  {
+	    /* Unknown event type, ignore it */
+	    break;
+	  }
+	}
+      /* Free the Generic Event */
+      free (e);
+    }
+
+  return 1;
+}
+
      +
    +
  11. Handling text and fonts
    12. +

    + Besides drawing graphics on a window, we often want to draw + text. Text strings have two major properties: the characters to + be drawn and the font with which they are drawn. In order to + draw text, we need to first request the X server to load a + font. We the assign a font to a Graphic Context, and finally, we + draw the text in a window, using the Graphic Context. +

    +
      +
    1. The Font structure
      2. +

      + In order to support flexible fonts, a font structure is + defined. You know what ? Its an Id: +

      + 
      +typedef struct {
+    CARD32 xid;
+} XCBFONT;
+
      +

      + It is used to contain information about a font, and is passed + to several functions that handle fonts selection and text drawing. +

      +
    +
  12. Interacting with the window manager
    13. +

    + After we have seen how to create windows and draw on them, we + take one step back, and look at how our windows are interacting + with their environment (the full screen and the other + windows). First of all, our application needs to interact with + the window manager. The window manager is responsible to + decorating drawn windows (i.e. adding a frame, an iconify + button, a system menu, a title bar, etc), as well as handling + icons shown when windows are being iconified. It also handles + ordering of windows on the screen, and other administrative + tasks. We need to give it various hints as to how we want it to + treat our application's windows. +

    +
      +
    1. Window properties
      2. +

      + Many of the parameters communicated to the window manager are + passed using data called "properties". These properties are + attached by the X server to different windows, and are stores + in a format that makes it possible to read them from different + machines that may use different architectures (remember that + an X client program may run on a remote machine). +

      +

      + The property and its type (a string, an integer, etc) are + Id. Their type are XCBATOM: +

      + 
      +typedef struct {
+    CARD32 xid;
+} XCBATOM;
+
      +

      + To change the property of a window, we use the following + function: +

      + 
      +XCBVoidCookie XCBChangeProperty (XCBConnection *c,  /* Connection to the X server */
+                                 CARD8 mode,        /* Property mode */
+				 XCBWINDOW window,  /* Window */
+				 XCBATOM property,  /* Property to change */
+				 XCBATOM type,      /* Type of the property */
+				 CARD8 format,      /* Format of the property (8, 16, 32) */
+				 CARD32 data_len,   /* Length of the data parameter */
+				 const void *data); /* Data */
+
      +

      + The mode parameter coud be one of + the following value (defined in the X.h header file): +

      +
        +
      • PropModeReplace
        • +
      • PropModePrepend
        • +
      • PropModeAppend
        • +
      +

      +
    2. Setting the window name and icon name
      3. +

      + The firt thing we want to do would be to set the name for our + window. This is done using the + XCBChangeProperty() function. This + name may be used by the window manager as the title of the + window (in the title bar), in a task list, etc. The property + atom to use to set the name of a window is + WM_NAME (and + WM_ICON_NAME for the iconified + window) and its type is STRING. Here + is an example of utilization: +

      + 
      +#include <string.h>
+
+#include <X11/XCB/xcb.h>
+#include <X11/XCB/xcb_atom.h>
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection *c;
+  XCBSCREEN     *screen;
+  XCBDRAWABLE    win;
+  char          *title = "Hello World !";
+  char          *title_icon = "Hello World ! (iconified)";
+
+
+  
+  /* Open the connection to the X server */
+  c = XCBConnect (NULL, NULL);
+  
+  /* Get the first screen */
+  screen = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c)).data;
+
+  /* Ask for our window's Id */
+  win.window = XCBWINDOWNew(c);
+
+  /* Create the window */
+  XCBCreateWindow (c,                        /* Connection          */
+ 		   0,                        /* depth               */
+		   win.window,               /* window Id           */
+		   screen->root,             /* parent window       */
+		   0, 0,                     /* x, y                */
+		   250, 150,                 /* width, height       */
+		   10,                       /* border_width        */
+		   InputOutput,              /* class               */
+		   screen->root_visual,      /* visual              */
+		   0, NULL);                 /* masks, not used     */
+
+  /* Set the title of the window */
+  XCBChangeProperty(c, PropModeReplace, win.window,
+		    WM_NAME, STRING, 8,
+		    strlen(title), title);
+
+  /* Set the title of the window icon */
+  XCBChangeProperty(c, PropModeReplace, win.window,
+		    WM_ICON_NAME, STRING, 8,
+		    strlen(title_icon), title_icon);
+
+  /* Map the window on the screen */
+  XCBMapWindow (c, win.window);
+
+  XCBSync (c, 0);
+  
+  while (1) {}
+
+  return 1;
+}
+
      +
      +

      Note: the use of the atoms needs our program to be compiled + and linked against xcb_atom, so that we have to use +

      +
      + 
      +gcc prog.c -o prog `pkg-config --cflags --libs xcb_atom`
+
      +
      +

      + for the program to compile fine. +

      +
      +
    +
  13. Simple window operations
    14. +

    + One more thing we can do to our window is manipulate them on the + screen (resize them, move them, raise or lower them, iconify + them, and so on). Some window operations functions are supplied + by XCB for this purpose. +

    +
      +
    1. Mapping and un-mapping a window
      2. +

      + The first pair of operations we can apply on a window is + mapping it, or un-mapping it. Mapping a window causes the + window to appear on the screen, as we have seen in our simple + window program example. Un-mapping it causes it to be removed + from the screen (although the window as a logical entity still + exists). This gives the effect of making a window hidden + (unmapped) and shown again (mapped). For example, if we have a + dialog box window in our program, instead of creating it every + time the user asks to open it, we can create the window once, + in an un-mapped mode, and when the user asks to open it, we + simply map the window on the screen. When the user clicked the + 'OK' or 'Cancel' button, we simply un-map the window. This is + much faster than creating and destroying the window, however, + the cost is wasted resources, both on the client side, and on + the X server side. +

      +

      + To map a window, you use the following function: +

      + 
      +XCBVoidCookie XCBMapWindow(XCBConnection *c, XCBWINDOW window);
+
      +

      + To have a simple example, see the example + above. The mapping operation will cause an + Expose event to be sent to our + application, unless the window is completely covered by other + windows. +

      +

      + Un-mapping a window is also simple. You use the function +

      + 
      +XCBVoidCookie XCBUnmapWindow(XCBConnection *c, XCBWINDOW window);
+
      +

      + The utilization of this function is the same as + XCBMapWindow(). +

      +
    2. Configuring a window
      3. +

      + As we have seen when we have created our first window, in the + X Events subsection, we can set some attributes to the window + (that is, the position, the size, the events the window will + receive, etc). If we want to modify them, but the window is + already created, we can change them by using hte following + function: +

      + 
      +XCBVoidCookie XCBConfigureWindow (XCBConnection *c,            /* The connection to the X server*/
+                                  XCBWINDOW      window,       /* The window to configure */
+				  CARD16         value_mask,   /* The mask */
+				  const CARD32  *value_list);  /* The values to set */
+
      +

      + We set the value_mask to one or + several mask values that are in the X.h header: +

        +
      • CWX: new x coordinate of the window's top left corner
        • +
      • CWY: new y coordinate of the window's top left corner
        • +
      • CWWidth: new width of the window
        • +
      • CWHeight: new height of the window
        • +
      • CWBorderWidth: new width of the border of the window
        • +
      • CWSibling
        • +
      • CWStackMode: the new stacking order
        • +
      +

      +

      + We then give to value_mask the new + value. We now describe how to use + XCBConfigureWindow in some useful + situations. +

      +
    3. Moving a window around the screen
      4. +

      + An operation we might want to do with windows is to move them + to a different location. This can be done like this: +

      + 
      +const static CARD32 values[] = { 10, 20 };
+
+/* The connection c and the window win are supposed to be defined */
+
+/* Move the window to coordinates x = 10 and y = 20 */
+XCBConfigureWindow (c, win, CWX | CWY, values);
+
      +

      + Note that when the window is moved, it might get partially + exposed or partially hidden by other windows, and thus we + might get Expose events due to this + operation. +

      +
    4. Resizing a window
      5. +

      + Yet another operation we can do is to change the size of a + window. This is done using the following code: +

      + 
      +const static CARD32 values[] = { 200, 300 };
+
+/* The connection c and the window win are supposed to be defined */
+
+/* Resize the window to width = 10 and height = 20 */
+XCBConfigureWindow (c, win, CWWidth | CWHeight, values);
+
      +

      + We can also combine the move and resize operations using one + single call to XCBConfigureWindow: +

      + 
      +const static CARD32 values[] = { 10, 20, 200, 300 };
+
+/* The connection c and the window win are supposed to be defined */
+
+/* Move the window to coordinates x = 10 and y = 20 */
+/* and resize the window to width = 10 and height = 20 */
+XCBConfigureWindow (c, win, CWX | CWY | CWWidth | CWHeight, values);
+
      +
    5. Changing windows stacking order: raise and lower
      6. +

      + Until now, we changed properties of a single window. We'll see + that there are properties that relate to the window and other + windows. One of hem is the stacking order. That is, the order + in which the windows are layered on top of each other. The + front-most window is said to be on the top of the stack, while + the back-most window is at the bottom of the stack. Here is + how to manipulate our windows stack order: +

      + 
      +const static CARD32 values[] = { Above };
+
+/* The connection c and the window win are supposed to be defined */
+
+/* Move the window on the top of the stack */
+XCBConfigureWindow (c, win, CWStackMode, values);
+
      + 
      +const static CARD32 values[] = { Below };
+
+/* The connection c and the window win are supposed to be defined */
+
+/* Move the window on the bottom of the stack */
+XCBConfigureWindow (c, win, CWStackMode, values);
+
      +
    6. Getting information about a window
      7. +

      + Just like we can set various attributes of our windows, we can + also ask the X server supply the current values of these + attributes. For example, we can chewk where a window is + located on the screen, what is its current size, wheter it is + mapped or not, etc. The structure that contains some of this + information is +

      + 
      +typedef struct {
+    BYTE response_type;
+    CARD8 depth;            /* depth of the window */
+    CARD16 sequence;
+    CARD32 length;
+    XCBWINDOW root;         /* Id of the root window *>
+    INT16 x;                /* X coordinate of the window's location */
+    INT16 y;                /* Y coordinate of the window's location */
+    CARD16 width;           /* Width of the window */
+    CARD16 height;          /* Height of the window */
+    CARD16 border_width;    /* Width of the window's border */
+} XCBGetGeometryRep;
+
      +

      + XCB fill this structure with two functions: +

      + 
      +XCBGetGeometryCookie  XCBGetGeometry      (XCBConnection         *c,
+                                           XCBDRAWABLE            drawable);
+XCBGetGeometryRep    *XCBGetGeometryReply (XCBConnection         *c,
+                                           XCBGetGeometryCookie   cookie,
+                                           XCBGenericError      **e);
+
      +

      + You use them as follows: +

      + 
      +  XCBConnection     *c;
+  XCBDRAWABLE        win;
+  XCBGetGeometryRep *geom;
+
+  /* You initialize c and win */
+
+  geom = XCBGetGeometryReply (c, XCBGetGeometry (c, win), 0);
+
+  /* Do something with the fields of geom */
+  
+  free (geom);
+
      +

      + Remark that you have to free the structure, as + XCBGetGeometryReply allocates a + newly one. +

      +

      + One problem is that the returned location of the window is + relative to its parent window. This makes these coordinates + rather useless for any window manipulation functions, like + moving it on the screen. In order to overcome this problem, we + need to take a two-step operation. First, we find out the Id + of the parent window of our window. We then translate the + above relative coordinates to the screen coordinates. +

      +

      + To get the Id of the parent window, we need this structure: +

      + 
      +typedef struct {
+    BYTE response_type;
+    CARD8 pad0;
+    CARD16 sequence;
+    CARD32 length;
+    XCBWINDOW root;
+    XCBWINDOW parent;    /* Id of the parent window */
+    CARD16 children_len;
+    CARD8 pad1[14];
+} XCBQueryTreeRep;
+
      +

      + To fill this structure, we use these two functions: +

      + 
      +XCBQueryTreeCookie XCBQueryTree      (XCBConnection       *c,
+                                      XCBWINDOW            window);
+XCBQueryTreeRep   *XCBQueryTreeReply (XCBConnection       *c,
+                                      XCBQueryTreeCookie   cookie,
+				      XCBGenericError    **e);
+
      +

      + The translated coordinates will be found in this structure: +

      + 
      +typedef struct {
+    BYTE response_type;
+    BOOL same_screen;
+    CARD16 sequence;
+    CARD32 length;
+    XCBWINDOW child;
+    CARD16 dst_x;        /* Translated x coordinate */
+    CARD16 dst_y;        /* Translated y coordinate */
+} XCBTranslateCoordinatesRep;
+
      +

      + As usual, we need two functions to fill this structure: +

      + 
      +XCBTranslateCoordinatesCookie XCBTranslateCoordinates      (XCBConnection                  *c,
+                                                            XCBWINDOW                       src_window,
+							    XCBWINDOW                       dst_window,
+							    INT16                           src_x,
+							    INT16                           src_y);
+XCBTranslateCoordinatesRep   *XCBTranslateCoordinatesReply (XCBConnection                 *c,
+							    XCBTranslateCoordinatesCookie   cookie,
+							    XCBGenericError               **e);
+
      +

      + We use them as follows: +

      + 
      +  XCBConnection              *c;
+  XCBDRAWABLE                 win;
+  XCBGetGeometryRep          *geom;
+  XCBQueryTreeRep            *tree;
+  XCBTranslateCoordinatesRep *trans;
+
+  /* You initialize c and win */
+
+  geom  = XCBGetGeometryReply (c, XCBGetGeometry (c, win), 0);
+  if (!geom)
+    return 0;
+
+  tree  = XCBQueryTreeReply (c, XCBQueryTree (c, win), 0);
+  if (!tree)
+    return 0;
+
+  trans = XCBTranslateCoordinatesReply (c,
+                                        XCBTranslateCoordinates (c,
+                                                                 win,
+								 tree->parent,
+								 geom->x, geom->y),
+                                        0);
+  if (!trans)
+    return 0;
+
+  /* the translated coordinates are in trans->dst_x and trans->dst_y */
+
+  free (trans);
+  free (tree);
+  free (geom);
+
      +

      + Of course, as for geom, + tree and + trans have to be freed. +

      +

      + The work is a bit hard, but XCB is a very low-level library. +

      +

      + TODO: the utilization of these functions should be a + prog, which displays the coordinates of the window. +

      +

      + There is another structure that gives informations about our window: +

      + 
      +typedef struct {
+    BYTE response_type;
+    CARD8 backing_store;
+    CARD16 sequence;
+    CARD32 length;
+    XCBVISUALID visual;            /* Visual of the window */
+    CARD16 _class;
+    CARD8 bit_gravity;
+    CARD8 win_gravity;
+    CARD32 backing_planes;
+    CARD32 backing_pixel;
+    BOOL save_under;
+    BOOL map_is_installed;
+    CARD8 map_state;               /* Map state of the window */
+    BOOL override_redirect;
+    XCBCOLORMAP colormap;          /* Colormap of the window */
+    CARD32 all_event_masks;
+    CARD32 your_event_mask;
+    CARD16 do_not_propagate_mask;
+} XCBGetWindowAttributesRep;
+
      +

      + XCB supplies these two functions to fill it: +

      + 
      +XCBGetWindowAttributesCookie XCBGetWindowAttributes      (XCBConnection                 *c, 
+                                                          XCBWINDOW                      window);
+XCBGetWindowAttributesRep   *XCBGetWindowAttributesReply (XCBConnection                 *c, 
+                                                          XCBGetWindowAttributesCookie   cookie,
+							  XCBGenericError              **e);
+
      +

      + You use them as follows: +

      + 
      +  XCBConnection             *c;
+  XCBDRAWABLE                win;
+  XCBGetWindowAttributesRep *attr;
+
+  /* You initialize c and win */
+
+  attr = XCBGetWindowAttributesReply (c, XCBGetWindowAttributes (c, win), 0);
+
+  if (!attr)
+    return 0;
+
+  /* Do something with the fields of attr */
+  
+  free (attr);
+
      +

      + As for geom, + attr has to be freed. +

      +
    +
  14. Using colors to paint the rainbow
    15. +

    + Up until now, all our painting operation were done using black + and white. We will (finally) see now how to draw using colors. +

    +
      +
    1. Color maps
      2. +

      + In the beginning, there were not enough colors. Screen + controllers could only support a limited number of colors + simultaneously (initially 2, then 4, 16 and 256). Because of + this, an application could not just ask to draw in a "light + purple-red" color, and expect that color to be available. Each + application allocated the colors it needed, and when all the + color entries (4, 16, 256 colors) were in use, the next color + allocation would fail. +

      +

      + Thus, the notion of "a color map" was introduced. A color map + is a table whose size is the same as the number of + simultaneous colors a given screen controller. Each entry + contained the RGB (Red, Green and Blue) values of a different + color (all colors can be drawn using some combination of red, + green and blue). When an application wants to draw on the + screen, it does not specify which color to use. Rather, it + specifies which color entry of some color map to be used + during this drawing. Change the value in this color map entry + and the drawing will use a different color. +

      +

      + In order to be able to draw using colors that got something to + do with what the programmer intended, color map allocation + functions are supplied. You could ask to allocate entry for a + color with a set of RGB values. If one already existed, you + would get its index in the table. If none existed, and the + table was not full, a new cell would be allocated to contain + the given RGB values, and its index returned. If the table was + full, the procedure would fail. You could then ask to get a + color map entry with a color that is closest to the one you + were asking for. This would mean that the actual drawing on + the screen would be done using colors similar to what you + wanted, but not the same. +

      +

      + On today's more modern screens where one runs an X server with + support for 16 million colors, this limitation looks a little + silly, but remember that there are still older computers with + older graphics cards out there. Using color map, support for + these screen becomes transparent to you. On a display + supporting 16 million colors, any color entry allocation + request would succeed. On a display supporting a limited + number of colors, some color allocation requests would return + similar colors. It won't look as good, but your application + would still work. +

      +
    2. Allocating and freeing Color Maps
      3. +

      + When you draw using XCB, you can choose to use the standard + color map of the screen your window is displayed on, or you + can allocate a new color map and apply it to a window. In the + latter case, each time the mouse moves onto your window, the + screen color map will be replaced by your window's color map, + and you'll see all the other windows on screen change their + colors into something quite bizzare. In fact, this is the + effect you get with X applications that use the "-install" + command line option. +

      +

      + In XCB, a color map is (as often in X) an Id: +

      + 
      +typedef struct {
+    CARD32 xid;
+} XCBCOLORMAP;
+
      +

      + In order to access the screen's default color map, you just + have to retrieve the default_colormap + field of the XCBSCREEN structure + (see Section + Checking basic information about a connection): +

      + 
      +#include <stdio.h>
+
+#include <X11/XCB/xcb.h>
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection *c;
+  XCBSCREEN     *screen;
+  XCBCOLORMAP    colormap;
+  
+  /* Open the connection to the X server and get the first screen */
+  c = XCBConnect (NULL, NULL);
+  screen = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c)).data;
+
+  colormap = screen->default_colormap;
+
+  return 1;
+}
+
      +

      + This will return the color map used by default on the first + screen (again, remember that an X server may support several + different screens, each of which might have its own resources). +

      +

      + The other option, that of allocating a new colormap, works as + follows. We first ask the X server to give an Id to our color + map, with this function: +

      + 
      +XCBCOLORMAP XCBCOLORMAPNew (XCBConnection *c);
+
      +

      + Then, we create the color map with +

      + 
      +XCBVoidCookie XCBCreateColormap (XCBConnection *c,       /* Pointer to the XCBConnection structure */
+                                 BYTE           alloc,   /* Colormap entries to be allocated (AllocNone or AllocAll) */
+				 XCBCOLORMAP    mid,     /* Id of the color map */
+				 XCBWINDOW      window,  /* Window on whose screen the colormap will be created */
+				 XCBVISUALID    visual); /* Id of the visual supported by the screen */
+
      +

      + Here is an example of creation of a new color map: +

      + 
      +#include <X11/XCB/xcb.h>
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection *c;
+  XCBSCREEN     *screen;
+  XCBWINDOW      win;
+  XCBCOLORMAP    cmap
+  
+  /* Open the connection to the X server and get the first screen */
+  c = XCBConnect (NULL, NULL);
+  screen = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c)).data;
+
+  /* We create the window win here*/
+
+  cmap = XCBCOLORMAPNew (c);
+  XCBCreateColormap (c, AllocNone, cmap, win, screen->root_visual);
+
+  return 1;
+}
+
      +

      + Note that the window parameter is only used to allow the X + server to create the color map for the given screen. We can + then use this color map for any window drawn on the same screen. +

      +

      + To free a color map, it suffices to use this function: +

      + 
      +XCBVoidCookie XCBFreeColormap (XCBConnection *c,   /* The connection */
+                               XCBCOLORMAP cmap);  /* The color map */
+
      +
      +
      + Comparison Xlib/XCB +
      +
      +
        +
      • XCreateColormap ()
        • +
      +
      +
      +
        +
      • XCBCOLORMAPNew ()
        • +
      • XCBCreateColormap ()
        • +
      +
      +
      +
        +
      • XFreeColormap ()
        • +
      +
      +
      +
        +
      • XCBFreeColormap ()
        • +
      +
      +
      +

      +
    3. Allocating and freeing a color entry
      4. +

      + Once we got access to some color map, we can strat allocating + colors. The informations related to a color are stored in the + following structure: +

      + 
      +typedef struct {
+    BYTE response_type;
+    CARD8 pad0;
+    CARD16 sequence;
+    CARD32 length;
+    CARD16 red;          /* The red component   */
+    CARD16 green;        /* The green component */
+    CARD16 blue;         /* The blue component  */
+    CARD8 pad1[2];
+    CARD32 pixel;        /* The entry in the color map, supplied by the X server */
+} XCBAllocColorRep;
+
      +

      + XCB supplies these two functions to fill it: +

      + 
      +XCBAllocColorCookie XCBAllocColor      (XCBConnection *c,
+                                        XCBCOLORMAP    cmap,
+				        CARD16         red,
+			                CARD16         green,
+				        CARD16         blue);
+XCBAllocColorRep   *XCBAllocColorReply (XCBConnection        *c,
+                                        XCBAllocColorCookie   cookie,
+					XCBGenericError     **e);
+
      +

      + The fuction XCBAllocColor() takes the + 3 RGB components as parameters (red, green and blue). Here is an + example of using these functions: +

      + 
      +#include <malloc.h>
+
+#include <X11/XCB/xcb.h>
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection    *c;
+  XCBSCREEN        *screen;
+  XCBWINDOW         win;
+  XCBCOLORMAP       cmap;
+  XCBAllocColorRep *rep;
+  
+  /* Open the connection to the X server and get the first screen */
+  c = XCBConnect (NULL, NULL);
+  screen = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c)).data;
+
+  /* We create the window win here*/
+
+  cmap = XCBCOLORMAPNew (c);
+  XCBCreateColormap (c, AllocNone, cmap, win, screen->root_visual);
+
+  rep = XCBAllocColorReply (c, XCBAllocColor (c, cmap, 65535, 0, 0), 0);
+  
+  if (!rep)
+    return 0;
+
+  /* Do something with r->pixel or the components */
+
+  free (rep);
+
+  return 1;
+}
+
      +

      + As XCBAllocColorReply() allocates + memory, you have to free rep. +

      +

      + TODO: Talk about freeing colors. +

      +
    +
  15. X Bitmaps and Pixmaps
    16. +

    + One thing many so-called "Multi-Media" applications need to od, + is display images. In the X world, this is done using bitmaps + and pixmaps. We have already seen some usage of them when + setting an icon for our application. Lets study them further, + and see how to draw these images inside a window, along side the + simple graphics and text we have seen so far. +

    +

    + One thing to note before delving further, is that XCB (nor Xlib) + supplies no means of manipulating popular image formats, such as + gif, png, jpeg or tiff. It is up to the programmer (or to higher + level graphics libraries) to translate these image formats into + formats that the X server is familiar with (x bitmaps and x + pixmaps). +

    +
      +
    1. What is a X Bitmap ? An X Pixmap ?
      2. +

      + An X bitmap is a two-color image stored in a format specific + to the X window system. When stored in a file, the bitmap data + looks like a C source file. It contains variables defining the + width and the height of the bitmap, an array containing the + bit values of the bitmap (the size of the array is + weight*height), and an optional hot-spot location (that will + be explained later, when discussing mouse cursors). +

      +

      + An X pixmap is a format used to stored images in the memory of + an X server. This format can store both black and white images + (such as x bitmaps) as well as color images. It is the only + image format supported by the X protocol, and any image to be + drawn on screen, should be first translated into this format. +

      +

      + In actuality, an X pixmap can be thought of as a window that + does not appear on the screen. Many graphics operations that + work on windows, will also work on pixmaps. Indeed, the type + of X pixmap in XCB is an Id like a window: +

      + 
      +typedef struct {
+    CARD32 xid;
+} XCBPIXMAP;
+
      +

      + In order to make the difference between a window and a pixmap, + XCB introduces a drawable type, which is a union +

      + 
      +typedef union {
+    XCBWINDOW window;
+    XCBPIXMAP pixmap;
+} XCBDRAWABLE;
+
      +

      + in order to avoid confusion between a window and a pixmap.The + operations that will work indifferently on a window or a pixmap + will require a XCBDRAWABLE +

      +
      +

      + Remark: In Xlib, there is no specific difference between a + Drawable, a + Pixmap or a + Window: all are 32 bit long + integer. +

      +
      +
    2. Creating a pixmap
      3. +

      + Sometimes we want to create an un-initialized pixmap, so we + can later draw into it. This is useful for image drawing + programs (creating a new empty canvas will cause the creation + of a new pixmap on which the drawing can be stored). It is + also useful when reading various image formats: we load the + image data into memory, create a pixmap on the server, and + then draw the decoded image data onto that pixmap. +

      +

      + To create a new pixmap, we first ask the X server to give an + Id to our pixmap, with this function: +

      + 
      +XCBPIXMAP XCBPIXMAPNew (XCBConnection *c);
+
      +

      + Then, XCB supplies the following function to create new pixmaps: +

      + 
      +XCBVoidCookie XCBCreatePixmap (XCBConnection *c,         /* Pointer to the XCBConnection structure */
+                               CARD8          depth,     /* Depth of the screen */
+			       XCBPIXMAP      pid,       /* Id of the pixmap */
+			       XCBDRAWABLE    drawable,
+			       CARD16         width,     /* Width of the window (in pixels) */
+			       CARD16         height);   /* Height of the window (in pixels) */
+
      +

      + TODO: Explain the drawable parameter, and give an + example (like xpoints.c) +

      +
    3. Drawing a pixmap in a window
      4. +

      + Once we got a handle to a pixmap, we can draw it on some + window, using the following function: +

      + 
      +XCBVoidCookie XCBCopyArea (XCBConnection *c,             /* Pointer to the XCBConnection structure */
+                           XCBDRAWABLE    src_drawable,  /* The Drawable we want to paste */
+			   XCBDRAWABLE    dst_drawable,  /* The Drawable on which we copy the previous Drawable */
+			   XCBGCONTEXT    gc,            /* A Graphic Context */
+			   INT16          src_x,         /* Top left x coordinate of the region we want to copy */
+			   INT16          src_y,         /* Top left y coordinate of the region we want to copy */
+			   INT16          dst_x,         /* Top left x coordinate of the region where we want to copy */
+			   INT16          dst_y,         /* Top left y coordinate of the region where we want to copy */
+			   CARD16         width,         /* Width of the region we want to copy */
+			   CARD16         height);       /* Height of the region we want to copy */
+
      +

      + As you can see, we could copy the whole pixmap, as well as + only a given rectangle of the pixmap. This is useful to + optimize the drawing speed: we could copy only what we have + modified in the pixmap. +

      +

      + One important note should be made: it is possible to + create pixmaps with different depths on the same screen. When + we perform copy operations (a pixmaap onto a window, etc), we + should make sure that both source and target have the same + depth. If they have a different depth, the operation would + fail. The exception to this is if we copy a specific bit plane + of the source pixmap using the + XCBCopyPlane function. In such an + event, we can copy a specific plain to the target window (in + actuality, setting a specific bit in the color of each pixel + copied). This can be used to generate strange graphic effects + in widow, but beyond the scope of this tutorial. +

      +
    4. Freeing a pixmap
      5. +

      + Finally, when we are done using a given pixmap, we should free + it, in order to free resources of the X server. This is done + using this function: +

      + 
      +XCBVoidCookie XCBFreePixmap (XCBConnection *c,        /* Pointer to the XCBConnection structure */
+                             XCBPIXMAP      pixmap);  /* A given pixmap */
+
      +

      + Of course, after having freed it, we must not try accessing + the pixmap again. +

      +

      + TODO: Give an example, or a link to xpoints.c +

      +
    +
  16. Translation of basic Xlib functions and macros
    17. +

    + The problem when you want to port an Xlib program to XCB is that + you don't know if the Xlib function that you want to "translate" + is a X Window one or an Xlib macro. In that section, we describe + a way to translate the usual functions or macros that Xlib + provides. It's usually just a member of a structure. +

    +
      +
    1. Members of the Display structure
      2. + In this section, we look at how to translate the macros that + returns some members of the Display + structure. They are obtain by using a function that requires a + XCBConnection * or a member of the + XCBConnSetupSuccessRep structure + (via the function XCBGetSetup), or + a function that requires that structure. +
        +
      1. ConnectionNumber
        2. +

        + This number is the file descriptor that connects the client + to the server. You just have to use that function: +

        + 
        +int XCBGetFileDescriptor(XCBConnection *c);
+
        +
      2. DefaultScreen
        3. +

        + That number is not stored by XCB. It is returned in the + second parameter of the function XCBConnect. + Hence, you have to store it yourself if you want to use + it. Then, to get the XCBSCREEN + structure, you have to iterate on the screens. + The equivalent function of the Xlib's + ScreenOfDisplay function can be + found below. OK, here is the + small piece of code to get that number: +

        + 
        +XCBConnection *c;
+int            screen_default_nbr;
+
+/* you pass the name of the display you want to XCBConnect */
+
+c = XCBConnect (display_name, &screen_default_nbr);
+
+/* screen_default_nbr contains now the number of the default screen */
+
        +
      3. QLength
        4. +

        + Not documented yet. +

        +
      4. ScreenCount
        5. +

        + You get the count of screens with the functions + XCBGetSetup + and + XCBConnSetupSuccessRepRootsIter + (if you need to iterate): +

        + 
        +XCBConnection *c;
+int            screen_count;
+
+/* you init the connection */
+
+screen_count = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c)).rem;
+
+/* screen_count contains now the count of screens */
+
        +

        + If you don't want to iterate over the screens, a better way + to get that number is to use + XCBConnSetupSuccessRepRootsLength: +

        + 
        +XCBConnection *c;
+int            screen_count;
+
+/* you init the connection */
+
+screen_count = XCBConnSetupSuccessRepRootsLength (XCBGetSetup (c));
+
+/* screen_count contains now the count of screens */
+
        +
      5. ServerVendor
        6. +

        + You get the name of the vendor of the server hardware with + the functions XCBGetSetup + and + XCBConnSetupSuccessRepVendor. Beware + that, unlike Xlib, the string returned by XCB is not + necessarily null-terminaled: +

        + 
        +XCBConnection *c;
+char          *vendor = NULL;
+int            length;
+
+/* you init the connection */
+length = XCBConnSetupSuccessRepVendorLength (XCBGetSetup (c));
+vendor = (char *)malloc (length + 1);
+if (vendor)
+memcpy (vendor, XCBConnSetupSuccessRepVendor (XCBGetSetup (c)), length);
+vendor[length] = '\0';
+
+/* vendor contains now the name of the vendor. Must be freed when not used anymore */
+
        +
      6. ProtocolVersion
        7. +

        + You get the major version of the protocol in the + XCBConnSetupSuccessRep + structure, with the function XCBGetSetup: +

        + 
        +XCBConnection *c;
+CARD16         protocol_major_version;
+
+/* you init the connection */
+
+protocol_major_version = XCBGetSetup (c)->protocol_major_version;
+
+/* protocol_major_version contains now the major version of the protocol */
+
        +
      7. ProtocolRevision
        8. +

        + You get the minor version of the protocol in the + XCBConnSetupSuccessRep + structure, with the function XCBGetSetup: +

        + 
        +XCBConnection *c;
+CARD16         protocol_minor_version;
+
+/* you init the connection */
+
+protocol_minor_version = XCBGetSetup (c)->protocol_minor_version;
+
+/* protocol_minor_version contains now the minor version of the protocol */
+
        +
      8. VendorRelease
        9. +

        + You get the number of the release of the server hardware in the + XCBConnSetupSuccessRep + structure, with the function XCBGetSetup: +

        + 
        +XCBConnection *c;
+CARD32         release_number;
+
+/* you init the connection */
+
+release_number = XCBGetSetup (c)->release_number;
+
+/* release_number contains now the number of the release of the server hardware */
+
        +
      9. DisplayString
        10. +

        + The name of the display is not stored in XCB. You have to + store it by yourself. +

        +
      10. BitmapUnit
        11. +

        + You get the bitmap scanline unit in the + XCBConnSetupSuccessRep + structure, with the function XCBGetSetup: +

        + 
        +XCBConnection *c;
+CARD8          bitmap_format_scanline_unit;
+
+/* you init the connection */
+
+bitmap_format_scanline_unit = XCBGetSetup (c)->bitmap_format_scanline_unit;
+
+/* bitmap_format_scanline_unit contains now the bitmap scanline unit */
+
        +
      11. BitmapBitOrder
        12. +

        + You get the bitmap bit order in the + XCBConnSetupSuccessRep + structure, with the function XCBGetSetup: +

        + 
        +XCBConnection *c;
+CARD8          bitmap_format_bit_order;
+
+/* you init the connection */
+
+bitmap_format_bit_order = XCBGetSetup (c)->bitmap_format_bit_order;
+
+/* bitmap_format_bit_order contains now the bitmap bit order */
+
        +
      12. BitmapPad
        13. +

        + You get the bitmap scanline pad in the + XCBConnSetupSuccessRep + structure, with the function XCBGetSetup: +

        + 
        +XCBConnection *c;
+CARD8          bitmap_format_scanline_pad;
+
+/* you init the connection */
+
+bitmap_format_scanline_pad = XCBGetSetup (c)->bitmap_format_scanline_pad;
+
+/* bitmap_format_scanline_pad contains now the bitmap scanline pad */
+
        +
      13. ImageByteOrder
        14. +

        + You get the image byte order in the + XCBConnSetupSuccessRep + structure, with the function XCBGetSetup: +

        + 
        +XCBConnection *c;
+CARD8          image_byte_order;
+
+/* you init the connection */
+
+image_byte_order = XCBGetSetup (c)->image_byte_order;
+
+/* image_byte_order contains now the image byte order */
+
        +
      +
    2. ScreenOfDisplay related functions
      3. +

      + in Xlib, ScreenOfDisplay returns a + Screen structure that contains + several characteristics of your screen. XCB has a similar + structure (XCBSCREEN), + but the way to obtain it is a bit different. With + Xlib, you just provide the number of the screen and you grab it + from an array. With XCB, you iterate over all the screens to + obtain the one you want. The complexity of this operation is + O(n). So the best is to store this structure if you often use + it. See ScreenOfDisplay just below. +

      +

      + Xlib provides generally two functions to obtain the characteristics + related to the screen. One with the display and the number of + the screen, which calls ScreenOfDisplay, + and the other that uses the Screen structure. + This might be a bit confusing. As mentioned above, with XCB, it + is better to store the XCBSCREEN + structure. Then, you have to read the members of this + structure. That's why the Xlib functions are put by pairs (or + more) as, with XCB, you will use the same code. +

      +
        +
      1. ScreenOfDisplay
        2. +

        + This function returns the Xlib Screen + structure. With XCB, you iterate over all thee screens and + once you get the one you want, you return it: +

        + 
        
+XCBSCREEN *ScreenOfDisplay (XCBConnection *c,
+                            int            screen)
+{
+  XCBSCREENIter iter;
+
+  iter = XCBConnSetupSuccessRepRootsIter (XCBGetSetup (c));
+  for (; iter.rem; --screen, XCBSCREENNext (&iter))
+    if (screen == 0)
+      return iter.data;
+
+  return NULL;
+}
+
        +

        + As mentioned above, you might want to store the value + returned by this function. +

        +

        + All the functions below will use the result of that + fonction, as they just grab a specific member of the + XCBSCREEN structure. +

        +
      2. DefaultScreenOfDisplay
        3. +

        + It is the default screen that you obtain when you connect to + the X server. It suffices to call the ScreenOfDisplay + function above with the connection and the number of the + default screen. +

        + 
        +XCBConnection *c;
+int            screen_default_nbr;
+XCBSCREEN     *default_screen;  /* the returned default screen */
+
+/* you pass the name of the display you want to XCBConnect */
+
+c = XCBConnect (display_name, &screen_default_nbr);
+default_screen = ScreenOfDisplay (c, screen_default_nbr);
+
+/* default_screen contains now the default root window, or a NULL window if no screen is found */
+
        +
      3. RootWindow / RootWindowOfScreen
        4. +

        +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+XCBWINDOW      root_window = { 0 };  /* the returned window */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  root_window = screen->root;
+
+/* root_window contains now the root window, or a NULL window if no screen is found */
+
        +
      4. DefaultRootWindow
        5. +

        + It is the root window of the default screen. So, you call + ScreenOfDisplay with the + default screen number and you get the + root window as above: +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_default_nbr;
+XCBWINDOW      root_window = { 0 };  /* the returned root window */
+
+/* you pass the name of the display you want to XCBConnect */
+
+c = XCBConnect (display_name, &screen_default_nbr);
+screen = ScreenOfDisplay (c, screen_default_nbr);
+if (screen)
+  root_window = screen->root;
+
+/* root_window contains now the default root window, or a NULL window if no screen is found */
+
        +
      5. DefaultVisual / DefaultVisualOfScreen
        6. +

        + While a Visual is, in Xlib, a structure, in XCB, there are + two types: XCBVISUALID, which is + the Id of the visual, and XCBVISUALTYPE, + which corresponds to the Xlib Visual. To get the Id of the + visual of a screen, just get the + root_visual + member of a XCBSCREEN: +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+XCBVISUALID    root_visual = { 0 };    /* the returned visual Id */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  root_visual = screen->root_visual;
+
+/* root_visual contains now the value of the Id of the visual, or a NULL visual if no screen is found */
+
        +

        + To get the XCBVISUALTYPE + structure, it's a bit less easier. You have to get the + XCBSCREEN structure that you want, + get its root_visual member, + then iterate on the XCBDEPTHs + and the XCBVISUALTYPEs, and compare + the XCBVISUALID of these XCBVISUALTYPEs: + with root_visual: +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+XCBVISUALID    root_visual = { 0 };
+XCBVISUATYPE  *visual_type = NULL;    /* the returned visual type */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  {
+    XCBDEPTHIter depth_iter;
+
+    depth_iter = XCBSCREENAllowedDepthsIter (screen);
+    for (; depth_iter.rem; XCBDEPTHNext (&depth_iter))
+      {
+        XCBVISUALTYPEIter visual_iter;
+
+        visual_iter = XCBDEPTHVisualsIter (depth_iter.data);
+        for (; visual_iter.rem; XCBVISUALTYPENext (&visual_iter))
+          {
+            if (screen->root_visual.id == visual_iter.data->visual_id.id)
+              {
+                visual_type = visual_iter.data;
+                break;
+              }
+          }
+      }
+  }
+
+/* visual_type contains now the visual structure, or a NULL visual structure if no screen is found */
+
        +
      6. DefaultGC / DefaultGCOfScreen
        7. +

        + This default Graphic Context is just a newly created Graphic + Context, associated to the root window of a + XCBSCREEN, + using the black white pixels of that screen: +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+XCBGCONTEXT    gc = { 0 };    /* the returned default graphic context */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  {
+    XCBDRAWABLE draw;
+    CARD32      mask;
+    CARD32      values[2];
+
+    gc = XCBGCONTEXTNew (c);
+    draw.window = screen->root;
+    mask = GCForeground | GCBackground;
+    values[0] = screen->black_pixel;
+    values[1] = screen->white_pixel;
+    XCBCreateGC (c, gc, draw, mask, values);
+  }
+
+/* gc contains now the default graphic context */
+
        +
      7. BlackPixel / BlackPixelOfScreen
        8. +

        + It is the Id of the black pixel, which is in the structure + of an XCBSCREEN. +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+CARD32         black_pixel = 0;    /* the returned black pixel */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  black_pixel = screen->black_pixel;
+
+/* black_pixel contains now the value of the black pixel, or 0 if no screen is found */
+
        +
      8. WhitePixel / WhitePixelOfScreen
        9. +

        + It is the Id of the white pixel, which is in the structure + of an XCBSCREEN. +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+CARD32         white_pixel = 0;    /* the returned white pixel */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  white_pixel = screen->white_pixel;
+
+/* white_pixel contains now the value of the white pixel, or 0 if no screen is found */
+
        +
      9. DisplayWidth / WidthOfScreen
        10. +

        + It is the width in pixels of the screen that you want, and + which is in the structure of the corresponding + XCBSCREEN. +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+CARD32         width_in_pixels = 0;    /* the returned width in pixels */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  width_in_pixels = screen->width_in_pixels;
+
+/* width_in_pixels contains now the width in pixels, or 0 if no screen is found */
+
        +
      10. DisplayHeight / HeightOfScreen
        11. +

        + It is the height in pixels of the screen that you want, and + which is in the structure of the corresponding + XCBSCREEN. +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+CARD32         height_in_pixels = 0;    /* the returned height in pixels */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  height_in_pixels = screen->height_in_pixels;
+
+/* height_in_pixels contains now the height in pixels, or 0 if no screen is found */
+
        +
      11. DisplayWidthMM / WidthMMOfScreen
        12. +

        + It is the width in millimeters of the screen that you want, and + which is in the structure of the corresponding + XCBSCREEN. +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+CARD32         width_in_millimeters = 0;    /* the returned width in millimeters */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  width_in_millimeters = screen->width_in_millimeters;
+
+/* width_in_millimeters contains now the width in millimeters, or 0 if no screen is found */
+
        +
      12. DisplayHeightMM / HeightMMOfScreen
        13. +

        + It is the height in millimeters of the screen that you want, and + which is in the structure of the corresponding + XCBSCREEN. +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+CARD32         height_in_millimeters = 0;    /* the returned height in millimeters */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  height_in_millimeters = screen->height_in_millimeters;
+
+/* height_in_millimeters contains now the height in millimeters, or 0 if no screen is found */
+
        +
      13. DisplayPlanes / DefaultDepth / DefaultDepthOfScreen / PlanesOfScreen
        14. +

        + It is the depth (in bits) of the root window of the + screen. You get it from the XCBSCREEN structure. +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+CARD8          root_depth = 0;  /* the returned depth of the root window */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  root_depth = screen->root_depth;
+
+/* root_depth contains now the depth of the root window, or 0 if no screen is found */
+
        +
      14. DefaultColormap / DefaultColormapOfScreen
        15. +

        + This is the default colormap of the screen (and not the + (default) colormap of the default screen !). As usual, you + get it from the XCBSCREEN structure: +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+XCBCOLORMAP    default_colormap = { 0 };  /* the returned default colormap */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  default_colormap = screen->default_colormap;
+
+/* default_colormap contains now the default colormap, or a NULL colormap if no screen is found */
+
        +
      15. MinCmapsOfScreen
        16. +

        + You get the minimum installed colormaps in the XCBSCREEN structure: +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+CARD16         min_installed_maps = 0;  /* the returned minimum installed colormaps */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  min_installed_maps = screen->min_installed_maps;
+
+/* min_installed_maps contains now the minimum installed colormaps, or 0 if no screen is found */
+
        +
      16. MaxCmapsOfScreen
        17. +

        + You get the maximum installed colormaps in the XCBSCREEN structure: +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+CARD16         max_installed_maps = 0;  /* the returned maximum installed colormaps */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  max_installed_maps = screen->max_installed_maps;
+
+/* max_installed_maps contains now the maximum installed colormaps, or 0 if no screen is found */
+
        +
      17. DoesSaveUnders
        18. +

        + You know if save_unders is set, + by looking in the XCBSCREEN structure: +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+BOOL           save_unders = 0;  /* the returned value of save_unders */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  save_unders = screen->save_unders;
+
+/* save_unders contains now the value of save_unders, or FALSE if no screen is found */
+
        +
      18. DoesBackingStore
        19. +

        + You know the value of backing_stores, + by looking in the XCBSCREEN structure: +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+BYTE           backing_stores = 0;  /* the returned value of backing_stores */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  backing_stores = screen->backing_stores;
+
+/* backing_stores contains now the value of backing_stores, or FALSE if no screen is found */
+
        +
      19. EventMaskOfScreen
        20. +

        + To get the current input masks, + you look in the XCBSCREEN structure: +

        + 
        +XCBConnection *c;
+XCBSCREEN     *screen;
+int            screen_nbr;
+CARD32         current_input_masks = 0;  /* the returned value of current input masks */
+
+/* you init the connection and screen_nbr */
+
+screen = ScreenOfDisplay (c, screen_nbr);
+if (screen)
+  current_input_masks = screen->current_input_masks;
+
+/* current_input_masks contains now the value of the current input masks, or FALSE if no screen is found */
+
        +
      +
    3. Miscellaneous macros
      4. +
        +
      1. DisplayOfScreen
        2. +

        + in Xlib, the Screen structure + stores its associated Display + structure. This is not the case in the X Window protocol, + hence, it's also not the case in XCB. So you have to store + it by yourself. +

        +
      2. DisplayCells / CellsOfScreen
        3. +

        + To get the colormap entries, + you look in the XCBVISUALTYPE + structure, that you grab like here: +

        + 
        +XCBConnection *c;
+XCBVISUALTYPE *visual_type;
+CARD16         colormap_entries = 0;  /* the returned value of the colormap entries */
+
+/* you init the connection and visual_type */
+
+if (visual_type)
+  colormap_entries = visual_type->colormap_entries;
+
+/* colormap_entries contains now the value of the colormap entries, or FALSE if no screen is found */
+
        +
      +
    +
+
+ + + diff --git a/doc/tutorial/xcb.css b/doc/tutorial/xcb.css new file mode 100755 index 0000000..84352c5 --- /dev/null +++ b/doc/tutorial/xcb.css @@ -0,0 +1,82 @@ +body +{ + background-color: #dddddd; + color: #000000; + padding: 8px; + margin: 0px; +} +div.title +{ + text-align: center; + font-weight: bold; + font-size: 28px; +} +div.emph +{ + text-align: left; + font-weight: bold; +} +div.section li.title +{ + font-weight: bold; + font-size: 22px; +} +div.section li.subtitle +{ + font-weight: bold; + font-size: 18px; +} +div.section li.subsubtitle +{ + font-weight: bold; + font-size: 16px; +} +div.comp +{ + border: thin solid #000000; + background-color: #ffffe0; + padding: 14px; +} +div.comp div.title +{ + font-weight: bold; + font-size: 16px; + text-align: center; +} +div.comp div.xlib +{ + font-family: monospace; + position: absolute; + width: 49%; + margin-left: 0px; + margin-top: 10px; +} +div.comp div.xcb +{ + font-family: monospace; + position: relative; + margin-left: 51%; + margin-top: 10px; +} +pre.code +{ + border: thin solid #000000; + background-color: #efefef; + padding: 4px; + text-align: left; + font-size: 10; +} +pre.text +{ + border: thin solid #000000; + background-color: #efefef; + padding: 4px; + text-align: left; + font-size: 10; +} +span.code +{ + font-family: monospace; + font-size: 10; +} + diff --git a/src/.cvsignore b/src/.cvsignore new file mode 100644 index 0000000..adf4164 --- /dev/null +++ b/src/.cvsignore @@ -0,0 +1,17 @@ +.deps +.libs +Makefile +Makefile.in +config.h +config.h.in +stamp-h1 +*.lo +*.loT +*.la +xproto.c +xproto.h +xcb_types.c +xcb_types.h +extensions +X11 +check_all diff --git a/src/Makefile.am b/src/Makefile.am new file mode 100644 index 0000000..8d43475 --- /dev/null +++ b/src/Makefile.am @@ -0,0 +1,83 @@ +lib_LTLIBRARIES = libXCB.la + +EXTHEADERS = \ + extensions/bigreq.h \ + extensions/composite.h \ + extensions/damage.h \ + extensions/glx.h \ + extensions/shm.h \ + extensions/shape.h \ + extensions/randr.h \ + extensions/record.h \ + extensions/render.h \ + extensions/res.h \ + extensions/dpms.h \ + extensions/sync.h \ + extensions/xc_misc.h \ + extensions/xevie.h \ + extensions/xf86dri.h \ + extensions/xfixes.h \ + extensions/xprint.h \ + extensions/xv.h \ + extensions/xvmc.h +EXTSOURCES = \ + extensions/bigreq.c \ + extensions/composite.c \ + extensions/damage.c \ + extensions/glx.c \ + extensions/shm.c \ + extensions/shape.c \ + extensions/randr.c \ + extensions/record.c \ + extensions/render.c \ + extensions/res.c \ + extensions/dpms.c \ + extensions/sync.c \ + extensions/xc_misc.c \ + extensions/xevie.c \ + extensions/xf86dri.c \ + extensions/xfixes.c \ + extensions/xprint.c \ + extensions/xv.c \ + extensions/xvmc.c +EXTENSIONS = $(EXTSOURCES) $(EXTHEADERS) + +COREHEADERS = xproto.h xcb_types.h +CORESOURCES = xproto.c xcb_types.c +COREPROTO = $(CORESOURCES) $(COREHEADERS) + +xcbinclude_HEADERS = xcb.h xcbext.h xcbxlib.h $(COREHEADERS) $(EXTHEADERS) + +CFLAGS = +AM_CFLAGS = -include config.h $(CDEBUGFLAGS) $(XCBPROTO_CFLAGS) $(XPROTO_CFLAGS) $(XAU_CFLAGS) +libXCB_la_LIBADD = $(XCBPROTO_LIBS) $(XPROTO_LIBS) $(XAU_LIBS) +libXCB_la_SOURCES = \ + xcb_conn.c xcb_out.c xcb_in.c xcb_ext.c xcb_xid.c \ + xcb_list.c xcb_util.c xcb_xlib.c xcb_auth.c xcb_des.c \ + $(COREPROTO) $(EXTENSIONS) + +xcb_des.c: + touch xcb_des.c + +BUILT_SOURCES = $(COREPROTO) $(EXTENSIONS) +CLEANFILES = $(COREPROTO) $(EXTENSIONS) +clean-local: + rmdir extensions || true + +vpath %.xml $(XCBPROTO_XCBINCLUDEDIR) $(XCBPROTO_XCBINCLUDEDIR)/extensions + +%.h: %.xml c-client.xsl + @n=`dirname $*`; test -d $$n || (echo mkdir $$n; mkdir $$n) + $(XSLTPROC) --stringparam mode header \ + --stringparam base-path $(XCBPROTO_XCBINCLUDEDIR)/ \ + --stringparam extension-path \ + $(XCBPROTO_XCBINCLUDEDIR)/extensions/ \ + -o $@ $(srcdir)/c-client.xsl $< + +%.c: %.xml c-client.xsl + @n=`dirname $*`; test -d $$n || (echo mkdir $$n; mkdir $$n) + $(XSLTPROC) --stringparam mode source \ + --stringparam base-path $(XCBPROTO_XCBINCLUDEDIR)/ \ + --stringparam extension-path \ + $(XCBPROTO_XCBINCLUDEDIR)/extensions/ \ + -o $@ $(srcdir)/c-client.xsl $< diff --git a/src/c-client.xsl b/src/c-client.xsl new file mode 100644 index 0000000..903895d --- /dev/null +++ b/src/c-client.xsl @@ -0,0 +1,1301 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { "" } + + + + return XCBGetExtensionData(c, &XCBId); + + + + + + + + + + + _ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + XCB + + + + + + Multiple definitions of type " + + " found. + + + + + + + + + + + + No definitions of type " + + " found + + , and it is not a known core type + + . + + + + + + + + + + XCB + + + + + + Void + + + Cookie + + + + + + + + + + + + + + + + + + + + + + + + + + + true + + + + + + + + + + + + + + + + + + + + + + return (XCBRep *) XCBWaitForReply(c, cookie.sequence, e); + + + + + + + + + + + + + XCB ret; + ret.xid = XCBGenerateID(c); + return ret; + + + + + + + union + + + + + + + + + + + + Event + + + Error + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + + + + + + + + + + + + + + + length + 2 + + + + + + + + + Encountered a list with no length expresssion outside a request or reply. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + const + + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Unions must be fixed length. + + + + + + + + + + + + + + + + + + + + + + + static const XCBProtocolRequest xcb_req = { + + /* count */ , + /* ext */ + + &XCB + + Id + + 0 + , + /* opcode */ , + /* isvoid */ + + }; + + + struct iovec xcb_parts[]; + xcb_ret; + xcb_out; + + + + + + xcb_parts[0].iov_base = &xcb_out; + xcb_parts[0].iov_len = sizeof(xcb_out); + + + xcb_parts[].iov_base = (void *) ; + xcb_parts[].iov_len = + * sizeof( + + ) + ; + + + XCBSendRequest(c, &xcb_ret.sequence, xcb_parts, &xcb_req); + return xcb_ret; + + + + + xcb_out. + + = + + ; + + + + + + xcb_out. + + = + + ; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + R + 1 + + + + End(Iter(R)) + + + End(R) + + + + + + + + + + + + + + + + + return ( *) (); + + + XCBGenericIter prev = ; + return ( *) ((char *) prev.data + XCB_TYPE_PAD(, prev.index)); + + + + + + + return + + ; + + + + + + Iter i; + + + i.data = ( *) (); + + + XCBGenericIter prev = ; + i.data = ( *) ((char *) prev.data + XCB_TYPE_PAD(, prev.index)); + + + i.rem = + + ; + i.index = (char *) i.data - (char *) R; + return i; + + + + + + char + + + + + + XCBGenericIter i; + + + i.data = (( *) ()) + ( + + ); + + + XCBGenericIter child = ; + i.data = (( *) child.data) + ( + + ); + + + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; + + + + + + + + + + *R = i->data; + XCBGenericIter child = ; + --i->rem; + i->data = ( *) child.data; + i->index = child.index; + + + --i->rem; + ++i->data; + i->index += sizeof(); + + + + + + XCBGenericIter ret; + + + while(i.rem > 0) + + Next(&i); + + ret.data = i.data; + ret.rem = i.rem; + ret.index = i.index; + + + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + + + return ret; + + + + + + + + Error: This stylesheet requires the EXSL node-set extension. + + + + Error: Parameter "mode" must be "header" or "source". + + + + + + + ___H + +/* + * This file generated automatically from +.xml by c-client.xsl using XSLT. + * Edit at your peril. + */ + + + +#ifndef +#define + +#include "xcb.h" + +#include ".h" + + + + + + + +#include <assert.h> +#include "xcbext.h" +#include ".h" + + + + + + + +#endif + + + + + + + + + #define + + + + + + + + + + + extern + + const char + + [] + + = " + + " + + ; + + + + + + extern + + + + = + + + ; + + + + + + + + + typedef + + + + ; + + + + + + + + + + + + + typedef + struct + { + + + + + + + ; + + + } + + ; + + + + + + + + typedef enum { + + + , + + + + + + + = + + + + + + + +} ; + + + + + + + + + + + + + + + + + + + , + + + + + + + + + + + + + + + + ) + + ; + + + + + +{ + + + + + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ( + + + + + + + + + + ) + + + + + + ( + + + + + + + + + + + ) + + + + + + Invalid element in expression: + + + + + + + + + + + + + + + + + [ + + ] + + + + + + + + + + + pad + + + + + + [ + + ] + + + + + + + + + 0 + 0 + + + + + + + + + + + + + + + + + + + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + + + diff --git a/src/xcb.h b/src/xcb.h new file mode 100644 index 0000000..8dd308a --- /dev/null +++ b/src/xcb.h @@ -0,0 +1,165 @@ +/* + * Copyright (C) 2001-2004 Bart Massey, Jamey Sharp, and Josh Triplett. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +#ifndef __XCB_H +#define __XCB_H +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)) +#define deprecated __attribute__((__deprecated__)) +#else +#define deprecated +#endif + +/* Pre-defined constants */ + +/* current protocol version */ +#define X_PROTOCOL 11 + +/* current minor version */ +#define X_PROTOCOL_REVISION 0 + +/* X_TCP_PORT + display number = server port for TCP transport */ +#define X_TCP_PORT 6000 + +#define XCB_TYPE_PAD(T,I) (-(I) & (sizeof(T) > 4 ? 3 : sizeof(T) - 1)) + + +/* Opaque structures */ + +typedef struct XCBConnection XCBConnection; + + +/* Other types */ + +typedef struct { + void *data; + int rem; + int index; +} XCBGenericIter; + +typedef struct { + BYTE response_type; + CARD8 pad0; + CARD16 sequence; + CARD32 length; +} XCBGenericRep; + +typedef struct { + BYTE response_type; + CARD8 pad0; + CARD16 sequence; +} XCBGenericEvent; + +typedef struct { + BYTE response_type; + BYTE error_code; + CARD16 sequence; +} XCBGenericError; + +typedef struct { + unsigned int sequence; +} XCBVoidCookie; + + +/* Include the generated xproto and xcb_types headers. */ +#include "xcb_types.h" +#include "xproto.h" + + +/* xcb_auth.c */ + +typedef struct XCBAuthInfo { + int namelen; + char *name; + int datalen; + char *data; +} XCBAuthInfo; + +int XCBGetAuthInfo(int fd, XCBAuthInfo *info) deprecated; + + +/* xcb_out.c */ + +int XCBFlush(XCBConnection *c); +CARD32 XCBGetMaximumRequestLength(XCBConnection *c); + + +/* xcb_in.c */ + +XCBGenericEvent *XCBWaitEvent(XCBConnection *c) deprecated; +XCBGenericEvent *XCBWaitForEvent(XCBConnection *c); +XCBGenericEvent *XCBPollForEvent(XCBConnection *c, int *error); +unsigned int XCBGetRequestRead(XCBConnection *c); + + +/* xcb_ext.c */ + +typedef struct XCBExtension XCBExtension; + +/* Do not free the returned XCBQueryExtensionRep - on return, it's aliased + * from the cache. */ +const XCBQueryExtensionRep *XCBGetExtensionData(XCBConnection *c, XCBExtension *ext); + +void XCBPrefetchExtensionData(XCBConnection *c, XCBExtension *ext); + + +/* xcb_conn.c */ + +XCBConnSetupSuccessRep *XCBGetSetup(XCBConnection *c); +int XCBGetFileDescriptor(XCBConnection *c); + +XCBConnection *XCBConnectToFD(int fd, XCBAuthInfo *auth_info); +void XCBDisconnect(XCBConnection *c); + + +/* xcb_util.c */ + +int XCBParseDisplay(const char *name, char **host, int *display, int *screen); +int XCBOpen(const char *host, int display) deprecated; +int XCBOpenTCP(const char *host, unsigned short port) deprecated; +int XCBOpenUnix(const char *file) deprecated; + +XCBConnection *XCBConnectBasic(void) deprecated; +XCBConnection *XCBConnect(const char *displayname, int *screenp); +XCBConnection *XCBConnectToDisplayWithAuthInfo(const char *display, XCBAuthInfo *auth, int *screen); + +int XCBSync(XCBConnection *c, XCBGenericError **e); + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/xcb_auth.c b/src/xcb_auth.c new file mode 100644 index 0000000..9f2cb5a --- /dev/null +++ b/src/xcb_auth.c @@ -0,0 +1,296 @@ +/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +/* Authorization systems for the X protocol. */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "xcb.h" +#include "xcbint.h" + +#ifdef HAS_AUTH_XA1 +#include "xcb_des.h" +#endif + +enum auth_protos { +#ifdef HAS_AUTH_XA1 + AUTH_XA1, +#endif + AUTH_MC1, + N_AUTH_PROTOS +}; + +static char *authnames[N_AUTH_PROTOS] = { +#ifdef HAS_AUTH_XA1 + "XDM-AUTHORIZATION-1", +#endif + "MIT-MAGIC-COOKIE-1", +}; + +#ifdef HAS_AUTH_XA1 + +static int next_nonce(void) +{ + static int nonce = 0; + static pthread_mutex_t nonce_mutex = PTHREAD_MUTEX_INITIALIZER; + int ret; + pthread_mutex_lock(&nonce_mutex); + ret = nonce++; + pthread_mutex_unlock(&nonce_mutex); + return ret; +} + +/* + * This code and the code it calls is taken from libXdmcp, + * specifically from Wrap.c, Wrap.h, and Wraphelp.c. The US + * has changed, thank goodness, and it should be OK to bury + * DES code in an open source product without a maze of + * twisty wrapper functions stored offshore. Or maybe + * not. --Bart Massey 2003/11/5 + */ + +static void +Wrap ( + des_cblock input, + des_cblock key, + des_cblock output, + int bytes) +{ + int i, j; + int len; + des_cblock tmp; + des_cblock expand_key; + des_key_schedule schedule; + + XCBDESKeyToOddParity (key, expand_key); + XCBDESKeySchedule (expand_key, schedule); + for (j = 0; j < bytes; j += 8) + { + len = 8; + if (bytes - j < len) + len = bytes - j; + /* block chaining */ + for (i = 0; i < len; i++) + { + if (j == 0) + tmp[i] = input[i]; + else + tmp[i] = input[j + i] ^ output[j - 8 + i]; + } + for (; i < 8; i++) + { + if (j == 0) + tmp[i] = 0; + else + tmp[i] = 0 ^ output[j - 8 + i]; + } + XCBDESEncrypt (tmp, (output + j), schedule, 1); + } +} + +#endif + +static size_t memdup(char **dst, void *src, size_t len) +{ + if(len) + *dst = malloc(len); + else + *dst = 0; + if(!*dst) + return 0; + memcpy(*dst, src, len); + return len; +} + +static int authname_match(enum auth_protos kind, char *name, int namelen) +{ + if(strlen(authnames[kind]) != namelen) + return 0; + if(memcmp(authnames[kind], name, namelen)) + return 0; + return 1; +} + +static Xauth *get_authptr(struct sockaddr *sockname, unsigned int socknamelen) +{ + char *addr = 0; + int addrlen = 0; + unsigned short family; + char hostnamebuf[256]; /* big enough for max hostname */ + char dispbuf[40]; /* big enough to hold more than 2^64 base 10 */ + char *display; + int authnamelens[N_AUTH_PROTOS]; + int i; + + family = FamilyLocal; /* 256 */ + switch (sockname->sa_family) { + case AF_INET: + /*block*/ { + struct sockaddr_in *si = (struct sockaddr_in *) sockname; + assert(sizeof(*si) == socknamelen); + addr = (char *) &si->sin_addr; + addrlen = 4; + if (ntohl(si->sin_addr.s_addr) != 0x7f000001) + family = FamilyInternet; /* 0 */ + snprintf(dispbuf, sizeof(dispbuf), "%d", ntohs(si->sin_port) - X_TCP_PORT); + display = dispbuf; + } + break; + case AF_UNIX: + /*block*/ { + struct sockaddr_un *su = (struct sockaddr_un *) sockname; + assert(sizeof(*su) >= socknamelen); + display = strrchr(su->sun_path, 'X'); + if (display == 0) + return 0; /* sockname is mangled somehow */ + display++; + } + break; + default: + return 0; /* cannot authenticate this family */ + } + if (family == FamilyLocal) { + if (gethostname(hostnamebuf, sizeof(hostnamebuf)) == -1) + return 0; /* do not know own hostname */ + addr = hostnamebuf; + addrlen = strlen(addr); + } + + for (i = 0; i < N_AUTH_PROTOS; i++) + authnamelens[i] = strlen(authnames[i]); + return XauGetBestAuthByAddr (family, + (unsigned short) addrlen, addr, + (unsigned short) strlen(display), display, + N_AUTH_PROTOS, authnames, authnamelens); +} + +#ifdef HAS_AUTH_XA1 +static void do_append(char *buf, int *idxp, void *val, size_t valsize) { + memcpy(buf + *idxp, val, valsize); + *idxp += valsize; +} +#endif + +static int compute_auth(XCBAuthInfo *info, Xauth *authptr, struct sockaddr *sockname) +{ + if (authname_match(AUTH_MC1, authptr->name, authptr->name_length)) { + info->datalen = memdup(&info->data, authptr->data, authptr->data_length); + if(!info->datalen) + return 0; + return 1; + } +#ifdef HAS_AUTH_XA1 +#define APPEND(buf,idx,val) do_append((buf),&(idx),(val),sizeof(val)) + if (authname_match(AUTH_XA1, authptr->name, authptr->name_length)) { + int j; + + info->data = malloc(192 / 8); + if(!info->data) + return 0; + + for (j = 0; j < 8; j++) + info->data[j] = authptr->data[j]; + switch(sockname->sa_family) { + case AF_INET: + /*block*/ { + struct sockaddr_in *si = (struct sockaddr_in *) sockname; + APPEND(info->data, j, si->sin_addr.s_addr); + APPEND(info->data, j, si->sin_port); + } + break; + case AF_UNIX: + /*block*/ { + long fakeaddr = htonl(0xffffffff - next_nonce()); + short fakeport = htons(getpid()); + APPEND(info->data, j, fakeaddr); + APPEND(info->data, j, fakeport); + } + break; + default: + free(info->data); + return 0; /* do not know how to build this */ + } + { + long now; + time(&now); + now = htonl(now); + APPEND(info->data, j, now); + } + assert(j <= 192 / 8); + while (j < 192 / 8) + info->data[j++] = 0; + info->datalen = j; + Wrap (info->data, authptr->data + 8, info->data, info->datalen); + return 1; + } +#undef APPEND +#endif + + return 0; /* Unknown authorization type */ +} + +int XCBGetAuthInfo(int fd, XCBAuthInfo *info) +{ + /* code adapted from Xlib/ConnDis.c, xtrans/Xtranssocket.c, + xtrans/Xtransutils.c */ + char sockbuf[sizeof(struct sockaddr) + MAXPATHLEN]; + unsigned int socknamelen = sizeof(sockbuf); /* need extra space */ + struct sockaddr *sockname = (struct sockaddr *) &sockbuf; + Xauth *authptr = 0; + int ret = 1; + + /* ensure info has reasonable contents */ + /* XXX This should be removed, but Jamey depends on it + somehow but can't remember how. Principle: don't touch + someone else's data if you're borken. */ + info->namelen = info->datalen = 0; + info->name = info->data = 0; + + if (getpeername(fd, sockname, &socknamelen) == -1) + return 0; /* can only authenticate sockets */ + + authptr = get_authptr(sockname, socknamelen); + if (authptr == 0) + return 0; /* cannot find good auth data */ + + info->namelen = memdup(&info->name, authptr->name, authptr->name_length); + if(info->namelen) + ret = compute_auth(info, authptr, sockname); + if(!ret) + { + free(info->name); + info->name = 0; + info->namelen = 0; + } + XauDisposeAuth(authptr); + return ret; +} diff --git a/src/xcb_conn.c b/src/xcb_conn.c new file mode 100644 index 0000000..0148abf --- /dev/null +++ b/src/xcb_conn.c @@ -0,0 +1,239 @@ +/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +/* Connection management: the core of XCB. */ + +#include +#include +#include +#include +#include +#include +#include + +#include "xcb.h" +#include "xcbint.h" + +static int write_setup(XCBConnection *c, XCBAuthInfo *auth_info) +{ + XCBConnSetupReq out; + struct iovec parts[3]; + int count = 0; + int endian = 0x01020304; + int ret; + + memset(&out, 0, sizeof(out)); + + /* B = 0x42 = MSB first, l = 0x6c = LSB first */ + if(htonl(endian) == endian) + out.byte_order = 0x42; + else + out.byte_order = 0x6c; + out.protocol_major_version = X_PROTOCOL; + out.protocol_minor_version = X_PROTOCOL_REVISION; + out.authorization_protocol_name_len = 0; + out.authorization_protocol_data_len = 0; + parts[count].iov_len = sizeof(XCBConnSetupReq); + parts[count++].iov_base = &out; + + if(auth_info) + { + parts[count].iov_len = out.authorization_protocol_name_len = auth_info->namelen; + parts[count++].iov_base = auth_info->name; + parts[count].iov_len = out.authorization_protocol_data_len = auth_info->datalen; + parts[count++].iov_base = auth_info->data; + } + + pthread_mutex_lock(&c->iolock); + _xcb_out_write_block(c, parts, count); + ret = _xcb_out_flush(c); + pthread_mutex_unlock(&c->iolock); + if(ret <= 0) + return 0; + return 1; +} + +static int read_setup(XCBConnection *c) +{ + /* Read the server response */ + c->setup = malloc(sizeof(XCBConnSetupGenericRep)); + if(!c->setup) + return 0; + + if(_xcb_read_block(c->fd, c->setup, sizeof(XCBConnSetupGenericRep)) != sizeof(XCBConnSetupGenericRep)) + return 0; + + { + void *tmp = realloc(c->setup, c->setup->length * 4 + sizeof(XCBConnSetupGenericRep)); + if(!tmp) + return 0; + c->setup = tmp; + } + + if(_xcb_read_block(c->fd, (char *) c->setup + sizeof(XCBConnSetupGenericRep), c->setup->length * 4) <= 0) + return 0; + + /* 0 = failed, 2 = authenticate, 1 = success */ + switch(c->setup->status) + { + case 0: /* failed */ + { + XCBConnSetupFailedRep *setup = (XCBConnSetupFailedRep *) c->setup; + write(STDERR_FILENO, XCBConnSetupFailedRepReason(setup), XCBConnSetupFailedRepReasonLength(setup)); + return 0; + } + + case 2: /* authenticate */ + { + XCBConnSetupAuthenticateRep *setup = (XCBConnSetupAuthenticateRep *) c->setup; + write(STDERR_FILENO, XCBConnSetupAuthenticateRepReason(setup), XCBConnSetupAuthenticateRepReasonLength(setup)); + return 0; + } + } + + return 1; +} + +/* Public interface */ + +XCBConnSetupSuccessRep *XCBGetSetup(XCBConnection *c) +{ + /* doesn't need locking because it's never written to. */ + return c->setup; +} + +int XCBGetFileDescriptor(XCBConnection *c) +{ + /* doesn't need locking because it's never written to. */ + return c->fd; +} + +XCBConnection *XCBConnectToFD(int fd, XCBAuthInfo *auth_info) +{ + XCBConnection* c; + + c = calloc(1, sizeof(XCBConnection)); + if(!c) + return 0; + + c->fd = fd; + + if(!( + _xcb_set_fd_flags(fd) && + pthread_mutex_init(&c->iolock, 0) == 0 && + _xcb_in_init(&c->in) && + _xcb_out_init(&c->out) && + write_setup(c, auth_info) && + read_setup(c) && + _xcb_ext_init(c) && + _xcb_xid_init(c) + )) + { + XCBDisconnect(c); + return 0; + } + + return c; +} + +void XCBDisconnect(XCBConnection *c) +{ + if(!c) + return; + + free(c->setup); + close(c->fd); + + pthread_mutex_destroy(&c->iolock); + _xcb_in_destroy(&c->in); + _xcb_out_destroy(&c->out); + + _xcb_ext_destroy(c); + _xcb_xid_destroy(c); + + free(c); +} + +/* Private interface */ + +int _xcb_conn_wait(XCBConnection *c, const int should_write, pthread_cond_t *cond) +{ + int ret = 1; + fd_set rfds, wfds; +#if USE_THREAD_ASSERT + static __thread int already_here = 0; + + assert(!already_here); + ++already_here; +#endif + + _xcb_assert_valid_sequence(c); + + /* If the thing I should be doing is already being done, wait for it. */ + if(should_write ? c->out.writing : c->in.reading) + { + pthread_cond_wait(cond, &c->iolock); +#if USE_THREAD_ASSERT + --already_here; +#endif + return 1; + } + + FD_ZERO(&rfds); + FD_SET(c->fd, &rfds); + ++c->in.reading; + + FD_ZERO(&wfds); + if(should_write) + { + FD_SET(c->fd, &wfds); + ++c->out.writing; + } + + pthread_mutex_unlock(&c->iolock); + ret = select(c->fd + 1, &rfds, &wfds, 0, 0); + pthread_mutex_lock(&c->iolock); + + if(ret <= 0) /* error: select failed */ + goto done; + + if(FD_ISSET(c->fd, &rfds)) + if((ret = _xcb_in_read(c)) <= 0) + goto done; + + if(FD_ISSET(c->fd, &wfds)) + if((ret = _xcb_out_write(c)) <= 0) + goto done; + +done: + if(should_write) + --c->out.writing; + --c->in.reading; + +#if USE_THREAD_ASSERT + --already_here; +#endif + return ret; +} diff --git a/src/xcb_ext.c b/src/xcb_ext.c new file mode 100644 index 0000000..46a5519 --- /dev/null +++ b/src/xcb_ext.c @@ -0,0 +1,122 @@ +/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +/* A cache for QueryExtension results. */ + +#include +#include + +#include "xcb.h" +#include "xcbext.h" +#include "xcbint.h" + +typedef struct { + enum { LAZY_COOKIE, LAZY_FORCED } tag; + union { + XCBQueryExtensionCookie cookie; + XCBQueryExtensionRep *reply; + } value; +} lazyreply; + +static lazyreply *get_lazyreply(XCBConnection *c, XCBExtension *ext) +{ + static pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER; + static int next_global_id; + + lazyreply *data; + + pthread_mutex_lock(&global_lock); + if(!ext->global_id) + ext->global_id = ++next_global_id; + pthread_mutex_unlock(&global_lock); + + data = _xcb_map_get(c->ext.extensions, ext->global_id); + if(!data) + { + /* cache miss: query the server */ + data = malloc(sizeof(lazyreply)); + if(!data) + return 0; + data->tag = LAZY_COOKIE; + data->value.cookie = XCBQueryExtension(c, strlen(ext->name), ext->name); + _xcb_map_put(c->ext.extensions, ext->global_id, data); + } + return data; +} + +static void free_lazyreply(void *p) +{ + lazyreply *data = p; + if(data->tag == LAZY_FORCED) + free(data->value.reply); + free(data); +} + +/* Public interface */ + +/* Do not free the returned XCBQueryExtensionRep - on return, it's aliased + * from the cache. */ +const XCBQueryExtensionRep *XCBGetExtensionData(XCBConnection *c, XCBExtension *ext) +{ + lazyreply *data; + + pthread_mutex_lock(&c->ext.lock); + data = get_lazyreply(c, ext); + if(data && data->tag == LAZY_COOKIE) + { + data->tag = LAZY_FORCED; + data->value.reply = XCBQueryExtensionReply(c, data->value.cookie, 0); + } + pthread_mutex_unlock(&c->ext.lock); + + return data ? data->value.reply : 0; +} + +void XCBPrefetchExtensionData(XCBConnection *c, XCBExtension *ext) +{ + pthread_mutex_lock(&c->ext.lock); + get_lazyreply(c, ext); + pthread_mutex_unlock(&c->ext.lock); +} + +/* Private interface */ + +int _xcb_ext_init(XCBConnection *c) +{ + if(pthread_mutex_init(&c->ext.lock, 0)) + return 0; + + c->ext.extensions = _xcb_map_new(); + if(!c->ext.extensions) + return 0; + + return 1; +} + +void _xcb_ext_destroy(XCBConnection *c) +{ + pthread_mutex_destroy(&c->ext.lock); + _xcb_map_delete(c->ext.extensions, free_lazyreply); +} diff --git a/src/xcb_in.c b/src/xcb_in.c new file mode 100644 index 0000000..c260b7b --- /dev/null +++ b/src/xcb_in.c @@ -0,0 +1,319 @@ +/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +/* Stuff that reads stuff from the server. */ + +#include +#include +#include +#include +#include + +#include "xcb.h" +#include "xcbext.h" +#include "xcbint.h" + +typedef struct XCBReplyData { + unsigned int request; + void *data; + XCBGenericError **error; +} XCBReplyData; + +static int match_request_error(const void *request, const void *data) +{ + const XCBGenericError *e = data; + return e->response_type == 0 && e->sequence == ((*(unsigned int *) request) & 0xffff); +} + +static int match_reply(const void *request, const void *data) +{ + return ((XCBReplyData *) data)->request == *(unsigned int *) request; +} + +static void wake_up_next_reader(XCBConnection *c) +{ + XCBReplyData *cur = _xcb_list_peek_head(c->in.readers); + int pthreadret; + if(cur) + pthreadret = pthread_cond_signal(cur->data); + else + pthreadret = pthread_cond_signal(&c->in.event_cond); + assert(pthreadret == 0); +} + +/* Public interface */ + +void *XCBWaitForReply(XCBConnection *c, unsigned int request, XCBGenericError **e) +{ + pthread_cond_t cond = PTHREAD_COND_INITIALIZER; + XCBReplyData reader; + void *ret = 0; + if(e) + *e = 0; + + pthread_mutex_lock(&c->iolock); + + /* If this request has not been written yet, write it. */ + if((signed int) (c->out.request_written - request) < 0) + if(_xcb_out_flush(c) <= 0) + goto done; /* error */ + + if(_xcb_list_find(c->in.readers, match_reply, &request)) + goto done; /* error */ + + if(e) + { + *e = _xcb_list_remove(c->in.events, match_request_error, &request); + if(*e) + goto done; + } + + reader.request = request; + reader.data = &cond; + reader.error = e; + _xcb_list_append(c->in.readers, &reader); + + /* If this request has not been read yet, wait for it. */ + while(!(e && *e) && ((signed int) (c->in.request_read - request) < 0 || + (c->in.request_read == request && + _xcb_queue_is_empty(c->in.current_reply)))) + if(_xcb_conn_wait(c, /*should_write*/ 0, &cond) <= 0) + goto done; + + if(c->in.request_read != request) + { + _xcb_queue *q = _xcb_map_get(c->in.replies, request); + if(q) + { + ret = _xcb_queue_dequeue(q); + if(_xcb_queue_is_empty(q)) + _xcb_queue_delete(_xcb_map_remove(c->in.replies, request), free); + } + } + else + ret = _xcb_queue_dequeue(c->in.current_reply); + +done: + _xcb_list_remove(c->in.readers, match_reply, &request); + pthread_cond_destroy(&cond); + + wake_up_next_reader(c); + pthread_mutex_unlock(&c->iolock); + return ret; +} + +XCBGenericEvent *XCBWaitEvent(XCBConnection *c) +{ + return XCBWaitForEvent(c); +} + +XCBGenericEvent *XCBWaitForEvent(XCBConnection *c) +{ + XCBGenericEvent *ret; + +#if XCBTRACEEVENT + fprintf(stderr, "Entering XCBWaitEvent\n"); +#endif + + pthread_mutex_lock(&c->iolock); + /* _xcb_list_remove_head returns 0 on empty list. */ + while(!(ret = _xcb_queue_dequeue(c->in.events))) + if(_xcb_conn_wait(c, /*should_write*/ 0, &c->in.event_cond) <= 0) + break; + + wake_up_next_reader(c); + pthread_mutex_unlock(&c->iolock); + +#if XCBTRACEEVENT + fprintf(stderr, "Leaving XCBWaitEvent, event type %d\n", ret ? ret->response_type : -1); +#endif + + return ret; +} + +XCBGenericEvent *XCBPollForEvent(XCBConnection *c, int *error) +{ + XCBGenericEvent *ret = 0; + pthread_mutex_lock(&c->iolock); + if(error) + *error = 0; + /* FIXME: follow X meets Z architecture changes. */ + if(_xcb_in_read(c) >= 0) + ret = _xcb_queue_dequeue(c->in.events); + else if(error) + *error = -1; + else + { + fprintf(stderr, "XCBPollForEvent: I/O error occured, but no handler provided.\n"); + abort(); + } + pthread_mutex_unlock(&c->iolock); + return ret; +} + +unsigned int XCBGetRequestRead(XCBConnection *c) +{ + unsigned int ret; + pthread_mutex_lock(&c->iolock); + /* FIXME: follow X meets Z architecture changes. */ + _xcb_in_read(c); + ret = c->in.request_read; + pthread_mutex_unlock(&c->iolock); + return ret; +} + +/* Private interface */ + +int _xcb_in_init(_xcb_in *in) +{ + if(pthread_cond_init(&in->event_cond, 0)) + return 0; + in->reading = 0; + + in->queue_len = 0; + + in->request_read = 0; + in->current_reply = _xcb_queue_new(); + + in->replies = _xcb_map_new(); + in->events = _xcb_queue_new(); + in->readers = _xcb_list_new(); + if(!in->current_reply || !in->replies || !in->events || !in->readers) + return 0; + + return 1; +} + +void _xcb_in_destroy(_xcb_in *in) +{ + pthread_cond_destroy(&in->event_cond); + _xcb_queue_delete(in->current_reply, free); + _xcb_map_delete(in->replies, free); + _xcb_queue_delete(in->events, free); + _xcb_list_delete(in->readers, 0); +} + +int _xcb_in_expect_reply(XCBConnection *c, unsigned int request) +{ + /* XXX: currently a no-op */ + return 1; +} + +int _xcb_in_read_packet(XCBConnection *c) +{ + XCBGenericRep genrep; + int length = 32; + unsigned char *buf; + + /* Wait for there to be enough data for us to read a whole packet */ + if(c->in.queue_len < length) + return 0; + + /* Get the response type, length, and sequence number. */ + memcpy(&genrep, c->in.queue, sizeof(genrep)); + + /* For reply packets, check that the entire packet is available. */ + if(genrep.response_type == 1) + length += genrep.length * 4; + + buf = malloc(length); + if(!buf) + return 0; + if(_xcb_in_read_block(c, buf, length) <= 0) + { + free(buf); + return 0; + } + + /* Compute 32-bit sequence number of this packet. */ + /* XXX: do "sequence lost" check here */ + if((genrep.response_type & 0x7f) != KeymapNotify) + { + int lastread = c->in.request_read; + c->in.request_read = (lastread & 0xffff0000) | genrep.sequence; + if(c->in.request_read != lastread && !_xcb_queue_is_empty(c->in.current_reply)) + { + _xcb_map_put(c->in.replies, lastread, c->in.current_reply); + c->in.current_reply = _xcb_queue_new(); + } + if(c->in.request_read < lastread) + c->in.request_read += 0x10000; + } + + if(buf[0] == 1) /* response is a reply */ + { + XCBReplyData *reader = _xcb_list_find(c->in.readers, match_reply, &c->in.request_read); + _xcb_queue_enqueue(c->in.current_reply, buf); + if(reader) + pthread_cond_signal(reader->data); + return 1; + } + + if(buf[0] == 0) /* response is an error */ + { + XCBReplyData *reader = _xcb_list_find(c->in.readers, match_reply, &c->in.request_read); + if(reader && reader->error) + { + *reader->error = (XCBGenericError *) buf; + pthread_cond_signal(reader->data); + return 1; + } + } + + /* event, or error without a waiting reader */ + _xcb_queue_enqueue(c->in.events, buf); + pthread_cond_signal(&c->in.event_cond); + return 1; /* I have something for you... */ +} + +int _xcb_in_read(XCBConnection *c) +{ + int n = _xcb_readn(c->fd, c->in.queue, sizeof(c->in.queue), &c->in.queue_len); + if(n < 0 && errno == EAGAIN) + n = 1; + while(_xcb_in_read_packet(c) > 0) + /* empty */; + return n; +} + +int _xcb_in_read_block(XCBConnection *c, void *buf, int len) +{ + int done = c->in.queue_len; + if(len < done) + done = len; + + memcpy(buf, c->in.queue, done); + c->in.queue_len -= done; + memmove(c->in.queue, c->in.queue + done, c->in.queue_len); + + if(len > done) + { + int ret = _xcb_read_block(c->fd, (char *) buf + done, len - done); + if(ret <= 0) + return ret; + } + + return len; +} diff --git a/src/xcb_list.c b/src/xcb_list.c new file mode 100644 index 0000000..5b2edc0 --- /dev/null +++ b/src/xcb_list.c @@ -0,0 +1,215 @@ +/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +/* A generic implementation of a list of void-pointers. */ + +#include + +#include "xcb.h" +#include "xcbint.h" + +typedef struct node { + struct node *next; + void *data; +} node; + +struct _xcb_list { + node *head; + node **tail; +}; + +/* Private interface */ + +_xcb_list *_xcb_list_new() +{ + _xcb_list *list; + list = malloc(sizeof(_xcb_list)); + if(!list) + return 0; + list->head = 0; + list->tail = &list->head; + return list; +} + +static void _xcb_list_clear(_xcb_list *list, XCBListFreeFunc do_free) +{ + void *tmp; + while((tmp = _xcb_list_remove_head(list))) + if(do_free) + do_free(tmp); +} + +void _xcb_list_delete(_xcb_list *list, XCBListFreeFunc do_free) +{ + if(!list) + return; + _xcb_list_clear(list, do_free); + free(list); +} + +int _xcb_list_insert(_xcb_list *list, void *data) +{ + node *cur; + cur = malloc(sizeof(node)); + if(!cur) + return 0; + cur->data = data; + + cur->next = list->head; + list->head = cur; + return 1; +} + +int _xcb_list_append(_xcb_list *list, void *data) +{ + node *cur; + cur = malloc(sizeof(node)); + if(!cur) + return 0; + cur->data = data; + cur->next = 0; + + *list->tail = cur; + list->tail = &cur->next; + return 1; +} + +void *_xcb_list_peek_head(_xcb_list *list) +{ + if(!list->head) + return 0; + return list->head->data; +} + +void *_xcb_list_remove_head(_xcb_list *list) +{ + void *ret; + node *tmp = list->head; + if(!tmp) + return 0; + ret = tmp->data; + list->head = tmp->next; + if(!list->head) + list->tail = &list->head; + free(tmp); + return ret; +} + +void *_xcb_list_remove(_xcb_list *list, int (*cmp)(const void *, const void *), const void *data) +{ + node **cur; + for(cur = &list->head; *cur; cur = &(*cur)->next) + if(cmp(data, (*cur)->data)) + { + node *tmp = *cur; + void *ret = (*cur)->data; + *cur = (*cur)->next; + if(!*cur) + list->tail = cur; + + free(tmp); + return ret; + } + return 0; +} + +void *_xcb_list_find(_xcb_list *list, int (*cmp)(const void *, const void *), const void *data) +{ + node *cur; + for(cur = list->head; cur; cur = cur->next) + if(cmp(data, cur->data)) + return cur->data; + return 0; +} + +_xcb_queue *_xcb_queue_new(void) __attribute__ ((alias ("_xcb_list_new"))); +void _xcb_queue_delete(_xcb_queue *q, XCBListFreeFunc do_free) __attribute__ ((alias ("_xcb_list_delete"))); +int _xcb_queue_enqueue(_xcb_queue *q, void *data) __attribute__ ((alias ("_xcb_list_append"))); +void *_xcb_queue_dequeue(_xcb_queue *q) __attribute__ ((alias ("_xcb_list_remove_head"))); + +int _xcb_queue_is_empty(_xcb_queue *q) +{ + return q->head == 0; +} + +typedef struct { + unsigned int key; + void *value; +} map_pair; + +_xcb_map *_xcb_map_new(void) __attribute__ ((alias ("_xcb_list_new"))); + +void _xcb_map_delete(_xcb_map *q, XCBListFreeFunc do_free) +{ + map_pair *tmp; + if(!q) + return; + while((tmp = _xcb_list_remove_head(q))) + { + if(do_free) + do_free(tmp->value); + free(tmp); + } + free(q); +} + +int _xcb_map_put(_xcb_map *q, unsigned int key, void *data) +{ + map_pair *cur = malloc(sizeof(map_pair)); + if(!cur) + return 0; + cur->key = key; + cur->value = data; + if(!_xcb_list_append(q, cur)) + { + free(cur); + return 0; + } + return 1; +} + +static int match_map_pair(const void *key, const void *pair) +{ + return ((map_pair *) pair)->key == *(unsigned int *) key; +} + +void *_xcb_map_get(_xcb_map *q, unsigned int key) +{ + map_pair *cur = _xcb_list_find(q, match_map_pair, &key); + if(!cur) + return 0; + return cur->value; +} + +void *_xcb_map_remove(_xcb_map *q, unsigned int key) +{ + map_pair *cur = _xcb_list_remove(q, match_map_pair, &key); + void *ret; + if(!cur) + return 0; + ret = cur->value; + free(cur); + return ret; +} diff --git a/src/xcb_out.c b/src/xcb_out.c new file mode 100644 index 0000000..b3a556a --- /dev/null +++ b/src/xcb_out.c @@ -0,0 +1,272 @@ +/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +/* Stuff that sends stuff to the server. */ + +#include +#include +#include +#include + +#include "xcb.h" +#include "xcbext.h" +#include "xcbint.h" +#include "extensions/bigreq.h" + +static int force_sequence_wrap(XCBConnection *c) +{ + int ret = 1; + if((c->out.request - c->in.request_read) > 65530) + { + pthread_mutex_unlock(&c->iolock); + ret = XCBSync(c, 0); + pthread_mutex_lock(&c->iolock); + } + return ret; +} + +/* Public interface */ + +CARD32 XCBGetMaximumRequestLength(XCBConnection *c) +{ + pthread_mutex_lock(&c->out.reqlenlock); + if(!c->out.maximum_request_length) + { + const XCBQueryExtensionRep *ext; + c->out.maximum_request_length = c->setup->maximum_request_length; + ext = XCBGetExtensionData(c, &XCBBigRequestsId); + if(ext && ext->present) + { + XCBBigRequestsEnableRep *r = XCBBigRequestsEnableReply(c, XCBBigRequestsEnable(c), 0); + c->out.maximum_request_length = r->maximum_request_length; + free(r); + } + } + pthread_mutex_unlock(&c->out.reqlenlock); + return c->out.maximum_request_length; +} + +int XCBSendRequest(XCBConnection *c, unsigned int *request, struct iovec *vector, const XCBProtocolRequest *req) +{ + int ret; + int i; + struct iovec prefix[2]; + CARD16 shortlen = 0; + CARD32 longlen = 0; + + assert(c != 0); + assert(request != 0); + assert(vector != 0); + assert(req->count > 0); + + /* put together the length field, possibly using BIGREQUESTS */ + for(i = 0; i < req->count; ++i) + longlen += XCB_CEIL(vector[i].iov_len) >> 2; + + if(longlen > c->setup->maximum_request_length) + { + if(longlen > XCBGetMaximumRequestLength(c)) + return 0; /* server can't take this; maybe need BIGREQUESTS? */ + } + else + { + /* we don't need BIGREQUESTS. */ + shortlen = longlen; + longlen = 0; + } + + /* set the length field. */ + i = 0; + prefix[i].iov_base = vector[0].iov_base; + prefix[i].iov_len = sizeof(CARD32); + vector[0].iov_base = ((char *) vector[0].iov_base) + sizeof(CARD32); + vector[0].iov_len -= sizeof(CARD32); + ((CARD16 *) prefix[i].iov_base)[1] = shortlen; + ++i; + if(!shortlen) + { + ++longlen; + prefix[i].iov_base = &longlen; + prefix[i].iov_len = sizeof(CARD32); + ++i; + } + + /* set the major opcode, and the minor opcode for extensions */ + if(req->ext) + { + const XCBQueryExtensionRep *extension = XCBGetExtensionData(c, req->ext); + /* TODO: better error handling here, please! */ + assert(extension && extension->present); + ((CARD8 *) prefix[0].iov_base)[0] = extension->major_opcode; + ((CARD8 *) prefix[0].iov_base)[1] = req->opcode; + } + else + ((CARD8 *) prefix[0].iov_base)[0] = req->opcode; + + /* get a sequence number and arrange for delivery. */ + pthread_mutex_lock(&c->iolock); + if(req->isvoid && !force_sequence_wrap(c)) + { + pthread_mutex_unlock(&c->iolock); + return -1; + } + + *request = ++c->out.request; + + if(!req->isvoid) + _xcb_in_expect_reply(c, *request); + + ret = _xcb_out_write_block(c, prefix, i); + if(ret > 0) + ret = _xcb_out_write_block(c, vector, req->count); + pthread_mutex_unlock(&c->iolock); + + return ret; +} + +int XCBFlush(XCBConnection *c) +{ + int ret; + pthread_mutex_lock(&c->iolock); + ret = _xcb_out_flush(c); + pthread_mutex_unlock(&c->iolock); + return ret; +} + +/* Private interface */ + +int _xcb_out_init(_xcb_out *out) +{ + if(pthread_cond_init(&out->cond, 0)) + return 0; + out->writing = 0; + + out->queue_len = 0; + out->vec = 0; + out->vec_len = 0; + + out->last_request = 0; + out->request = 0; + out->request_written = 0; + + if(pthread_mutex_init(&out->reqlenlock, 0)) + return 0; + out->maximum_request_length = 0; + + return 1; +} + +void _xcb_out_destroy(_xcb_out *out) +{ + pthread_cond_destroy(&out->cond); + pthread_mutex_destroy(&out->reqlenlock); + free(out->vec); +} + +int _xcb_out_write(XCBConnection *c) +{ + int n; + if(c->out.vec_len) + n = _xcb_writev(c->fd, c->out.vec, c->out.vec_len); + else + n = _xcb_write(c->fd, &c->out.queue, &c->out.queue_len); + + if(n < 0 && errno == EAGAIN) + n = 1; + + if(c->out.vec_len) + { + int i; + for(i = 0; i < c->out.vec_len; ++i) + if(c->out.vec[i].iov_len) + return n; + c->out.vec_len = 0; + } + return n; +} + +int _xcb_out_write_block(XCBConnection *c, struct iovec *vector, size_t count) +{ + static const char pad[3]; + int i; + int len = 0; + + for(i = 0; i < count; ++i) + len += XCB_CEIL(vector[i].iov_len); + + /* Is the queue about to overflow? */ + if(c->out.queue_len + len < sizeof(c->out.queue)) + { + /* No, this will fit. */ + for(i = 0; i < count; ++i) + { + memcpy(c->out.queue + c->out.queue_len, vector[i].iov_base, vector[i].iov_len); + if(vector[i].iov_len & 3) + memset(c->out.queue + c->out.queue_len + vector[i].iov_len, 0, XCB_PAD(vector[i].iov_len)); + c->out.queue_len += XCB_CEIL(vector[i].iov_len); + } + return len; + } + + assert(!c->out.vec_len); + assert(!c->out.vec); + c->out.vec = malloc(sizeof(struct iovec) * (1 + count * 2)); + if(!c->out.vec) + return -1; + if(c->out.queue_len) + { + c->out.vec[c->out.vec_len].iov_base = c->out.queue; + c->out.vec[c->out.vec_len++].iov_len = c->out.queue_len; + c->out.queue_len = 0; + } + for(i = 0; i < count; ++i) + { + if(!vector[i].iov_len) + continue; + c->out.vec[c->out.vec_len].iov_base = vector[i].iov_base; + c->out.vec[c->out.vec_len++].iov_len = vector[i].iov_len; + if(!XCB_PAD(vector[i].iov_len)) + continue; + c->out.vec[c->out.vec_len].iov_base = (void *) pad; + c->out.vec[c->out.vec_len++].iov_len = XCB_PAD(vector[i].iov_len); + } + if(_xcb_out_flush(c) <= 0) + len = -1; + free(c->out.vec); + c->out.vec = 0; + + return len; +} + +int _xcb_out_flush(XCBConnection *c) +{ + int ret = 1; + while(ret > 0 && (c->out.queue_len || c->out.vec_len)) + ret = _xcb_conn_wait(c, /*should_write*/ 1, &c->out.cond); + c->out.last_request = 0; + c->out.request_written = c->out.request; + pthread_cond_broadcast(&c->out.cond); + return ret; +} diff --git a/src/xcb_util.c b/src/xcb_util.c new file mode 100644 index 0000000..b25a2d8 --- /dev/null +++ b/src/xcb_util.c @@ -0,0 +1,279 @@ +/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +/* Utility functions implementable using only public APIs. */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "xcb.h" +#include "xcbext.h" + +int XCBPopcount(CARD32 mask) +{ + unsigned long y; + y = (mask >> 1) & 033333333333; + y = mask - y - ((y >> 1) & 033333333333); + return ((y + (y >> 3)) & 030707070707) % 077; +} + +int XCBParseDisplay(const char *name, char **host, int *displayp, int *screenp) +{ + int len, display, screen; + char *colon, *dot, *end; + if(!name || !*name) + name = getenv("DISPLAY"); + if(!name) + return 0; + colon = strrchr(name, ':'); + if(!colon) + return 0; + len = colon - name; + ++colon; + display = strtoul(colon, &dot, 10); + if(dot == colon) + return 0; + if(*dot == '\0') + screen = 0; + else + { + if(*dot != '.') + return 0; + ++dot; + screen = strtoul(dot, &end, 10); + if(end == dot || *end != '\0') + return 0; + } + /* At this point, the display string is fully parsed and valid, but + * the caller's memory is untouched. */ + + *host = malloc(len + 1); + if(!*host) + return 0; + memcpy(*host, name, len); + (*host)[len] = '\0'; + *displayp = display; + if(screenp) + *screenp = screen; + return 1; +} + +int XCBOpen(const char *host, const int display) +{ + int fd; + + if(*host) + { + /* display specifies TCP */ + unsigned short port = X_TCP_PORT + display; + fd = XCBOpenTCP(host, port); + } + else + { + /* display specifies Unix socket */ + static const char base[] = "/tmp/.X11-unix/X"; + char file[sizeof(base) + 20]; + snprintf(file, sizeof(file), "%s%d", base, display); + fd = XCBOpenUnix(file); + } + + return fd; +} + +int XCBOpenTCP(const char *host, const unsigned short port) +{ + int fd; + struct sockaddr_in addr; + struct hostent *hostaddr = gethostbyname(host); + if(!hostaddr) + return -1; + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + memcpy(&addr.sin_addr, hostaddr->h_addr_list[0], sizeof(addr.sin_addr)); + + fd = socket(PF_INET, SOCK_STREAM, 0); + if(fd == -1) + return -1; + if(connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) + return -1; + return fd; +} + +int XCBOpenUnix(const char *file) +{ + int fd; + struct sockaddr_un addr = { AF_UNIX }; + strcpy(addr.sun_path, file); + + fd = socket(AF_UNIX, SOCK_STREAM, 0); + if(fd == -1) + return -1; + if(connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) + return -1; + return fd; +} + +XCBConnection *XCBConnect(const char *displayname, int *screenp) +{ + int fd, display = 0; + char *host; + XCBConnection *c; + XCBAuthInfo auth; + + if(!XCBParseDisplay(displayname, &host, &display, screenp)) + return 0; + fd = XCBOpen(host, display); + free(host); + if(fd == -1) + return 0; + + XCBGetAuthInfo(fd, &auth); + c = XCBConnectToFD(fd, &auth); + free(auth.name); + free(auth.data); + return c; +} + +XCBConnection *XCBConnectToDisplayWithAuthInfo(const char *displayname, XCBAuthInfo *auth, int *screenp) +{ + int fd, display = 0; + char *host; + + if(!XCBParseDisplay(displayname, &host, &display, screenp)) + return 0; + fd = XCBOpen(host, display); + free(host); + if(fd == -1) + return 0; + + return XCBConnectToFD(fd, auth); +} + +/* backwards compatible interface: remove before 1.0 release */ +XCBConnection *XCBConnectBasic() +{ + XCBConnection *c = XCBConnect(0, 0); + if(c) + return c; + perror("XCBConnect"); + abort(); +} + +int XCBSync(XCBConnection *c, XCBGenericError **e) +{ + XCBGetInputFocusRep *reply = XCBGetInputFocusReply(c, XCBGetInputFocus(c), e); + free(reply); + return reply != 0; +} + +/* The functions beyond this point still use only public interfaces, + * but are not themselves part of the public interface. So their + * prototypes are in xcbint.h. */ + +#include "xcbint.h" + +int _xcb_set_fd_flags(const int fd) +{ + long flags = fcntl(fd, F_GETFL, 0); + if(flags == -1) + return 0; + flags |= O_NONBLOCK; + if(fcntl(fd, F_SETFL, flags) == -1) + return 0; + if(fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) + return 0; + return 1; +} + +int _xcb_readn(const int fd, void *buf, const int buflen, int *count) +{ + int n = read(fd, ((char *) buf) + *count, buflen - *count); + if(n > 0) + *count += n; + return n; +} + +int _xcb_read_block(const int fd, void *buf, const size_t len) +{ + int done = 0; + while(done < len) + { + int ret = _xcb_readn(fd, buf, len, &done); + if(ret < 0 && errno == EAGAIN) + { + fd_set fds; + FD_ZERO(&fds); + FD_SET(fd, &fds); + ret = select(fd + 1, &fds, 0, 0, 0); + } + if(ret <= 0) + return ret; + } + return len; +} + +int _xcb_write(const int fd, char (*buf)[], int *count) +{ + int n = write(fd, *buf, *count); + if(n > 0) + { + *count -= n; + if(*count) + memmove(*buf, *buf + n, *count); + } + return n; +} + +int _xcb_writev(const int fd, struct iovec *vec, int count) +{ + int n = writev(fd, vec, count); + if(n > 0) + { + int rem = n; + for(; count; --count, ++vec) + { + int cur = vec->iov_len; + if(cur > rem) + cur = rem; + vec->iov_len -= cur; + vec->iov_base = (char *) vec->iov_base + cur; + rem -= cur; + if(vec->iov_len) + break; + } + assert(rem == 0); + } + return n; +} diff --git a/src/xcb_xid.c b/src/xcb_xid.c new file mode 100644 index 0000000..7d7f784 --- /dev/null +++ b/src/xcb_xid.c @@ -0,0 +1,70 @@ +/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +/* XID allocators. */ + +#include +#include "xcb.h" +#include "xcbext.h" +#include "xcbint.h" +#include "extensions/xc_misc.h" + +/* Public interface */ + +CARD32 XCBGenerateID(XCBConnection *c) +{ + CARD32 ret; + pthread_mutex_lock(&c->xid.lock); + if(c->xid.last == c->xid.max) + { + XCBXCMiscGetXIDRangeRep *range; + range = XCBXCMiscGetXIDRangeReply(c, XCBXCMiscGetXIDRange(c), 0); + c->xid.last = range->start_id; + c->xid.max = range->start_id + (range->count - 1) * c->xid.inc; + free(range); + } + ret = c->xid.last | c->xid.base; + c->xid.last += c->xid.inc; + pthread_mutex_unlock(&c->xid.lock); + return ret; +} + +/* Private interface */ + +int _xcb_xid_init(XCBConnection *c) +{ + if(pthread_mutex_init(&c->xid.lock, 0)) + return 0; + c->xid.last = 0; + c->xid.base = c->setup->resource_id_base; + c->xid.max = c->setup->resource_id_mask; + c->xid.inc = c->setup->resource_id_mask & -(c->setup->resource_id_mask); + return 1; +} + +void _xcb_xid_destroy(XCBConnection *c) +{ + pthread_mutex_destroy(&c->xid.lock); +} diff --git a/src/xcb_xlib.c b/src/xcb_xlib.c new file mode 100644 index 0000000..8cc6837 --- /dev/null +++ b/src/xcb_xlib.c @@ -0,0 +1,41 @@ +/* Copyright (C) 2005 Bart Massey and Jamey Sharp. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +#include "xcbxlib.h" +#include "xcbint.h" + +unsigned int XCBGetRequestSent(XCBConnection *c) +{ + unsigned int ret; + pthread_mutex_lock(&c->iolock); + ret = c->out.request; + pthread_mutex_unlock(&c->iolock); + return ret; +} + +pthread_mutex_t *XCBGetIOLock(XCBConnection *c) +{ + return &c->iolock; +} diff --git a/src/xcbext.h b/src/xcbext.h new file mode 100644 index 0000000..c8f532c --- /dev/null +++ b/src/xcbext.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2001-2004 Bart Massey and Jamey Sharp. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +#ifndef __XCBEXT_H +#define __XCBEXT_H + +#include "xcb.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* xcb_ext.c */ + +struct XCBExtension { + const char *name; + int global_id; +}; + + +/* xcb_out.c */ + +typedef struct { + size_t count; + XCBExtension *ext; + CARD8 opcode; + BOOL isvoid; +} XCBProtocolRequest; + +int XCBSendRequest(XCBConnection *c, unsigned int *sequence, struct iovec *vector, const XCBProtocolRequest *request); + + +/* xcb_in.c */ + +void *XCBWaitForReply(XCBConnection *c, unsigned int request, XCBGenericError **e); + + +/* xcb_xid.c */ + +CARD32 XCBGenerateID(XCBConnection *c); + + +/* xcb_util.c */ + +int XCBPopcount(CARD32 mask); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/xcbint.h b/src/xcbint.h new file mode 100644 index 0000000..057a315 --- /dev/null +++ b/src/xcbint.h @@ -0,0 +1,183 @@ +/* + * Copyright (C) 2001-2004 Bart Massey and Jamey Sharp. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +#ifndef __XCBINT_H +#define __XCBINT_H + +/* Not simply (a <= b) because eventually the 32-bit sequence number + * will wrap, causing earlier sequence numbers to be higher than later + * ones for a brief but fatal period. (a and b must be unsigned.) */ +#define _xcb_assert_sequence_less(a,b) assert((b) - (a) < 65536) + +#define _xcb_assert_valid_sequence(c) do { \ + _xcb_assert_sequence_less((c)->in.request_read, (c)->out.request_written); \ + _xcb_assert_sequence_less((c)->out.request_written, (c)->out.request); \ +} while(0) + +/* xcb_list.c */ + +typedef struct _xcb_list _xcb_list; +typedef void (*XCBListFreeFunc)(void *); + +_xcb_list *_xcb_list_new(void); +void _xcb_list_delete(_xcb_list *list, XCBListFreeFunc do_free); +int _xcb_list_insert(_xcb_list *list, void *data); +int _xcb_list_append(_xcb_list *list, void *data); +void *_xcb_list_peek_head(_xcb_list *list); +void *_xcb_list_remove_head(_xcb_list *list); +void *_xcb_list_remove(_xcb_list *list, int (*cmp)(const void *, const void *), const void *data); +void *_xcb_list_find(_xcb_list *list, int (*cmp)(const void *, const void *), const void *data); + +typedef _xcb_list _xcb_queue; + +_xcb_queue *_xcb_queue_new(void); +void _xcb_queue_delete(_xcb_queue *q, XCBListFreeFunc do_free); +int _xcb_queue_enqueue(_xcb_queue *q, void *data); +void *_xcb_queue_dequeue(_xcb_queue *q); +int _xcb_queue_is_empty(_xcb_queue *q); + +typedef _xcb_list _xcb_map; + +_xcb_map *_xcb_map_new(void); +void _xcb_map_delete(_xcb_map *q, XCBListFreeFunc do_free); +int _xcb_map_put(_xcb_map *q, unsigned int key, void *data); +void *_xcb_map_get(_xcb_map *q, unsigned int key); +void *_xcb_map_remove(_xcb_map *q, unsigned int key); + + +/* xcb_util.c */ + +/* Index of nearest 4-byte boundary following E. */ +#define XCB_CEIL(E) (((E)+3)&~3) + +#define XCB_PAD(i) ((4 - (i & 3)) & 3) + +int _xcb_set_fd_flags(const int fd); +int _xcb_readn(const int fd, void *buf, const int buflen, int *count); +int _xcb_read_block(const int fd, void *buf, const size_t len); +int _xcb_write(const int fd, char (*buf)[], int *count); +int _xcb_writev(const int fd, struct iovec *vec, int count); + + +/* xcb_out.c */ + +typedef struct _xcb_out { + pthread_cond_t cond; + int writing; + + char queue[4096]; + int queue_len; + struct iovec *vec; + int vec_len; + + void *last_request; + unsigned int request; + unsigned int request_written; + + pthread_mutex_t reqlenlock; + CARD32 maximum_request_length; +} _xcb_out; + +int _xcb_out_init(_xcb_out *out); +void _xcb_out_destroy(_xcb_out *out); + +int _xcb_out_write(XCBConnection *c); +int _xcb_out_write_block(XCBConnection *c, struct iovec *vector, size_t count); +int _xcb_out_flush(XCBConnection *c); + + +/* xcb_in.c */ + +typedef struct _xcb_in { + pthread_cond_t event_cond; + int reading; + + char queue[4096]; + int queue_len; + + unsigned int request_read; + _xcb_queue *current_reply; + + _xcb_map *replies; + _xcb_queue *events; + _xcb_list *readers; +} _xcb_in; + +int _xcb_in_init(_xcb_in *in); +void _xcb_in_destroy(_xcb_in *in); + +int _xcb_in_expect_reply(XCBConnection *c, unsigned int request); + +int _xcb_in_read_packet(XCBConnection *c); +int _xcb_in_read(XCBConnection *c); +int _xcb_in_read_block(XCBConnection *c, void *buf, int nread); + + +/* xcb_xid.c */ + +typedef struct _xcb_xid { + pthread_mutex_t lock; + CARD32 last; + CARD32 base; + CARD32 max; + CARD32 inc; +} _xcb_xid; + +int _xcb_xid_init(XCBConnection *c); +void _xcb_xid_destroy(XCBConnection *c); + + +/* xcb_ext.c */ + +typedef struct _xcb_ext { + pthread_mutex_t lock; + _xcb_map *extensions; +} _xcb_ext; + +int _xcb_ext_init(XCBConnection *c); +void _xcb_ext_destroy(XCBConnection *c); + + +/* xcb_conn.c */ + +struct XCBConnection { + /* constant data */ + XCBConnSetupSuccessRep *setup; + int fd; + + /* I/O data */ + pthread_mutex_t iolock; + _xcb_in in; + _xcb_out out; + + /* misc data */ + _xcb_ext ext; + _xcb_xid xid; +}; + +int _xcb_conn_wait(XCBConnection *c, const int should_write, pthread_cond_t *cond); +#endif diff --git a/src/xcbxlib.h b/src/xcbxlib.h new file mode 100644 index 0000000..e9f7140 --- /dev/null +++ b/src/xcbxlib.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2005 Bart Massey and Jamey Sharp. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +#ifndef __XCBXLIB_H +#define __XCBXLIB_H + +#include +#include "xcb.h" + +unsigned int XCBGetRequestSent(XCBConnection *c); + +pthread_mutex_t *XCBGetIOLock(XCBConnection *c); + +#endif diff --git a/tests/.cvsignore b/tests/.cvsignore new file mode 100644 index 0000000..bfa26dd --- /dev/null +++ b/tests/.cvsignore @@ -0,0 +1,2 @@ +Makefile.in +CheckLog.html diff --git a/tests/CheckLog.xsl b/tests/CheckLog.xsl new file mode 100644 index 0000000..3daebaa --- /dev/null +++ b/tests/CheckLog.xsl @@ -0,0 +1,104 @@ + + + + + + + + + + Test Suite Results + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + + + +
Test PathTest Function LocationC IdentifierTest CaseResult
+
+ + + + +

Unit Test Statistics

+
    +
  • date/time:
    • +
  • duration:
    • +
+
+ + + +

Test Suite:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/Makefile.am b/tests/Makefile.am new file mode 100644 index 0000000..fceaf13 --- /dev/null +++ b/tests/Makefile.am @@ -0,0 +1,32 @@ +######################## +## tests/Makefile.am +######################## +SUBDIRS = +EXTRA_DIST = CheckLog.xsl +AM_MAKEFLAGS = -k +AM_CFLAGS = -Wall -Werror $(XPROTO_CFLAGS) @CHECK_CFLAGS@ -I$(top_srcdir)/src +LDADD = @CHECK_LIBS@ $(top_builddir)/src/libXCB.la + +if HAVE_CHECK +TESTS = check_all +check_PROGRAMS = check_all +check_all_SOURCES = check_all.c check_suites.h check_public.c + +all-local:: + $(RM) CheckLog*.xml + +check-local: + $(RM) CheckLog.html + if test x$(HTML_CHECK_RESULT) = xtrue; then \ + $(XSLTPROC) $(srcdir)/CheckLog.xsl CheckLog*.xml > CheckLog.html; \ + else \ + touch CheckLog.html; \ + fi + +CheckLog.html: $(check_PROGRAMS) + $(MAKE) $(AM_MAKEFLAGS) check; + +endif + +clean-local:: + $(RM) CheckLog.html CheckLog*.txt CheckLog*.xml diff --git a/tests/check_all.c b/tests/check_all.c new file mode 100644 index 0000000..4393422 --- /dev/null +++ b/tests/check_all.c @@ -0,0 +1,20 @@ +#include +#include "check_suites.h" + +void suite_add_test(Suite *s, TFun tf, const char *name) +{ + TCase *tc = tcase_create(name); + tcase_add_test(tc, tf); + suite_add_tcase(s, tc); +} + +int main(void) +{ + int nf; + SRunner *sr = srunner_create(public_suite()); + srunner_set_xml(sr, "CheckLog_xcb.xml"); + srunner_run_all(sr, CK_NORMAL); + nf = srunner_ntests_failed(sr); + srunner_free(sr); + return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/tests/check_public.c b/tests/check_public.c new file mode 100644 index 0000000..9a32ba9 --- /dev/null +++ b/tests/check_public.c @@ -0,0 +1,129 @@ +#include +#include +#include +#include "check_suites.h" +#include "xcb.h" + +/* XCBParseDisplay tests {{{ */ + +static void parse_display_pass(const char *name, const char *host, const int display, const int screen) +{ + int success; + char *got_host; + int got_display, got_screen; + + got_host = (char *) -1; + got_display = got_screen = -42; + mark_point(); + success = XCBParseDisplay(name, &got_host, &got_display, &got_screen); + fail_unless(success, "unexpected parse failure for '%s'", name); + fail_unless(strcmp(host, got_host) == 0, "parse produced unexpected hostname '%s' for '%s': expected '%s'", got_host, name, host); + fail_unless(display == got_display, "parse produced unexpected display '%d' for '%s': expected '%d'", got_display, name, display); + fail_unless(screen == got_screen, "parse produced unexpected screen '%d' for '%s': expected '%d'", got_screen, name, screen); + + got_host = (char *) -1; + got_display = got_screen = -42; + mark_point(); + success = XCBParseDisplay(name, &got_host, &got_display, 0); + fail_unless(success, "unexpected screenless parse failure for '%s'", name); + fail_unless(strcmp(host, got_host) == 0, "screenless parse produced unexpected hostname '%s' for '%s': expected '%s'", got_host, name, host); + fail_unless(display == got_display, "screenless parse produced unexpected display '%d' for '%s': expected '%d'", got_display, name, display); +} + +static void parse_display_fail(const char *name) +{ + int success; + char *got_host; + int got_display, got_screen; + + got_host = (char *) -1; + got_display = got_screen = -42; + mark_point(); + success = XCBParseDisplay(name, &got_host, &got_display, &got_screen); + fail_unless(!success, "unexpected parse success for '%s'", name); + fail_unless(got_host == (char *) -1, "host changed on failure for '%s': got %p", got_host); + fail_unless(got_display == -42, "display changed on failure for '%s': got %d", got_display); + fail_unless(got_screen == -42, "screen changed on failure for '%s': got %d", got_screen); + + got_host = (char *) -1; + got_display = got_screen = -42; + mark_point(); + success = XCBParseDisplay(name, &got_host, &got_display, 0); + fail_unless(!success, "unexpected screenless parse success for '%s'", name); + fail_unless(got_host == (char *) -1, "host changed on failure for '%s': got %p", got_host); + fail_unless(got_display == -42, "display changed on failure for '%s': got %d", got_display); +} + +START_TEST(parse_display_unix) +{ + parse_display_pass(":0", "", 0, 0); + parse_display_pass(":1", "", 1, 0); + parse_display_pass(":0.1", "", 0, 1); +} +END_TEST + +START_TEST(parse_display_ip) +{ + parse_display_pass("x.org:0", "x.org", 0, 0); + parse_display_pass("expo:0", "expo", 0, 0); + parse_display_pass("bigmachine:1", "bigmachine", 1, 0); + parse_display_pass("hydra:0.1", "hydra", 0, 1); +} +END_TEST + +START_TEST(parse_display_ipv4) +{ + parse_display_pass("198.112.45.11:0", "198.112.45.11", 0, 0); + parse_display_pass("198.112.45.11:0.1", "198.112.45.11", 0, 1); +} +END_TEST + +START_TEST(parse_display_ipv6) +{ + parse_display_pass("::1:0", "::1", 0, 0); + parse_display_pass("::1:0.1", "::1", 0, 1); + parse_display_pass("2002:83fc:d052::1:0", "2002:83fc:d052::1", 0, 0); + parse_display_pass("2002:83fc:d052::1:0.1", "2002:83fc:d052::1", 0, 1); +} +END_TEST + +START_TEST(parse_display_decnet) +{ + parse_display_pass("myws::0", "myws:", 0, 0); + parse_display_pass("big::1", "big:", 1, 0); + parse_display_pass("hydra::0.1", "hydra:", 0, 1); +} +END_TEST + +START_TEST(parse_display_negative) +{ + parse_display_fail(0); + parse_display_fail(""); + parse_display_fail(":"); + parse_display_fail("::"); + parse_display_fail(":."); + parse_display_fail(":a"); + parse_display_fail(":a."); + parse_display_fail(":0."); + parse_display_fail(":0.a"); + parse_display_fail(":0.0."); + + parse_display_fail("localhost"); + parse_display_fail("localhost:"); +} +END_TEST + +/* }}} */ + +Suite *public_suite(void) +{ + Suite *s = suite_create("Public API"); + putenv("DISPLAY"); + suite_add_test(s, parse_display_unix, "XCBParseDisplay unix"); + suite_add_test(s, parse_display_ip, "XCBParseDisplay ip"); + suite_add_test(s, parse_display_ipv4, "XCBParseDisplay ipv4"); + suite_add_test(s, parse_display_ipv6, "XCBParseDisplay ipv6"); + suite_add_test(s, parse_display_decnet, "XCBParseDisplay decnet"); + suite_add_test(s, parse_display_negative, "XCBParseDisplay negative"); + return s; +} diff --git a/tests/check_suites.h b/tests/check_suites.h new file mode 100644 index 0000000..499f1af --- /dev/null +++ b/tests/check_suites.h @@ -0,0 +1,4 @@ +#include + +void suite_add_test(Suite *s, TFun tf, const char *name); +Suite *public_suite(void); diff --git a/xcb.pc.in b/xcb.pc.in new file mode 100644 index 0000000..108165d --- /dev/null +++ b/xcb.pc.in @@ -0,0 +1,10 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: XCB +Description: X-protocol C Binding +Version: @PACKAGE_VERSION@ +Libs: -L${libdir} -lXCB @XPROTO_LIBS@ @LIBS@ +Cflags: -I${includedir} @XPROTO_CFLAGS@ -- 2.34.1