use std::collections::{HashMap, HashSet};
use crate::{
config::{Band, Breakpoint, Config, Saved},
model::{
Group, GroupId, PanelId,
packed::{DragSource, DropTarget, GridState, MinSize, PackedGrid},
serial,
},
persist,
};
const REM_PX: f64 = 16.0;
const DRAG_THRESHOLD: f64 = 4.0;
pub struct PackedState {
grid: PackedGrid,
cols: u32,
step_px: (f64, f64),
rem_px: f64,
breakpoint: Breakpoint,
drag: Option<Drag>,
resize: Option<ResizeStart>,
root_origin: (f64, f64),
root_size: (f64, f64),
focused: Option<GroupId>,
maximized: Option<GroupId>,
help: bool,
popups: HashSet<GroupId>,
undo: UndoHistory,
shown: Option<Band>,
#[cfg(target_arch = "wasm32")]
root: Option<web_sys::Element>,
cfg: Config,
}
impl PackedState {
pub fn new(cfg: Config) -> Self {
let cols = cfg.steps.max(1);
Self {
grid: PackedGrid::default(),
cols,
step_px: (0.0, 0.0),
rem_px: REM_PX,
breakpoint: Breakpoint::default(),
drag: None,
resize: None,
root_origin: (0.0, 0.0),
root_size: (0.0, 0.0),
focused: None,
maximized: None,
help: false,
popups: HashSet::new(),
undo: UndoHistory::default(),
shown: None,
#[cfg(target_arch = "wasm32")]
root: None,
cfg,
}
}
#[cfg(target_arch = "wasm32")]
pub fn set_root(&mut self, el: web_sys::Element) {
self.root = Some(el);
}
#[cfg(target_arch = "wasm32")]
fn tab_drop_index(&self, mx: f64, group: u64, dragged: &[String]) -> Option<usize> {
use wasm_bindgen::JsCast;
let root = self.root.as_ref().expect("binding sets the root at mount, before any drag");
let nodes = root.query_selector_all(&format!("[data-dvg=\"{group}\"] .dv-tab")).expect("numeric-only selector");
let mut idx = 0;
for i in 0..nodes.length() {
let el = nodes.get(i).expect("index below length").dyn_into::<web_sys::Element>().expect("selector matches elements");
if dragged.iter().any(|p| *p == el.get_attribute("data-panel").unwrap_or_default()) {
continue;
}
let r = el.get_bounding_client_rect();
if mx > r.x() + r.width() / 2.0 {
idx += 1;
}
}
Some(idx)
}
#[cfg(not(target_arch = "wasm32"))]
fn tab_drop_index(&self, _: f64, _: u64, _: &[String]) -> Option<usize> {
None
}
pub fn place(&mut self, group: Group, w: u32, h: u32, min: MinSize) {
let (sw, sh) = self.step_px;
assert!(sw > 0.0 && sh > 0.0, "place before the first measure: no step size yet");
self.grid.place(group, w, h, min.resolve(sw, sh, self.rem_px), self.cols);
}
pub fn set_min(&mut self, panel: &PanelId, min: MinSize) {
let (sw, sh) = self.step_px;
assert!(sw > 0.0 && sh > 0.0, "set_min before the first measure: no step size yet");
self.grid.set_min(panel, min.resolve(sw, sh, self.rem_px), self.cols);
}
pub fn add_tab(&mut self, group: GroupId, panel: PanelId) {
self.grid.add_tab(group, panel);
}
pub fn close_active(&mut self, group: GroupId) {
self.grid.close_active(group);
}
pub fn resize(&mut self, idx: usize, new_w: u32, new_h: u32) {
self.grid.resize(idx, new_w, new_h, self.cols);
}
pub fn save(&self) -> String {
serial::save(&self.grid)
}
pub fn load(&mut self, json: &str) -> Result<(), serial::LoadError> {
self.grid = serial::load(json)?;
self.grid.refit(self.cols);
Ok(())
}
pub fn mint_group_id(&mut self) -> GroupId {
self.grid.mint_group_id()
}
pub fn cols(&self) -> u32 {
self.cols
}
pub fn band(&self) -> Band {
self.breakpoint.band()
}
pub fn title_h(&self) -> f64 {
self.cfg.title_h_rem * self.rem_px
}
pub fn grid(&self) -> &PackedGrid {
&self.grid
}
pub fn reset(&mut self) {
self.grid = PackedGrid::default();
self.drag = None;
self.resize = None;
}
pub fn set_measure(&mut self, origin: (f64, f64), size: (f64, f64)) {
self.root_origin = origin;
self.root_size = size;
self.rem_px = root_font_px();
let (width, height) = size;
if width <= 0.0 || height <= 0.0 {
return;
}
let steps = self.cfg.steps.max(1);
let rows = self.cfg.rows.max(1);
let bp = Breakpoint::of(width);
let c = bp.scale_cols(steps);
self.breakpoint = bp;
if self.cols != c {
self.cols = c;
self.grid.refit(c);
}
self.step_px = (width / c as f64, height / rows as f64);
}
pub fn wants_undo_snapshot(&self) -> bool {
self.drag.is_none() && self.grid.state == GridState::Settled && !self.grid.cells.is_empty() && self.undo.states.get(self.undo.cursor) != Some(&self.grid)
}
pub fn capture_undo(&mut self) {
if self.drag.is_some() {
return;
}
if self.grid.state != GridState::Settled || self.grid.cells.is_empty() {
return;
}
if self.undo.states.get(self.undo.cursor) == Some(&self.grid) {
return;
}
self.undo.push(self.grid.clone());
}
pub fn take_band(&mut self) -> Option<bool> {
let band = self.band();
if self.step_px.0 <= 0.0 || self.shown == Some(band) {
return None;
}
self.shown = Some(band);
self.reset();
let Some(key) = self.cfg.storage_key.as_ref().map(|k| format!("{k}-{band}")) else {
return Some(false);
};
let Some(json) = persist::read(&key) else { return Some(false) };
match serial::load(&json) {
Ok(grid) if grid.cells.is_empty() => {
report(&format!("dockview: cached layout at {key:?} is empty; re-seeding"));
Some(false)
}
Ok(grid) => {
self.grid = grid;
self.grid.refit(self.cols);
Some(true)
}
Err(e) => {
report(&format!("dockview: cached layout at {key:?} is unusable ({e:?}); re-seeding"));
Some(false)
}
}
}
pub fn press_tile(&mut self, gid: GroupId, start: (f64, f64), grab: (f64, f64)) {
self.focused = Some(gid);
let (w, h) = self.grid.cells.iter().find(|c| c.group.id == gid).map(|c| (c.w, c.h)).expect("press_tile: group exists");
self.drag = Some(Drag {
source: DragSource::Tile(gid),
src_w: w,
src_h: h,
start,
grab,
cursor: start,
armed: false,
target: None,
});
}
pub fn press_tab(&mut self, panel: PanelId, from: GroupId, start: (f64, f64), grab: (f64, f64)) {
self.focused = Some(from);
let (w, h) = self.grid.cells.iter().find(|c| c.group.id == from).map(|c| (c.w, c.h)).expect("press_tab: group exists");
self.drag = Some(Drag {
source: DragSource::Tab { panel, from },
src_w: w,
src_h: h,
start,
grab,
cursor: start,
armed: false,
target: None,
});
}
pub fn drag_move(&mut self, cursor: (f64, f64), scroll_y: f64) {
let Some(mut d) = self.drag.clone() else { return };
d.cursor = cursor;
if !d.armed {
let (dx, dy) = (cursor.0 - d.start.0, cursor.1 - d.start.1);
if (dx * dx + dy * dy).sqrt() <= DRAG_THRESHOLD {
return;
}
d.armed = true;
}
let (ox, oy) = self.root_origin;
let (sw, sh) = self.step_px;
let cx = cursor.0 - d.grab.0 + d.src_w as f64 * sw / 2.0;
let cy = cursor.1 - d.grab.1 + d.src_h as f64 * sh / 2.0;
let mut t = self.grid.resolve_target(
&d.source,
cx - ox,
cy - oy + scroll_y,
cursor.0 - ox,
cursor.1 - oy + scroll_y,
sw,
sh,
self.title_h(),
self.cols,
d.src_w,
d.src_h,
);
if let DropTarget::Tab { group, index } = t {
let dragged: Vec<String> = match &d.source {
DragSource::Tab { panel, .. } => vec![panel.0.clone()],
DragSource::Tile(g) => self
.grid
.cells
.iter()
.find(|c| c.group.id == *g)
.expect("drag source group exists")
.group
.tabs
.iter()
.map(|p| p.0.clone())
.collect(),
};
t = DropTarget::Tab {
group,
index: self.tab_drop_index(cursor.0, group.0, &dragged).unwrap_or(index),
};
}
d.target = Some(t);
self.drag = Some(d);
}
pub fn drag_release(&mut self) {
let Some(d) = self.drag.take() else { return };
if d.armed {
if let Some(t) = d.target {
self.grid.drop(d.source, t, self.cols);
}
} else if let DragSource::Tab { panel, from } = &d.source
&& let Some(c) = self.grid.cells.iter_mut().find(|c| c.group.id == *from)
&& let Some(i) = c.group.tabs.iter().position(|p| p == panel)
{
c.group.active = i;
}
}
pub fn drag_cancel(&mut self) {
self.drag = None;
}
pub fn resize_start(&mut self, idx: usize, px: f64, py: f64) {
let (w, h) = {
let c = &self.grid.cells[idx];
(c.w, c.h)
};
self.resize = Some(ResizeStart { idx, px, py, w, h });
self.grid.state = GridState::Resizing;
}
pub fn resize_move(&mut self, cursor: (f64, f64)) {
let Some(s) = self.resize else { return };
let (sw, sh) = self.step_px;
let dw = ((cursor.0 - s.px) / sw).round() as i64;
let dh = ((cursor.1 - s.py) / sh).round() as i64;
let nw = (s.w as i64 + dw).max(1) as u32;
let nh = (s.h as i64 + dh).max(1) as u32;
self.grid.resize(s.idx, nw, nh, self.cols);
}
pub fn resize_end(&mut self) {
if self.resize.is_none() {
return;
}
self.resize = None;
self.grid.state = GridState::Settled;
}
pub fn focus(&mut self, gid: GroupId) {
self.focused = Some(gid);
}
fn live(&self, gid: Option<GroupId>) -> Option<GroupId> {
gid.filter(|g| self.grid.cells.iter().any(|c| c.group.id == *g))
}
fn restore(&mut self, dir: i32) {
if let Some(mut g) = self.undo.step(dir) {
g.refit(self.cols);
self.grid = g;
}
}
pub fn close_help(&mut self) {
self.help = false;
}
pub fn dragging(&self) -> bool {
self.drag.is_some()
}
pub fn resizing(&self) -> bool {
self.resize.is_some()
}
pub fn help_open(&self) -> bool {
self.help
}
pub fn on_key(&mut self, key: &str, alt: bool, ctrl: bool, cursor: (f64, f64), scroll_y: f64) -> KeyOutcome {
let recognized = |action: &str| {
debug_assert!(!action.is_empty(), "every recognized chord names its action");
#[cfg(target_arch = "wasm32")]
web_sys::console::debug_1(&format!("dockview keybind: {key:?} (alt={alt}, ctrl={ctrl}) → {action}").into());
};
let prevent = |b: bool| KeyOutcome { prevent_default: b };
let kb = self.cfg.keybinds;
if key == "Escape" && (self.help || !self.popups.is_empty()) {
recognized("Escape");
self.help = false;
self.popups.clear();
return prevent(true);
}
if kb.undo.matches(key, alt, ctrl) {
recognized("undo");
self.restore(-1);
return prevent(true);
}
if kb.redo.matches(key, alt, ctrl) {
recognized("redo");
self.restore(1);
return prevent(true);
}
if kb.close.matches(key, alt, ctrl) {
recognized("close");
if let Some(g) = self.live(self.focused) {
self.close_active(g);
return prevent(true);
}
return prevent(false);
}
if kb.maximize.matches(key, alt, ctrl) {
recognized("maximize");
if let Some(f) = self.live(self.focused) {
self.maximized = if self.maximized == Some(f) { None } else { Some(f) };
return prevent(true);
}
return prevent(false);
}
if kb.help.matches(key, alt, ctrl) {
recognized("help");
self.help = !self.help;
return prevent(true);
}
if key == "d" && !alt && !ctrl {
recognized("inspect");
let (cx, cy) = cursor;
let (ox, oy) = self.root_origin;
let (sw, sh) = self.step_px;
let hit = self.live(self.maximized).or_else(|| {
self.grid
.cells
.iter()
.find(|c| {
let (gx, gy) = (cx - ox, cy - oy + scroll_y);
gx >= c.x as f64 * sw && gx < (c.x + c.w) as f64 * sw && gy >= c.y as f64 * sh && gy < (c.y + c.h) as f64 * sh
})
.map(|c| c.group.id)
});
if let Some(gid) = hit {
if !self.popups.remove(&gid) {
self.popups.insert(gid);
}
return prevent(true);
}
return prevent(false);
}
if kb.save.matches(key, alt, ctrl) {
recognized("save");
let band = self.band();
if let Some(k) = self.cfg.storage_key.as_ref() {
persist::write(&format!("{k}-{band}"), &self.save());
}
if let Some(hook) = self.cfg.on_save.clone() {
hook(Saved::Cached { band });
}
return prevent(true);
}
if kb.publish.matches(key, alt, ctrl)
&& let Some(hook) = self.cfg.on_save.clone()
{
recognized("publish");
hook(Saved::Published {
band: self.band(),
json: self.save(),
});
return prevent(true);
}
let actions = std::mem::take(&mut self.cfg.actions);
let mut prevent_default = false;
for (bind, run) in &actions {
if bind.matches(key, alt, ctrl) {
recognized("custom-action");
run(self);
prevent_default = true;
break;
}
}
self.cfg.actions = actions;
prevent(prevent_default)
}
fn preview(&self) -> PackedGrid {
let g = self.grid.clone();
match &self.drag {
Some(d) if d.armed => match &d.target {
Some(t) => {
let mut p = g;
p.drop(d.source.clone(), t.clone(), self.cols);
p
}
None => g,
},
_ => g,
}
}
pub fn frames(&self, titles: &HashMap<PanelId, String>) -> Vec<Frame> {
let g = self.preview();
let (sw, sh) = self.step_px;
let maximized = self.live(self.maximized);
let mut out = Vec::new();
for (idx, cell) in g.cells.iter().enumerate() {
let gid = cell.group.id;
if let Some(mg) = maximized
&& mg != gid
{
continue;
}
let style = if maximized == Some(gid) {
"left:0; top:0; width:100%; height:100%;".to_string()
} else {
format!(
"left:{}px; top:{}px; width:{}px; height:{}px;",
cell.x as f64 * sw,
cell.y as f64 * sh,
cell.w as f64 * sw,
cell.h as f64 * sh
)
};
let (shadow, tab_drop) = self.drop_flags(gid, cell);
if shadow {
out.push(Frame {
gid,
idx,
style,
shadow: true,
tab_drop: false,
tabs: Vec::new(),
});
continue;
}
let tabs = cell
.group
.tabs
.iter()
.enumerate()
.map(|(i, id)| Tab {
id: id.clone(),
title: titles.get(id).cloned().unwrap_or_default(),
active: i == cell.group.active,
})
.collect();
out.push(Frame {
gid,
idx,
style,
shadow: false,
tab_drop,
tabs,
});
}
out
}
fn drop_flags(&self, gid: GroupId, cell: &crate::model::packed::Cell) -> (bool, bool) {
match &self.drag {
Some(d) if d.armed => match &d.target {
Some(DropTarget::Tab { group, .. }) => (false, *group == gid),
Some(DropTarget::Displace { .. }) | Some(DropTarget::Pack { .. }) => {
let src = match &d.source {
DragSource::Tile(g) => *g == gid,
DragSource::Tab { panel, .. } => cell.group.tabs.iter().any(|p| p == panel),
};
(src, false)
}
None => (false, false),
},
_ => (false, false),
}
}
pub fn content_slots(&self) -> HashMap<PanelId, ContentSlot> {
let g = self.preview();
let (sw, sh) = self.step_px;
let hidden = self.ghost_hidden(&g);
let maximized = self.live(self.maximized);
let mut map = HashMap::new();
for cell in &g.cells {
let active = cell.group.active_panel().clone();
for id in &cell.group.tabs {
let style = if hidden.contains(id) {
"display:none;".to_string()
} else {
slot_style(maximized, cell.group.id, cell.x, cell.y, cell.w, cell.h, id == &active, sw, sh, self.title_h())
};
map.insert(id.clone(), ContentSlot { style, group: cell.group.id });
}
}
map
}
fn ghost_hidden(&self, preview: &PackedGrid) -> HashSet<PanelId> {
match &self.drag {
Some(d) if d.armed => match &d.source {
DragSource::Tile(g) => preview
.cells
.iter()
.find(|c| c.group.id == *g)
.map(|c| c.group.tabs.iter().cloned().collect())
.unwrap_or_default(),
DragSource::Tab { panel, .. } => std::iter::once(panel.clone()).collect(),
},
_ => HashSet::new(),
}
}
pub fn ghost(&self, titles: &HashMap<PanelId, String>) -> Option<Ghost> {
let d = self.drag.as_ref().filter(|d| d.armed)?;
let title = match &d.source {
DragSource::Tile(g) => self
.grid
.cells
.iter()
.find(|c| c.group.id == *g)
.map(|c| titles.get(c.group.active_panel()).cloned().unwrap_or_default())
.unwrap_or_default(),
DragSource::Tab { panel, .. } => titles.get(panel).cloned().unwrap_or_default(),
};
let (sw, sh) = self.step_px;
Some(Ghost {
title,
left: d.cursor.0 - d.grab.0,
top: d.cursor.1 - d.grab.1,
w: d.src_w as f64 * sw,
h: d.src_h as f64 * sh,
})
}
pub fn inspect(&self) -> Vec<(String, String)> {
let g = self.preview();
let (sw, sh) = self.step_px;
g.cells
.iter()
.filter(|c| self.popups.contains(&c.group.id))
.map(|c| {
(
format!(
"left:{}px; top:{}px; width:{}px; height:{}px;",
c.x as f64 * sw,
c.y as f64 * sh,
c.w as f64 * sw,
c.h as f64 * sh
),
format!("{}x{}", c.w, c.h),
)
})
.collect()
}
pub fn help_rows(&self) -> Vec<(&'static str, String)> {
let kb = self.cfg.keybinds;
[
("Undo", kb.undo),
("Redo", kb.redo),
("Close pane", kb.close),
("Maximize pane", kb.maximize),
("Toggle this hint", kb.help),
("Save layout", kb.save),
]
.into_iter()
.chain(self.cfg.on_save.is_some().then_some(("Publish layout", kb.publish)))
.map(|(label, b)| (label, format!("{}{}{}", if b.ctrl { "Ctrl+" } else { "" }, if b.alt { "Alt+" } else { "" }, b.key)))
.chain(std::iter::once(("Inspect pane", "d".into())))
.collect()
}
}
pub struct Frame {
pub gid: GroupId,
pub idx: usize,
pub style: String,
pub shadow: bool,
pub tab_drop: bool,
pub tabs: Vec<Tab>,
}
pub struct Tab {
pub id: PanelId,
pub title: String,
pub active: bool,
}
pub struct ContentSlot {
pub style: String,
pub group: GroupId,
}
pub struct Ghost {
pub title: String,
pub left: f64,
pub top: f64,
pub w: f64,
pub h: f64,
}
pub struct KeyOutcome {
pub prevent_default: bool,
}
fn report(msg: &str) {
#[cfg(target_arch = "wasm32")]
web_sys::console::error_1(&msg.into());
#[cfg(not(target_arch = "wasm32"))]
eprintln!("{msg}");
}
fn slot_style(maximized: Option<GroupId>, group: GroupId, x: u32, y: u32, w: u32, h: u32, active: bool, step_w: f64, step_h: f64, chrome_h: f64) -> String {
if let Some(mg) = maximized {
if group != mg || !active {
return "display:none;".into();
}
return format!("display:block; left:0; top:{chrome_h}px; width:100%; height:calc(100% - {chrome_h}px);");
}
if !active {
return "display:none;".into();
}
let (left, top) = (x as f64 * step_w, y as f64 * step_h);
let (width, height) = (w as f64 * step_w, h as f64 * step_h);
format!("display:block; left:{left}px; top:calc({top}px + {chrome_h}px); width:{width}px; height:calc({height}px - {chrome_h}px);")
}
#[cfg(target_arch = "wasm32")]
fn root_font_px() -> f64 {
let win = web_sys::window().expect("a browser window");
let root = win.document().expect("a document").document_element().expect("a document element");
let style = win
.get_computed_style(&root)
.expect("our own document element is never cross-origin")
.expect("a rendered root has a style declaration");
style
.get_property_value("font-size")
.expect("property lookup never throws")
.trim_end_matches("px")
.parse()
.expect("computed font-size is an absolute px length")
}
#[cfg(not(target_arch = "wasm32"))]
fn root_font_px() -> f64 {
REM_PX
}
#[derive(Clone)]
struct Drag {
source: DragSource,
src_w: u32,
src_h: u32,
start: (f64, f64),
grab: (f64, f64),
cursor: (f64, f64),
armed: bool,
target: Option<DropTarget>,
}
#[derive(Clone, Copy)]
struct ResizeStart {
idx: usize,
px: f64,
py: f64,
w: u32,
h: u32,
}
#[derive(Default)]
struct UndoHistory {
states: Vec<PackedGrid>,
cursor: usize,
}
impl UndoHistory {
fn push(&mut self, g: PackedGrid) {
if !self.states.is_empty() {
self.states.truncate(self.cursor + 1);
}
self.states.push(g);
self.cursor = self.states.len() - 1;
}
fn step(&mut self, dir: i32) -> Option<PackedGrid> {
let next = self.cursor.checked_add_signed(dir as isize)?;
let g = self.states.get(next)?.clone();
self.cursor = next;
Some(g)
}
}