niko/oxkerclone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wip: header+column widths

Browse Source
This commit is contained in:
Jack Wills
2022-07-22 19:38:19 +00:00
parent d14744b378
commit 96ca208197
6 changed files with 430 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ui/draw_blocks.rs
+335 -144
View File
@@ -48,7 +48,7 @@ fn generate_block<'a>(
gui_state: &Arc<Mutex<GuiState>>,
panel: SelectablePanel,
) -> Block<'a> {
gui_state.lock().insert_into_area_map(panel, area);
gui_state.lock().insert_into_panel_map(panel, area);
let mut block = Block::default()
.borders(Borders::ALL)
.border_type(BorderType::Rounded);
@@ -124,72 +124,163 @@ pub fn draw_containers<B: Backend>(
widths: &Columns,
) {
let block = generate_block(app_data, area, gui_state, SelectablePanel::Containers);
let items = app_data
.lock()
.containers
.items
.iter()
.map(|i| {
let state_style = Style::default().fg(i.state.get_color());
let blue = Style::default().fg(Color::Blue);
let mems = format!(
"{:>1} / {:>1}",
i.mem_stats.back().unwrap_or(&ByteStats::new(0)),
i.mem_limit
);
let sorted = app_data.lock().get_sorted();
let lines = Spans::from(vec![
Span::styled(
format!("{:<width$}", i.state.to_string(), width = widths.state.1),
state_style,
),
Span::styled(
format!("{}{:>width$}", MARGIN, i.status, width = widths.status.1),
state_style,
),
Span::styled(
format!(
"{}{:>width$}",
MARGIN,
i.cpu_stats.back().unwrap_or(&CpuStats::new(0.0)),
width = widths.cpu.1
),
state_style,
),
Span::styled(
format!("{}{:>width$}", MARGIN, mems, width = widths.mem.1),
state_style,
),
Span::styled(
format!(
"{}{:>width$}",
MARGIN,
i.id.chars().take(8).collect::<String>(),
width = widths.id.1
),
blue,
),
Span::styled(
format!("{}{:>width$}", MARGIN, i.name, width = widths.name.1),
blue,
),
Span::styled(
format!("{}{:>width$}", MARGIN, i.image, width = widths.image.1),
blue,
),
Span::styled(
format!("{}{:>width$}", MARGIN, i.net_rx, width = widths.net_rx.1),
Style::default().fg(Color::Rgb(255, 233, 193)),
),
Span::styled(
format!("{}{:>width$}", MARGIN, i.net_tx, width = widths.net_tx.1),
Style::default().fg(Color::Rgb(205, 140, 140)),
),
]);
ListItem::new(lines)
})
.collect::<Vec<_>>();
// if containers sorted, increase width to match headers
// let sorted_width = if app_data.lock().get_sorted().is_some() {
// 2
// }else {
// 0
// };
// Check if need to alter column width to watch the heading widths
let sorted_width = |(x,s): &(Header,usize)| {
let mut output = 0;
if let Some((h,_)) = &sorted {
if h == x {
output = 2;
}
}
// s + output
s.to_owned()
};
// let items = app_data
// .lock()
// .containers
// .items
// .iter()
// .map(|i| {
// let state_style = Style::default().fg(i.state.get_color());
// let blue = Style::default().fg(Color::Blue);
// let mems = format!(
// "{:>1} / {:>1}",
// i.mem_stats.back().unwrap_or(&ByteStats::new(0)),
// i.mem_limit
// );
// let lines = Spans::from(vec![
// Span::styled(
// format!("{:<width$}", i.state.to_string(), width = sorted_width(&widths.state)),
// state_style,
// ),
// Span::styled(
// format!("{}{:>width$}", MARGIN, i.status, width = sorted_width(&widths.status)),
// state_style,
// ),
// Span::styled(
// format!(
// "{}{:>width$}",
// MARGIN,
// i.cpu_stats.back().unwrap_or(&CpuStats::new(0.0)),
// width = sorted_width(&widths.cpu)
// ),
// state_style,
// ),
// Span::styled(
// format!("{}{:>width$}", MARGIN, mems, width = sorted_width(&widths.mem)),
// state_style,
// ),
// Span::styled(
// format!(
// "{}{:>width$}",
// MARGIN,
// i.id.chars().take(8).collect::<String>(),
// width =sorted_width(&widths.id),
// ),
// blue,
// ),
// Span::styled(
// format!("{}{:>width$}", MARGIN, i.name, width = sorted_width(&widths.name)),
// blue,
// ),
// Span::styled(
// format!("{}{:>width$}", MARGIN, i.image, width = sorted_width(&widths.image)),
// blue,
// ),
// Span::styled(
// format!("{}{:>width$}", MARGIN, i.net_rx, width = sorted_width(&widths.net_rx)),
// Style::default().fg(Color::Rgb(255, 233, 193)),
// ),
// Span::styled(
// format!("{}{:>width$}", MARGIN, i.net_tx, width = sorted_width(&widths.net_tx)),
// Style::default().fg(Color::Rgb(205, 140, 140)),
// ),
// ]);
// ListItem::new(lines)
// })
// .collect::<Vec<_>>();
let items = app_data
.lock()
.containers
.items
.iter()
.map(|i| {
let state_style = Style::default().fg(i.state.get_color());
let blue = Style::default().fg(Color::Blue);
let mems = format!(
"{:>1} / {:>1}",
i.mem_stats.back().unwrap_or(&ByteStats::new(0)),
i.mem_limit
);
let lines = Spans::from(vec![
Span::styled(
format!("{:<width$}", i.state.to_string(), width = widths.state.1),
state_style,
),
Span::styled(
format!("{}{:>width$}", MARGIN, i.status, width = widths.status.1),
state_style,
),
Span::styled(
format!(
"{}{:>width$}",
MARGIN,
i.cpu_stats.back().unwrap_or(&CpuStats::new(0.0)),
width = widths.cpu.1
),
state_style,
),
Span::styled(
format!("{}{:>width$}", MARGIN, mems, width = widths.mem.1),
state_style,
),
Span::styled(
format!(
"{}{:>width$}",
MARGIN,
i.id.chars().take(8).collect::<String>(),
width = widths.id.1
),
blue,
),
Span::styled(
format!("{}{:>width$}", MARGIN, i.name, width = widths.name.1),
blue,
),
Span::styled(
format!("{}{:>width$}", MARGIN, i.image, width = widths.image.1),
blue,
),
Span::styled(
format!("{}{:>width$}", MARGIN, i.net_rx, width = widths.net_rx.1),
Style::default().fg(Color::Rgb(255, 233, 193)),
),
Span::styled(
format!("{}{:>width$}", MARGIN, i.net_tx, width = widths.net_tx.1),
Style::default().fg(Color::Rgb(205, 140, 140)),
),
]);
ListItem::new(lines)
})
.collect::<Vec<_>>();
if items.is_empty() {
let debug_text = String::from("no containers running");
@@ -357,99 +448,149 @@ pub fn draw_heading_bar<B: Backend>(
f: &mut Frame<'_, B>,
has_containers: bool,
loading_icon: String,
info_visible: bool,
sorted_by: Option<(Header, SortedOrder)>,
gui_state: &Arc<Mutex<GuiState>>,
) {
let block = || Block::default().style(Style::default().bg(Color::Magenta).fg(Color::Black));
let info_visible = gui_state.lock().show_help;
f.render_widget(block(), area);
let aaa = |x: &Header| {
let mut output = "";
/// Generate a bloack for the header, if the header is currently being used to sort a column, then highlight it white
let header_block = |x: &Header| {
let mut color = Color::Black;
let mut s = "";
let mut c = 0;
if let Some((a, b)) = sorted_by.as_ref() {
if x == a {
output = match b {
SortedOrder::Asc => "A",
SortedOrder::Desc => "B",
};
match b{
SortedOrder::Asc => s=" ⌄",
SortedOrder::Desc => s=" ⌃",
}
c = 2;
color = Color::White
};
};
output
(Block::default().style(Style::default().bg(Color::Magenta).fg(color)), s, c)
};
// need to split this into blocks, and put each block in the split block, and set color to white if is selected
// then just put in the split in a horizontal fashion, with a width equal to widtrh, or char count?
// let white = "\x1b[37m";
// let reset = "\x1b[0m";
// let mut column_headings = format!(
// " {}{:>width$}{}",
// loading_icon,
// columns.state.0,
// width = columns.state.1,
// );
// Each
let mut column_headings = format!(
" {}{:>width$}",
// Create blocks for each header, count widths
let state_block = header_block(&Header::State);
let state_text = format!(
" {}{:>width$}{ic}",
loading_icon,
columns.state.0,
width = columns.state.1
);
column_headings.push_str(
format!(
"{} {:>width$}",
MARGIN,
columns.status.0,
width = columns.status.1
)
.as_str(),
ic=state_block.1,
width = columns.state.1 - state_block.2
);
let state_count = state_text.chars().count() as u16;
let state = Paragraph::new(state_text)
.block(state_block.0)
.alignment(Alignment::Left);
// Get selected and sorted
// Maybe each heading needs to be its own boock
column_headings
.push_str(format!("{}{:>width$}", MARGIN, columns.cpu.0, width = columns.cpu.1).as_str());
column_headings
.push_str(format!("{}{:>width$}", MARGIN, columns.mem.0, width = columns.mem.1).as_str());
column_headings
.push_str(format!("{}{:>width$}", MARGIN, columns.id.0, width = columns.id.1).as_str());
column_headings.push_str(
format!(
"{}{:>width$}",
MARGIN,
columns.name.0,
width = columns.name.1
)
.as_str(),
let gen_header = |x: Header, w: usize| {
let status_block = header_block(&x);
let status_text = format!(
"{} {:>width$}{ic}",
MARGIN,
x,
ic=status_block.1,
width = w - status_block.2
);
let count = status_text.chars().count() as u16;
let status = Paragraph::new(status_text)
.block(status_block.0)
.alignment(Alignment::Left);
(status, count)
};
// let (status, status_count) = gen_header(Header::Status,columns.status.1);
// let (cpu, cpu_count) = gen_header(Header::Cpu,columns.cpu.1);
// let (mem, mem_count) = gen_header(Header::Memory,columns.mem.1);
// let (id, id_count) = gen_header(Header::Id,columns.id.1);
// let (name, name_count) = gen_header(Header::Name,columns.name.1);
// let (image, image_count) = gen_header(Header::Image,columns.image.1);
// let (rx, rx_count) = gen_header(Header::Rx,columns.net_rx.1);
// let (tx, tx_count) = gen_header(Header::Tx,columns.net_tx.1);
let status_block = header_block(&Header::Status);
let status_text = format!(
"{} {:>width$}{ic}",
MARGIN,
columns.status.0,
ic=status_block.1,
width = columns.status.1 - status_block.2
);
column_headings.push_str(
format!(
"{}{:>width$}",
MARGIN,
columns.image.0,
width = columns.image.1
)
.as_str(),
let status_count = status_text.chars().count() as u16;
let status = Paragraph::new(status_text)
.block(status_block.0)
.alignment(Alignment::Left);
let cpu_text = format!("{}{:>width$}", MARGIN, columns.cpu.0, width = columns.cpu.1);
let cpu_count = cpu_text.chars().count() as u16;
let cpu = Paragraph::new(cpu_text)
.block(header_block(&Header::Cpu).0)
.alignment(Alignment::Left);
// TODO put block into the mouse click hashmap
let mem_text = format!("{}{:>width$}", MARGIN, columns.mem.0, width = columns.mem.1);
let mem_count = mem_text.chars().count() as u16;
let mem = Paragraph::new(mem_text)
.block(header_block(&Header::Memory).0)
.alignment(Alignment::Left);
let id_text = format!("{}{:>width$}", MARGIN, columns.id.0, width = columns.id.1);
let id_count = id_text.chars().count() as u16;
let id = Paragraph::new(id_text)
.block(header_block(&Header::Id).0)
.alignment(Alignment::Left);
let name_text = format!(
"{}{:>width$}",
MARGIN,
columns.name.0,
width = columns.name.1
);
column_headings.push_str(
format!(
"{}{:>width$}",
MARGIN,
columns.net_rx.0,
width = columns.net_rx.1
)
.as_str(),
let name_count = name_text.chars().count() as u16;
let name = Paragraph::new(name_text)
.block(header_block(&Header::Name).0)
.alignment(Alignment::Left);
let image_text = format!(
"{}{:>width$}",
MARGIN,
columns.image.0,
width = columns.image.1
);
column_headings.push_str(
format!(
"{}{:>width$}",
MARGIN,
columns.net_tx.0,
width = columns.net_tx.1
)
.as_str(),
let image_count = image_text.chars().count() as u16;
let image = Paragraph::new(image_text)
.block(header_block(&Header::Image).0)
.alignment(Alignment::Left);
let rx_text = format!(
"{}{:>width$}",
MARGIN,
columns.net_rx.0,
width = columns.net_rx.1
);
let rx_count = rx_text.chars().count() as u16;
let rx = Paragraph::new(rx_text)
.block(header_block(&Header::Rx).0)
.alignment(Alignment::Left);
let tx_text = format!(
"{}{:>width$}",
MARGIN,
columns.net_tx.0,
width = columns.net_tx.1
);
let tx_count = tx_text.chars().count() as u16;
let tx = Paragraph::new(tx_text)
.block(header_block(&Header::Tx).0)
.alignment(Alignment::Left);
let suffix = if info_visible { "exit" } else { "show" };
let info_text = format!("( h ) {} help {}", suffix, MARGIN);
@@ -467,12 +608,61 @@ pub fn draw_heading_bar<B: Backend>(
.direction(Direction::Horizontal)
.constraints(splits.as_ref())
.split(area);
if has_containers {
let paragraph = Paragraph::new(column_headings)
.block(block())
.alignment(Alignment::Left);
f.render_widget(paragraph, split_bar[0]);
// let a = state_text.chars().count() as u16;
// let b = status_text.chars().count() as u16;
let container_splits = vec![
Constraint::Max(state_count),
Constraint::Max(status_count),
Constraint::Max(cpu_count),
Constraint::Max(mem_count),
Constraint::Max(id_count),
Constraint::Max(name_count),
Constraint::Max(image_count),
Constraint::Max(rx_count),
Constraint::Max(tx_count),
// Constraint::Min(1)
];
// insert or update
let v = [
(Header::State,state),
(Header::Status,status),
(Header::Cpu,cpu),
(Header::Memory,mem),
(Header::Id,id),
(Header::Name,name),
(Header::Image,image),
(Header::Rx,rx),
(Header::Tx,tx)
];
let headers_section = Layout::default()
.direction(Direction::Horizontal)
.constraints(container_splits.as_ref())
.split(split_bar[0]);
for (index, (header, para)) in v.into_iter().enumerate() {
gui_state
.lock()
.insert_into_header_map(header, headers_section[index]);
f.render_widget(para, headers_section[index]);
}
// gui_state.lock()
// f.render_widget(tx, headers_section[8]);
// f.render_widget(rx, headers_section[7]);
// f.render_widget(image, headers_section[6]);
// f.render_widget(name, headers_section[5]);
// f.render_widget(id, headers_section[4]);
// f.render_widget(mem, headers_section[3]);
// f.render_widget(cpu, headers_section[2]);
// f.render_widget(status, headers_section[1]);
// f.render_widget(state, headers_section[0]);
}
let paragraph = Paragraph::new(info_text)
@@ -506,7 +696,8 @@ pub fn draw_help_box<B: Backend>(f: &mut Frame<'_, B>) {
.push_str("\n ( ↑ ↓ ) or ( j k ) or (PgUp PgDown) or (Home End) to change selected line");
help_text.push_str("\n ( enter ) to send docker container commands");
help_text.push_str("\n ( h ) to toggle this help information");
help_text.push_str("\n ( 1 - 9 ) order headers");
help_text.push_str("\n ( 0 ) stop sort");
help_text.push_str("\n ( 1 - 9 ) sort by matching header - or click header");
help_text.push_str(
"\n ( m ) to toggle mouse capture - if disabled, text on screen can be selected & copied",
);
src/ui/gui_state.rs
+30 -7
View File
@@ -1,6 +1,8 @@
use std::{collections::HashMap, fmt};
use tui::layout::{Constraint, Rect};
use crate::app_data::Header;
#[derive(Debug, PartialEq, std::hash::Hash, std::cmp::Eq, Clone, Copy)]
pub enum SelectablePanel {
Containers,
@@ -165,7 +167,8 @@ pub struct GuiState {
// Think this should be a BMapTree, so can define order when iterating over potential intersects
// Is an issue if two panels are in the same space, sush as a smaller panel embedded, yet infront of, a larger panel
// If a BMapTree think it would mean have to implement ordering for SelectablePanel
area_map: HashMap<SelectablePanel, Rect>,
panel_map: HashMap<SelectablePanel, Rect>,
heading_map: HashMap<Header, Rect>,
loading_icon: Loading,
// Should be a vec, each time loading add a new to the vec, and reset remove from vec
// for for if is_loading just check if vec is empty or not
@@ -179,7 +182,8 @@ impl GuiState {
/// Generate a default gui_state
pub fn default() -> Self {
Self {
area_map: HashMap::new(),
panel_map: HashMap::new(),
heading_map: HashMap::new(),
loading_icon: Loading::One,
selected_panel: SelectablePanel::Containers,
show_help: false,
@@ -190,13 +194,13 @@ impl GuiState {
/// clear panels hash map, so on resize can fix the sizes for mouse clicks
pub fn clear_area_map(&mut self) {
self.area_map.clear();
self.panel_map.clear();
}
/// Check if a given Rect (a clicked area of 1x1), interacts with any known panels
pub fn rect_insersects(&mut self, rect: Rect) {
pub fn panel_intersect(&mut self, rect: Rect) {
if let Some(data) = self
.area_map
.panel_map
.iter()
.filter(|i| i.1.intersects(rect))
.collect::<Vec<_>>()
@@ -206,9 +210,28 @@ impl GuiState {
}
}
/// Check if a given Rect (a clicked area of 1x1), interacts with any known panels
pub fn header_intersect(&mut self, rect: Rect) -> Option<Header> {
self.heading_map
.iter()
.filter(|i| i.1.intersects(rect))
.collect::<Vec<_>>()
.get(0)
.map(|data| data.0.to_owned())
}
/// Insert selectable gui panel into area map
pub fn insert_into_area_map(&mut self, panel: SelectablePanel, area: Rect) {
self.area_map.entry(panel).or_insert(area);
/// Remove each time, as terminal may have been resized!
pub fn insert_into_panel_map(&mut self, panel: SelectablePanel, area: Rect) {
self.panel_map.remove(&panel);
self.panel_map.insert(panel, area);
}
/// Insert selectable gui panel into area map
/// Remove each time, as terminal may have been resized!
pub fn insert_into_header_map(&mut self, header: Header, area: Rect) {
self.heading_map.remove(&header);
self.heading_map.insert(header, area);
}
/// Change to next selectable panel
src/ui/mod.rs
+5 -3
View File
@@ -154,10 +154,11 @@ fn ui<B: Backend>(
let has_containers = !app_data.lock().containers.items.is_empty();
let has_error = app_data.lock().get_error();
let log_index = app_data.lock().get_selected_log_index();
let sorted_by = app_data.lock().get_sorted();
let show_help = gui_state.lock().show_help;
let info_text = gui_state.lock().info_box_text.clone();
let loading_icon = gui_state.lock().get_loading();
let sorted_by = app_data.lock().get_sorted();
let whole_layout = Layout::default()
.direction(Direction::Vertical)
@@ -214,8 +215,9 @@ fn ui<B: Backend>(
f,
has_containers,
loading_icon,
show_help,
sorted_by,
sorted_by,
gui_state,
);
// only draw charts if there are containers