Struct x11rb::xcb_ffi::XCBConnection

pub struct XCBConnection {
    conn: XcbConnectionWrapper,
    setup: Setup,
    ext_mgr: Mutex<ExtensionManager>,
    errors: PendingErrors,
    maximum_sequence_received: AtomicU64,
}

A connection to an X11 server.

This type wraps *mut xcb_connection_t that is provided by libxcb. It provides a rust interface to this C library.

Fields

conn: XcbConnectionWrapper

setup: Setup

ext_mgr: Mutex<ExtensionManager>

errors: PendingErrors

maximum_sequence_received: AtomicU64

Implementations

impl XCBConnection

unsafe fn connection_error_from_connection( c: *mut xcb_connection_t, ) -> ConnectionError

fn connection_error_from_c_error(error: c_int) -> ConnectionError

fn connect_error_from_c_error(error: c_int) -> ConnectError

pub fn connect( dpy_name: Option<&CStr>, ) -> Result<(XCBConnection, usize), ConnectError>

Establish a new connection to an X11 server.

If a dpy_name is provided, it describes the display that should be connected to, for example 127.0.0.1:1. If no value is provided, the $DISPLAY environment variable is used.

pub unsafe fn from_raw_xcb_connection( ptr: *mut c_void, should_drop: bool, ) -> Result<XCBConnection, ConnectError>

Create a connection wrapper for a raw libxcb xcb_connection_t.

xcb_disconnect is called on drop only if should_drop is true. If this function returns an Err() and should_drop was true, then xcb_disconnect was already called.

Safety

If should_drop is false, the connection must live longer than the returned XCBConnection. If should_drop is true, the returned XCBConnection will take the ownership of the connection.

unsafe fn parse_setup(setup: *const xcb_setup_t) -> Result<Setup, ParseError>

