use std::sync::Arc;
use super::{ColumnPin, ExportFormat, ExportScope, HostState, SortDirection, TableColumn, TrackWidth};
#[derive(Clone, Debug, PartialEq)]
pub struct ColumnPlace {
pub id: Arc<str>,
pub hidden: bool,
pub width: Option<f32>,
pub fit: bool,
pub pin: ColumnPin,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ColumnLayout {
pub columns: Vec<ColumnPlace>,
}
impl crate::app::component::DevtoolsInspectable for ColumnLayout {}
impl ColumnLayout {
pub fn place(&self, id: &str) -> Option<&ColumnPlace> {
self.columns.iter().find(|place| &*place.id == id)
}
pub fn hidden(&self) -> impl Iterator<Item = &str> {
self.columns.iter().filter(|place| place.hidden).map(|place| &*place.id)
}
pub(super) fn full<R>(&self, columns: &[TableColumn<R>]) -> ColumnLayout {
let mut full = self.clone().valid(columns.iter().map(|column| &*column.id));
for place in &mut full.columns {
if !self.columns.iter().any(|held| held.id == place.id)
&& let Some(column) = columns.iter().find(|column| column.id == place.id)
{
place.pin = column.pin;
}
}
full
}
pub(super) fn arrange<R>(&self, columns: Vec<TableColumn<R>>) -> Vec<TableColumn<R>> {
let full = self.full(&columns);
let mut by_id: Vec<Option<TableColumn<R>>> = columns.into_iter().map(Some).collect();
let mut arranged = Vec::with_capacity(by_id.len());
for place in &full.columns {
let Some(slot) = by_id
.iter_mut()
.find(|slot| slot.as_ref().is_some_and(|column| column.id == place.id))
else {
continue;
};
let mut column = slot.take().expect("found");
if place.hidden {
continue;
}
if place.fit {
column.track.width = TrackWidth::Content;
} else if let Some(width) = place.width {
column.track.width = TrackWidth::Px(width.max(0.0));
}
column.pin = place.pin;
arranged.push(column);
}
let rank = |pin: ColumnPin| match pin {
ColumnPin::Start => 0,
ColumnPin::None => 1,
ColumnPin::End => 2,
};
arranged.sort_by_key(|column| rank(column.pin));
arranged
}
fn place_mut(&mut self, id: &str) -> Option<&mut ColumnPlace> {
self.columns.iter_mut().find(|place| &*place.id == id)
}
pub(super) fn with_hidden(mut self, id: &str, hidden: bool) -> Self {
if let Some(place) = self.place_mut(id) {
place.hidden = hidden;
}
self
}
pub(super) fn with_all_shown(mut self) -> Self {
for place in &mut self.columns {
place.hidden = false;
}
self
}
pub(super) fn with_pin(mut self, id: &str, pin: ColumnPin) -> Self {
if let Some(place) = self.place_mut(id) {
place.pin = pin;
}
self
}
pub(super) fn with_fit(mut self, id: &str) -> Self {
if let Some(place) = self.place_mut(id) {
place.fit = true;
place.width = None;
}
self
}
pub(super) fn with_width(mut self, id: &str, width: f32) -> Self {
if let Some(place) = self.place_mut(id) {
place.fit = false;
place.width = Some(width);
}
self
}
pub(super) fn with_moved(mut self, id: &str, before: Option<&str>) -> Self {
let Some(from) = self.columns.iter().position(|place| &*place.id == id) else {
return self;
};
if before == Some(id) {
return self;
}
let place = self.columns.remove(from);
let at = before
.and_then(|before| self.columns.iter().position(|place| &*place.id == before))
.unwrap_or_else(|| {
self
.columns
.iter()
.rposition(|other| !other.hidden && other.pin == place.pin)
.map_or(self.columns.len(), |last| last + 1)
});
self.columns.insert(at, place);
self
}
}
#[derive(Clone, Debug, PartialEq)]
pub(super) enum MenuChoice {
Sort(Option<SortDirection>),
Pin(ColumnPin),
Fit,
Hide,
Toggle(Arc<str>),
ShowAll,
Filter,
ClearFilter,
ClearAllFilters,
Export(ExportScope, ExportFormat),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum DropSide {
Before,
After,
}
type Choose = Arc<dyn Fn(MenuChoice) + Send + Sync>;
type Told<T> = Arc<dyn Fn(T) + Send + Sync>;
pub(super) struct ColumnMenuLink {
pub id: Arc<str>,
pub title: Arc<str>,
pub sortable: bool,
pub sorted: Option<SortDirection>,
pub pin: ColumnPin,
pub can_hide: bool,
pub columns: Vec<(Arc<str>, Arc<str>, bool)>,
pub open: bool,
pub host: Arc<HostState>,
pub choose: Choose,
pub set_open: Told<bool>,
pub move_by: Told<isize>,
pub move_to: Told<Option<usize>>,
pub place: usize,
pub labels: Arc<ColumnMenuLabels>,
pub trigger_label: String,
pub filtering: Option<(bool, bool)>,
pub filter_labels: Arc<super::FilterLabels>,
pub export: Option<super::export::ExportLink>,
}
impl HostState {
pub(super) fn drop_place(&self, x: f32) -> Option<usize> {
let refs = self.header_refs.lock();
let mut places: Vec<(usize, f32)> = refs
.iter()
.filter(|(_, element)| element.is_attached())
.map(|(column, element)| {
let (left, _, width, _) = element.rect();
(*column, left + width / 2.0)
})
.collect();
places.sort_by_key(|(column, _)| *column);
places
.into_iter()
.find(|(_, middle)| x < *middle)
.map(|(column, _)| column)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ColumnMenuLabels {
pub sort_ascending: String,
pub sort_descending: String,
pub clear_sort: String,
pub pin_start: String,
pub pin_end: String,
pub unpin: String,
pub size_to_fit: String,
pub hide: String,
pub columns: String,
pub show_all: String,
}
impl Default for ColumnMenuLabels {
fn default() -> Self {
let locale = crate::ui::current_locale();
Self {
sort_ascending: locale.data.sort_ascending.to_string(),
sort_descending: locale.data.sort_descending.to_string(),
clear_sort: locale.data.clear_sort.to_string(),
pin_start: locale.data.pin_start.to_string(),
pin_end: locale.data.pin_end.to_string(),
unpin: locale.data.unpin.to_string(),
size_to_fit: locale.data.size_to_fit.to_string(),
hide: locale.data.hide_column.to_string(),
columns: locale.data.columns.to_string(),
show_all: locale.data.show_all_columns.to_string(),
}
}
}