monospace font for floatings windows

to avoid breaking plugins such as fzf-lua, and before having a better
solution, floating windows are now rendered with monospace font.

in the future, we may want to have per-grid/window/buffer option.

to chose the monospace font, set this in ginit.vim:
call rpcnotify(1, 'Gui', 'FontMono', 'Fira Code 16')

Author: thjbdvlt

README.md

@@ -23,3 +23,13 @@ the project could thus have been named *gtkleguinvim*. but it's too long.
 ![](./screenshots/completion.png)
 
 ![](./screenshots/fzf-and-split.png)
+
+![](./screenshots/fzf-lua-monospace.png)
+
+to configure __leguinvim__, you may:
+
+```vim
+" ~/.config/nvim/ginit.vim
+call rpcnotify(1, 'Gui', 'Font', 'Liberation Sans 20')  " main font
+call rpcnotify(1, 'Gui', 'FontMono', 'Fira Code 16')  " monospace font (floating windows)
+```

screenshots/fzf-lua-monospace.png

@@ -122,14 +122,14 @@ pub struct Grid {
     pub start_row: i64,
     pub start_col: i64,
 
-    // Floating windows
-    pub is_float: bool,
+    pub floating: bool,
     pub zindex: u64,
     pub compindex: u64,
     pub anchor: String,
     pub anchor_grid_id: u64,
-    pub anchor_pos: (i64, i64), // for pmenu
+    pub anchor_pos: (i64, i64),
     pub border_removed: bool,
+    pub monospace: bool,
 
     pub border: [bool; 4],
 }
