#include <string.h>
#include <sys/time.h>
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
#include <X11/Xlib.h>
will be the one in the environment variable DISPLAY.
</p>
<pre class="code">
-<type>xcb_connection_t</type> *xcb_connect (<keyword>const</keyword> <type>char</type> *displayname,
- <type>int</type> *screenp);
+<span class="type">xcb_connection_t</span> *xcb_connect (<span class="keyword">const</span> <span class="type">char</span> *displayname,
+ <span class="type">int</span> *screenp);
</pre>
<p>
The second parameter returns the screen number used for the
and is opaque. Here is how the connection can be opened:
</p>
<pre class="code">
-#<include>include</include> <string><X11/XCB/xcb.h></string>
+#<span class="include">include</span> <span class="string"><xcb/xcb.h></span>
-<type>int</type>
-<function>main</function> ()
+<span class="type">int</span>
+<span class="function">main</span> ()
{
- <type>xcb_connection_t</type> *c;
+ <span class="type">xcb_connection_t</span> *c;
/* Open the connection to the X server. Use the DISPLAY environment variable as the default display name */
c = xcb_connect (NULL, NULL);
- <keyword>return</keyword> 0;
+ <span class="keyword">return</span> 0;
}
</pre>
<p>
To close a connection, it suffices to use:
</p>
<pre class="code">
-<type>void</type> xcb_disconnect (<type>xcb_connection_t</type> *c);
+<span class="type">void</span> xcb_disconnect (<span class="type">xcb_connection_t</span> *c);
</pre>
<div class="comp">
<div class="title">
</ul>
</div>
</div>
- <p>
- </p>
+ <br>
<li class="title"><a name="screen">Checking basic information about a connection</a>
<p>
Once we have opened a connection to an X server, we should check some
<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;
- xcb_drawable_t win;
+ xcb_window_t win;
/* Open the connection to the X server */
c = xcb_connect (NULL, NULL);
screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;
/* Ask for our window's Id */
- win.window = xcb_window_new(c);
+ win = xcb_generate_id(c);
/* Create the window */
xcb_create_window (c, /* Connection */
XCB_COPY_FROM_PARENT, /* depth (same as root)*/
- win.window, /* window Id */
+ win, /* window Id */
screen->root, /* parent window */
0, 0, /* x, y */
150, 150, /* width, height */
0, NULL); /* masks, not used yet */
/* Map the window on the screen */
- xcb_map_window (c, win.window);
+ xcb_map_window (c, win);
/* Make sure commands are sent before we pause, so window is shown */
xcb_flush (c);
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;
screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;
/* Create a black graphic context for drawing in the foreground */
- win.window = screen->root;
- black = xcb_gcontext_new (c);
+ win = screen->root;
+ 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;
screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;
/* Create black (foreground) graphic context */
- win.window = screen->root;
+ win = 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 = xcb_generate_id(c);
/* Create the window */
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
values[1] = XCB_EVENT_MASK_EXPOSURE;
xcb_create_window (c, /* Connection */
XCB_COPY_FROM_PARENT, /* depth */
- win.window, /* window Id */
+ win, /* window Id */
screen->root, /* parent window */
0, 0, /* x, y */
150, 150, /* width, height */
mask, values); /* masks */
/* Map the window on the screen */
- xcb_map_window (c, win.window);
+ xcb_map_window (c, win);
/* We flush the request */
<pre class="code">
mask = XCB_CW_EVENT_MASK;
valwin[0] = XCB_EVENT_MASK_EXPOSURE;
- win.window = xcb_window_new (c);
- xcb_create_window (c, depth, win.window, root->root,
+ win = xcb_generate_id (c);
+ xcb_create_window (c, depth, win, root->root,
0, 0, 150, 150, 10,
XCB_WINDOW_CLASS_INPUT_OUTPUT, root->root_visual,
mask, valwin);
<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);
- xcb_create_window (c, depth, win.window, root->root,
+ win = xcb_generate_id (c);
+ xcb_create_window (c, depth, win, root->root,
0, 0, 150, 150, 10,
XCB_WINDOW_CLASS_INPUT_OUTPUT, root->root_visual,
mask, valwin);
#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_window_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 = xcb_generate_id (c);
/* Create the window */
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE;
xcb_create_window (c, /* Connection */
0, /* depth */
- win.window, /* window Id */
+ win, /* window Id */
screen->root, /* parent window */
0, 0, /* x, y */
150, 150, /* width, height */
mask, values); /* masks */
/* Map the window on the screen */
- xcb_map_window (c, win.window);
+ xcb_map_window (c, win);
xcb_flush (c);
<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
the function <span class="code">xcb_create_glyph_cursor</span>:
</p>
<pre class="code">
-xcb_void_cookie_t xcb_create_glyph_cursor_checked (xcb_connection_t *c,
- xcb_cursor_t cid,
- xcb_font_t source_font, /* font for the source glyph */
- xcb_font_t mask_font, /* font for the mask glyph or XCB_NONE */
- uint16_t source_char, /* character glyph for the source */
- uint16_t mask_char, /* character glyph for the mask */
- uint16_t fore_red, /* red value for the foreground of the source */
- uint16_t fore_green, /* green value for the foreground of the source */
- uint16_t fore_blue, /* blue value for the foreground of the source */
- uint16_t back_red, /* red value for the background of the source */
- uint16_t back_green, /* green value for the background of the source */
- uint16_t back_blue) /* blue value for the background of the source */
+xcb_void_cookie_t xcb_create_glyph_cursor (xcb_connection_t *c,
+ xcb_cursor_t cid,
+ xcb_font_t source_font, /* font for the source glyph */
+ xcb_font_t mask_font, /* font for the mask glyph or XCB_NONE */
+ uint16_t source_char, /* character glyph for the source */
+ uint16_t mask_char, /* character glyph for the mask */
+ uint16_t fore_red, /* red value for the foreground of the source */
+ uint16_t fore_green, /* green value for the foreground of the source */
+ uint16_t fore_blue, /* blue value for the foreground of the source */
+ uint16_t back_red, /* red value for the background of the source */
+ uint16_t back_green, /* green value for the background of the source */
+ uint16_t back_blue) /* blue value for the background of the source */
</pre>
<p>
<b>TODO</b>: Describe <span class="code">source_char</span>
<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,
</p>
<li class="subtitle"><a name="mousecursorexample">Complete example</a>
<p>
- <b>TODO</b>: to do...
+ The following example displays a window with a
+ button. When entering the window, the window cursor is changed
+ to an arrow. When clicking once on the button, the cursor is
+ changed to a hand. When clicking again on the button, the
+ cursor window gets back to the arrow. The Esc key exits the
+ application.
</p>
+ <pre class="code">
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <xcb/xcb.h>
+
+#define WIDTH 300
+#define HEIGHT 150
+
+
+
+static xcb_gc_t gc_font_get (xcb_connection_t *c,
+ xcb_screen_t *screen,
+ xcb_window_t window,
+ const char *font_name);
+
+static void button_draw (xcb_connection_t *c,
+ xcb_screen_t *screen,
+ xcb_window_t window,
+ int16_t x1,
+ int16_t y1,
+ const char *label);
+
+static void text_draw (xcb_connection_t *c,
+ xcb_screen_t *screen,
+ xcb_window_t window,
+ int16_t x1,
+ int16_t y1,
+ const char *label);
+
+static void cursor_set (xcb_connection_t *c,
+ xcb_screen_t *screen,
+ xcb_window_t window,
+ int cursor_id);
+
+
+static void
+button_draw (xcb_connection_t *c,
+ xcb_screen_t *screen,
+ xcb_window_t window,
+ int16_t x1,
+ int16_t y1,
+ const char *label)
+{
+ xcb_point_t points[5];
+ xcb_void_cookie_t cookie_gc;
+ xcb_void_cookie_t cookie_line;
+ xcb_void_cookie_t cookie_text;
+ xcb_generic_error_t *error;
+ xcb_gcontext_t gc;
+ int16_t width;
+ int16_t height;
+ uint8_t length;
+ int16_t inset;
+
+ length = strlen (label);
+ inset = 2;
+
+ gc = gc_font_get(c, screen, window, "7x13");
+
+ width = 7 * length + 2 * (inset + 1);
+ height = 13 + 2 * (inset + 1);
+ points[0].x = x1;
+ points[0].y = y1;
+ points[1].x = x1 + width;
+ points[1].y = y1;
+ points[2].x = x1 + width;
+ points[2].y = y1 - height;
+ points[3].x = x1;
+ points[3].y = y1 - height;
+ points[4].x = x1;
+ points[4].y = y1;
+ cookie_line = xcb_poly_line_checked (c, XCB_COORD_MODE_ORIGIN,
+ window, gc, 5, points);
+
+ error = xcb_request_check (c, cookie_line);
+ if (error) {
+ fprintf (stderr, "ERROR: can't draw lines : %d\n", error->error_code);
+ xcb_disconnect (c);
+ exit (-1);
+ }
+
+ cookie_text = xcb_image_text_8_checked (c, length, window, gc,
+ x1 + inset + 1,
+ y1 - inset - 1, label);
+ error = xcb_request_check (c, cookie_text);
+ if (error) {
+ fprintf (stderr, "ERROR: can't paste text : %d\n", error->error_code);
+ xcb_disconnect (c);
+ exit (-1);
+ }
+
+ cookie_gc = xcb_free_gc (c, gc);
+ error = xcb_request_check (c, cookie_gc);
+ if (error) {
+ fprintf (stderr, "ERROR: can't free gc : %d\n", error->error_code);
+ xcb_disconnect (c);
+ exit (-1);
+ }
+}
+
+static void
+text_draw (xcb_connection_t *c,
+ xcb_screen_t *screen,
+ xcb_window_t window,
+ int16_t x1,
+ int16_t y1,
+ const char *label)
+{
+ xcb_void_cookie_t cookie_gc;
+ xcb_void_cookie_t cookie_text;
+ xcb_generic_error_t *error;
+ xcb_gcontext_t gc;
+ uint8_t length;
+
+ length = strlen (label);
+
+ gc = gc_font_get(c, screen, window, "7x13");
+
+ cookie_text = xcb_image_text_8_checked (c, length, window, gc,
+ x1,
+ y1, label);
+ error = xcb_request_check (c, cookie_text);
+ if (error) {
+ fprintf (stderr, "ERROR: can't paste text : %d\n", error->error_code);
+ xcb_disconnect (c);
+ exit (-1);
+ }
+
+ cookie_gc = xcb_free_gc (c, gc);
+ error = xcb_request_check (c, cookie_gc);
+ if (error) {
+ fprintf (stderr, "ERROR: can't free gc : %d\n", error->error_code);
+ xcb_disconnect (c);
+ exit (-1);
+ }
+}
+
+static xcb_gc_t
+gc_font_get (xcb_connection_t *c,
+ xcb_screen_t *screen,
+ xcb_window_t window,
+ const char *font_name)
+{
+ uint32_t value_list[3];
+ xcb_void_cookie_t cookie_font;
+ xcb_void_cookie_t cookie_gc;
+ xcb_generic_error_t *error;
+ xcb_font_t font;
+ xcb_gcontext_t gc;
+ uint32_t mask;
+
+ font = xcb_generate_id (c);
+ cookie_font = xcb_open_font_checked (c, font,
+ strlen (font_name),
+ font_name);
+
+ error = xcb_request_check (c, cookie_font);
+ if (error) {
+ fprintf (stderr, "ERROR: can't open font : %d\n", error->error_code);
+ xcb_disconnect (c);
+ return -1;
+ }
+
+ gc = xcb_generate_id (c);
+ mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
+ value_list[0] = screen->black_pixel;
+ value_list[1] = screen->white_pixel;
+ value_list[2] = font;
+ cookie_gc = xcb_create_gc_checked (c, gc, window, mask, value_list);
+ error = xcb_request_check (c, cookie_gc);
+ if (error) {
+ fprintf (stderr, "ERROR: can't create gc : %d\n", error->error_code);
+ xcb_disconnect (c);
+ exit (-1);
+ }
+
+ cookie_font = xcb_close_font_checked (c, font);
+ error = xcb_request_check (c, cookie_font);
+ if (error) {
+ fprintf (stderr, "ERROR: can't close font : %d\n", error->error_code);
+ xcb_disconnect (c);
+ exit (-1);
+ }
+
+ return gc;
+}
+
+static void
+cursor_set (xcb_connection_t *c,
+ xcb_screen_t *screen,
+ xcb_window_t window,
+ int cursor_id)
+{
+ uint32_t values_list[3];
+ xcb_void_cookie_t cookie_font;
+ xcb_void_cookie_t cookie_gc;
+ xcb_generic_error_t *error;
+ xcb_font_t font;
+ xcb_cursor_t cursor;
+ xcb_gcontext_t gc;
+ uint32_t mask;
+ uint32_t value_list;
+
+ font = xcb_generate_id (c);
+ cookie_font = xcb_open_font_checked (c, font,
+ strlen ("cursor"),
+ "cursor");
+ error = xcb_request_check (c, cookie_font);
+ if (error) {
+ fprintf (stderr, "ERROR: can't open font : %d\n", error->error_code);
+ xcb_disconnect (c);
+ exit (-1);
+ }
+
+ cursor = xcb_generate_id (c);
+ xcb_create_glyph_cursor (c, cursor, font, font,
+ cursor_id, cursor_id + 1,
+ 0, 0, 0,
+ 0, 0, 0);
+
+ gc = xcb_generate_id (c);
+ mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
+ values_list[0] = screen->black_pixel;
+ values_list[1] = screen->white_pixel;
+ values_list[2] = font;
+ cookie_gc = xcb_create_gc_checked (c, gc, window, mask, values_list);
+ error = xcb_request_check (c, cookie_gc);
+ if (error) {
+ fprintf (stderr, "ERROR: can't create gc : %d\n", error->error_code);
+ xcb_disconnect (c);
+ exit (-1);
+ }
+
+ mask = XCB_CW_CURSOR;
+ value_list = cursor;
+ xcb_change_window_attributes (c, window, mask, &value_list);
+
+ xcb_free_cursor (c, cursor);
+
+ cookie_font = xcb_close_font_checked (c, font);
+ error = xcb_request_check (c, cookie_font);
+ if (error) {
+ fprintf (stderr, "ERROR: can't close font : %d\n", error->error_code);
+ xcb_disconnect (c);
+ exit (-1);
+ }
+}
+
+int main ()
+{
+ xcb_screen_iterator_t screen_iter;
+ xcb_connection_t *c;
+ const xcb_setup_t *setup;
+ xcb_screen_t *screen;
+ xcb_generic_event_t *e;
+ xcb_generic_error_t *error;
+ xcb_void_cookie_t cookie_window;
+ xcb_void_cookie_t cookie_map;
+ xcb_window_t window;
+ uint32_t mask;
+ uint32_t values[2];
+ int screen_number;
+ uint8_t is_hand = 0;
+
+ /* getting the connection */
+ c = xcb_connect (NULL, &screen_number);
+ if (!c) {
+ fprintf (stderr, "ERROR: can't connect to an X server\n");
+ return -1;
+ }
+
+ /* getting the current screen */
+ setup = xcb_get_setup (c);
+
+ screen = NULL;
+ screen_iter = xcb_setup_roots_iterator (setup);
+ for (; screen_iter.rem != 0; --screen_number, xcb_screen_next (&screen_iter))
+ if (screen_number == 0)
+ {
+ screen = screen_iter.data;
+ break;
+ }
+ if (!screen) {
+ fprintf (stderr, "ERROR: can't get the current screen\n");
+ xcb_disconnect (c);
+ return -1;
+ }
+
+ /* creating the window */
+ window = xcb_generate_id (c);
+ mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
+ values[0] = screen->white_pixel;
+ values[1] =
+ XCB_EVENT_MASK_KEY_RELEASE |
+ XCB_EVENT_MASK_BUTTON_PRESS |
+ XCB_EVENT_MASK_EXPOSURE |
+ XCB_EVENT_MASK_POINTER_MOTION;
+ cookie_window = xcb_create_window_checked (c,
+ screen->root_depth,
+ window, screen->root,
+ 20, 200, WIDTH, HEIGHT,
+ 0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
+ screen->root_visual,
+ mask, values);
+ cookie_map = xcb_map_window_checked (c, window);
+
+ /* error managing */
+ error = xcb_request_check (c, cookie_window);
+ if (error) {
+ fprintf (stderr, "ERROR: can't create window : %d\n", error->error_code);
+ xcb_disconnect (c);
+ return -1;
+ }
+ error = xcb_request_check (c, cookie_map);
+ if (error) {
+ fprintf (stderr, "ERROR: can't map window : %d\n", error->error_code);
+ xcb_disconnect (c);
+ return -1;
+ }
+
+ cursor_set (c, screen, window, 68);
+
+ xcb_flush(c);
+
+ while (1) {
+ e = xcb_poll_for_event(c);
+ if (e) {
+ switch (e->response_type) {
+ case XCB_EXPOSE: {
+ char *text;
+
+ text = "click here to change cursor";
+ button_draw (c, screen, window,
+ (WIDTH - 7 * strlen(text)) / 2,
+ (HEIGHT - 16) / 2, text);
+
+ text = "Press ESC key to exit...";
+ text_draw (c, screen, window, 10, HEIGHT - 10, text);
+ break;
+ }
+ case XCB_BUTTON_PRESS: {
+ xcb_button_press_event_t *ev;
+ int length;
+
+ ev = (xcb_button_press_event_t *)e;
+ length = strlen ("click here to change cursor");
+
+ if ((ev->event_x >= (WIDTH - 7 * length) / 2) &&
+ (ev->event_x <= ((WIDTH - 7 * length) / 2 + 7 * length + 6)) &&
+ (ev->event_y >= (HEIGHT - 16) / 2 - 19) &&
+ (ev->event_y <= ((HEIGHT - 16) / 2)))
+ is_hand = 1 - is_hand;
+
+ is_hand ? cursor_set (c, screen, window, 58) : cursor_set (c, screen, window, 68);
+ }
+ case XCB_KEY_RELEASE: {
+ xcb_key_release_event_t *ev;
+
+ ev = (xcb_key_release_event_t *)e;
+
+ switch (ev->detail) {
+ /* ESC */
+ case 9:
+ free (e);
+ xcb_disconnect (c);
+ return 0;
+ }
+ }
+ }
+ free (e);
+ }
+ }
+
+ return 0;
+}
+</pre>
</ol>
<li class="title"><a name="translation">Translation of basic Xlib functions and macros</a>
<p>
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;
/* default_screen contains now the default root window, or a NULL window if no screen is found */
</pre>
<li class="subtitle"><a name="RootWindow">RootWindow / RootWindowOfScreen</a>
- <p>
- </p>
+ <br>
<pre class="code">
xcb_connection_t *c;
xcb_screen_t *screen;
uint32_t mask;
uint32_t values[2];
- gc = xcb_gcontext_new (c);
- draw.window = screen->root;
+ gc = xcb_generate_id (c);
+ draw = screen->root;
mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND;
values[0] = screen->black_pixel;
values[1] = screen->white_pixel;
projects / free-sw / xcb / libxcb / blobdiff