Struct termimad::CompoundStyle

pub struct CompoundStyle {
    pub object_style: ContentStyle,
}

A style which may be applied to a compound

Fields

object_style: ContentStyle

Implementations

impl CompoundStyle

pub fn apply_to<D>(&self, val: D) -> StyledContent<D>

where D: Clone + Display,

Apply an StyledContent to the passed displayable object.

pub const fn new( foreground_color: Option<Color>, background_color: Option<Color>, attributes: Attributes ) -> Self

Get an new instance of CompoundStyle

pub fn blend_with<C: Into<Color>>(&mut self, dest: C, weight: f32)

Blend the foreground and background colors (if any) into the given dest color, with a weight in [0..1].

The dest color can be for example a [crossterm] color or a coolor one.

pub fn with_fgbg(fg: Color, bg: Color) -> Self

Get an new instance of CompoundStyle

pub fn with_fg(fg: Color) -> Self

Get an new instance of CompoundStyle

pub fn with_bg(bg: Color) -> Self

Get an new instance of CompoundStyle

pub fn with_attr(attr: Attribute) -> Self

Get an new instance of CompoundStyle

pub fn set_fg(&mut self, color: Color)

Set the foreground color to the passed color.

pub fn set_bg(&mut self, color: Color)

Set the background color to the passed color.

pub fn set_fgbg(&mut self, fg: Color, bg: Color)

Set the colors to the passed ones

pub fn add_attr(&mut self, attr: Attribute)

Add an Attribute. Like italic, underlined or bold.

pub fn has_attr(&self, attr: Attribute) -> bool

Check whether the style contains the attribute

pub fn remove_attr(&mut self, attr: Attribute)

Remove an Attribute. Like italic, underlined or bold.

pub fn overwrite_with(&mut self, other: &Self)

Add the defined characteristics of other to self, overwriting its own one when defined

pub const fn get_fg(&self) -> Option<Color>

pub const fn get_bg(&self) -> Option<Color>

pub fn repeat_char( &self, f: &mut Formatter<'_>, c: char, count: usize ) -> Result

Write a char several times with the line compound style

pub fn repeat_string( &self, f: &mut Formatter<'_>, s: &str, count: usize ) -> Result

Write a string several times with the line compound style

Implementation Note: performances here are critical

pub fn repeat_space(&self, f: &mut Formatter<'_>, count: usize) -> Result

Write 0 or more spaces with the line’s compound style

pub fn queue<W, D>(&self, w: &mut W, val: D) -> Result<(), Error>

where D: Clone + Display, W: Write,

write the value with this style on the given writer

pub fn queue_str<W, S: Into<String>>( &self, w: &mut W, s: S ) -> Result<(), Error>

where W: Write,

write the string with this style on the given writer

pub fn queue_fg<W>(&self, w: &mut W) -> Result<(), Error>

where W: Write,

pub fn queue_bg<W>(&self, w: &mut W) -> Result<(), Error>

where W: Write,

pub fn clear<W>(&self, w: &mut W, clear_type: ClearType) -> Result<(), Error>

where W: Write,

Clear with the compound_style’s background.

let mut w = std::io::stderr();
skin.paragraph.compound_style.clear(&mut w, ClearType::UntilNewLine).unwrap();

pub fn style_char(&self, nude_char: char) -> StyledChar

pub fn attrs(&self) -> Attributes

Trait Implementations

impl Clone for CompoundStyle

fn clone(&self) -> CompoundStyle

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CompoundStyle

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

Formats the value using the given formatter.

impl Default for CompoundStyle

fn default() -> CompoundStyle

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CompoundStyle

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&[StyleToken]> for CompoundStyle

fn from(tokens: &[StyleToken]) -> Self

Converts to this type from the input type.

impl From<CompoundStyle> for LineStyle

fn from(compound_style: CompoundStyle) -> Self

Converts to this type from the input type.

impl From<ContentStyle> for CompoundStyle

fn from(object_style: ContentStyle) -> Self

Converts to this type from the input type.

impl PartialEq for CompoundStyle

fn eq(&self, other: &CompoundStyle) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PushStyleTokens for CompoundStyle

fn push_style_tokens(&self, tokens: &mut Vec<StyleToken>)

fn to_style_tokens_string(&self) -> String

impl Serialize for CompoundStyle

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CompoundStyle