Struct xcb::x::CwMask

pub struct CwMask { /* private fields */ }

Implementations

impl CwMask

pub const BACK_PIXMAP: Self = _

Overrides the default background-pixmap. The background pixmap and window must have the same root and same depth. Any size pixmap can be used, although some sizes may be faster than others.

If XCB_BACK_PIXMAP_NONE is specified, the window has no defined background. The server may fill the contents with the previous screen contents or with contents of its own choosing.

If XCB_BACK_PIXMAP_PARENT_RELATIVE is specified, the parent’s background is used, but the window must have the same depth as the parent (or a Match error results). The parent’s background is tracked, and the current version is used each time the window background is required.

pub const BACK_PIXEL: Self = _

Overrides BackPixmap. A pixmap of undefined size filled with the specified background pixel is used for the background. Range-checking is not performed, the background pixel is truncated to the appropriate number of bits.

pub const BORDER_PIXMAP: Self = _

Overrides the default border-pixmap. The border pixmap and window must have the same root and the same depth. Any size pixmap can be used, although some sizes may be faster than others.

The special value XCB_COPY_FROM_PARENT means the parent’s border pixmap is copied (subsequent changes to the parent’s border attribute do not affect the child), but the window must have the same depth as the parent.

pub const BORDER_PIXEL: Self = _

Overrides BorderPixmap. A pixmap of undefined size filled with the specified border pixel is used for the border. Range checking is not performed on the border-pixel value, it is truncated to the appropriate number of bits.

pub const BIT_GRAVITY: Self = _

Defines which region of the window should be retained if the window is resized.

pub const WIN_GRAVITY: Self = _

Defines how the window should be repositioned if the parent is resized (see ConfigureWindow).

pub const BACKING_STORE: Self = _

A backing-store of WhenMapped advises the server that maintaining contents of obscured regions when the window is mapped would be beneficial. A backing-store of Always advises the server that maintaining contents even when the window is unmapped would be beneficial. In this case, the server may generate an exposure event when the window is created. A value of NotUseful advises the server that maintaining contents is unnecessary, although a server may still choose to maintain contents while the window is mapped. Note that if the server maintains contents, then the server should maintain complete contents not just the region within the parent boundaries, even if the window is larger than its parent. While the server maintains contents, exposure events will not normally be generated, but the server may stop maintaining contents at any time.

pub const BACKING_PLANES: Self = _

The backing-planes indicates (with bits set to 1) which bit planes of the window hold dynamic data that must be preserved in backing-stores and during save-unders.

pub const BACKING_PIXEL: Self = _

The backing-pixel specifies what value to use in planes not covered by backing-planes. The server is free to save only the specified bit planes in the backing-store or save-under and regenerate the remaining planes with the specified pixel value. Any bits beyond the specified depth of the window in these values are simply ignored.

pub const OVERRIDE_REDIRECT: Self = _

The override-redirect specifies whether map and configure requests on this window should override a SubstructureRedirect on the parent, typically to inform a window manager not to tamper with the window.

pub const SAVE_UNDER: Self = _

If 1, the server is advised that when this window is mapped, saving the contents of windows it obscures would be beneficial.

pub const EVENT_MASK: Self = _

The event-mask defines which events the client is interested in for this window (or for some event types, inferiors of the window).

pub const DONT_PROPAGATE: Self = _

The do-not-propagate-mask defines which events should not be propagated to ancestor windows when no client has the event type selected in this window.

pub const COLORMAP: Self = _

The colormap specifies the colormap that best reflects the true colors of the window. Servers capable of supporting multiple hardware colormaps may use this information, and window man- agers may use it for InstallColormap requests. The colormap must have the same visual type and root as the window (or a Match error results). If CopyFromParent is specified, the parent’s colormap is copied (subsequent changes to the parent’s colormap attribute do not affect the child). However, the window must have the same visual type as the parent (or a Match error results), and the parent must not have a colormap of None (or a Match error results). For an explanation of None, see FreeColormap request. The colormap is copied by sharing the colormap object between the child and the parent, not by making a complete copy of the colormap contents.

pub const CURSOR: Self = _

If a cursor is specified, it will be used whenever the pointer is in the window. If None is speci- fied, the parent’s cursor will be used when the pointer is in the window, and any change in the parent’s cursor will cause an immediate change in the displayed cursor.

pub const fn empty() -> Self

Returns an empty set of flags.

pub const fn all() -> Self

Returns the set containing all flags.

pub const fn bits(&self) -> u32

Returns the raw value of the flags currently stored.

pub const fn from_bits(bits: u32) -> Option<Self>

Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

pub const fn from_bits_truncate(bits: u32) -> Self

Convert from underlying bit representation, dropping any bits that do not correspond to flags.

pub const unsafe fn from_bits_unchecked(bits: u32) -> Self

Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

