Struct LightDark 

pub struct LightDark {
    pub dark: Rgba,
    pub light: Rgba,
}

Represents a dark and light color.

Note that this struct converts IntoVar<Rgba> with a contextual var that selects the color, so you can just set color properties directly with a color pair.

Fields

dark: Rgba

Color used when ColorScheme::Dark.

light: Rgba

Color used when ColorScheme::Light.

Implementations

impl LightDark

pub fn new(light: impl Into<Rgba>, dark: impl Into<Rgba>) -> LightDark

New from light, dark colors.

pub fn shade_fct(self, factor: impl Into<Factor>) -> LightDark

Overlay WHITE/BLACK to the dark/light color depending on the factor, negative factor inverts overlay.

pub fn shade(self, shade: i8) -> LightDark

Shade at 8% increments.

Common usage: 1=hovered, 2=pressed.

pub fn rgba(self) -> Var<Rgba>

Gets a contextual Rgba var that selects the color for the context scheme.

Also see LightDarkVarExt for mapping from vars.

pub fn rgba_map<T>(self, map: impl FnMut(Rgba) -> T + Send + 'static) -> Var<T>

where T: VarValue,

Gets a contextual Rgba var that selects the color for the context scheme and map it.

pub fn rgba_into<T>(self) -> Var<T>

where T: VarValue + From<Rgba>,

Gets a contextual Rgba var that selects the color for the context scheme and converts it to T.

Trait Implementations

impl Clone for LightDark

fn clone(&self) -> LightDark

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LightDark

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LightDark

fn deserialize<__D>( __deserializer: __D, ) -> Result<LightDark, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<L, D> From<(L, D)> for LightDark

where L: Into<Rgba>, D: Into<Rgba>,

fn from(_: (L, D)) -> LightDark

From (light, dark) tuple.

impl From<Hsla> for LightDark

fn from(color: Hsla) -> LightDark

From same color to both.

impl From<Hsva> for LightDark

fn from(color: Hsva) -> LightDark

From same color to both.

impl From<Rgba> for LightDark

fn from(color: Rgba) -> LightDark

From same color to both.

impl Hash for LightDark

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

where __H: Hasher,

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 Index<ColorScheme> for LightDark

type Output = Rgba

The returned type after indexing.

fn index( &self, index: ColorScheme, ) -> &<LightDark as Index<ColorScheme>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<ColorScheme> for LightDark

fn index_mut( &mut self, index: ColorScheme, ) -> &mut <LightDark as Index<ColorScheme>>::Output

Performs the mutable indexing (container[index]) operation.

impl<L, D> IntoVar<LightDark> for (L, D)

where L: Into<Rgba>, D: Into<Rgba>,

fn into_var(self) -> Var<LightDark>

From (light, dark) tuple.

impl IntoVar<LightDark> for Hsla

fn into_var(self) -> Var<LightDark>

From same color to both.

impl IntoVar<LightDark> for Hsva

fn into_var(self) -> Var<LightDark>

From same color to both.

impl IntoVar<LightDark> for Rgba

fn into_var(self) -> Var<LightDark>

From same color to both.

impl IntoVar<Option<LightDark>> for LightDark

fn into_var(self) -> Var<Option<LightDark>>

impl IntoVar<Rgba> for LightDark

fn into_var(self) -> Var<Rgba>

impl PartialEq for LightDark

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Transitionable for LightDark

fn lerp(self, to: &LightDark, step: Factor) -> LightDark

Sample the linear interpolation from self -> to by step.

impl Copy for LightDark

impl<L, D> IntoValue<LightDark> for (L, D)

where L: Into<Rgba>, D: Into<Rgba>,

impl IntoValue<LightDark> for Hsla

impl IntoValue<LightDark> for Hsva

impl IntoValue<LightDark> for Rgba

impl IntoValue<Option<LightDark>> for LightDark

impl StructuralPartialEq for LightDark