Struct Hsla 

#[repr(C)]
pub struct Hsla {
    pub h: f32,
    pub s: f32,
    pub l: f32,
    pub a: f32,
}

An HSLA color

Fields

h: f32

Hue, in a range from 0 to 1

s: f32

Saturation, in a range from 0 to 1

l: f32

Lightness, in a range from 0 to 1

a: f32

Alpha, in a range from 0 to 1

Implementations

impl Hsla

pub fn to_rgb(self) -> Rgba

Converts this HSLA color to an RGBA color.

pub const fn red() -> Self

The color red

pub const fn green() -> Self

The color green

pub const fn blue() -> Self

The color blue

pub const fn black() -> Self

The color black

pub const fn white() -> Self

The color white

pub const fn transparent_black() -> Self

The color transparent black

pub fn is_transparent(&self) -> bool

Returns true if the HSLA color is fully transparent, false otherwise.

pub fn is_opaque(&self) -> bool

Returns true if the HSLA color is fully opaque, false otherwise.

pub fn blend(self, other: Hsla) -> Hsla

Blends other on top of self based on other’s alpha value. The resulting color is a combination of self’s and other’s colors.

If other’s alpha value is 1.0 or greater, other color is fully opaque, thus other is returned as the output color. If other’s alpha value is 0.0 or less, other color is fully transparent, thus self is returned as the output color. Else, the output color is calculated as a blend of self and other based on their weighted alpha values.

Assumptions:

• Alpha values are contained in the range [0, 1], with 1 as fully opaque and 0 as fully transparent.
• The relative contributions of self and other is based on self’s alpha value (self.a) and other’s alpha value (other.a), self contributing self.a * (1.0 - other.a) and other contributing its own alpha value.
• RGB color components are contained in the range [0, 1].
• If self and other colors are out of the valid range, the blend operation’s output and behavior is undefined.

pub fn grayscale(&self) -> Self

Returns a new HSLA color with the same hue, and lightness, but with no saturation.

pub fn fade_out(&mut self, factor: f32)

Fade out the color by a given factor. This factor should be between 0.0 and 1.0. Where 0.0 will leave the color unchanged, and 1.0 will completely fade out the color.

pub fn opacity(&self, factor: f32) -> Self

Multiplies the alpha value of the color by a given factor and returns a new HSLA color.

Useful for transforming colors with dynamic opacity, like a color from an external source.

Example:

let color = gpui::red();
let faded_color = color.opacity(0.5);
assert_eq!(faded_color.a, 0.5);

This will return a red color with half the opacity.

Example:

use gpui::hsla;
let color = hsla(0.7, 1.0, 0.5, 0.7); // A saturated blue
let faded_color = color.opacity(0.16);
assert!((faded_color.a - 0.112).abs() < 1e-6);

This will return a blue color with around ~10% opacity, suitable for an element’s hover or selected state.

pub fn alpha(&self, a: f32) -> Self

Returns a new HSLA color with the same hue, saturation, and lightness, but with a new alpha value.

Example:

let color = gpui::red();
let red_color = color.alpha(0.25);
assert_eq!(red_color.a, 0.25);

This will return a red color with half the opacity.

Example:

use gpui::hsla;
let color = hsla(0.7, 1.0, 0.5, 0.7); // A saturated blue
let faded_color = color.alpha(0.25);
assert_eq!(faded_color.a, 0.25);

This will return a blue color with 25% opacity.

Trait Implementations

impl Clone for Hsla

fn clone(&self) -> Hsla

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hsla

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

Formats the value using the given formatter.

impl Default for Hsla

fn default() -> Hsla

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Hsla

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Hsla

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

Formats the value using the given formatter.

impl From<Hsla> for Background

fn from(value: Hsla) -> Self

Converts to this type from the input type.

impl From<Hsla> for Fill

fn from(color: Hsla) -> Self

Converts to this type from the input type.

impl From<Hsla> for HighlightStyle

fn from(color: Hsla) -> Self

Converts to this type from the input type.

impl From<Hsla> for Rgba

fn from(color: Hsla) -> Self

Converts to this type from the input type.

impl From<Rgba> for Hsla

fn from(color: Rgba) -> Self

Converts to this type from the input type.

impl Hash for Hsla

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 JsonSchema for Hsla

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

impl Ord for Hsla

fn cmp(&self, other: &Self) -> 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,

Restrict a value to a certain interval.

impl PartialEq for Hsla

fn eq(&self, other: &Self) -> 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 Hsla

fn partial_cmp(&self, other: &Self) -> 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 Serialize for Hsla

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Hsla

impl Eq for Hsla