#include <string.h>
#include <sys/time.h>
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
#include <X11/Xlib.h>
and is opaque. Here is how the connection can be opened:
</p>
<pre class="code">
-#<include>include</include> <string><X11/XCB/xcb.h></string>
+#<include>include</include> <string><xcb/xcb.h></string>
<type>int</type>
<function>main</function> ()
<pre class="code">
#include <stdio.h>
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
int
-main (int argc, char *argv[])
+main ()
{
xcb_connection_t *c;
xcb_screen_t *screen;
We first ask for a new Id for our window, with this function:
</p>
<pre class="code">
-xcb_window_t xcb_window_new(xcb_connection_t *c);
+xcb_window_t xcb_generate_id(xcb_connection_t *c);
</pre>
<p>
Then, XCB supplies the following function to create new windows:
uint16_t height, /* Height of the window (in pixels) */
uint16_t border_width, /* Width of the window's border (in pixels) */
uint16_t _class,
- xcb_visualid_t visual,
+ xcb_visualid_t visual,
uint32_t value_mask,
const uint32_t *value_list);
</pre>
<pre class="code">
#include <unistd.h> /* pause() */
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
int
-main (int argc, char *argv[])
+main ()
{
xcb_connection_t *c;
xcb_screen_t *screen;
screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;
/* Ask for our window's Id */
- win.window = xcb_window_new(c);
+ win.window = xcb_generate_id(c);
/* Create the window */
xcb_create_window (c, /* Connection */
This function flushes all pending requests to the X server (much
like the <span class="code">fflush()</span> function is used to
flush standard output). The second function is
- <span class="code">xcb_sync()</span>:
+ <span class="code">xcb_aux_sync()</span>:
</p>
<pre class="code">
int xcb_aux_sync (xcb_connection_t *c);
now, we put it there.
</p>
<p>
- The window that is created by the above code has a default
- background (gray). This one can be set to a specific color,
+ The window that is created by the above code has a non defined
+ background. This one can be set to a specific color,
thanks to the two last parameters of
<span class="code">xcb_create_window()</span>, which are not
described yet. See the subsections
</div>
<div class="xcb">
<ul>
- <li>xcb_window_new ()
+ <li>xcb_generate_id ()
<li>xcb_create_window ()
</ul>
</div>
context with this function:
</p>
<pre class="code">
-xcb_gcontext_t xcb_gcontext_new (xcb_connection_t *c);
+xcb_gcontext_t xcb_generate_id (xcb_connection_t *c);
</pre>
<p>
Then, we set the attributes of the graphic context with this function:
draw in foreground with a black color.
</p>
<pre class="code">
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
int
-main (int argc, char *argv[])
+main ()
{
xcb_connection_t *c;
xcb_screen_t *screen;
/* Create a black graphic context for drawing in the foreground */
win.window = screen->root;
- black = xcb_gcontext_new (c);
+ black = xcb_generate_id (c);
mask = XCB_GC_FOREGROUND;
value[0] = screen->black_pixel;
xcb_create_gc (c, black, win, mask, value);
</div>
<div class="xcb">
<ul>
- <li>xcb_gcontext_new ()
+ <li>xcb_generate_id ()
<li>xcb_create_gc ()
</ul>
</div>
#include <stdlib.h>
#include <stdio.h>
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
int
-main (int argc, char *argv[])
+main ()
{
xcb_connection_t *c;
xcb_screen_t *screen;
/* Create black (foreground) graphic context */
win.window = screen->root;
- foreground = xcb_gcontext_new (c);
+ foreground = xcb_generate_id (c);
mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
values[0] = screen->black_pixel;
values[1] = 0;
xcb_create_gc (c, foreground, win, mask, values);
/* Ask for our window's Id */
- win.window = xcb_window_new(c);
+ win.window = xcb_generate_id(c);
/* Create the window */
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
<pre class="code">
mask = XCB_CW_EVENT_MASK;
valwin[0] = XCB_EVENT_MASK_EXPOSURE;
- win.window = xcb_window_new (c);
+ win.window = xcb_generate_id (c);
xcb_create_window (c, depth, win.window, root->root,
0, 0, 150, 150, 10,
XCB_WINDOW_CLASS_INPUT_OUTPUT, root->root_visual,
<pre class="code">
mask = XCB_CW_EVENT_MASK;
valwin[0] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS;
- win.window = xcb_window_new (c);
+ win.window = xcb_generate_id (c);
xcb_create_window (c, depth, win.window, root->root,
0, 0, 150, 150, 10,
XCB_WINDOW_CLASS_INPUT_OUTPUT, root->root_visual,
#include <stdlib.h>
#include <stdio.h>
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
void
print_modifiers (uint32_t mask)
}
int
-main (int argc, char *argv[])
+main ()
{
- xcb_connection_t *c;
- xcb_screen_t *screen;
- xcb_drawable_t win;
+ xcb_connection_t *c;
+ xcb_screen_t *screen;
+ xcb_drawable_t win;
xcb_generic_event_t *e;
uint32_t mask = 0;
uint32_t values[2];
screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;
/* Ask for our window's Id */
- win.window = xcb_window_new (c);
+ win.window = xcb_generate_id (c);
/* Create the window */
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
<pre class="code">
#include <string.h>
-#include <X11/XCB/xcb.h>
-#include <X11/XCB/xcb_atom.h>
+#include <xcb/xcb.h>
+#include <xcb/xcb_atom.h>
int
-main (int argc, char *argv[])
+main ()
{
xcb_connection_t *c;
xcb_screen_t *screen;
screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;
/* Ask for our window's Id */
- win = xcb_window_new (c);
+ win = xcb_generate_id (c);
/* Create the window */
xcb_create_window (c, /* Connection */
<pre class="code">
#include <stdio.h>
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
int
-main (int argc, char *argv[])
+main ()
{
xcb_connection_t *c;
xcb_screen_t *screen;
map, with this function:
</p>
<pre class="code">
-xcb_colormap_t xcb_colormap_new (xcb_connection_t *c);
+xcb_colormap_t xcb_generate_id (xcb_connection_t *c);
</pre>
<p>
Then, we create the color map with
Here is an example of creation of a new color map:
</p>
<pre class="code">
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
int
-main (int argc, char *argv[])
+main ()
{
xcb_connection_t *c;
xcb_screen_t *screen;
/* We create the window win here*/
- cmap = xcb_colormap_new (c);
+ cmap = xcb_generate_id (c);
xcb_create_colormap (c, XCB_COLORMAP_ALLOC_NONE, cmap, win, screen->root_visual);
return 0;
</div>
<div class="xcb">
<ul>
- <li>xcb_colormap_new ()
+ <li>xcb_generate_id ()
<li>xcb_create_colormap ()
</ul>
</div>
<pre class="code">
#include <malloc.h>
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
int
-main (int argc, char *argv[])
+main ()
{
xcb_connection_t *c;
xcb_screen_t *screen;
/* We create the window win here*/
- cmap = xcb_colormap_new (c);
+ cmap = xcb_generate_id (c);
xcb_create_colormap (c, XCB_COLORMAP_ALLOC_NONE, cmap, win, screen->root_visual);
rep = xcb_alloc_color_reply (c, xcb_alloc_color (c, cmap, 65535, 0, 0), NULL);
Id to our pixmap, with this function:
</p>
<pre class="code">
-xcb_pixmap_t xcb_pixmap_new (xcb_connection_t *c);
+xcb_pixmap_t xcb_generate_id (xcb_connection_t *c);
</pre>
<p>
Then, XCB supplies the following function to create new pixmaps:
xcb_drawable_t src_drawable, /* The Drawable we want to paste */
xcb_drawable_t dst_drawable, /* The Drawable on which we copy the previous Drawable */
xcb_gcontext_t gc, /* A Graphic Context */
- int16_t src_x, /* Top left x coordinate of the region we want to copy */
- int16_t src_y, /* Top left y coordinate of the region we want to copy */
- int16_t dst_x, /* Top left x coordinate of the region where we want to copy */
- int16_t dst_y, /* Top left y coordinate of the region where we want to copy */
- uint16_t width, /* Width of the region we want to copy */
- uint16_t height); /* Height of the region we want to copy */
+ int16_t src_x, /* Top left x coordinate of the region we want to copy */
+ int16_t src_y, /* Top left y coordinate of the region we want to copy */
+ int16_t dst_x, /* Top left x coordinate of the region where we want to copy */
+ int16_t dst_y, /* Top left y coordinate of the region where we want to copy */
+ uint16_t width, /* Width of the region we want to copy */
+ uint16_t height); /* Height of the region we want to copy */
</pre>
<p>
As you can see, we could copy the whole pixmap, as well as
<p>
So we first open that font (see <a href="#loadfont">Loading a Font</a>)
and create the new cursor. As for every X ressource, we have to
- ask for an X id with <span class="code">xcb_cursor_new</span>
+ ask for an X id with <span class="code">xcb_generate_id</span>
first:
</p>
<pre class="code">
/* The connection is set */
-font = xcb_font_new (conn);
+font = xcb_generate_id (conn);
xcb_open_font (conn, font, strlen ("cursor"), "cursor");
-cursor = xcb_cursor_new (conn);
+cursor = xcb_generate_id (conn);
xcb_create_glyph_cursor (conn, cursor, font, font,
58, 58 + 1,
0, 0, 0,
structure. They are obtained by using a function that requires a
<span class="code">xcb_connection_t *</span> or a member of the
<span class="code">xcb_setup_t</span> structure
- (via the function <span class="code">xcb_get_setup_t</span>), or
+ (via the function <span class="code">xcb_get_setup</span>), or
a function that requires that structure.
</p>
<ol>
<li class="subtitle"><a name="ScreenCount"></a>ScreenCount
<p>
You get the count of screens with the functions
- <span class="code">xcb_get_setup_t</span>
+ <span class="code">xcb_get_setup</span>
and
- <span class="code">xcb_setup_roots_iterator_t</span>
+ <span class="code">xcb_setup_roots_iterator</span>
(if you need to iterate):
</p>
<pre class="code">
<li class="subtitle"><a name="ServerVendor"></a>ServerVendor
<p>
You get the name of the vendor of the server hardware with
- the functions <span class="code">xcb_get_setup_t</span>
+ the functions <span class="code">xcb_get_setup</span>
and
<span
- class="code">xcb_setup_vendor_t</span>. Beware
+ class="code">xcb_setup_vendor</span>. Beware
that, unlike Xlib, the string returned by XCB is not
necessarily null-terminaled:
</p>
<p>
You get the major version of the protocol in the
<span class="code">xcb_setup_t</span>
- structure, with the function <span class="code">xcb_get_setup_t</span>:
+ structure, with the function <span class="code">xcb_get_setup</span>:
</p>
<pre class="code">
xcb_connection_t *c;
<p>
You get the minor version of the protocol in the
<span class="code">xcb_setup_t</span>
- structure, with the function <span class="code">xcb_get_setup_t</span>:
+ structure, with the function <span class="code">xcb_get_setup</span>:
</p>
<pre class="code">
xcb_connection_t *c;
<p>
You get the number of the release of the server hardware in the
<span class="code">xcb_setup_t</span>
- structure, with the function <span class="code">xcb_get_setup_t</span>:
+ structure, with the function <span class="code">xcb_get_setup</span>:
</p>
<pre class="code">
xcb_connection_t *c;
<p>
You get the bitmap scanline unit in the
<span class="code">xcb_setup_t</span>
- structure, with the function <span class="code">xcb_get_setup_t</span>:
+ structure, with the function <span class="code">xcb_get_setup</span>:
</p>
<pre class="code">
xcb_connection_t *c;
<p>
You get the bitmap bit order in the
<span class="code">xcb_setup_t</span>
- structure, with the function <span class="code">xcb_get_setup_t</span>:
+ structure, with the function <span class="code">xcb_get_setup</span>:
</p>
<pre class="code">
xcb_connection_t *c;
<p>
You get the bitmap scanline pad in the
<span class="code">xcb_setup_t</span>
- structure, with the function <span class="code">xcb_get_setup_t</span>:
+ structure, with the function <span class="code">xcb_get_setup</span>:
</p>
<pre class="code">
xcb_connection_t *c;
<p>
You get the image byte order in the
<span class="code">xcb_setup_t</span>
- structure, with the function <span class="code">xcb_get_setup_t</span>:
+ structure, with the function <span class="code">xcb_get_setup</span>:
</p>
<pre class="code">
xcb_connection_t *c;
uint32_t mask;
uint32_t values[2];
- gc = xcb_gcontext_new (c);
+ gc = xcb_generate_id (c);
draw.window = screen->root;
mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND;
values[0] = screen->black_pixel;