top: tui impl C

Author: Bluemangoo

src/uu/top/src/tui/input.rs

@@ -55,6 +55,11 @@ pub fn handle_input(
                 stat.highlight_bold = !stat.highlight_bold;
                 should_update.store(true, Ordering::Relaxed);
             }
+            char!('C') => {
+                let mut stat = tui_stat.write().unwrap();
+                stat.show_coordinates = !stat.show_coordinates;
+                should_update.store(true, Ordering::Relaxed);
+            }
             char!('c') => {
                 {
                     // drop the lock as soon as possible

src/uu/top/src/tui/mod.rs

@@ -65,24 +65,22 @@ impl<'a> Tui<'a> {
         height
     }
 
-    fn calc_offset(&self) -> ((usize, usize), (usize, usize, usize)) {
+    fn calc_list_coordinates(&self) -> (usize, usize) {
         let list_total = self.proc_list.collected.len();
         let list_offset = self.stat.list_offset;
+        (list_offset, list_total)
+    }
 
-        let horizontal_total = self.proc_list.fields.len();
-        let mut horizontal_offset = self.stat.horizontal_offset;
-        let column = if horizontal_offset >= horizontal_total {
-            horizontal_offset -= horizontal_total - 1;
-            horizontal_total - 1
+    fn calc_column_coordinates(&self) -> (usize, usize, usize) {
+        let total_columns = self.proc_list.fields.len();
+        let horizontal_offset = self.stat.horizontal_offset;
+        let column_coordinate = min(horizontal_offset, total_columns - 1);
+        let horizontal_offset = if horizontal_offset >= total_columns {
+            horizontal_offset - (total_columns - 1)
         } else {
-            let o = horizontal_offset;
-            horizontal_offset = 0;
-            o
+            0
         };
-        (
-            (list_offset, list_total),
-            (column, horizontal_total, horizontal_offset * 8),
-        )
+        (column_coordinate, total_columns, horizontal_offset * 8)
     }
 
     fn render_header(&self, area: Rect, buf: &mut Buffer) {
@@ -367,11 +365,32 @@ impl<'a> Tui<'a> {
                 .render(layout[0], buf);
             return;
         }
-        let input = Line::from(vec![
-            Span::styled(&self.stat.input_label, Style::default().primary(colorful)),
-            Span::raw(" "),
-            Span::raw(&self.stat.input_value),
-        ]);
+        let input = if !self.stat.input_label.is_empty() || !self.stat.input_value.is_empty() {
+            Line::from(vec![
+                Span::styled(&self.stat.input_label, Style::default().primary(colorful)),
+                Span::raw(" "),
+                Span::raw(&self.stat.input_value),
+            ])
+        } else if self.stat.show_coordinates {
+            let list_coordinates = self.calc_list_coordinates();
+            let column_coordinates = self.calc_column_coordinates();
+            Line::from(vec![
+                Span::raw(format!(
+                    "  scroll coordinates: y = {}/{} (tasks), x = {}/{} (fields)",
+                    list_coordinates.0 + 1,
+                    list_coordinates.1,
+                    column_coordinates.0 + 1,
+                    column_coordinates.1
+                )),
+                Span::raw(if column_coordinates.2 > 0 {
+                    format!(" + {}", column_coordinates.2)
+                } else {
+                    String::new()
+                }),
+            ])
+        } else {
+            Line::from("")
+        };
         input.render(area, buf);
     }
 
@@ -406,47 +425,57 @@ impl<'a> Tui<'a> {
             _ => Constraint::Length(0),
         };
 
-        let (list_offset, column_offset) = self.calc_offset();
+        let list_coordinates = self.calc_list_coordinates();
+        let column_coordinates = self.calc_column_coordinates();
 
         let constraints: Vec<Constraint> = self
             .proc_list
             .fields
             .iter()
             .map(|field| build_constraint(field))
-            .skip(column_offset.0)
+            .skip(column_coordinates.0)
             .collect();
 
-        let header = Row::new(self.proc_list.fields.clone().split_off(column_offset.0))
-            .style(Style::default().bg_secondary(colorful));
+        let header = Row::new(
+            self.proc_list
+                .fields
+                .clone()
+                .split_off(column_coordinates.0),
+        )
+        .style(Style::default().bg_secondary(colorful));
 
         let rows = self.proc_list.collected.iter().map(|item| {
-            let cells = item.iter().enumerate().skip(column_offset.0).map(|(n, c)| {
-                let c = if column_offset.2 > 0 {
-                    if c.len() < column_offset.2 {
-                        ""
+            let cells = item
+                .iter()
+                .enumerate()
+                .skip(column_coordinates.0)
+                .map(|(n, c)| {
+                    let c = if column_coordinates.2 > 0 {
+                        if c.len() < column_coordinates.2 {
+                            ""
+                        } else {
+                            &c[column_coordinates.2..]
+                        }
+                    } else {
+                        c
+                    };
+                    if highlight_sorted && n == highlight_column {
+                        Cell::from(Span::styled(
+                            c,
+                            if highlight_bold {
+                                Style::default().bg_primary(colorful)
+                            } else {
+                                Style::default().primary(colorful)
+                            },
+                        ))
                     } else {
-                        &c[column_offset.2..]
+                        Cell::from(c)
                     }
-                } else {
-                    c
-                };
-                if highlight_sorted && n == highlight_column {
-                    Cell::from(Span::styled(
-                        c,
-                        if highlight_bold {
-                            Style::default().bg_primary(colorful)
-                        } else {
-                            Style::default().primary(colorful)
-                        },
-                    ))
-                } else {
-                    Cell::from(c)
-                }
-            });
+                });
             Row::new(cells).height(1)
         });
 
-        let mut state = TableState::default().with_offset(list_offset.0);
+        let mut state = TableState::default().with_offset(list_coordinates.0);
 
         let table = Table::new(rows, constraints).header(header);
         StatefulWidget::render(table, area, buf, &mut state);

src/uu/top/src/tui/stat.rs

@@ -27,6 +27,7 @@ pub(crate) struct TuiStat {
     pub sort_by_pid: bool,
     pub highlight_sorted: bool,
     pub highlight_bold: bool,
+    pub show_coordinates: bool,
 }
 
 impl TuiStat {
@@ -58,6 +59,7 @@ impl TuiStat {
             sort_by_pid: false,
             highlight_sorted: false,
             highlight_bold: false,
+            show_coordinates: false,
         }
     }