reduce font size of too long lines

lines that are too longs with non-monospace fonts, for example:
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
are now rendered in smaller font. the font size is dynamically
computed so that the text is not too small (if possible).

+ minor changes
+ update readme
+ bump to 0.0.6

Author: thjbdvlt

.gitignore

@@ -1,4 +1,5 @@
 u-k-le-guin*
+toolong.md
 
 release.sh
 profile.sh

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leguinvim"
-version = "0.0.5"
+version = "0.0.6"
 authors = [
     "daa84 <daa84@inbox.ru>",
     "Lyude Paul <thatslyude@gmail.com>",

README.md

@@ -2,11 +2,10 @@ __leguinvim__ - neovim gui with non-monospace font support.
 
 for people who want to use neovim for prose writing: sf novel, master thesis...
 
-may look awful with some plugins. still very buggy, with strong [limitations](#limitations).
-
+may look awful with some plugins. still very buggy.
 if you want to try it anyway, check how to [install](#install) and [configure](#configure) it.
 
-the name is a reference to sf writer [ursula k le guin](https://de.wikipedia.org/wiki/Ursula_K._Le_Guin): neovim makes possible to edit text at the speed of thought, just as fast as le guin's characters with their telepathy abilities and their ansibles.
+the name is a reference to sf writer [ursula k le guin](https://de.wikipedia.org/wiki/Ursula_K._Le_Guin): neovim makes possible to [edit text at the speed of thought](https://archive.org/details/practical-vim-edit-text-at-the-speed-of-thought), just as fast as le guin's characters with their telepathy abilities and their [ansibles](https://en.wikipedia.org/wiki/Ansible).
 the project could thus have been named *gtkleguinvim* (because it uses [gtk](https://www.gtk.org/)). but it's too long.
 
 ![](./screenshots/completion.png)
@@ -45,17 +44,21 @@ call rpcnotify(1, 'Gui', 'FontMono', 'Fira Code 12') " default
 call rpcnotify(1, 'Gui', 'MonoFloat', 1)
 ```
 
-## limitations
+## how it works
 
 the rendering of non-monospace font by __leguinvim__ is a quick and dirty (and ultra-lazy) solution, and kind of a hacky one: __leguinvim__ don't try to wrap the lines by itself, it just lets neovim do it.
 some lines could thus be very long, and some other very short..?
 yes.
 but when writing prose, at least for some languages, and maybe surprisingely, it actually just works, because lines naturally tend to be a mix of narrow, wide and medium-width letters.
-except for extreme edge-cases (that __leguinvim__ will try to catch soon):
+except for extreme edge-cases, like lines full of bold-uppercased __W__. for these cases, __leguinvim__ reduce the font size for the line, to keep the whole text visible:
 
-![](./screenshots/limitation-out-of-bound-line.png)
+![](./screenshots/www.png)
 
 ## source
 
 __leguinvim__ is forked from [neovim-gtk](https://github.com/lyude/neovim-gtk).
 (lot of removals and changes.)
+
+## todo
+
+this project aims to stay simple. no funky widgets nor smooth scrolling. just monospace fonts: that's still a lot to improves, lot of bugs to fix, of workaround to find!

makefile

@@ -5,7 +5,8 @@ src := $(shell find -name '*.rs')
 install_path := $(DEST_DIR)$(PREFIX)/bin/$(name)
 
 all: $(bin)
-	./$(bin) u-k*
+	# ./$(bin) u-k*
+	./$(bin) toolong.md
 
 $(bin): $(src) Cargo.toml
 	cargo build --release

src/grid.rs

@@ -132,20 +132,6 @@ impl Grid {
     pub fn new(id: u64) -> Self {
         Grid {
             id,
-            // model: UiModel::default(),
-            // start_row: 0,  // split window
-            // start_col: 0,  // split window
-            // hidden: false, // e.g. tabs
-            // floating: false,
-            // anchor: String::from(""),
-            // anchor_grid_id: 0,
-            // zindex: 0,
-            // compindex: 0,
-            // border_removed: false,
-            // border: [false, false, false, false], // top, right, bottom, left
-            // anchor_pos: (-1, -1),
-            // monospace: false,
-            // pix: PixModel::default(),
             ..Grid::default()
         }
     }

src/pix_grid.rs

@@ -12,39 +12,29 @@ pub struct PixModel {
     rows: usize,
 }
 
-fn new_pix_matrix(columns: usize, rows: usize, space_width: f32) -> PixMatrix {
-    vec![vec![space_width; columns + 1].into_boxed_slice(); rows].into_boxed_slice()
-}
-
 impl PixModel {
     pub fn new(columns: usize, rows: usize) -> Self {
         PixModel {
-            matrix: new_pix_matrix(columns, rows, 0.0),
             columns,
             rows,
-            ..PixModel::default()
+            matrix: vec![vec![0.0; columns + 1].into_boxed_slice(); rows].into_boxed_slice(),
         }
     }
 
     pub fn from_grid(model: &UiModel, space_width: f32, sign_column: usize) -> Self {
         let model = model;
         let (rows, columns) = (model.rows, model.columns);
-        let matrix = new_pix_matrix(columns, rows, space_width);
-        let mut pix_model = PixModel {
-            matrix,
-            columns,
-            rows,
-            ..PixModel::default()
-        };
+        let mut pix_model = PixModel::new(columns, rows);
         for (row, line) in model.model().iter().enumerate() {
-            pix_model.update_line(line, row, space_width, sign_column);
+            pix_model.update(line, row, space_width, sign_column);
         }
         pix_model
     }
 
-    pub fn update_line(&mut self, line: &Line, row: usize, space_width: f32, sign_column: usize) {
+    pub fn update(&mut self, line: &Line, row: usize, space_width: f32, sign_column: usize) -> f32 {
         let pix_line = &mut self.matrix[row];
         pix_line.fill(space_width);
+        let mut last_non_space: usize = sign_column;
         for col in sign_column..self.columns {
             for item in &line.item_line[col] {
                 let glyphs = item.glyphs();
@@ -60,31 +50,33 @@ impl PixModel {
                                 pix_line[col + i] = 0.0;
                             }
                         }
+                        last_non_space = col + n as usize;
                     }
                 }
             }
         }
-        self.len_to_pos(row);
+        self.len_to_pos(row, last_non_space + 1)
     }
 
-    pub fn update_line_monospace(&mut self, row: usize, space_width: f32) {
+    pub fn update_mono(&mut self, row: usize, space_width: f32) -> f32 {
         self.matrix[row].fill(space_width);
-        self.len_to_pos(row);
+        self.len_to_pos(row, self.matrix[row].len())
     }
 
-    fn len_to_pos(&mut self, row: usize) {
+    fn len_to_pos(&mut self, row: usize, last_non_space: usize) -> f32 {
         /* compute the horizontal position in pixel of each cell
          * we just reuse the same array here, because the previous one
          * is not usefull anymore
          * */
         let pix_line = &mut self.matrix[row];
         let mut x: f32 = 0.0;
-        for i in 0..self.columns {
+        for i in 0..last_non_space {
             let len = pix_line[i];
             pix_line[i] = x;
             x += len;
         }
         pix_line[self.columns] = pix_line[self.columns - 1];
+        x
     }
 
     pub fn fit(&self, model: &UiModel) -> bool {

src/render/context.rs

@@ -1,6 +1,7 @@
+use fnv::FnvHashMap;
 use std::collections::HashSet;
 
-use pango::{self, prelude::*};
+use pango::{self, FontDescription, prelude::*};
 
 use super::itemize::ItemizeIterator;
 use crate::ui_model::StyledLine;
@@ -9,21 +10,67 @@ pub struct Context {
     font_metrics: FontMetrix,
     font_features: FontFeatures,
     line_space: i32,
+    size: i32,
+}
+
+pub struct SubCtx {
+    font_map: pango::FontMap,
+    super_desc: FontDescription,
+    ctxs: FnvHashMap<i32, Context>,
+}
+
+impl SubCtx {
+    pub fn new(pango_context: pango::Context, font_desc: FontDescription) -> Self {
+        Self {
+            font_map: pango_context.font_map().unwrap(),
+            super_desc: FontDescription::from_string(&font_desc.to_str()),
+            ctxs: FnvHashMap::default(),
+        }
+    }
+
+    pub fn get(&self, size: i32) -> Option<&Context> {
+        self.ctxs.get(&size)
+    }
+
+    pub fn max_smaller_size(&self, ratio: f32) -> i32 {
+        ((self.super_desc.size() as f32 * ratio) * 0.8).trunc() as i32
+    }
+
+    fn add_smaller_font(&mut self, new_size: i32) {
+        let mut new_desc = self.super_desc.clone();
+        new_desc.set_size(new_size);
+        let pango_ctx = self.font_map.create_context();
+        pango_ctx.set_font_description(Some(&new_desc));
+        self.ctxs
+            .insert(new_size, Context::new(pango_ctx, new_size));
+    }
+
+    pub fn get_or_create(&mut self, size: i32) -> &Context {
+        if !self.ctxs.contains_key(&size) {
+            self.add_smaller_font(size);
+        }
+        self.get(size).unwrap()
+    }
 }
 
 impl Context {
-    pub fn new(pango_context: pango::Context) -> Self {
+    pub fn new(pango_context: pango::Context, size: i32) -> Self {
         Context {
             line_space: 0,
             font_metrics: FontMetrix::new(pango_context, 0),
             font_features: FontFeatures::new(),
+            size,
         }
     }
 
     pub fn update(&mut self, pango_context: pango::Context) {
         self.font_metrics = FontMetrix::new(pango_context, self.line_space);
     }
 
+    pub fn size(&self) -> i32 {
+        self.size
+    }
+
     pub fn update_font_features(&mut self, font_features: FontFeatures) {
         self.font_features = font_features;
     }

src/render/mod.rs

@@ -1,7 +1,7 @@
 mod context;
 mod itemize;
 
-pub use self::context::{CellMetrics, Context, FontFeatures};
+pub use self::context::{CellMetrics, Context, FontFeatures, SubCtx};
 
 use log::warn;
 
@@ -672,54 +672,69 @@ fn snapshot_cell(
 
 pub fn shape_dirty(
     ctx: &context::Context,
-    ui_model: &mut ui_model::UiModel,
-    pix: &mut PixModel,
+    sub_ctxs: &mut SubCtx,
+    grid: &mut Grid,
     hl: &HighlightMap,
     update_pix: bool,
-    sign_column: usize,
     monospace: bool,
 ) {
-    let space_width = ctx.cell_metrics().char_width as f32;
-
-    for (row, line) in ui_model.model_mut().iter_mut().enumerate() {
+    let cell_metrics = ctx.cell_metrics();
+    let space_width = cell_metrics.char_width as f32;
+    let sign_column = grid.sign_column_len();
+    let width = (grid.rect.0 + grid.rect.2) as f32;
+    for (row, line) in grid.model.model_mut().iter_mut().enumerate() {
         if !line.dirty_line {
             continue;
         }
-
-        let styled_line = ui_model::StyledLine::from(line, hl, ctx.font_features());
-        let items = ctx.itemize(&styled_line);
-        line.merge(&styled_line, &items);
-
-        for (col, cell) in line.line.iter_mut().enumerate() {
-            if cell.dirty {
-                for item in &mut *line.item_line[col] {
-                    let mut glyphs = pango::GlyphString::new();
-                    {
-                        let analysis = item.analysis();
-                        let offset = item.item.offset() as usize;
-                        let length = item.item.length() as usize;
-                        if let Some(line_str) = styled_line.line_str.get(offset..offset + length) {
-                            pango::shape(line_str, analysis, &mut glyphs);
-                        } else {
-                            warn!("Wrong itemize split");
-                        }
-                    }
-
-                    item.set_glyphs(glyphs);
-                }
+        shape_dirty_line(line, hl, ctx);
+        line.dirty_line = false;
+        if !update_pix {
+            continue;
+        }
+        if monospace {
+            grid.pix.update_mono(row, space_width);
+            continue;
+        }
+        let x = grid.pix.update(line, row, space_width, sign_column);
+        if x <= width {
+            continue;
+        }
+        let mut ratio = 1.0;
+        loop {
+            ratio -= 0.05;
+            let size = sub_ctxs.max_smaller_size(ratio);
+            for cell in line.line.iter_mut().skip(sign_column) {
+                cell.dirty = true;
+            }
+            shape_dirty_line(line, hl, sub_ctxs.get_or_create(size));
+            if grid.pix.update(line, row, space_width, sign_column) <= width {
+                break;
             }
-
-            cell.dirty = false;
         }
+    }
+}
 
-        if update_pix {
-            if monospace {
-                pix.update_line_monospace(row, space_width);
-            } else {
-                pix.update_line(line, row, space_width, sign_column);
+fn shape_dirty_line(line: &mut Line, hl: &HighlightMap, ctx: &Context) {
+    let styled_line = ui_model::StyledLine::from(line, hl, ctx.font_features());
+    let items = ctx.itemize(&styled_line);
+    line.merge(&styled_line, &items);
+    for (col, cell) in line.line.iter_mut().enumerate() {
+        if cell.dirty {
+            for item in &mut *line.item_line[col] {
+                let mut glyphs = pango::GlyphString::new();
+                {
+                    let analysis = item.analysis();
+                    let offset = item.item.offset() as usize;
+                    let length = item.item.length() as usize;
+                    if let Some(line_str) = styled_line.line_str.get(offset..offset + length) {
+                        pango::shape(line_str, analysis, &mut glyphs);
+                    } else {
+                        warn!("Wrong itemize split");
+                    }
+                }
+                item.set_glyphs(glyphs);
             }
         }
-
-        line.dirty_line = false;
+        cell.dirty = false;
     }
 }