Struct termimad::MadSkin

pub struct MadSkin {

    pub paragraph: LineStyle,
    pub bold: CompoundStyle,
    pub italic: CompoundStyle,
    pub strikeout: CompoundStyle,
    pub inline_code: CompoundStyle,
    pub code_block: LineStyle,
    pub headers: [LineStyle; 8],
    pub scrollbar: ScrollBarStyle,
    pub table: LineStyle,
    pub bullet: StyledChar,
    pub quote_mark: StyledChar,
    pub horizontal_rule: StyledChar,
    pub ellipsis: CompoundStyle,
    pub table_border_chars: &'static TableBorderChars,
    pub list_items_indentation_mode: ListItemsIndentationMode,
    pub special_chars: HashMap<Compound<'static>, StyledChar>,
}

A skin defining how a parsed markdown appears on the terminal (fg and bg colors, bold, italic, underline, etc.)

Fields

paragraph: LineStyle

bold: CompoundStyle

italic: CompoundStyle

strikeout: CompoundStyle

inline_code: CompoundStyle

code_block: LineStyle

headers: [LineStyle; 8]

scrollbar: ScrollBarStyle

table: LineStyle

bullet: StyledChar

quote_mark: StyledChar

horizontal_rule: StyledChar

ellipsis: CompoundStyle

table_border_chars: &'static TableBorderChars

list_items_indentation_mode: ListItemsIndentationMode

special_chars: HashMap<Compound<'static>, StyledChar>

compounds which should be replaced with special renders. Experimental. This API will probably change (comments welcome) Do not use compounds with a length different than 1.

Implementations

impl MadSkin

pub fn no_style() -> Self

Build a customizable skin with no style, most useful when your application must run in no-color mode, for example when piped to a file.

Note that without style you have no underline, no strikeout, etc.

pub fn default_dark() -> Self

Build a customizable skin with gray levels suitable when the terminal has a dark background

To determine whether the terminal is in light mode, you may use the terminal-light crate.

pub fn default_light() -> Self

Build a customizable skin with gray levels suitable when the terminal has a light background

To determine whether the terminal is in light mode, you may use the terminal-light crate.

pub fn limit_to_ascii(&mut self)

Change the characters used for table borders, bullets, etc. to be in the non extended ASCII range

pub fn blend_with<C: Into<Color> + Copy>(&mut self, color: 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. A weight of 0 lets the skin unchanged.

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

Change the foreground of most styles (the ones which commonly have a default or uniform baground, don’t change code styles for example).

This can be used either as a first step in skin customization or as the only change done to a default skin.

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

Change the background of most styles (the ones which commonly have a default or uniform baground, don’t change code styles for example).

This can be used either as a first step in skin customization or as the only change done to a default skin.

pub fn set_headers_fg(&mut self, c: Color)

Set a common foreground color for all header levels

(it’s still possible to change them individually with skin.headers[i])

pub fn set_headers_bg(&mut self, c: Color)

Set a common background color for all header levels

(it’s still possible to change them individually with skin.headers[i])

pub fn set_global_bg(&mut self, c: Color)

set a common background for the paragraph, headers, rules, etc.

pub fn visible_composite_length( &self, kind: CompositeKind, compounds: &[Compound<'_>] ) -> usize

Return the number of visible cells

pub fn visible_line_length(&self, line: &Line<'_>) -> usize

pub const fn line_style(&self, kind: CompositeKind) -> &LineStyle

return the style to apply to a given line

pub fn inline<'k, 's>(&'k self, src: &'s str) -> FmtInline<'k, 's>

return a formatted line or part of line.

Don’t use this function if src is expected to be several lines.

pub fn text<'k, 's>( &'k self, src: &'s str, width: Option<usize> ) -> FmtText<'k, 's>

return a formatted text.

Code blocs will be right justified

pub fn term_text<'k, 's>(&'k self, src: &'s str) -> FmtText<'k, 's>

return a formatted text, with lines wrapped or justified for the current terminal width.

Code blocs will be right justified

pub fn area_text<'k, 's>(&'k self, src: &'s str, area: &Area) -> FmtText<'k, 's>

return a formatted text, with lines wrapped or justified for the passed area width (with space for a scrollbar).

Code blocs will be right justified

pub fn write_in_area(&self, markdown: &str, area: &Area) -> Result<(), Error>

pub fn write_in_area_on<W: Write>( &self, w: &mut W, markdown: &str, area: &Area ) -> Result<(), Error>

queue the rendered markdown in the specified area, without flush

pub fn print_inline(&self, src: &str)

do a print! of the given src interpreted as a markdown span

Don’t use this function if the string is expected to be several lines or have typed lines (titles, bullets, code fences, etc.): use print_text instead.

pub fn print_text(&self, src: &str)

do a print! of the given src interpreted as a markdown text

pub fn print_expander(&self, expander: TextTemplateExpander<'_, '_>)

do a print! of the given expander

pub fn print_owning_expander( &self, expander: &OwningTemplateExpander<'_>, template: &TextTemplate<'_> )

do a print! of the given owning expander

pub fn print_owning_expander_md<T: Into<String>>( &self, expander: &OwningTemplateExpander<'_>, template: T )

do a print! of the given owning expander

pub fn print_composite(&self, composite: Composite<'_>)

pub fn write_composite<W>( &self, w: &mut W, composite: Composite<'_> ) -> Result<(), Error>

where W: Write,

pub fn write_composite_fill<W>( &self, w: &mut W, composite: Composite<'_>, width: usize, align: Alignment ) -> Result<(), Error>

where W: Write,

write a composite filling the given width

Ellision or truncation may occur, but no wrap. Use Alignement::Unspecified for a smart internal ellision

pub fn write_inline_on<W: Write>( &self, w: &mut W, src: &str ) -> Result<(), Error>

parse the given src as a markdown snippet and write it on the given Write

pub fn write_text_on<W: Write>(&self, w: &mut W, src: &str) -> Result<(), Error>

parse the given src as a markdown text and write it on the given Write

pub fn write_inline(&self, src: &str) -> Result<(), Error>

parse the given src as a markdown snippet and write it on stdout

pub fn write_text(&self, src: &str) -> Result<(), Error>

parse the given src as a markdown text and write it on stdout

pub fn write_fmt_composite( &self, f: &mut Formatter<'_>, fc: &FmtComposite<'_>, outer_width: Option<usize>, with_right_completion: bool, with_margins: bool ) -> Result

Write a composite.

This function is internally used and normally not needed outside of Termimad’s implementation. Its arguments may change.

pub fn write_fmt_line( &self, f: &mut Formatter<'_>, line: &FmtLine<'_>, width: Option<usize>, with_right_completion: bool ) -> Result

Write a line in the passed formatter, with completions.

Right completion is optional because:

• if a text isn’t right completed it shrinks better when you reduce the width of the terminal
• right completion is useful to overwrite previous rendering without flickering (in scrollable views)

Trait Implementations

impl Clone for MadSkin

fn clone(&self) -> MadSkin

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MadSkin

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

Formats the value using the given formatter.

impl Default for MadSkin

fn default() -> Self

Build a customizable skin.

It’s initialized with sensible gray level settings which should work whatever the terminal colors.

If you want a default skin and you already know if your terminal is light or dark, you may use MadSkin::default_light or MadSkin::default_dark.

impl<'de> Deserialize<'de> for MadSkin

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MadSkin

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

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 MadSkin