Struct XcbConnection

pub struct XcbConnection { /* private fields */ }

Handles communication with an X server via the XCB library.

XcbConnection is a minimal implementation that does not make use of the full asyc capabilities of the underlying C XCB library.

Implementations

impl XcbConnection

pub fn new() -> Result<Self>

Establish a new connection to the running X server. Fails if unable to connect

pub fn xcb_connection(&self) -> &Connection

Get a handle on the underlying XCB Connection used by Api to communicate with the X server.

pub fn api(&self) -> &Api

Get a handle on the underlying Api to communicate with the X server.

pub fn api_mut(&mut self) -> &mut Api

Get a mutable handle on the underlying Api to communicate with the X server.

pub fn known_atoms(&self) -> &HashMap<Atom, u32>

The current interned Atom values known to the underlying Api connection

Trait Implementations

impl Debug for XcbConnection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl XAtomQuerier for XcbConnection

fn atom_name(&self, atom: Xid) -> Result<String>

Convert an X atom id to its human friendly name

fn atom_id(&self, name: &str) -> Result<Xid>

Fetch or intern an atom by name

impl XClientConfig for XcbConnection

fn configure_client(&self, id: Xid, data: &[ClientConfig]) -> Result<()>

Configure the on screen appearance of a client window

fn set_client_attributes(&self, id: Xid, data: &[ClientAttr]) -> Result<()>

Set client attributes such as event masks, border color etc

fn get_window_attributes(&self, id: Xid) -> Result<WindowAttributes>

Get the WindowAttributes for this client

fn position_client( &self, id: Xid, r: Region, border: u32, stack_above: bool, ) -> Result<()>

Reposition the window identified by ‘id’ to the specifed region

fn raise_client(&self, id: Xid) -> Result<()>

Raise the window to the top of the stack so it renders above peers

fn set_client_border_color(&self, id: Xid, color: Color) -> Result<()>

Change the border color for the given client

impl XClientHandler for XcbConnection

fn map_client(&self, id: Xid) -> Result<()>

Map a client to the display.

fn unmap_client(&self, id: Xid) -> Result<()>

Unmap a client from the display.

fn focus_client(&self, id: Xid) -> Result<()>

Mark the given client as having focus

fn destroy_client(&self, id: Xid) -> Result<()>

Destroy an existing client.

fn kill_client(&self, id: Xid) -> Result<()>

Forcably kill an existing client.

fn map_client_if_needed(&self, win: Option<&mut Client>) -> Result<()>

Map a known penrose Client if it is not currently visible

fn unmap_client_if_needed(&self, win: Option<&mut Client>) -> Result<()>

Unmap a known penrose Client if it is currently visible

impl XClientProperties for XcbConnection

fn get_prop(&self, id: Xid, name: &str) -> Result<Prop>

Query a property for a client by ID and name.

fn list_props(&self, id: Xid) -> Result<Vec<String>>

Return the list of all properties set on the given client window

fn delete_prop(&self, id: Xid, name: &str) -> Result<()>

Delete an existing property from a client

fn change_prop(&self, id: Xid, prop: &str, val: Prop) -> Result<()>

Change an existing property for a client

fn set_client_state(&self, id: Xid, state: WindowState) -> Result<()>

Update a client’s WM_STATE property to the given value.

fn client_supports_protocol(&self, id: Xid, proto: &str) -> Result<bool>

Check to see if a given client window supports a particular protocol or not

fn client_accepts_focus(&self, id: Xid) -> bool

Check to see if a given client accepts input focus

fn toggle_client_fullscreen( &self, id: Xid, client_is_fullscreen: bool, ) -> Result<()>

Toggle the fullscreen state of the given client ID with the X server

fn client_name(&self, id: Xid) -> Result<String>

Fetch a client’s name proprty following ICCCM / EWMH standards

fn client_should_float(&self, id: Xid, floating_classes: &[&str]) -> bool

Determine whether the target client should be tiled or allowed to float

impl XConn for XcbConnection

fn init(&self) -> Result<()>

Initialise any state required before this connection can be used by the WindowManager.

fn check_window(&self) -> Xid

An X id for a check window that will be used for holding EWMH window manager properties

fn cleanup(&self) -> Result<()>

Perform any state cleanup required prior to shutting down the window manager

fn grab_keys( &self, key_bindings: &KeyBindings<Self>, mouse_bindings: &MouseBindings<Self>, ) -> Result<()>

Notify the X server that we are intercepting the user specified key bindings and prevent them being passed through to the underlying applications.

fn mark_new_client(&self, id: Xid) -> Result<()>

Mark the given client as newly created

fn set_wm_properties(&self, workspaces: &[String]) -> Result<()>

Set required EWMH properties to ensure compatability with external programs

fn update_desktops(&self, workspaces: &[String]) -> Result<()>

Update the root window properties with the current desktop details

fn update_known_clients(&self, clients: &[Xid]) -> Result<()>

Update the root window properties with the current client details

fn set_current_workspace(&self, wix: usize) -> Result<()>

Update which desktop is currently focused

fn set_root_window_name(&self, name: &str) -> Result<()>

Set the WM_NAME prop of the root window

fn set_client_workspace(&self, id: Xid, wix: usize) -> Result<()>

Update which desktop a client is currently on

fn is_managed_client(&self, c: &Client) -> bool

Check to see if this client is one that we should be handling or not

fn active_managed_clients( &self, floating_classes: &[&str], ) -> Result<Vec<Client>>

The subset of active clients that are considered managed by penrose

impl XEventHandler for XcbConnection

fn flush(&self) -> bool

Flush pending actions to the X event loop

fn wait_for_event(&self) -> Result<XEvent>

Wait for the next event from the X server and return it as an XEvent

fn send_client_event(&self, msg: ClientMessage) -> Result<()>

Send an X event to the target client

fn build_client_event(&self, kind: ClientMessageKind) -> Result<ClientMessage>

Build the required event data for sending a known client event.

impl XState for XcbConnection

fn root(&self) -> Xid

The root window ID

fn current_screens(&self) -> Result<Vec<Screen>>

Determine the currently connected screens and return their details

fn cursor_position(&self) -> Result<Point>

Determine the current (x,y) position of the cursor relative to the root window.

fn warp_cursor(&self, win_id: Option<Xid>, screen: &Screen) -> Result<()>

Warp the cursor to be within the specified window. If id == None then behaviour is definined by the implementor (e.g. warp cursor to active window, warp to center of screen)

fn client_geometry(&self, id: Xid) -> Result<Region>

Return the current (x, y, w, h) dimensions of the requested window

fn active_clients(&self) -> Result<Vec<Xid>>

Run on startup/restart to determine already running windows that we need to track

fn focused_client(&self) -> Result<Xid>

Return the client ID of the crate::core::client::Client that currently holds X focus