Enum penrose::Error

pub enum Error {
    ClientIsNotVisible(Xid),
    Custom(String),
    InsufficientWorkspaces {
        n_ws: usize,
        n_screens: usize,
    },
    InvalidClientMessage {
        format: u8,
    },
    InvalidHexColor {
        hex_code: String,
    },
    InvalidHints {
        reason: String,
    },
    Io(Error),
    InvalidUtf8(FromUtf8Error),
    InvalidPropertyData {
        id: Xid,
        ty: String,
        prop: String,
    },
    NonUniqueTags {
        tags: Vec<String>,
    },
    NoScreens,
    ParseInt(ParseIntError),
    Randr(String),
    UnknownClient(Xid),
    UnknownKeyName {
        name: String,
    },
    UnknownModifier {
        name: String,
    },
    UnknownMouseButton {
        button: u8,
    },
    UnknownStateExtension {
        type_id: TypeId,
    },
    X11rbConnect(ConnectError),
    X11rbConnection(ConnectionError),
    X11rbReplyError(ReplyError),
    X11rbReplyOrIdError(ReplyOrIdError),
    X11rbX11Error(X11Error),
}

Error variants from the core penrose library.

Variants

ClientIsNotVisible(Xid)

An operation requiring the client to be on a screen was requested on a client window that is not currently visible

Custom(String)

A custom error message from user code or extensions

InsufficientWorkspaces

Fields

n_ws: usize

Number of provided workspaces

n_screens: usize

Number of connected screens

There were not enough workspaces to cover the number of connected screens

InvalidClientMessage

Fields

format: u8

The format received

Data received as part of a client message had an invalid format

InvalidHexColor

Fields

hex_code: String

The string that was used

Attempt to create a Color from an invalid hex string

InvalidHints

Fields

reason: String

Why parsing failed

A window hints message was received but unable to be parsed

Io(Error)

IO error

InvalidUtf8(FromUtf8Error)

Invalid UTF8 encoded string

InvalidPropertyData

Fields

id: Xid

The window that was queried

ty: String

The type of property that was queried

prop: String

The name of the property that was queried

Data received from the X server when requesting a window property was invalid

NonUniqueTags

Fields

tags: Vec<String>

The set of non-unique tags

Duplicate tags were provided for one or more workspaces

NoScreens

Penrose is running without any screens to connect to

ParseInt(ParseIntError)

ParseIntError

Randr(String)

There was a problem initialising randr

UnknownClient(Xid)

An operation was requested on a client window that is unknown

UnknownKeyName

Fields

name: String

The name of the unknown key

A keybinding has been specified for an unknown key name for this machine.

UnknownModifier

Fields

name: String

The unrecognised modifier name

An unknown character has been used to specify a modifier key

UnknownMouseButton

Fields

button: u8

The button ID that was pressed

An unknown mouse button was pressed

UnknownStateExtension

Fields

type_id: TypeId

The type ID of the type that was requested

An attempt was made to fetch a state extension for a type that has not been stored

X11rbConnect(ConnectError)

An error that occurred while connecting to an X11 server

X11rbConnection(ConnectionError)

An error that occurred on an already established X11 connection

X11rbReplyError(ReplyError)

An error that occurred with some request.

X11rbReplyOrIdError(ReplyOrIdError)

An error caused by some request or by the exhaustion of IDs.

X11rbX11Error(X11Error)

Representation of an X11 error packet that was sent by the server.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access #99301)

Provides type based access to context intended for error reports.

impl From<ConnectError> for Error

fn from(source: ConnectError) -> Self

Converts to this type from the input type.

impl From<ConnectionError> for Error

fn from(source: ConnectionError) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<FromUtf8Error> for Error

fn from(source: FromUtf8Error) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for Error

fn from(source: ParseIntError) -> Self

Converts to this type from the input type.

impl From<ReplyError> for Error

fn from(source: ReplyError) -> Self

Converts to this type from the input type.

impl From<ReplyOrIdError> for Error

fn from(source: ReplyOrIdError) -> Self

Converts to this type from the input type.