tvision_rs/widgets/table/
columns.rs1use std::sync::Mutex;
11
12use super::body::{TEXT_X, row_layout};
13use super::layout::MAX_COLUMN_WIDTH;
14use super::{Table, TableData};
15use crate::capture::TrackMask;
16use crate::command::Command;
17use crate::event::{Event, MouseEvent};
18use crate::menu::{Menu, popup_menu};
19use crate::view::{Context, Point, View};
20use crate::widgets::cluster::check_box;
21
22#[derive(Clone, Debug, PartialEq, Eq)]
25pub struct ColumnState {
26 pub column: usize,
29 pub order: usize,
31 pub width: i32,
33 pub flex: u16,
35 pub fixed: bool,
38 pub hidden: bool,
40}
41
42pub(super) enum HeaderDrag {
44 Resize {
47 col: usize,
48 press_x: i32,
49 start: i32,
50 changed: bool,
51 },
52 Move { col: usize, moving: bool },
56}
57
58const TOGGLE_PREFIX: &str = "tv.table_toggle_column.";
60
61fn toggle_command(col: usize) -> Command {
65 static NAMES: Mutex<Vec<&'static str>> = Mutex::new(Vec::new());
66 let mut names = NAMES.lock().unwrap_or_else(|e| e.into_inner());
67 while names.len() <= col {
68 let name = format!("{TOGGLE_PREFIX}{}", names.len());
69 names.push(Box::leak(name.into_boxed_str()));
70 }
71 Command::custom(names[col])
72}
73
74fn toggle_index(command: Command) -> Option<usize> {
76 command.name().strip_prefix(TOGGLE_PREFIX)?.parse().ok()
77}
78
79impl TableData {
80 fn visible_count(&self) -> usize {
82 self.columns.iter().filter(|c| !c.hidden).count()
83 }
84}
85
86impl Table {
87 pub fn toggle_column_command(col: usize) -> Command {
93 toggle_command(col)
94 }
95
96 pub fn column_layout(&self) -> Vec<ColumnState> {
101 let d = self.data.borrow();
102 d.columns
103 .iter()
104 .enumerate()
105 .map(|(column, c)| ColumnState {
106 column,
107 order: d.display_pos(column).unwrap_or(column),
108 width: c.width,
109 flex: c.flex,
110 fixed: c.fixed,
111 hidden: c.hidden,
112 })
113 .collect()
114 }
115
116 pub fn set_column_layout(&mut self, layout: &[ColumnState]) {
123 let mut d = self.data.borrow_mut();
124 let n = d.columns.len();
125 let mut named: Vec<&ColumnState> = layout.iter().filter(|s| s.column < n).collect();
126 named.sort_by_key(|s| s.order);
127 let mut order: Vec<usize> = Vec::with_capacity(n);
128 for s in &named {
129 if !order.contains(&s.column) {
130 order.push(s.column);
131 }
132 let c = &mut d.columns[s.column];
133 c.width = s.width.clamp(width_floor(c), MAX_COLUMN_WIDTH);
134 c.flex = s.flex;
135 c.fixed = s.fixed;
136 c.hidden = s.hidden;
137 }
138 let rest: Vec<usize> = d
139 .col_order
140 .iter()
141 .copied()
142 .filter(|c| !order.contains(c))
143 .collect();
144 order.extend(rest);
145 d.col_order = order;
146 drop(d);
147 self.needs_publish = true;
148 }
149
150 pub(super) fn header_event(&mut self, ev: &Event, ctx: &mut Context) -> bool {
153 match *ev {
154 Event::MouseDown(me) if me.position.y == 0 && self.drag.is_none() => {
155 self.header_press(me, ctx);
156 true
157 }
158 Event::MouseMove(me) if self.drag.is_some() => {
159 self.header_drag(me.position.x, ctx);
160 true
161 }
162 Event::MouseUp(me) if self.drag.is_some() => {
165 self.header_release(me.position, ctx);
166 true
167 }
168 Event::Command(c) if c == Command::TABLE_COLUMNS => {
169 self.open_column_popup(Point::new(TEXT_X, 0), ctx);
170 true
171 }
172 Event::Command(c) => match toggle_index(c) {
173 Some(col) if col < self.data.borrow().columns.len() => {
174 self.user_toggle(col, ctx);
175 true
176 }
177 _ => false,
178 },
179 _ => false,
180 }
181 }
182
183 fn header_press(&mut self, me: MouseEvent, ctx: &mut Context) {
187 if me.buttons.right {
188 self.open_column_popup(me.position, ctx);
189 return;
190 }
191 if !me.buttons.left {
192 return;
193 }
194 let x = me.position.x;
195 let drag = {
196 let d = self.data.borrow();
197 let l = row_layout(&d, self.group.state().size.x);
198 let tx = x - TEXT_X;
199 if let Some(lc) = l.separator_at(tx, d.h_offset)
200 && let Some(col) = d.model_col(lc)
201 {
202 d.columns[col].resizable.then_some(HeaderDrag::Resize {
203 col,
204 press_x: x,
205 start: l.widths[lc],
206 changed: false,
207 })
208 } else {
209 l.column_at(tx, d.h_offset)
212 .filter(|&lc| lc >= l.frozen)
213 .and_then(|lc| d.model_col(lc))
214 .map(|col| HeaderDrag::Move { col, moving: false })
215 }
216 };
217 let Some(drag) = drag else { return };
218 match self.group.state().id() {
219 Some(id) => {
220 ctx.start_mouse_track(
221 id,
222 self.abs_origin,
223 TrackMask {
224 mouse_move: true,
225 ..Default::default()
226 },
227 );
228 self.drag = Some(drag);
229 }
230 None => {
233 if let HeaderDrag::Move { col, .. } = drag {
234 let sort = self.click_sort(col);
235 self.user_sort(sort, ctx);
236 }
237 }
238 }
239 }
240
241 fn header_drag(&mut self, x: i32, ctx: &mut Context) {
243 match self.drag {
244 Some(HeaderDrag::Resize {
245 col,
246 press_x,
247 start,
248 ref mut changed,
249 }) => {
250 let mut d = self.data.borrow_mut();
251 let c = &mut d.columns[col];
252 let width = start
253 .saturating_add(x - press_x)
254 .clamp(width_floor(c), MAX_COLUMN_WIDTH);
255 if !*changed && width == start {
256 return;
257 }
258 *changed = true;
260 c.width = width;
261 c.flex = 0;
262 c.fixed = true;
263 drop(d);
264 self.publish_h(ctx);
265 }
266 Some(HeaderDrag::Move {
267 col,
268 ref mut moving,
269 }) => {
270 let mut d = self.data.borrow_mut();
271 if !*moving {
272 let off_label = d.columns[col].movable
273 && label_span(&d, self.group.state().size.x, col)
274 .is_none_or(|(s, e)| x < s || x >= e);
275 if !off_label {
276 return;
277 }
278 *moving = true;
279 }
280 let size_x = self.group.state().size.x;
281 d.drop_x = drop_gap(&d, size_x, x).and_then(|(_, gx)| gx);
282 }
283 None => {}
284 }
285 }
286
287 fn header_release(&mut self, at: Point, ctx: &mut Context) {
291 let x = at.x;
292 let Some(drag) = self.drag.take() else { return };
293 self.data.borrow_mut().drop_x = None;
294 match drag {
295 HeaderDrag::Resize { changed, .. } => {
296 if changed {
297 self.columns_changed();
298 }
299 }
300 HeaderDrag::Move { col, moving: false } => {
301 let on_label = at.y == 0
302 && label_span(&self.data.borrow(), self.group.state().size.x, col)
303 .is_some_and(|(s, e)| (s..e).contains(&x));
304 if on_label {
305 let sort = self.click_sort(col);
306 self.user_sort(sort, ctx);
307 }
308 }
309 HeaderDrag::Move { col, moving: true } => {
310 let size_x = self.group.state().size.x;
311 let moved = {
312 let mut d = self.data.borrow_mut();
313 match drop_gap(&d, size_x, x) {
314 Some((gap, _)) => move_column(&mut d, size_x, col, gap),
315 None => false,
316 }
317 };
318 if moved {
319 self.publish_h(ctx);
320 self.columns_changed();
321 }
322 }
323 }
324 }
325
326 fn open_column_popup(&mut self, at: Point, ctx: &mut Context) {
329 let menu = {
330 let d = self.data.borrow();
331 d.col_order
332 .iter()
333 .fold(Menu::builder(), |b, &c| {
334 let spec = &d.columns[c];
335 let name: String = spec.label.chars().filter(|&c| c != '~').collect();
338 let label = format!("{} {name}", check_box(!spec.hidden));
339 b.command(label, toggle_command(c))
340 })
341 .build()
342 };
343 let screen = if self.screen.x > 0 && self.screen.y > 0 {
346 self.screen
347 } else {
348 ctx.owner_size()
349 };
350 popup_menu(self.abs_origin + at, menu, screen, ctx);
351 }
352
353 fn user_toggle(&mut self, col: usize, ctx: &mut Context) {
356 {
357 let mut d = self.data.borrow_mut();
358 let hide = !d.columns[col].hidden;
359 if hide && d.visible_count() <= 1 {
360 return;
361 }
362 d.columns[col].hidden = hide;
363 }
364 self.publish_h(ctx);
365 self.columns_changed();
366 }
367
368 fn columns_changed(&mut self) {
370 self.data
371 .borrow_mut()
372 .pending
373 .push(Command::TABLE_COLUMNS_CHANGED);
374 }
375}
376
377fn width_floor(c: &super::ColumnSpec) -> i32 {
380 c.min_width.clamp(1, MAX_COLUMN_WIDTH)
381}
382
383fn label_span(d: &TableData, size_x: i32, col: usize) -> Option<(i32, i32)> {
386 let l = row_layout(d, size_x);
387 let lc = d.display_pos(col)? + l.frozen;
388 let (_, s, e) = l.spans().into_iter().find(|&(i, _, _)| i == lc)?;
389 let x = |cx| TEXT_X + l.text_x(cx, d.h_offset);
390 Some((x(s), x(e)))
391}
392
393fn drop_gap(d: &TableData, size_x: i32, x: i32) -> Option<(usize, Option<i32>)> {
398 let l = row_layout(d, size_x);
399 let spans = l.spans();
400 let last = spans.last()?.2;
401 let cx = (x - TEXT_X - l.frozen_width).saturating_add(l.clamp(d.h_offset));
403 let gap = spans
404 .iter()
405 .position(|&(_, s, e)| cx < s + (e - s) / 2)
406 .unwrap_or(spans.len());
407 let mark = spans.get(gap).map_or(last, |&(_, s, _)| s - 1);
409 let gx = TEXT_X + l.text_x(mark, d.h_offset);
410 let lo = TEXT_X + l.frozen_width - 1;
412 let hi = (TEXT_X + l.frozen_width + l.view).min(size_x - 1);
413 Some((gap, (lo..=hi).contains(&gx).then_some(gx.max(0))))
414}
415
416fn move_column(d: &mut TableData, size_x: i32, col: usize, gap: usize) -> bool {
420 let l = row_layout(d, size_x);
421 let visible: Vec<usize> = l
422 .spans()
423 .into_iter()
424 .filter_map(|(lc, _, _)| d.model_col(lc))
425 .collect();
426 let before = visible.get(gap).copied();
427 let after = gap.checked_sub(1).and_then(|g| visible.get(g)).copied();
428 if before == Some(col) || after == Some(col) {
429 return false;
430 }
431 let Some(from) = d.display_pos(col) else {
432 return false;
433 };
434 d.col_order.remove(from);
435 let to = match (before, after) {
436 (Some(b), _) => d.display_pos(b),
437 (None, Some(a)) => d.display_pos(a).map(|p| p + 1),
438 (None, None) => None,
439 };
440 match to {
441 Some(to) => d.col_order.insert(to, col),
442 None => {
443 d.col_order.insert(from, col);
444 return false;
445 }
446 }
447 true
448}