Merge pull request #99 from kas-gui/push-xwvsnqwxlrot

Replace Effect::aux with e; merge fns runs, runs_with_effects

Author: dhardy

src/display/glyph_pos.rs

@@ -16,36 +16,25 @@ use crate::fonts::{self, FaceId};
 use crate::{shaper, Glyph, Range, Vec2};
 
 /// Effect formatting marker
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Effect<X> {
+pub struct Effect {
     /// Index in text at which formatting becomes active
     ///
     /// (Note that we use `u32` not `usize` since it can be assumed text length
     /// will never exceed `u32::MAX`.)
     pub start: u32,
+    /// User-specified value, e.g. index into a colour palette
+    pub e: u16,
     /// Effect flags
     pub flags: EffectFlags,
-    /// User payload
-    pub aux: X,
-}
-
-impl<X> Effect<X> {
-    /// Construct a "default" instance with the supplied `aux` value
-    pub fn default(aux: X) -> Self {
-        Effect {
-            start: 0,
-            flags: EffectFlags::empty(),
-            aux,
-        }
-    }
 }
 
 bitflags::bitflags! {
     /// Text effects
     #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-    pub struct EffectFlags: u32 {
+    pub struct EffectFlags: u16 {
         /// Glyph is underlined
         const UNDERLINE = 1 << 0;
         /// Glyph is crossed through by a center-line
@@ -143,15 +132,14 @@ impl ExactSizeIterator for MarkerPosIter {}
 /// A sequence of positioned glyphs with effects
 ///
 /// Yielded by [`TextDisplay::runs`] and [`TextDisplay::runs_with_effects`].
-pub struct GlyphRun<'a, X: Copy> {
+pub struct GlyphRun<'a> {
     run: &'a shaper::GlyphRun,
     range: Range,
     offset: Vec2,
-    effects: &'a [Effect<X>],
-    default_aux: X,
+    effects: &'a [Effect],
 }
 
-impl<'a, X: Copy> GlyphRun<'a, X> {
+impl<'a> GlyphRun<'a> {
     /// Get the font face used for this run
     #[inline]
     pub fn face_id(&self) -> FaceId {
@@ -182,25 +170,22 @@ impl<'a, X: Copy> GlyphRun<'a, X> {
 
     /// Yield glyphs and effects for this run
     ///
-    /// The callback `f` receives `glyph, i, aux` where
-    /// `dpu` and `height` are both measures of the font size (pixels per font
-    /// unit and pixels per height, respectively), and `i` is the index within
-    /// `effects` (or `usize::MAX` when a default-constructed effect token is
-    /// used).
+    /// The callback `f` receives `glyph, e` where `e` is the [`Effect::e`]
+    /// value (defaults to 0).
     ///
     /// The callback `g` receives positioning for each underline/strike-through
     /// segment: `x1, x2, y_top, h` where `h` is the thickness (height). Note
     /// that it is possible to have `h < 1.0` and `y_top, y_top + h` to round to
     /// the same number; the renderer is responsible for ensuring such lines
-    /// are actually visible. The last parameters are `i, aux` as for `f`.
+    /// are actually visible. The last parameter is `e` as for `f`.
     ///
     /// Note: this is more computationally expensive than [`GlyphRun::glyphs`],
     /// so you may prefer to call that. Optionally one may choose to cache the
     /// result, though this is not really necessary.
     pub fn glyphs_with_effects<F, G>(&self, mut f: F, mut g: G)
     where
-        F: FnMut(Glyph, usize, X),
-        G: FnMut(f32, f32, f32, f32, usize, X),
+        F: FnMut(Glyph, u16),
+        G: FnMut(f32, f32, f32, f32, u16),
     {
         let sf = fonts::library()
             .get_face(self.run.face_id)
@@ -237,9 +222,7 @@ impl<'a, X: Copy> GlyphRun<'a, X> {
             .effects
             .get(effect_cur)
             .cloned()
-            .unwrap_or(Effect::default(self.default_aux));
-
-        let mut effect_i = effect_cur;
+            .unwrap_or(Effect::default());
 
         // In case an effect applies to the left-most glyph, it starts from that
         // glyph's x coordinate.
@@ -251,15 +234,15 @@ impl<'a, X: Copy> GlyphRun<'a, X> {
                     let y_top = position.1 - metrics.position;
                     let h = metrics.thickness;
                     let x1 = position.0;
-                    underline = Some((x1, y_top, h, fmt.aux));
+                    underline = Some((x1, y_top, h, fmt.e));
                 }
             }
             if fmt.flags.contains(EffectFlags::STRIKETHROUGH) {
                 if let Some(metrics) = sf.strikethrough_metrics() {
                     let y_top = position.1 - metrics.position;
                     let h = metrics.thickness;
                     let x1 = position.0;
-                    strikethrough = Some((x1, y_top, h, fmt.aux));
+                    strikethrough = Some((x1, y_top, h, fmt.e));
                 }
             }
         }
@@ -303,55 +286,53 @@ impl<'a, X: Copy> GlyphRun<'a, X> {
                     .effects
                     .get(effect_cur)
                     .cloned()
-                    .unwrap_or(Effect::default(self.default_aux));
+                    .unwrap_or(Effect::default());
 
                 if underline.is_some() != fmt.flags.contains(EffectFlags::UNDERLINE) {
-                    if let Some((x1, y_top, h, aux)) = underline {
+                    if let Some((x1, y_top, h, e)) = underline {
                         let x2 = glyph.position.0;
-                        g(x1, x2, y_top, h, effect_i, aux);
+                        g(x1, x2, y_top, h, e);
                         underline = None;
                     } else if let Some(metrics) = sf.underline_metrics() {
                         let y_top = glyph.position.1 - metrics.position;
                         let h = metrics.thickness;
                         let x1 = glyph.position.0;
-                        underline = Some((x1, y_top, h, fmt.aux));
+                        underline = Some((x1, y_top, h, fmt.e));
                     }
                 }
                 if strikethrough.is_some() != fmt.flags.contains(EffectFlags::STRIKETHROUGH) {
-                    if let Some((x1, y_top, h, aux)) = strikethrough {
+                    if let Some((x1, y_top, h, e)) = strikethrough {
                         let x2 = glyph.position.0;
-                        g(x1, x2, y_top, h, effect_i, aux);
+                        g(x1, x2, y_top, h, e);
                         strikethrough = None;
                     } else if let Some(metrics) = sf.strikethrough_metrics() {
                         let y_top = glyph.position.1 - metrics.position;
                         let h = metrics.thickness;
                         let x1 = glyph.position.0;
-                        strikethrough = Some((x1, y_top, h, fmt.aux));
+                        strikethrough = Some((x1, y_top, h, fmt.e));
                     }
                 }
-
-                effect_i = effect_cur;
             }
 
-            f(glyph, effect_cur, fmt.aux);
+            f(glyph, fmt.e);
         }
 
         // Effects end at the following glyph's start (or end of this run part)
-        if let Some((x1, y_top, h, aux)) = underline {
+        if let Some((x1, y_top, h, e)) = underline {
             let x2 = if self.range.end() < self.run.glyphs.len() {
                 self.run.glyphs[self.range.end()].position.0
             } else {
                 self.run.caret
             } + self.offset.0;
-            g(x1, x2, y_top, h, effect_i, aux);
+            g(x1, x2, y_top, h, e);
         }
-        if let Some((x1, y_top, h, aux)) = strikethrough {
+        if let Some((x1, y_top, h, e)) = strikethrough {
             let x2 = if self.range.end() < self.run.glyphs.len() {
                 self.run.glyphs[self.range.end()].position.0
             } else {
                 self.run.caret
             } + self.offset.0;
-            g(x1, x2, y_top, h, effect_i, aux);
+            g(x1, x2, y_top, h, e);
         }
     }
 }
@@ -461,43 +442,31 @@ impl TextDisplay {
 
     /// Iterate over runs of positioned glyphs
     ///
-    /// This method is just sugar for `self.runs_with_effects(&[], ())`.
+    /// All glyphs are translated by the given `offset` (this is practically
+    /// free).
     ///
-    /// [Requires status][Self#status-of-preparation]:
-    /// text is fully prepared for display.
+    /// An [`Effect`] sequence supports underline, strikethrough and custom
+    /// indexing (e.g. for a color palette). Pass `&[]` if effects are not
+    /// required. (The default effect is always [`Effect::default()`].)
     ///
     /// Runs are yielded in undefined order. The total number of
     /// glyphs yielded will equal [`TextDisplay::num_glyphs`].
-    pub fn runs(&self) -> impl Iterator<Item = GlyphRun<'_, ()>> {
-        self.runs_with_effects(&[], ())
-    }
-
-    /// Iterate over runs of positioned glyphs with effects
-    ///
-    /// If the list `effects` is empty or has first entry with `start > 0`, the
-    /// result of `Effect::default(default_aux)` is used. The user payload of
-    /// type `X` is simply passed through to `f` and `g` calls and may be useful
-    /// for color information.
     ///
     /// [Requires status][Self#status-of-preparation]:
     /// text is fully prepared for display.
-    ///
-    /// Runs are yielded in undefined order. The total number of
-    /// glyphs yielded will equal [`TextDisplay::num_glyphs`].
-    pub fn runs_with_effects<'a, X: Copy>(
+    pub fn runs<'a>(
         &'a self,
-        effects: &'a [Effect<X>],
-        default_aux: X,
-    ) -> impl Iterator<Item = GlyphRun<'a, X>> + 'a {
+        offset: Vec2,
+        effects: &'a [Effect],
+    ) -> impl Iterator<Item = GlyphRun<'a>> + 'a {
         self.wrapped_runs
             .iter()
             .filter(|part| !part.glyph_range.is_empty())
             .map(move |part| GlyphRun {
                 run: &self.runs[to_usize(part.glyph_run)],
                 range: part.glyph_range,
-                offset: part.offset,
+                offset: offset + part.offset,
                 effects,
-                default_aux,
             })
     }
 

src/display/text_runs.rs

@@ -140,10 +140,10 @@ impl TextDisplay {
         let mut last_is_htab = false;
         let mut non_control_end = 0;
 
-        for (pos, c) in text.char_indices() {
+        for (index, c) in text.char_indices() {
             // Handling for control chars
             if !last_is_control {
-                non_control_end = pos;
+                non_control_end = index;
             }
             let is_control = c.is_control();
             let is_htab = c == '\t';
@@ -158,10 +158,10 @@ impl TextDisplay {
             let is_break = hard_break || boundary == Boundary::Line;
 
             // Force end of current run?
-            let bidi_break = levels[pos] != input.level;
+            let bidi_break = levels[index] != input.level;
 
             if let Some(fmt) = next_fmt.as_ref() {
-                if to_usize(fmt.start) == pos {
+                if to_usize(fmt.start) == index {
                     font = fmt.font;
                     dpem = fmt.dpem;
                     next_fmt = font_tokens.next();
@@ -173,7 +173,7 @@ impl TextDisplay {
             }
 
             let opt_last_face = if matches!(
-                classes[pos],
+                classes[index],
                 BidiClass::L | BidiClass::R | BidiClass::AL | BidiClass::EN | BidiClass::AN
             ) {
                 None
@@ -205,15 +205,15 @@ impl TextDisplay {
                 self.runs
                     .push(shaper::shape(input, range, face, breaks, special));
 
-                start = pos;
-                non_control_end = pos;
-                input.level = levels[pos];
+                start = index;
+                non_control_end = index;
+                input.level = levels[index];
                 breaks = Default::default();
                 input.script = UNKNOWN_SCRIPT;
             } else if is_break && !is_control {
                 // We do break runs when hitting control chars, but only when
                 // encountering the next non-control character.
-                breaks.push(shaper::GlyphBreak::new(to_u32(pos)));
+                breaks.push(shaper::GlyphBreak::new(to_u32(index)));
             }
 
             last_is_control = is_control;

src/format.rs

@@ -56,7 +56,7 @@ pub trait FormattableText: std::cmp::PartialEq + std::fmt::Debug {
     /// most uses it should still be sufficient, but for other cases it may be
     /// preferable not to use this method (use a dummy implementation returning
     /// `&[]` and use inherent methods on the text object via [`Text::text`]).
-    fn effect_tokens(&self) -> &[Effect<()>];
+    fn effect_tokens(&self) -> &[Effect];
 }
 
 impl<F: FormattableText + ?Sized> FormattableText for &F {
@@ -73,7 +73,7 @@ impl<F: FormattableText + ?Sized> FormattableText for &F {
         F::font_tokens(self, dpem)
     }
 
-    fn effect_tokens(&self) -> &[Effect<()>] {
+    fn effect_tokens(&self) -> &[Effect] {
         F::effect_tokens(self)
     }
 }
@@ -115,7 +115,7 @@ pub trait FormattableTextDyn: std::fmt::Debug {
     /// most uses it should still be sufficient, but for other cases it may be
     /// preferable not to use this method (use a dummy implementation returning
     /// `&[]` and use inherent methods on the text object via [`Text::text`]).
-    fn effect_tokens(&self) -> &[Effect<()>];
+    fn effect_tokens(&self) -> &[Effect];
 }
 
 impl<F: FormattableText + Clone + 'static> FormattableTextDyn for F {
@@ -135,7 +135,7 @@ impl<F: FormattableText + Clone + 'static> FormattableTextDyn for F {
         OwningVecIter::new(iter.collect())
     }
 
-    fn effect_tokens(&self) -> &[Effect<()>] {
+    fn effect_tokens(&self) -> &[Effect] {
         FormattableText::effect_tokens(self)
     }
 }
@@ -168,7 +168,7 @@ impl<'t> FormattableText for &'t dyn FormattableTextDyn {
         FormattableTextDyn::font_tokens(*self, dpem)
     }
 
-    fn effect_tokens(&self) -> &[Effect<()>] {
+    fn effect_tokens(&self) -> &[Effect] {
         FormattableTextDyn::effect_tokens(*self)
     }
 }

src/format/markdown.rs

@@ -49,7 +49,7 @@ pub enum Error {
 pub struct Markdown {
     text: String,
     fmt: Vec<Fmt>,
-    effects: Vec<Effect<()>>,
+    effects: Vec<Effect>,
 }
 
 impl Markdown {
@@ -118,7 +118,7 @@ impl FormattableText for Markdown {
         FontTokenIter::new(&self.fmt, dpem)
     }
 
-    fn effect_tokens(&self) -> &[Effect<()>] {
+    fn effect_tokens(&self) -> &[Effect] {
         &self.effects
     }
 }
@@ -197,8 +197,8 @@ fn parse(input: &str) -> Result<Markdown, Error> {
         if token.flags != flags {
             effects.push(Effect {
                 start: token.start,
+                e: 0,
                 flags: token.flags,
-                aux: (),
             });
             flags = token.flags;
         }

src/format/plain.rs

@@ -22,7 +22,7 @@ impl FormattableText for str {
         std::iter::empty()
     }
 
-    fn effect_tokens(&self) -> &[Effect<()>] {
+    fn effect_tokens(&self) -> &[Effect] {
         &[]
     }
 }
@@ -38,7 +38,7 @@ impl FormattableText for String {
         std::iter::empty()
     }
 
-    fn effect_tokens(&self) -> &[Effect<()>] {
+    fn effect_tokens(&self) -> &[Effect] {
         &[]
     }
 }