Struct penrose::xcb::xconn::XcbConnection

pub struct XcbConnection { /* fields omitted */ }

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

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

Formats the value using the given formatter.

impl XConn for XcbConnection

pub fn flush(&self) -> bool

Flush pending actions to the X event loop

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

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

pub fn current_outputs(&self) -> Vec<Screen>

Determine the currently connected CRTCs and return their details

pub fn cursor_position(&self) -> Point

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

pub fn position_window(
    &self,
    id: WinId,
    reg: Region,
    border: u32,
    stack_above: bool
)

Reposition the window identified by 'id' to the specifed region

pub fn raise_window(&self, id: WinId)

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

pub fn mark_new_window(&self, id: WinId)

Mark the given window as newly created

pub fn map_window(&self, id: WinId)

Map a window to the display. Called each time a map_notify event is received

pub fn unmap_window(&self, id: WinId)

Unmap a window from the display. Called each time an unmap_notify event is received

pub fn send_client_event(&self, id: WinId, atom_name: &str) -> Result<()>

Send an X event to the target window

pub fn focused_client(&self) -> WinId

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

pub fn focus_client(&self, id: WinId)

Mark the given crate::core::client::Client as having focus

pub fn set_client_border_color(&self, id: WinId, color: u32)

Change the border color for the given client

pub fn toggle_client_fullscreen(&self, id: WinId, client_is_fullscreen: bool)

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

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

Notify the X server that we are intercepting the user specified key bindings and prevent them being passed through to the underlying applications. This is what determines which key press events end up being sent through in the main event loop for the WindowManager.

pub fn set_wm_properties(&self, workspaces: &[&str])

Set required EWMH properties to ensure compatability with external programs

pub fn update_desktops(&self, workspaces: &[&str])

Update the root window properties with the current desktop details

pub fn update_known_clients(&self, clients: &[WinId])

Update the root window properties with the current client details

pub fn set_current_workspace(&self, wix: usize)

Update which desktop is currently focused

pub fn set_root_window_name(&self, root_name: &str)

Set the WM_NAME prop of the root window

pub fn set_client_workspace(&self, id: WinId, workspace: usize)

Update which desktop a client is currently on

pub fn window_should_float(&self, id: WinId, floating_classes: &[&str]) -> bool

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

pub fn is_managed_window(&self, id: WinId) -> bool

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

pub fn window_geometry(&self, id: WinId) -> Result<Region>

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

pub fn warp_cursor(&self, win_id: Option<WinId>, screen: &Screen)

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)

pub fn query_for_active_windows(&self) -> Vec<WinId>

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

pub fn str_prop(&self, id: u32, name: &str) -> Result<String>

Query a string property for a window by window ID and poperty name. Can fail if the property name is invalid or we get a malformed response from xcb.

pub fn atom_prop(&self, id: u32, name: &str) -> Result<u32>

Fetch an atom prop by name for a particular window ID Can fail if the property name is invalid or we get a malformed response from xcb.

pub fn intern_atom(&self, atom: &str) -> Result<u32>

Intern an X atom by name and return the corresponding ID

pub fn cleanup(&self)

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