Add text decorations

[gyscos]

Allow a TextView to have special effects on parts of the content only: bold/italic/underline, different color/highlight...

[dermetfan]

I started working on this. Maybe you can have a look so we agree on the direction to take this?

You can test the current state by dropping the following in line 244 of TextView and running the lorem example. It just splits the text at "sit" and applies some style. (Yes, this is horrible and only works with the lorem ipsum text)

let delim = "sit";
let mut reappend_delim_i = 0;
let parts = text.split(delim)
    .map(|it| {
        let ret = if reappend_delim_i != 0 {
            format!("{}{}", delim, it)
        } else { it.to_owned() };
        reappend_delim_i += 1;
        ret
    })
    .collect::<Vec<_>>();
let parts = parts.iter()
    .map(|it| it.as_str())
    .collect::<Vec<_>>();
if parts.len() == 3 {
    let part1 = (parts[0], ::style::Style {
        .. Default::default()
    });
    let part2 = (parts[1], ::style::Style {
        color: Some(::theme::ColorStyle::Highlight),
        .. Default::default()
    });
    let part3 = (parts[2], ::style::Style {
        effect: ::theme::Effect::Reverse,
        .. Default::default()
    });
    printer.print_styled((x, 0), &[part1, part2, part3][..]);
} else {
    printer.print((x, 0), text);
}

[gyscos]

Thank you very much!

I was initially thinking of putting most of this feature in TextView itself (which would in turn call the Printer for each "styled" span), but now I realise that other views may want to use the same behaviour, and it makes sense to share the common code.

I'm still trying to find how to design it around use-cases like TextView where styled spans are rows are overlapping...

The "style" could be parsed as a tree (like in HTML), where each node can be:

• Raw text
• A style with a list of child nodes

I'd like, if possible, to separate the parsing part (where marked up text is parsed into a style tree) and the rendering part, to allow the same TextView to be easily filled from HTML, markdown or some other text format.

[dermetfan]

I was planning to do parsing in its own module where we could implement different parsers for different markup languages.

I don't think we need a tree to store a parsing result. That is only useful if you want to modify the tree (like JavaScript inserting DOM nodes) but that's probably overkill so we can just parse the new markup string instead. The result could be stored as Vec<StyledStr<'a>> as you said in #106 (comment).

My current draft is

/// Handle parsing markup into style.
pub mod markup {
    /// Parses a markup string into `StyledStr`s.
    pub type Parse = for<'a> FnOnce(&'a str) -> Vec<StyledStr<'a>>;

    /// Cursive's own markup language.
    pub fn parse_cursive<'a>(markup: &'a str) -> Vec<StyledStr<'a>> {
        unimplemented!()
    }
}

which would be used in widgets like

// If `None`, disable markup.
markup: Option<Box<markup::Parse>>,

I'm still trying to find how to design it around use-cases like TextView where styled spans are rows are overlapping...

After pondering a while I realized that the LinesIterator that computes rows must obviously not operate on the markup string but on the parsed result. That means we need to adapt computation and usage of rows anyway.

I haven't yet thought about this in depth but my first idea is to write a StyledLinesIterator or so with a type Row<'a> = &'a [StyledStr<'a>]. Maybe that StyledLinesIterator could use the already existing LinesIterator so it doesn't need to be completely rewritten.

I'm out earning money until Friday. Looking forward to continue with this.

[gyscos]

Let's start from the end.

• The Printer takes a &[StyledStr<'a>] per row.

• We want to store the rows (to avoir re-computing them) but storing these StyledStr<'a> inside TextView might be tricky (self-borrowing types are never easy to deal with).
  So instead, we'll store a list of struct StyledSpan { style: Style, start: usize, end: usize, width: usize }. It's then trivial to build the list of StyledStr<'a> from that when drawing.

• Our StyledLinesIterator should then output StyledSpans. It will need to:

  • Accumulate StyledSpans as long as they fit on one row
  • Split the last span following the current rules
  • Start the next row with the leftovers from the split span.

• The input to the StyledLinesIterator would then be a styled input, made of:

  • A list of StyledSpans
  • The input string the spans are indexing into

  (Keeping the string separate and using indices in there is just a trick to avoid issues with storing references in the string; if there is another option - I haven't checked Kimundi/owning-ref-rs yet - that could change.)

So all in all, a TextView would have to store:

• The main input string
• The result of the style parsing: a list of StyledSpan
• Pre-computed rows: a list of lists of StyledSpan

And when asked to draw itself, it would map a list of StyledSpan to a list of StyledStr<'a> using the input string, and give that to the printer...

[dermetfan]

That sounds good! I'll start working on it when I have some time.

I think our parse() signature from dermetfan@bf43333 (comment) is unable to parse markup with escape sequences.

Consider this HTML: <i>1 &lt; 2</i>

Using this signature, our parser could only return:

[(
  "1 < 2",
  Style {
    color: None,
    effect: Effect::Italic
  }
)]

Since parse() just has a string slice it cannot transform this into:

[(
  "1 < 2",
   ...
)]

A Cow solves the problem: parse<'a>(markup: &'a mut Cow<str>) -> Vec<StyledStr<'a>>

So to update the example from my previous comment:

/// Handle parsing markup into style.
pub mod markup {
    use super::*;
    use std::borrow::Cow;

    /// Parses a markup string into `StyledStr`s.
    pub type Parse = for<'a> FnOnce(&'a mut Cow<str>) -> Vec<StyledStr<'a>>;

    /// Cursive's own markup language.
    pub fn parse_cursive<'a>(markup: &'a mut Cow<str>) -> Vec<StyledStr<'a>> {
        unimplemented!()
    }
}

[gyscos]

Aah damn, I forgot about that. Cow seems perfectly indicated in this case indeed, though I'm still a bit wary about working with &str references.

[gyscos]

Oh wait - should the input itself be Cow, or just the content of StyledStr<'a>?

[dermetfan]

I meant the input into parse() but yes - type StyledString<'a> = (Cow<'a, str>, Style) is probably better. That would allow us to easily parse the tags and hand off a &mut [StyledString] to some function that replaces the escape sequences:

pub fn parse_html<'a>(html: &'a str) -> Vec<StyledString<'a>> {
    let mut result: Vec<StyledString> = parse_tags(html);
    parse_escapes(result.as_mut_slice());
    result
}

[spacekookie]

Any update on this feature?

[gyscos]

Yes, I've been working on the line-breaking algorithm for the past few days, and I almost got a working version. Should be able to push something this week.