Enum Color

pub enum Color {
    Named(NamedColor),
    Hex(String),
}

Text color representation (either named or hex)

Variants

Named(NamedColor)

Predefined Minecraft color name

Hex(String)

Hex color code in #RRGGBB format

Implementations

impl Color

pub fn to_named(&self) -> Option<NamedColor>

Gets the named color for a given Color. If the color is not a named color, it will try to find a matching named color for a hex color.

Examples found in repository

src/minimessage.rs (line 530)

    fn serialize_object(&mut self, obj: &ComponentObject) -> Result<(), MiniMessageError> {
        // Save current style to compare changes
        let prev_style = self.current_style.clone();

        // Apply style changes
        let mut style_changes = Vec::new();

        if let Some(color) = &obj.color
            && Some(color) != prev_style.color.as_ref()
        {
            if let Some(named) = color.to_named() {
                style_changes.push(named.to_string());
            } else if let Color::Hex(hex) = color {
                style_changes.push(format!("color:{hex}"));
            }
        }

        if obj.bold != prev_style.bold && obj.bold == Some(true) {
            style_changes.push("bold".to_string());
        }

        if obj.italic != prev_style.italic && obj.italic == Some(true) {
            style_changes.push("italic".to_string());
        }

        if obj.underlined != prev_style.underlined && obj.underlined == Some(true) {
            style_changes.push("underlined".to_string());
        }

        if obj.strikethrough != prev_style.strikethrough && obj.strikethrough == Some(true) {
            style_changes.push("strikethrough".to_string());
        }

        if obj.obfuscated != prev_style.obfuscated && obj.obfuscated == Some(true) {
            style_changes.push("obfuscated".to_string());
        }

        // Apply style changes
        for change in &style_changes {
            self.output.push_str(&format!("<{change}>"));
        }

        // Update current style
        self.current_style = Style {
            color: obj.color.clone(),
            bold: obj.bold,
            italic: obj.italic,
            underlined: obj.underlined,
            strikethrough: obj.strikethrough,
            obfuscated: obj.obfuscated,
            ..self.current_style.clone()
        };

        // Serialize text content
        if let Some(text) = &obj.text {
            self.serialize_text(text)?;
        }

        // Serialize children
        if let Some(extra) = &obj.extra {
            for comp in extra {
                self.serialize_component(comp)?;
            }
        }

        // Close style changes
        for change in style_changes.iter().rev() {
            self.output.push_str(&format!("</{change}>"));
        }

        // Restore previous style
        self.current_style = prev_style;

        Ok(())
    }

Trait Implementations

impl Clone for Color

fn clone(&self) -> Color

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Color

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Color

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Color

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

Formats the value using the given formatter.

impl From<[u8; 3]> for Color

fn from([r, g, b]: [u8; 3]) -> Self

Converts to this type from the input type.

impl From<(u8, u8, u8)> for Color

fn from((r, g, b): (u8, u8, u8)) -> Self

Converts to this type from the input type.

impl FromStr for Color

type Err = ParseColorError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Color

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 PartialEq for Color

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

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Color

impl StructuralPartialEq for Color