use anyhow::{Context as _, bail};use schemars::{JsonSchema, json_schema};use serde::{    Deserialize, Deserializer, Serialize, Serializer,    de::{self, Visitor},};use std::borrow::Cow;use std::{    fmt::{self, Display, Formatter},    hash::{Hash, Hasher},}; /// Convert an RGB hex color code number to a color typepub fn rgb(hex: u32) -> Rgba {    let [_, r, g, b] = hex.to_be_bytes().map(|b| (b as f32) / 255.0);    Rgba { r, g, b, a: 1.0 }} /// Convert an RGBA hex color code number to [`Rgba`]pub fn rgba(hex: u32) -> Rgba {    let [r, g, b, a] = hex.to_be_bytes().map(|b| (b as f32) / 255.0);    Rgba { r, g, b, a }} /// Swap from RGBA with premultiplied alpha to BGRApub fn swap_rgba_pa_to_bgra(color: &mut [u8]) {    color.swap(0, 2);    if color[3] > 0 {        let a = color[3] as f32 / 255.;        color[0] = (color[0] as f32 / a) as u8;        color[1] = (color[1] as f32 / a) as u8;        color[2] = (color[2] as f32 / a) as u8;    }} /// An RGBA color#[derive(PartialEq, Clone, Copy, Default)]#[repr(C)]pub struct Rgba {    /// The red component of the color, in the range 0.0 to 1.0    pub r: f32,    /// The green component of the color, in the range 0.0 to 1.0    pub g: f32,    /// The blue component of the color, in the range 0.0 to 1.0    pub b: f32,    /// The alpha component of the color, in the range 0.0 to 1.0    pub a: f32,} impl fmt::Debug for Rgba {    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {        write!(f, "rgba({:#010x})", u32::from(*self))    }} impl Rgba {    /// Create a new [`Rgba`] color by blending this and another color together    pub fn blend(&self, other: Rgba) -> Self {        if other.a >= 1.0 {            other        } else if other.a <= 0.0 {            *self        } else {            Rgba {                r: (self.r * (1.0 - other.a)) + (other.r * other.a),                g: (self.g * (1.0 - other.a)) + (other.g * other.a),                b: (self.b * (1.0 - other.a)) + (other.b * other.a),                a: self.a,            }        }    }     /// Returns a new RGBA color with the same red, green and blue channels, but    /// with a new alpha value.    ///    /// Example:    /// ```    /// use gpui::rgba;    /// let color = rgba(0xFF0000FF);    /// let faded = color.alpha(0.25);    /// assert_eq!(faded.a, 0.25);    /// ```    ///    /// This will return a red color with 25% opacity.    ///    /// Example:    /// ```    /// use gpui::rgba;    /// let color = rgba(0x3399FFCC);    /// let transparent = color.alpha(0.0);    /// assert_eq!(transparent.a, 0.0);    /// ```    ///    /// This will return the same blue color, fully transparent.    pub fn alpha(&self, a: f32) -> Self {        Rgba {            r: self.r,            g: self.g,            b: self.b,            a: a.clamp(0., 1.),        }    }     /// Returns a new RGBA color with the same red, green, and blue channels,    /// but with the alpha channel multiplied by the given factor.    ///    /// Example:    /// ```    /// use gpui::rgba;    /// let color = rgba(0xFF0000FF); // Fully opaque red    /// let faded = color.opacity(0.5);    /// assert_eq!(faded.a, 0.5);    /// ```    ///    /// This will return a red color with 50% opacity.    ///    /// Example:    /// ```    /// use gpui::rgba;    /// let color = rgba(0x3399FFCC); // A light blue with 80% opacity    /// let faded = color.opacity(0.5);    /// assert!((faded.a - 0.4).abs() < 1e-6);    /// ```    ///    /// This will return the same blue color scaled down to 40% opacity.    pub fn opacity(&self, factor: f32) -> Self {        Rgba {            r: self.r,            g: self.g,            b: self.b,            a: self.a * factor.clamp(0., 1.),        }    }} impl From<Rgba> for u32 {    fn from(rgba: Rgba) -> Self {        let r = (rgba.r * 255.0) as u32;        let g = (rgba.g * 255.0) as u32;        let b = (rgba.b * 255.0) as u32;        let a = (rgba.a * 255.0) as u32;        (r << 24) | (g << 16) | (b << 8) | a    }} struct RgbaVisitor; impl Visitor<'_> for RgbaVisitor {    type Value = Rgba;     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {        formatter.write_str("a string in the format #rrggbb or #rrggbbaa")    }     fn visit_str<E: de::Error>(self, value: &str) -> Result<Rgba, E> {        Rgba::try_from(value).map_err(E::custom)    }} impl JsonSchema for Rgba {    fn schema_name() -> Cow<'static, str> {        "Rgba".into()    }     fn json_schema(_generator: &mut schemars::SchemaGenerator) -> schemars::Schema {        json_schema!({            "type": "string",            "pattern": "^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$"        })    }} impl<'de> Deserialize<'de> for Rgba {    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {        deserializer.deserialize_str(RgbaVisitor)    }} impl Serialize for Rgba {    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>    where        S: Serializer,    {        let r = (self.r * 255.0).round() as u8;        let g = (self.g * 255.0).round() as u8;        let b = (self.b * 255.0).round() as u8;        let a = (self.a * 255.0).round() as u8;         let s = format!("#{r:02x}{g:02x}{b:02x}{a:02x}");        serializer.serialize_str(&s)    }} impl From<Hsla> for Rgba {    fn from(color: Hsla) -> Self {        let h = color.h;        let s = color.s;        let l = color.l;         let c = (1.0 - (2.0 * l - 1.0).abs()) * s;        let x = c * (1.0 - ((h * 6.0) % 2.0 - 1.0).abs());        let m = l - c / 2.0;        let cm = c + m;        let xm = x + m;         let (r, g, b) = match (h * 6.0).floor() as i32 {            0 | 6 => (cm, xm, m),            1 => (xm, cm, m),            2 => (m, cm, xm),            3 => (m, xm, cm),            4 => (xm, m, cm),            _ => (cm, m, xm),        };         Rgba {            r: r.clamp(0., 1.),            g: g.clamp(0., 1.),            b: b.clamp(0., 1.),            a: color.a,        }    }} impl TryFrom<&'_ str> for Rgba {    type Error = anyhow::Error;     fn try_from(value: &'_ str) -> Result<Self, Self::Error> {        const RGB: usize = "rgb".len();        const RGBA: usize = "rgba".len();        const RRGGBB: usize = "rrggbb".len();        const RRGGBBAA: usize = "rrggbbaa".len();         const EXPECTED_FORMATS: &str = "Expected #rgb, #rgba, #rrggbb, or #rrggbbaa";        const INVALID_UNICODE: &str = "invalid unicode characters in color";         let Some(("", hex)) = value.trim().split_once('#') else {            bail!("invalid RGBA hex color: '{value}'. {EXPECTED_FORMATS}");        };         let (r, g, b, a) = match hex.len() {            RGB | RGBA => {                let r = u8::from_str_radix(                    hex.get(0..1).with_context(|| {                        format!("{INVALID_UNICODE}: r component of #rgb/#rgba for value: '{value}'")                    })?,                    16,                )?;                let g = u8::from_str_radix(                    hex.get(1..2).with_context(|| {                        format!("{INVALID_UNICODE}: g component of #rgb/#rgba for value: '{value}'")                    })?,                    16,                )?;                let b = u8::from_str_radix(                    hex.get(2..3).with_context(|| {                        format!("{INVALID_UNICODE}: b component of #rgb/#rgba for value: '{value}'")                    })?,                    16,                )?;                let a = if hex.len() == RGBA {                    u8::from_str_radix(                        hex.get(3..4).with_context(|| {                            format!("{INVALID_UNICODE}: a component of #rgba for value: '{value}'")                        })?,                        16,                    )?                } else {                    0xf                };                 /// Duplicates a given hex digit.                /// E.g., `0xf` -> `0xff`.                const fn duplicate(value: u8) -> u8 {                    (value << 4) | value                }                 (duplicate(r), duplicate(g), duplicate(b), duplicate(a))            }            RRGGBB | RRGGBBAA => {                let r = u8::from_str_radix(                    hex.get(0..2).with_context(|| {                        format!(                            "{}: r component of #rrggbb/#rrggbbaa for value: '{}'",                            INVALID_UNICODE, value                        )                    })?,                    16,                )?;                let g = u8::from_str_radix(                    hex.get(2..4).with_context(|| {                        format!(                            "{INVALID_UNICODE}: g component of #rrggbb/#rrggbbaa for value: '{value}'"                        )                    })?,                    16,                )?;                let b = u8::from_str_radix(                    hex.get(4..6).with_context(|| {                        format!(                            "{INVALID_UNICODE}: b component of #rrggbb/#rrggbbaa for value: '{value}'"                        )                    })?,                    16,                )?;                let a = if hex.len() == RRGGBBAA {                    u8::from_str_radix(                        hex.get(6..8).with_context(|| {                            format!(                                "{INVALID_UNICODE}: a component of #rrggbbaa for value: '{value}'"                            )                        })?,                        16,                    )?                } else {                    0xff                };                (r, g, b, a)            }            _ => bail!("invalid RGBA hex color: '{value}'. {EXPECTED_FORMATS}"),        };         Ok(Rgba {            r: r as f32 / 255.,            g: g as f32 / 255.,            b: b as f32 / 255.,            a: a as f32 / 255.,        })    }} /// An HSLA color#[derive(Default, Copy, Clone, Debug)]#[repr(C)]pub struct Hsla {    /// Hue, in a range from 0 to 1    pub h: f32,     /// Saturation, in a range from 0 to 1    pub s: f32,     /// Lightness, in a range from 0 to 1    pub l: f32,     /// Alpha, in a range from 0 to 1    pub a: f32,} #[cfg(feature = "proptest")]mod property {    use super::Hsla;    use proptest::prelude::*;     impl Hsla {        /// Proptest [`Strategy`] that produces opaque colors (i.e. alpha = 1).        ///        /// For truly arbitrary colors, use the [`Arbitrary`] implementation.        pub fn opaque_strategy() -> impl Strategy<Value = Self> {            (0.0f32..=1.0, 0.0f32..=1.0, 0.0f32..=1.0).prop_map(|(h, s, l)| Hsla { h, s, l, a: 1. })        }    }     impl Arbitrary for Hsla {        type Strategy = BoxedStrategy<Self>;        type Parameters = ();         fn arbitrary_with((): Self::Parameters) -> Self::Strategy {            (0.0f32..=1.0, 0.0f32..=1.0, 0.0f32..=1.0, 0.0f32..=1.0)                .prop_map(|(h, s, l, a)| Hsla { h, s, l, a })                .boxed()        }    }} impl PartialEq for Hsla {    fn eq(&self, other: &Self) -> bool {        self.h            .total_cmp(&other.h)            .then(self.s.total_cmp(&other.s))            .then(self.l.total_cmp(&other.l).then(self.a.total_cmp(&other.a)))            .is_eq()    }} impl PartialOrd for Hsla {    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {        Some(self.cmp(other))    }} impl Ord for Hsla {    fn cmp(&self, other: &Self) -> std::cmp::Ordering {        self.h            .total_cmp(&other.h)            .then(self.s.total_cmp(&other.s))            .then(self.l.total_cmp(&other.l).then(self.a.total_cmp(&other.a)))    }} impl Eq for Hsla {} impl Hash for Hsla {    fn hash<H: Hasher>(&self, state: &mut H) {        state.write_u32(u32::from_be_bytes(self.h.to_be_bytes()));        state.write_u32(u32::from_be_bytes(self.s.to_be_bytes()));        state.write_u32(u32::from_be_bytes(self.l.to_be_bytes()));        state.write_u32(u32::from_be_bytes(self.a.to_be_bytes()));    }} impl Display for Hsla {    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {        write!(            f,            "hsla({:.2}, {:.2}%, {:.2}%, {:.2})",            self.h * 360.,            self.s * 100.,            self.l * 100.,            self.a        )    }} /// Construct an [`Hsla`] object from plain valuespub const fn hsla(h: f32, s: f32, l: f32, a: f32) -> Hsla {    Hsla {        h: h.clamp(0., 1.),        s: s.clamp(0., 1.),        l: l.clamp(0., 1.),        a: a.clamp(0., 1.),    }} /// Pure black in [`Hsla`]pub const fn black() -> Hsla {    Hsla {        h: 0.,        s: 0.,        l: 0.,        a: 1.,    }} /// Transparent black in [`Hsla`]pub const fn transparent_black() -> Hsla {    Hsla {        h: 0.,        s: 0.,        l: 0.,        a: 0.,    }} /// Transparent white in [`Hsla`]pub const fn transparent_white() -> Hsla {    Hsla {        h: 0.,        s: 0.,        l: 1.,        a: 0.,    }} /// Opaque grey in [`Hsla`], values will be clamped to the range [0, 1]pub const fn opaque_grey(lightness: f32, opacity: f32) -> Hsla {    Hsla {        h: 0.,        s: 0.,        l: lightness.clamp(0., 1.),        a: opacity.clamp(0., 1.),    }} /// Pure white in [`Hsla`]pub const fn white() -> Hsla {    Hsla {        h: 0.,        s: 0.,        l: 1.,        a: 1.,    }} /// The color red in [`Hsla`]pub const fn red() -> Hsla {    Hsla {        h: 0.,        s: 1.,        l: 0.5,        a: 1.,    }} /// The color blue in [`Hsla`]pub const fn blue() -> Hsla {    Hsla {        h: 0.6666666667,        s: 1.,        l: 0.5,        a: 1.,    }

Lines 1–500 of 1070. Load more