feat: make Scrollable generic over each line; expose type alias

Author: zjp-CN

src/bin/ui/mod.rs

@@ -1,7 +1,7 @@
-use self::scrollable::Scrollable;
+use self::scrollable::{ScrollText, ScrollTreeLines, Scrollable};
 use crate::{app::App, Result};
 use ratatui::prelude::*;
-use term_rustdoc::tree::{TreeLine, TreeLines};
+use term_rustdoc::tree::TreeLines;
 
 /// scroll up/down behavior and with what offset
 mod page_scroll;
@@ -58,17 +58,14 @@ pub struct Selected {
     col_end: u16,
 }
 
-/// Scrollable tree view but stored in lines.
-type ScrollTreeLines = Scrollable<TreeLines>;
-
 #[derive(Default, Debug)]
 struct Outline {
     display: ScrollTreeLines,
 }
 
 #[derive(Default, Debug)]
 struct Content {
-    display: Scrollable<Vec<TreeLine>>,
+    display: ScrollText,
 }
 
 #[derive(Default, Debug)]

src/bin/ui/scrollable/interaction.rs

@@ -3,7 +3,7 @@ use crate::ui::ScrollOffset;
 use term_rustdoc::tree::TreeLine;
 
 /// Scrolling
-impl<Line: AsRef<[TreeLine]>> Scrollable<Line> {
+impl<Lines: AsRef<[TreeLine]>> Scrollable<Lines, TreeLine> {
     pub fn scrolldown(&mut self, offset: ScrollOffset) {
         let height = self.area.height as usize;
         let len = self.len();
@@ -48,7 +48,7 @@ impl<Line: AsRef<[TreeLine]>> Scrollable<Line> {
 }
 
 /// Cursor movement
-impl<Line: AsRef<[TreeLine]>> Scrollable<Line> {
+impl<Lines: AsRef<[TreeLine]>> Scrollable<Lines, TreeLine> {
     pub fn move_forward_cursor(&mut self) {
         let height = self.area.height;
         let reach_sceen_bottom = (self.cursor + 1) == height;

src/bin/ui/scrollable/markdown/mod.rs

@@ -0,0 +1,25 @@
+use super::Scrollable;
+use std::fmt;
+use term_rustdoc::tree::Text as StyledText;
+
+/// Scrollable text area for displaying markdown.
+pub type ScrollText = Scrollable<Vec<StyledLine>, StyledLine>;
+
+#[derive(Default)]
+pub struct StyledLine {
+    line: Vec<StyledText>,
+}
+
+impl fmt::Debug for StyledLine {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StyledLine")
+            .field("line-len", &self.line.len())
+            .finish()
+    }
+}
+
+impl AsRef<[StyledText]> for StyledLine {
+    fn as_ref(&self) -> &[StyledText] {
+        &self.line
+    }
+}

src/bin/ui/scrollable/mod.rs

@@ -1,15 +1,20 @@
 use super::Selected;
 use crate::{err, Result};
 use ratatui::prelude::Rect;
-use std::fmt;
-use term_rustdoc::tree::TreeLine;
+use std::{fmt, marker::PhantomData};
+use term_rustdoc::tree::{TreeLine, TreeLines};
 
 mod interaction;
+mod markdown;
 mod render;
 
+pub use self::markdown::ScrollText;
+
+/// Scrollable tree view but stored in lines.
+pub type ScrollTreeLines = Scrollable<TreeLines, TreeLine>;
+
 /// A text panel that can be scrolled and select texts when the cursor is inside of it.
-#[derive(Default)]
-pub struct Scrollable<Lines> {
+pub struct Scrollable<Lines, L> {
     /// Styled texts on each line
     pub lines: Lines,
     /// The start of row to be displayed
@@ -22,10 +27,18 @@ pub struct Scrollable<Lines> {
     pub select: Option<Selected>,
     /// The widget area, usually not the full screen
     pub area: Rect,
+    _ph: PhantomData<L>,
+}
+
+impl<Lines, L> Scrollable<Lines, L> {
+    /// The index the current cursor on screen points to.
+    pub fn idx_of_current_cursor(&self) -> usize {
+        self.cursor as usize + self.start
+    }
 }
 
-impl<Line: AsRef<[TreeLine]>> Scrollable<Line> {
-    pub fn lines(&self) -> &[TreeLine] {
+impl<L, Lines: AsRef<[L]>> Scrollable<Lines, L> {
+    pub fn lines(&self) -> &[L] {
         self.lines.as_ref()
     }
 
@@ -34,7 +47,22 @@ impl<Line: AsRef<[TreeLine]>> Scrollable<Line> {
     }
 }
 
-impl<Lines: Default + AsRef<[TreeLine]>> Scrollable<Lines> {
+impl<Lines: Default, L> Default for Scrollable<Lines, L> {
+    fn default() -> Self {
+        let (lines, start, cursor, max_windth, select, area, _ph) = Default::default();
+        Scrollable {
+            lines,
+            start,
+            cursor,
+            max_windth,
+            select,
+            area,
+            _ph,
+        }
+    }
+}
+
+impl<Lines: Default + AsRef<[TreeLine]>> Scrollable<Lines, TreeLine> {
     pub fn new(lines: Lines, full: Rect) -> Result<Self> {
         let w = lines.as_ref().iter().map(TreeLine::width).max();
         let max_windth = w.ok_or_else(|| err!("The documentation is empty with no items."))?;
@@ -53,14 +81,7 @@ impl<Lines: Default + AsRef<[TreeLine]>> Scrollable<Lines> {
     }
 }
 
-impl<Lines> Scrollable<Lines> {
-    /// The index the current cursor on screen points to.
-    pub fn idx_of_current_cursor(&self) -> usize {
-        self.cursor as usize + self.start
-    }
-}
-
-impl<Lines: AsRef<[TreeLine]>> fmt::Debug for Scrollable<Lines> {
+impl<L: fmt::Debug, Lines: AsRef<[L]>> fmt::Debug for Scrollable<Lines, L> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut s = f.debug_struct("Scrollable");
         s.field("lines.len", &self.len())

src/bin/ui/scrollable/render.rs

@@ -2,7 +2,7 @@ use super::Scrollable;
 use ratatui::prelude::{Buffer, Color, Rect, Widget};
 use term_rustdoc::tree::TreeLine;
 
-impl<Lines: AsRef<[TreeLine]>> Widget for &mut Scrollable<Lines> {
+impl<Lines: AsRef<[TreeLine]>> Widget for &mut Scrollable<Lines, TreeLine> {
     fn render(self, area: Rect, buf: &mut Buffer) {
         // render tree by each line
         write_lines(self.lines.as_ref(), self.start, area, buf);

src/tree/textline.rs

@@ -24,6 +24,7 @@ impl fmt::Display for TextTag {
 }
 
 /// Onwed [`ratatui::text::Span`], mainly being a small styled string.
+#[derive(Debug)]
 pub struct Text {
     pub text: XString,
     pub style: Style,