Enum Compose

#[repr(u8)]
pub enum Compose {
    Clear = 0,
    Copy = 1,
    Dest = 2,
    SrcOver = 3,
    DestOver = 4,
    SrcIn = 5,
    DestIn = 6,
    SrcOut = 7,
    DestOut = 8,
    SrcAtop = 9,
    DestAtop = 10,
    Xor = 11,
    Plus = 12,
    PlusLighter = 13,
}

Defines the layer composition function for a blend operation.

Variants

Clear = 0

No regions are enabled.

Copy = 1

Only the source will be present.

Dest = 2

Only the destination will be present.

SrcOver = 3

The source is placed over the destination.

DestOver = 4

The destination is placed over the source.

SrcIn = 5

The parts of the source that overlap with the destination are placed.

DestIn = 6

The parts of the destination that overlap with the source are placed.

SrcOut = 7

The parts of the source that fall outside of the destination are placed.

DestOut = 8

The parts of the destination that fall outside of the source are placed.

SrcAtop = 9

The parts of the source which overlap the destination replace the destination. The destination is placed everywhere else.

DestAtop = 10

The parts of the destination which overlaps the source replace the source. The source is placed everywhere else.

Xor = 11

The non-overlapping regions of source and destination are combined.

Plus = 12

The sum of the source image and destination image is displayed.

PlusLighter = 13

Allows two elements to cross fade by changing their opacities from 0 to 1 on one element and 1 to 0 on the other element.

Trait Implementations

impl CheckedBitPattern for Compose

type Bits = u8

Self must have the same layout as the specified Bits except for the possible invalid bit patterns being checked during is_valid_bit_pattern.

fn is_valid_bit_pattern(bits: &u8) -> bool

If this function returns true, then it must be valid to reinterpret bits as &Self.

impl Clone for Compose

fn clone(&self) -> Compose

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Contiguous for Compose

const MIN_VALUE: u8 = 0u8

The lower inclusive bound for valid instances of this type.

const MAX_VALUE: u8 = 13u8

The upper inclusive bound for valid instances of this type.

type Int = u8

The primitive integer type with an identical representation to this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl Debug for Compose

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

Formats the value using the given formatter.

impl From<Compose> for BlendMode

fn from(compose: Compose) -> Self

Converts to this type from the input type.

impl PartialEq for Compose

fn eq(&self, other: &Compose) -> 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 Zeroable for Compose

fn zeroed() -> Self

Calls zeroed.

impl Copy for Compose

impl Eq for Compose

impl NoUninit for Compose

impl StructuralPartialEq for Compose