@@ -142,21 +142,22 @@ impl Grid {
             start_row: 0,  // split window
             start_col: 0,  // split window
             hidden: false, // e.g. tabs
-            is_float: false,
+            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,
         }
     }
 
     pub fn new_pmenu() -> Self {
         Grid {
             hidden: true,
-            is_float: true,
+            floating: true,
             zindex: 1000,
             border_removed: true,
             border: [true, true, true, true],
@@ -177,9 +178,10 @@ impl Grid {
         self.start_row = row;
         self.start_col = col;
         self.zindex = zindex;
-        self.is_float = true;
+        self.floating = true;
         self.border.fill(true);
         self.anchor_grid_id = anchor_grid;
+        self.monospace = true;
     }
 
     pub fn get_cursor(&self) -> (usize, usize) {
@@ -230,19 +232,27 @@ impl Grid {
     }
 
     pub fn start_x(&self, cell_metrics: &CellMetrics) -> f64 {
-        self.start_col as f64 * cell_metrics.char_width / GRID_WIDTH_RATIO
+        if self.monospace {
+            self.start_col as f64 * cell_metrics.char_width
+        } else {
+            self.start_col as f64 * cell_metrics.char_width / GRID_WIDTH_RATIO
+        }
     }
 
     pub fn start_y(&self, cell_metrics: &CellMetrics) -> f64 {
         self.start_row as f64 * cell_metrics.line_height
     }
 
     pub fn width(&self, cell_metrics: &CellMetrics) -> f64 {
-        self.columns() as f64 * cell_metrics.char_width / GRID_WIDTH_RATIO
+        if self.monospace {
+            self.model.columns as f64 * cell_metrics.char_width
+        } else {
+            self.model.columns as f64 * cell_metrics.char_width / GRID_WIDTH_RATIO
+        }
     }
 
     pub fn height(&self, cell_metrics: &CellMetrics) -> f64 {
-        self.rows() as f64 * cell_metrics.line_height
+        self.model.rows as f64 * cell_metrics.line_height
     }
 
     pub fn sign_column_len(&self) -> usize {

src/grid.rs

@@ -226,6 +226,7 @@ pub fn call_gui_event(
     args: Vec<Value>,
 ) -> result::Result<(), String> {
     match method {
+        "FontMono" => call!(ui->set_font_mono(args: str)),
         "Font" => call!(ui->set_font(args: str)),
         "FontFeatures" => call!(ui->set_font_features(args: str)),
         "Linespace" => call!(ui->set_line_space(args: str)),

src/nvim/redraw_handler.rs

@@ -156,9 +156,16 @@ impl WidgetImpl for NvimViewportObject {
             // Render scenes get pretty huge here, so we cache them as often as possible
             let font_ctx = &render_state.font_ctx;
             let cell_metrics = font_ctx.cell_metrics();
+            let mono_ctx = &render_state.mono_ctx;
+            let mono_metrics = mono_ctx.cell_metrics();
             if inner.snapshot_cache.is_none() {
-                inner.snapshot_cache =
-                    snapshot_all_grids(cell_metrics, &state.grids, &state.pix_grids, hl);
+                inner.snapshot_cache = snapshot_all_grids(
+                    cell_metrics,
+                    mono_metrics,
+                    &state.grids,
+                    &state.pix_grids,
+                    hl,
+                );
             }
             if let Some(ref cached_snapshot) = inner.snapshot_cache {
                 let push_opacity = transparency.filled_alpha < 0.99999;
@@ -175,7 +182,8 @@ impl WidgetImpl for NvimViewportObject {
 
             if let Some(cursor) = state.cursor() {
                 if let Some(grid) = state.grids.get(state.cursor_grid) {
-                    snapshot_cursor(snapshot_in, cursor, font_ctx, grid, hl, transparency);
+                    // let pix_grid = &state.pix_grids.get(&state.cursor_grid).unwrap();
+                    snapshot_cursor(snapshot_in, cursor, font_ctx, mono_ctx, grid, hl, transparency);
                 }
             }
         } else {

src/nvim_viewport.rs

@@ -25,14 +25,12 @@ fn new_pix_model(columns: usize, rows: usize, space_width: i32) -> PixModel {
 }
 
 impl PixGrid {
-    pub fn new(grid: &Grid, cell_metrics: &CellMetrics, start_x: f64) -> PixGrid {
+    pub fn new(grid: &Grid, cell_metrics: &CellMetrics, start_x: f64, start_y: f64) -> PixGrid {
         let model = grid.model.model();
 
         /* get infos about grid position and size */
         let (rows, columns) = (grid.model.rows, grid.model.columns);
         let space_width = cell_metrics.char_width as i32;
-        let start_x = start_x + grid.start_x(cell_metrics);
-        let start_y = grid.start_y(cell_metrics);
         let width = grid.width(cell_metrics);
         let height = grid.height(cell_metrics);
 
@@ -151,36 +149,34 @@ impl PixGridMap {
     pub fn get_mut(&mut self, id: &u64) -> Option<&mut PixGrid> {
         self.grids.get_mut(id)
     }
-    pub fn get_or_create(
-        &mut self,
-        id: &u64,
-        grid: &Grid,
-        cell_metrics: &CellMetrics,
-    ) -> &mut PixGrid {
-        if self.grids.contains_key(&id) {
-            return self.grids.get_mut(&id).unwrap();
-        }
-        self.insert(grid, cell_metrics);
-        self.get_mut(id).unwrap()
-    }
     pub fn new() -> Self {
         PixGridMap {
             grids: FnvHashMap::default(),
             pmenu: PixGrid::empty(),
         }
     }
-    pub fn insert(&mut self, grid: &Grid, cell_metrics: &CellMetrics) {
+    pub fn insert(&mut self, grid: &Grid, cell_metrics: &CellMetrics, start_x: f64, start_y: f64) {
         self.grids
-            .insert(grid.id, PixGrid::new(grid, cell_metrics, 0.0));
+            .insert(grid.id, PixGrid::new(grid, cell_metrics, start_x, start_y));
     }
-    pub fn fit_gridmap(&mut self, gridmap: &GridMap, cell_metrics: &CellMetrics) {
+    pub fn fit_gridmap(
+        &mut self,
+        gridmap: &GridMap,
+        cell_metrics: &CellMetrics,
+        mono_metrics: &CellMetrics,
+    ) {
         for (id, grid) in gridmap.grids.iter() {
             if let Some(pg) = self.get_mut(id) {
                 if pg.fit(grid) {
                     continue;
                 }
             }
-            self.insert(grid, cell_metrics);
+            let cm = if grid.monospace {
+                mono_metrics
+            } else {
+                cell_metrics
+            };
+            self.insert(grid, cm, grid.start_x(cm), grid.start_y(cm));
         }
     }
 }

src/pix_grid.rs

@@ -167,7 +167,6 @@ pub struct CellMetrics {
     pub strikethrough_thickness: f64,
     pub pango_ascent: i32,
     pub pango_descent: i32,
-    pub pango_char_width: i32,
 }
 
 impl CellMetrics {
@@ -195,7 +194,6 @@ impl CellMetrics {
         CellMetrics {
             pango_ascent: font_metrics.ascent(),
             pango_descent: font_metrics.descent(),
-            pango_char_width: font_metrics.approximate_char_width(),
             ascent,
             descent,
             line_height: ascent + descent + f64::from(line_space),
@@ -212,7 +210,6 @@ impl CellMetrics {
         CellMetrics {
             pango_ascent: 0,
             pango_descent: 0,
-            pango_char_width: 0,
             ascent: 0.0,
             descent: 0.0,
             line_height,

src/render/context.rs

@@ -87,33 +87,23 @@ enum RenderStepKind {
 
 pub fn snapshot_all_grids(
     cell_metrics: &CellMetrics,
+    mono_metrics: &CellMetrics,
     gridmap: &GridMap,
     pix_gridmap: &PixGridMap,
     hl: &HighlightMap,
 ) -> Option<gsk::RenderNode> {
     let mut snapshot = gtk::Snapshot::new();
     let grids = gridmap.sorted_visible();
-
     for (id, grid) in grids.iter() {
-        if let Some(pix_grid) = pix_gridmap.get(*id) {
-            if pix_grid.columns != grid.model.columns {
-                snapshot_grid(
-                    &mut snapshot,
-                    cell_metrics,
-                    &grid,
-                    &PixGrid::new(grid, cell_metrics, 0.0),
-                    hl,
-                );
-            } else {
-                snapshot_grid(&mut snapshot, cell_metrics, &grid, pix_grid, hl);
-            }
+        let pix_grid = pix_gridmap.get(*id).unwrap();
+        let cm = if grid.monospace {
+            mono_metrics
         } else {
-            eprintln!("missing PixGrid {id}");
-        }
+            cell_metrics
+        };
+        snapshot_grid(&mut snapshot, cm, &grid, pix_grid, hl);
     }
-
     snapshot_pmenu(&mut snapshot, gridmap, pix_gridmap, cell_metrics, hl);
-
     snapshot.to_node()
 }
 
@@ -252,20 +242,38 @@ fn snapshot_text(
     hl: &HighlightMap,
 ) {
     let line_height = cell_metrics.line_height as f32;
-    let mut y = (line_height * grid.start_row as f32) + cell_metrics.ascent as f32;
-    for (row, line) in model.iter().enumerate() {
-        let pix_row = &pix_grid.matrix[row];
-        for (col, cell) in line.line.iter().enumerate() {
-            snapshot_cell(
-                &snapshot,
-                &line.item_line[col],
-                hl,
-                cell,
-                pix_row[col] as f32,
-                y,
-            );
+    let mut y = (pix_grid.start_y + cell_metrics.ascent) as f32;
+    if !grid.monospace {
+        for (row, line) in model.iter().enumerate() {
+            let pix_row = &pix_grid.matrix[row];
+            for (col, cell) in line.line.iter().enumerate() {
+                snapshot_cell(
+                    &snapshot,
+                    &line.item_line[col],
+                    hl,
+                    cell,
+                    pix_row[col] as f32,
+                    y,
+                );
+            }
+            y += line_height;
+        }
+    } else {
+        let char_width = cell_metrics.char_width as f32;
+        let mut y = (pix_grid.start_y + cell_metrics.ascent) as f32;
+        for line in model {
+            for (col, cell) in line.line.iter().enumerate() {
+                snapshot_cell(
+                    &snapshot,
+                    &line.item_line[col],
+                    hl,
+                    cell,
+                    pix_grid.start_x as f32 + (col as f32 * char_width),
+                    y,
+                );
+            }
+            y += line_height;
         }
-        y += line_height;
     }
 }
 
@@ -293,7 +301,8 @@ fn snapshot_pmenu(
     }
     let model = pmenu.model.model();
     let start_x = anchor_pix.matrix[row as usize][col as usize] as f64;
-    let pmenu_pix_grid = PixGrid::new(pmenu, cell_metrics, start_x);
+    let start_y = pmenu.start_y(cell_metrics);
+    let pmenu_pix_grid = PixGrid::new(pmenu, cell_metrics, start_x, start_y);
     grid_bg(snapshot, &pmenu_pix_grid, hl.bg());
     snapshot_text(snapshot, cell_metrics, model, pmenu, &pmenu_pix_grid, hl);
     grid_border(snapshot, pmenu, &pmenu_pix_grid, hl);
@@ -303,6 +312,7 @@ pub fn snapshot_cursor<T: CursorRedrawCb + 'static>(
     snapshot: &gtk::Snapshot,
     cursor: &Cursor<T>,
     font_ctx: &Context,
+    mono_ctx: &Context,
     grid: &Grid,
     hl: &HighlightMap,
     transparency: TransparencySettings,
@@ -313,7 +323,15 @@ pub fn snapshot_cursor<T: CursorRedrawCb + 'static>(
 
     let ui_model = &grid.model;
 
-    let cell_metrics = font_ctx.cell_metrics();
+    // TODO monospace: i use this A LOT. it may be a macro?
+    let ctx = if grid.monospace {
+        mono_ctx
+    } else {
+        font_ctx
+    };
+
+    let cell_metrics = ctx.cell_metrics();
+
     let CellMetrics { ascent, .. } = *cell_metrics;
     let (cursor_row, cursor_col) = ui_model.get_flushed_cursor();
 
@@ -325,6 +343,7 @@ pub fn snapshot_cursor<T: CursorRedrawCb + 'static>(
     };
 
     let space_size: i32 = cell_metrics.char_width as i32;
+
     let (pixel_width, x, until_x) =
         cursor_x(cursor_line, cursor_col, space_size, grid.sign_column_len());
     let x = (x as f64 + grid.start_x(cell_metrics)) as i32;
@@ -352,7 +371,7 @@ pub fn snapshot_cursor<T: CursorRedrawCb + 'static>(
 
     cursor.snapshot(
         snapshot,
-        font_ctx,
+        ctx,
         (x, y),
         cell,
         hl,

src/render/mod.rs

@@ -45,7 +45,7 @@ impl State {
             return;
         }
 
-        shell.set_font_desc(&self.gnome_interface_settings.string("monospace-font-name"));
+        shell.set_font_desc(&self.gnome_interface_settings.string("monospace-font-name"), false); // TODO monospace?
         self.font_source = FontSource::Gnome;
     }
 }