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 special_chars: HashMap<Compound<'static>, StyledChar>,
}

A skin defining how a parsed mardkown 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

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 set_headers_fg(&mut self, c: Color)

Set a common foregreound 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, composite: &Composite) -> usize

Return the number of visible chars in a composite

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

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

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<()>

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

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

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

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_composite(&self, composite: Composite)

pub fn write_composite<W>(&self, w: &mut W, composite: Composite) -> Result<()> where
    W: Write, 

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

write a composite filling the given width

Ellision or truncation may occur, but no wrap

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

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

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

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

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

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

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

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
) -> Result

Write a composite.

This function is internally used and normally not needed outside of Termimad's implementation.

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 Default for MadSkin

fn default() -> MadSkin

Build a customizable skin.

It's initialized with sensible monochrome settings.