Safety

The caller of the bitflags! macro can chose to allow or disallow extra bits for their bitflags type.

The caller of from_bits_unchecked() has to ensure that all bits correspond to a defined flag or that extra bits are valid for this bitflags type.

pub const fn is_empty(&self) -> bool

Returns true if no flags are currently stored.

pub const fn is_all(&self) -> bool

Returns true if all flags are currently set.

pub const fn intersects(&self, other: Self) -> bool

Returns true if there are flags common to both self and other.

pub const fn contains(&self, other: Self) -> bool

Returns true if all of the flags in other are contained within self.

pub fn insert(&mut self, other: Self)

Inserts the specified flags in-place.

pub fn remove(&mut self, other: Self)

Removes the specified flags in-place.

pub fn toggle(&mut self, other: Self)

Toggles the specified flags in-place.

pub fn set(&mut self, other: Self, value: bool)

Inserts or removes the specified flags depending on the passed value.

pub const fn intersection(self, other: Self) -> Self

Returns the intersection between the flags in self and other.

Specifically, the returned set contains only the flags which are present in both self and other.

This is equivalent to using the & operator (e.g. ops::BitAnd), as in flags & other.

pub const fn union(self, other: Self) -> Self

Returns the union of between the flags in self and other.

Specifically, the returned set contains all flags which are present in either self or other, including any which are present in both (see Self::symmetric_difference if that is undesirable).

This is equivalent to using the | operator (e.g. ops::BitOr), as in flags | other.

pub const fn difference(self, other: Self) -> Self

Returns the difference between the flags in self and other.

Specifically, the returned set contains all flags present in self, except for the ones present in other.

It is also conceptually equivalent to the “bit-clear” operation: flags & !other (and this syntax is also supported).

This is equivalent to using the - operator (e.g. ops::Sub), as in flags - other.

pub const fn symmetric_difference(self, other: Self) -> Self

Returns the symmetric difference between the flags in self and other.

Specifically, the returned set contains the flags present which are present in self or other, but that are not present in both. Equivalently, it contains the flags present in exactly one of the sets self and other.

This is equivalent to using the ^ operator (e.g. ops::BitXor), as in flags ^ other.

pub const fn complement(self) -> Self

Returns the complement of this set of flags.

Specifically, the returned set contains all the flags which are not set in self, but which are allowed for this type.

Alternatively, it can be thought of as the set difference between Self::all() and self (e.g. Self::all() - self)

This is equivalent to using the ! operator (e.g. ops::Not), as in !flags.

Trait Implementations

impl Binary for CwMask

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

Formats the value using the given formatter.

impl BitAnd for CwMask

fn bitand(self, other: Self) -> Self

Returns the intersection between the two sets of flags.

type Output = CwMask

The resulting type after applying the & operator.

impl BitAndAssign for CwMask

fn bitand_assign(&mut self, other: Self)

Disables all flags disabled in the set.

impl BitOr for CwMask

fn bitor(self, other: CwMask) -> Self

Returns the union of the two sets of flags.

type Output = CwMask

The resulting type after applying the | operator.

impl BitOrAssign for CwMask

fn bitor_assign(&mut self, other: Self)

Adds the set of flags.

impl BitXor for CwMask

fn bitxor(self, other: Self) -> Self

Returns the left flags, but with all the right flags toggled.

type Output = CwMask

The resulting type after applying the ^ operator.

impl BitXorAssign for CwMask

fn bitxor_assign(&mut self, other: Self)

Toggles the set of flags.

impl Clone for CwMask

fn clone(&self) -> CwMask

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CwMask

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

Formats the value using the given formatter.

impl Extend<CwMask> for CwMask

fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<CwMask> for CwMask

fn from_iter<T: IntoIterator<Item = Self>>(iterator: T) -> Self

Creates a value from an iterator.

impl Hash for CwMask

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LowerHex for CwMask

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

Formats the value using the given formatter.

impl Not for CwMask

fn not(self) -> Self

Returns the complement of this set of flags.

type Output = CwMask

The resulting type after applying the ! operator.

impl Octal for CwMask

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

Formats the value using the given formatter.

impl Ord for CwMask

fn cmp(&self, other: &CwMask) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for CwMask

fn eq(&self, other: &CwMask) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for CwMask

fn partial_cmp(&self, other: &CwMask) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub for CwMask

fn sub(self, other: Self) -> Self

Returns the set difference of the two sets of flags.

type Output = CwMask

The resulting type after applying the - operator.

impl SubAssign for CwMask

fn sub_assign(&mut self, other: Self)

Disables all flags enabled in the set.

impl UpperHex for CwMask

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

Formats the value using the given formatter.

impl Copy for CwMask

impl Eq for CwMask

impl StructuralPartialEq for CwMask