Crate x11rb

X11 rust bindings.

This library allows to interact with an X11 server from rust code. A connection to an X11 server is represented by an implementation of the Connection trait.

The client can interact with the server by sending requests. The server can answer requests and can also generate events.

The examples that come with this library might be a good starting point for new users.

Getting started with X11

X11 is a big protocol. I would claim that most of it is not actually that complicated, but it is still difficult to get into it. A good starting point might be some libxcb tutorial. This tutorial was adapted in this crate as an example. A more in-depth look at the X11 protocol can be gained from the protocol reference manual, but this requires some existing basic understanding of X11. If you want to figure out what some specific request does, be sure to look it up in the specification!

Most extensions can be understood by reading their specification. Most of them can be found here. For example, the specification of Composite 0.4 consists of about six pages of text.

The notable exception is the X keyboard extension, which is documented in a PDF file with 168 pages which I am never going to read completely.

Getting started with x11rb

Most code in this code is automatically generated from an XML description of the protocol. This is the same approach as taken by libxcb (and in fact this uses the same XML description). This means that if you know your way around X11, most things should be obvious to you.

For example, here is how to create a new window with x11rb:

use x11rb::connection::Connection;
use x11rb::xcb_ffi::XCBConnection;
use x11rb::generated::xproto::*;
use x11rb::errors::ConnectionErrorOrX11Error;

fn main() -> Result<(), ConnectionErrorOrX11Error> {
    let (conn, screen_num) = XCBConnection::connect(None)?;
    let screen = &conn.setup().roots[screen_num];
    let win_id = conn.generate_id();
    conn.create_window(24, win_id, screen.root, 0, 0, 100, 100, 0, WindowClass::InputOutput,
                       0, &CreateWindowAux::new().background_pixel(screen.white_pixel))?;
    conn.map_window(win_id)?;
    conn.flush();
    loop {
        println!("Event: {:?}", conn.wait_for_event()?);
    }
}

More examples can be found in the examples directory.

Modules

connection	Generic connection-related types and definitions.
errors	This module contains the current mess that is error handling.
generated
rust_connection	A pure-rust implementation of a connection to an X11 server.
utils
wrapper	Some wrappers around the generated code to simplify use.
x11_utils
xcb_ffi	A FFI-based connection to an X11 server, using libxcb.