fn send_request( &self, bufs: &[IoSlice<'_>], fds: Vec<RawFdContainer>, has_reply: bool, reply_has_fds: bool, ) -> Result<SequenceNumber, ConnectionError>

pub fn has_error(&self) -> Option<ConnectionError>

Check if the underlying XCB connection is in an error state.

pub fn get_raw_xcb_connection(&self) -> *mut c_void

Get access to the raw libxcb xcb_connection_t.

The returned pointer is valid for as long as the original object was not dropped. No ownerhsip is transferred.

fn poll_for_reply(&self, sequence: SequenceNumber) -> Result<Option<CSlice>, ()>

Check if a reply to the given request already received.

Return Err(()) when the reply was not yet received. Returns Ok(None) when there can be no reply. Returns Ok(buffer) with the reply if there is one (this buffer can be an error or a reply).

unsafe fn wrap_reply( &self, reply: *const u8, sequence: SequenceNumber, ) -> CSlice

unsafe fn wrap_error( &self, error: *const u8, sequence: SequenceNumber, ) -> CSlice

unsafe fn wrap_event( &self, event: *mut u8, ) -> Result<RawEventAndSeqNumber, ParseError>

fn reconstruct_full_sequence(&self, seqno: u32) -> SequenceNumber

Reconstruct a full sequence number based on a partial value.

The assumption for the algorithm here is that the given sequence number was received recently. Thus, the maximum sequence number that was received so far is used to fill in the missing bytes for the result.

Trait Implementations

impl AsFd for XCBConnection

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor.

impl AsRawFd for XCBConnection

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl AsRawXcbConnection for XCBConnection

fn as_raw_xcb_connection(&self) -> *mut xcb_connection_t

Get a raw xcb connection pointer from this object.

impl Connection for XCBConnection

fn wait_for_raw_event_with_sequence( &self, ) -> Result<RawEventAndSeqNumber, ConnectionError>

Wait for a new raw/unparsed event from the X11 server.

fn poll_for_raw_event_with_sequence( &self, ) -> Result<Option<RawEventAndSeqNumber>, ConnectionError>

Poll for a new unparsed/raw event from the X11 server.

fn flush(&self) -> Result<(), ConnectionError>

Send all pending requests to the server.

fn generate_id(&self) -> Result<u32, ReplyOrIdError>

Generate a new X11 identifier.

fn setup(&self) -> &Setup

Get the setup information sent by the X11 server.

fn wait_for_event(&self) -> Result<Event, ConnectionError>

Wait for a new event from the X11 server.

fn wait_for_raw_event(&self) -> Result<Self::Buf, ConnectionError>

Wait for a new raw/unparsed event from the X11 server.

fn wait_for_event_with_sequence( &self, ) -> Result<EventAndSeqNumber, ConnectionError>

Wait for a new event from the X11 server.

fn poll_for_event(&self) -> Result<Option<Event>, ConnectionError>

Poll for a new event from the X11 server.

fn poll_for_raw_event(&self) -> Result<Option<Self::Buf>, ConnectionError>

Poll for a new raw/unparsed event from the X11 server.

fn poll_for_event_with_sequence( &self, ) -> Result<Option<EventAndSeqNumber>, ConnectionError>

Poll for a new event from the X11 server.

impl Debug for XCBConnection

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

Formats the value using the given formatter.

impl RequestConnection for XCBConnection

type Buf = CSlice

Type used as buffer to store raw replies or events before they are parsed.

fn send_request_with_reply<R>( &self, bufs: &[IoSlice<'_>], fds: Vec<RawFdContainer>, ) -> Result<Cookie<'_, Self, R>, ConnectionError>

where R: TryParse,

Send a request with a reply to the server.

fn send_request_with_reply_with_fds<R>( &self, bufs: &[IoSlice<'_>], fds: Vec<RawFdContainer>, ) -> Result<CookieWithFds<'_, Self, R>, ConnectionError>

where R: TryParseFd,

Send a request with a reply containing file descriptors to the server.

fn send_request_without_reply( &self, bufs: &[IoSlice<'_>], fds: Vec<RawFdContainer>, ) -> Result<VoidCookie<'_, Self>, ConnectionError>

Send a request without a reply to the server.

fn discard_reply( &self, sequence: SequenceNumber, _kind: RequestKind, mode: DiscardMode, )

A reply to an error should be discarded.

fn prefetch_extension_information( &self, extension_name: &'static str, ) -> Result<(), ConnectionError>

Prefetches information about an extension.

fn extension_information( &self, extension_name: &'static str, ) -> Result<Option<ExtensionInformation>, ConnectionError>

Get information about an extension.

fn wait_for_reply_or_raw_error( &self, sequence: SequenceNumber, ) -> Result<ReplyOrError<CSlice>, ConnectionError>

Wait for the reply to a request.

fn wait_for_reply( &self, sequence: SequenceNumber, ) -> Result<Option<CSlice>, ConnectionError>

Wait for the reply to a request.

fn wait_for_reply_with_fds_raw( &self, sequence: SequenceNumber, ) -> Result<ReplyOrError<BufWithFds, <XCBConnection as RequestConnection>::Buf>, ConnectionError>

Wait for the reply to a request that has FDs.

fn check_for_raw_error( &self, sequence: SequenceNumber, ) -> Result<Option<<XCBConnection as RequestConnection>::Buf>, ConnectionError>

Check whether a request that does not have a reply caused an X11 error.

fn maximum_request_bytes(&self) -> usize

The maximum number of bytes that the X11 server accepts in a request.

fn prefetch_maximum_request_bytes(&self)

Prefetches the maximum request length.

fn parse_error(&self, error: &[u8]) -> Result<X11Error, ParseError>

Parse a generic error.

fn parse_event(&self, event: &[u8]) -> Result<Event, ParseError>

Parse a generic event.

fn send_trait_request_with_reply<R>( &self, request: R, ) -> Result<Cookie<'_, Self, <R as ReplyRequest>::Reply>, ConnectionError>

where R: ReplyRequest,

Send a request with a reply to the server.

fn send_trait_request_with_reply_with_fds<R>( &self, request: R, ) -> Result<CookieWithFds<'_, Self, R::Reply>, ConnectionError>

where R: ReplyFDsRequest,

Send a request with a reply containing file descriptors to the server.

fn send_trait_request_without_reply<R>( &self, request: R, ) -> Result<VoidCookie<'_, Self>, ConnectionError>

where R: VoidRequest,

Send a request without a reply to the server.

fn wait_for_reply_or_error( &self, sequence: SequenceNumber, ) -> Result<Self::Buf, ReplyError>

Wait for the reply to a request.

fn wait_for_reply_with_fds( &self, sequence: SequenceNumber, ) -> Result<BufWithFds<Self::Buf>, ReplyError>

Wait for the reply to a request that has FDs.

fn check_for_error(&self, sequence: SequenceNumber) -> Result<(), ReplyError>

Check whether a request that does not have a reply caused an X11 error.