A drawing app built for agent/human collaboration
Rust
use super::clips::{self, Hit, Strip};
use super::layers::{self, LayerRow};
use super::tweens::{self, Span};
use super::{Editor, ms};
use crate::commands::Cmd;
use crate::composite::CanvasDone;
use crate::frames::Player;
use crate::messages::Tone;
use crate::theme::{self, Hint, icon};
use anyhow::Result;
use egui::{Align2, Color32, FontId, Key, Pos2, Rect, RichText, Sense, Stroke, pos2, vec2};
use klad_core::doc::{Cel, Kind, Layer, Loc, MASK};
use klad_core::ops::{Op, Place};
use klad_core::timing::{CelAction, CelSpec, FrameSpec, OPEN, ends};
use klad_render::onion::By;
use serde_json::{Map, json};
use std::collections::BTreeSet;
use std::sync::mpsc::{Receiver, RecvTimeoutError, TryRecvError, channel};
use std::time::{Duration, Instant};
const ROW: f32 = crate::theme::ROW;
const RULER: f32 = 18.0;
const NAMES: f32 = 236.0;
const EDGE: f32 = 8.0;
const PAST: f32 = 14.0;
const GRIP: f32 = 7.0;
const SETTLE: Duration = Duration::from_millis(150);
const FLIP_PX: f32 = 22.0;
const AHEAD: u32 = 4;
const PEN_WAIT: Duration = Duration::from_millis(60);
pub(super) const OPEN_WAIT: Duration = Duration::from_millis(400);
pub(super) const FILL: usize = 64;
pub(super) struct CanvasWait {
asked: u64,
frame: u32,
active: Vec<usize>,
rev: u64,
rx: Receiver<Result<CanvasDone>>,
since: Instant,
}
#[derive(Clone, Debug, PartialEq)]
enum Drag {
Scrub,
Range {
from: u32,
to: u32,
},
Hold {
layer: String,
cel: String,
start: u32,
end: u32,
open: bool,
to: u32,
},
Move {
cel: String,
from: u32,
to: u32,
},
NewClip {
from: u32,
to: u32,
},
Select {
from: u32,
to: u32,
first: usize,
last: usize,
},
ClipEnd {
index: usize,
name: String,
first: bool,
from: u32,
to: u32,
},
}
pub(super) struct Flip {
origin: u32,
x: f32,
}
pub(super) struct Timeline {
cell: f32,
drag: Option<Drag>,
pub folded: BTreeSet<String>,
pub masks: BTreeSet<String>,
fps: u32,
length: u32,
pub range: Option<(u32, u32)>,
pub on: u32,
pub player: Option<Player>,
pub playing: String,
moved_at: Instant,
step_start: Option<Instant>,
pub canvas_frame: Option<u32>,
pub kept: Option<(u32, u64, u64)>,
pub on_screen: Option<u32>,
shown_key: Option<u64>,
flip: Option<Flip>,
pub roll: Option<u32>,
direction: i32,
cache_rev: u64,
pub clip: Option<String>,
pub clip_name: (String, String),
pub clip_fps: u32,
pub godot: (String, String),
pub span: Option<Span>,
pub ask: tweens::Ask,
pub cells: Option<Vec<super::cells::CellCopy>>,
pub geom: Option<Geom>,
}
impl Default for Timeline {
fn default() -> Self {
Self {
cell: 18.0,
drag: None,
folded: BTreeSet::new(),
masks: BTreeSet::new(),
fps: 0,
length: 0,
range: None,
on: 2,
player: None,
playing: String::new(),
moved_at: Instant::now(),
step_start: None,
canvas_frame: None,
kept: None,
on_screen: None,
shown_key: None,
flip: None,
roll: None,
direction: 0,
cache_rev: u64::MAX,
clip: None,
clip_name: (String::new(), String::new()),
clip_fps: 0,
godot: (String::new(), String::new()),
span: None,
ask: tweens::Ask::default(),
cells: None,
geom: None,
}
}
}
fn span_of(
rows: &[LayerRow],
(from, to): (u32, u32),
(first, last): (usize, usize),
anchor: (u32, usize),
) -> Option<Span> {
let (a, b) = (first.min(last), first.max(last));
let ids: Vec<String> = rows[a..=b.min(rows.len().saturating_sub(1))]
.iter()
.filter(|r| matches!(r.kind, Kind::Paint | Kind::Vector))
.map(|r| r.id.clone())
.collect();
(!ids.is_empty()).then(|| Span {
from: from.min(to),
to: from.max(to),
rows: ids,
anchor,
})
}
#[derive(Clone, Debug, PartialEq)]
struct Block {
cel: String,
link: Option<String>,
start: u32,
end: u32,
open: bool,
tween: bool,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub(super) struct Geom {
left: f32,
top: f32,
cell: f32,
frames: u32,
rows: usize,
}
impl Geom {
fn x_of(&self, f: u32) -> f32 {
self.left + f as f32 * self.cell
}
pub(super) fn cell_centre(&self, f: u32, row: usize) -> Pos2 {
pos2(
self.x_of(f) + self.cell / 2.0,
self.top + RULER + ROW * (row as f32 + 0.5),
)
}
fn frame_at(&self, x: f32) -> u32 {
(((x - self.left) / self.cell).floor().max(0.0) as u32).min(self.frames.saturating_sub(1))
}
fn row_at(&self, y: f32) -> Option<usize> {
(y >= self.top + RULER)
.then(|| ((y - self.top - RULER) / ROW).floor() as usize)
.filter(|r| *r < self.rows)
}
}
#[derive(Clone, Debug, PartialEq)]
enum Press {
Ruler(u32),
End(usize, Block),
Start(usize, Block),
Cell(usize, u32),
}
fn press_at(g: &Geom, blocks: &[Vec<Block>], p: Pos2) -> Option<Press> {
if p.y < g.top {
return None;
}
let f = g.frame_at(p.x);
let Some(r) = g.row_at(p.y) else {
return Some(Press::Ruler(f));
};
let list = blocks.get(r)?;
if let Some(b) = list
.iter()
.find(|b| (p.x - g.x_of(b.end)).abs() <= EDGE && p.x > g.x_of(b.start) + g.cell / 2.0)
{
return Some(Press::End(r, b.clone()));
}
match list.iter().find(|b| b.start <= f && f < b.end) {
Some(b) if b.start == f && g.cell_centre(f, r).distance(p) <= GRIP => Some(Press::Start(r, b.clone())),
_ => Some(Press::Cell(r, f)),
}
}
fn drag_of(press: &Press, shift: bool, layer: impl Fn(usize) -> String) -> Drag {
match press {
Press::Ruler(f) if shift => Drag::Range { from: *f, to: *f },
Press::Ruler(_) => Drag::Scrub,
Press::End(r, b) => Drag::Hold {
layer: layer(*r),
cel: b.cel.clone(),
start: b.start,
end: b.end,
open: b.open,
to: b.end,
},
Press::Start(_, b) => Drag::Move {
cel: b.cel.clone(),
from: b.start,
to: b.start,
},
Press::Cell(r, f) => Drag::Select {
from: *f,
to: *f,
first: *r,
last: *r,
},
}
}
fn blocks(layer: &Layer, frames: u32) -> Vec<Block> {
let cels = layer.cels();
cels.iter()
.zip(ends(cels))
.filter(|(c, _)| c.frame < frames)
.map(|(c, end)| Block {
cel: c.id.clone(),
link: c.link.clone(),
start: c.frame,
end: end.min(frames),
open: end == OPEN,
tween: c.tween.is_some(),
})
.collect()
}
fn exposed(layer: &Layer, frame: u32) -> Option<(Cel, u32)> {
let cels = layer.cels();
cels.iter()
.zip(ends(cels))
.find(|(c, e)| c.frame <= frame && frame < *e)
.map(|(c, e)| (c.clone(), e))
}
impl Editor {
pub(super) fn busy(&self) -> bool {
self.live.is_some() || self.drag.is_some() || self.point_drag.is_some() || self.path_commit.is_some()
}
pub(crate) fn canvas_current(&self) -> bool {
self.timeline.canvas_frame == Some(self.scene.frame) && !self.scene.stale
}
pub(super) fn cacheable(&self) -> bool {
!(self.scene.active_is_mask() && self.scene.tint_mask)
}
pub(super) fn go_to(&mut self, frame: u32) -> Result<()> {
if self.timeline.player.is_some() {
self.stop_playback();
}
let last = self.scene.bundle.doc.timeline.frames - 1;
let frame = frame.min(last);
if self.busy() || frame == self.scene.frame {
return Ok(());
}
self.timeline.direction = if frame > self.scene.frame { 1 } else { -1 };
self.scene.move_to(frame);
let now = Instant::now();
self.timeline.moved_at = now;
self.timeline.step_start = Some(now);
self.selection = None;
self.picked = None;
self.direct = None;
self.cut_view = None;
self.lasso = None;
self.drop_preview();
Ok(())
}
pub(super) fn invalidate_canvas(&mut self) {
self.canvas_gen += 1;
self.scene.stale = true;
}
pub(super) fn canvas_loading(&self) -> bool {
self.canvas_wait.as_ref().is_some_and(|w| w.frame == self.scene.frame) && !self.canvas_current()
}
fn canvas_wanted(&self, wait: &CanvasWait) -> bool {
wait.asked == self.canvas_gen
&& wait.frame == self.scene.frame
&& wait.active == self.scene.active
&& wait.rev == self.scene.bundle.doc.rev
}
pub(super) fn request_canvas(&mut self) {
if self.canvas_wait.is_some() {
return;
}
let mut request = self.scene.canvas_request(&self.brushes);
if self.cacheable() {
let (frame, onion) = (self.scene.frame, self.scene.onion_on);
let key = self.frames.key(&mut self.scene, frame, onion, &self.brushes);
request = request.with_picture(
key,
self.frames.level,
self.scene.pictures(),
self.buffering.writes.clone(),
);
}
let (tx, rx) = channel();
let ctx = self.ctx.clone();
std::thread::spawn(move || {
let _ = tx.send(crate::background().install(|| request.run()));
ctx.request_repaint();
});
self.canvas_wait = Some(CanvasWait {
asked: self.canvas_gen,
frame: self.scene.frame,
active: self.scene.active.clone(),
rev: self.scene.bundle.doc.rev,
rx,
since: Instant::now(),
});
}
pub(super) fn tend_canvas(&mut self, wait: Duration) -> Result<()> {
let Some(pending) = self.canvas_wait.as_ref() else {
return Ok(());
};
let received = match wait.is_zero() {
true => pending.rx.try_recv().map_err(|e| e == TryRecvError::Disconnected),
false => pending
.rx
.recv_timeout(wait)
.map_err(|e| e == RecvTimeoutError::Disconnected),
};
let result = match received {
Ok(result) => result,
Err(gone) => {
if gone {
self.canvas_wait = None;
}
return Ok(());
}
};
let Some(pending) = self.canvas_wait.take() else {
return Ok(());
};
let mut done = match result {
Ok(done) => done,
Err(e) => {
self.failed(e.context(format!("frame {} could not be loaded", pending.frame)));
return Ok(());
}
};
let wanted = self.canvas_wanted(&pending);
let (frame, loaded) = (done.frame, done.loaded);
self.frames.heavy |= done.bytes > crate::frames::HEAVY;
self.scene.lean = self.frames.heavy;
let thumbs = std::mem::take(&mut done.thumbs);
let unchanged = self.timeline.kept.take() == Some((done.frame, self.scene.bundle.doc.rev, pending.asked))
&& self.timeline.canvas_frame == Some(done.frame);
if self.scene.adopt(done, wanted) {
self.keep_thumbs(thumbs);
if !unchanged {
self.dirty.extend(self.scene.all_tiles());
}
self.timeline.canvas_frame = Some(self.scene.frame);
self.measure(
"canvas",
format!(
"frame {frame} ready to draw on {:.0} ms after it was asked for ({loaded} drawings loaded for it, {} strokes and fills in memory)",
ms(pending.since),
self.scene.total_marks()
),
);
}
Ok(())
}
fn catch_up(&mut self, wait: Duration) -> Result<bool> {
if self.canvas_current() {
return Ok(true);
}
if !self.scene.stale && self.scene.has_frame(self.scene.frame) {
self.dirty.extend(self.scene.all_tiles());
self.timeline.canvas_frame = Some(self.scene.frame);
return Ok(true);
}
self.request_canvas();
self.tend_canvas(wait)?;
if !self.canvas_current() && self.canvas_wait.is_none() {
self.request_canvas();
self.tend_canvas(wait)?;
}
Ok(self.canvas_current())
}
pub(super) fn hold_still(&mut self) {
if self.timeline.player.is_some() {
self.stop_playback();
}
self.timeline.roll = None;
}
pub(super) fn ensure_canvas(&mut self) -> Result<bool> {
self.hold_still();
if !self.canvas_current() {
if !self.catch_up(PEN_WAIT)? {
return Ok(false);
}
self.timeline.on_screen = Some(self.scene.frame);
}
Ok(true)
}
fn shown(&mut self, frame: u32, cached: bool) {
self.timeline.on_screen = Some(frame);
if frame != self.scene.frame {
return;
}
if let Some(start) = self.timeline.step_start.take() {
let took = ms(start);
crate::stats::lock(&self.stats).step_ms.push(took as f32);
let text = format!(
"frame {frame} shown in {took:.1} ms {}, {} MB of drawings and {} MB of frames ({}) in memory",
if cached { "from the frame cache" } else { "composed" },
self.scene.cache_bytes() >> 20,
self.frames.bytes() >> 20,
self.frames.len()
);
self.measure("frame step", text);
}
}
fn forget_old_frames(&mut self) {
if self.frames.is_empty() {
return;
}
let frames = self.scene.bundle.doc.timeline.frames;
let onion = self.scene.onion_on;
let live: BTreeSet<u64> = (0..frames)
.flat_map(|f| [false, onion].into_iter().map(move |o| (f, o)))
.collect::<BTreeSet<_>>()
.into_iter()
.map(|(f, o)| self.frames.key(&mut self.scene, f, o, &self.brushes))
.collect();
self.frames.forget_unused(&live);
}
pub(super) fn frames_changed(&mut self) {
self.frames.changed();
self.forget_old_frames();
}
pub(super) fn tend_frames(&mut self) -> Result<Option<u64>> {
self.tend_canvas(Duration::ZERO)?;
let now = Instant::now();
let rev = self.scene.bundle.doc.rev;
if rev != self.timeline.cache_rev {
self.timeline.cache_rev = rev;
self.frames_changed();
}
if self.timeline.player.as_ref().is_some_and(|p| p.finished(now)) {
self.stop_playback();
}
self.frames.collect(&mut self.scene);
self.scene.lean = self.frames.heavy;
if let Some(e) = self.frames.error.take() {
self.error(e);
}
let show = match self.timeline.player.is_some() {
true => self.tend_playback(now),
false => self.tend_still(now)?,
};
let keep: BTreeSet<u64> = show.into_iter().collect();
self.frames.prune(&keep);
Ok(show)
}
fn tend_still(&mut self, now: Instant) -> Result<Option<u64>> {
let onion = self.scene.onion_on;
let target = self.timeline.roll.unwrap_or(self.scene.frame);
let cacheable = self.cacheable();
let key = cacheable.then(|| self.frames.key(&mut self.scene, target, onion, &self.brushes));
let cached = key.filter(|k| self.frames.has(*k));
let rolling = self.timeline.roll.is_some();
if !rolling && !self.canvas_current() {
let settled = now.duration_since(self.timeline.moved_at) >= SETTLE && self.timeline.flip.is_none();
let loaded = self.scene.has_frame(self.scene.frame);
let heavy = self.frames.heavy;
if (loaded && (cached.is_none() || settled)) || !cacheable || (heavy && settled) {
self.catch_up(Duration::ZERO)?;
}
if cached.is_some() && !self.canvas_current() {
self.ctx.request_repaint_after(SETTLE);
}
}
if !rolling && self.canvas_current() {
let filling = self.dirty.len() > FILL && self.live.is_none();
if let Some(key) = self.timeline.shown_key.filter(|k| filling && self.frames.has(*k)) {
self.frames.touch(key);
self.ctx.request_repaint();
return Ok(Some(key));
}
self.timeline.shown_key = None;
self.shown(self.scene.frame, false);
self.prefetch(onion);
return Ok(None);
}
if let Some(key) = cached {
self.frames.touch(key);
self.timeline.shown_key = Some(key);
self.shown(target, true);
self.prefetch(onion);
return Ok(Some(key));
}
let seen = key.is_some_and(|k| self.frames.on_disk(k));
let loading_here = !seen && (self.frames.heavy || self.canvas_wait.as_ref().is_some_and(|w| w.frame == target));
if !loading_here {
self.frames.request(&mut self.scene, target, onion, &self.brushes, true);
}
Ok(self.timeline.shown_key.filter(|k| self.frames.has(*k)))
}
fn prefetch(&mut self, onion: bool) {
let direction = self.timeline.direction;
if direction == 0 || self.busy() || !self.cacheable() {
return;
}
let last = self.scene.bundle.doc.timeline.frames as i64 - 1;
let from = self.scene.frame as i64;
(1..=AHEAD as i64)
.map(|k| from + k * direction as i64)
.filter(|f| (0..=last).contains(f))
.filter(|f| {
!self.frames.heavy || {
let key = self.frames.key(&mut self.scene, *f as u32, onion, &self.brushes);
self.frames.on_disk(key)
}
})
.collect::<Vec<_>>()
.into_iter()
.try_for_each(|f| {
match self
.frames
.request(&mut self.scene, f as u32, onion, &self.brushes, false)
{
true => Some(()),
false => None,
}
});
}
fn tend_playback(&mut self, now: Instant) -> Option<u64> {
let player = self.timeline.player.as_mut()?;
let (frames, scene, brushes) = (&mut self.frames, &mut self.scene, &self.brushes);
player.tick(now, |f| {
let key = frames.key(scene, f, false, brushes);
frames.has(key)
});
let length = (player.to - player.from + 1) as usize;
player
.ahead(now, length)
.into_iter()
.try_for_each(|f| match frames.request(scene, f, false, brushes, false) {
true => Some(()),
false => None,
});
let wait = player.next_in(now);
let shown = player.shown();
self.ctx.request_repaint_after(wait);
let key = shown.map(|f| frames.key(scene, f, false, brushes));
if let Some(f) = shown {
self.timeline.on_screen = Some(f);
}
key.filter(|k| self.frames.has(*k))
}
pub(super) fn play(&mut self) -> Result<()> {
if self.timeline.player.is_some() {
self.stop_playback();
return Ok(());
}
if self.busy() {
return Ok(());
}
let t = &self.scene.bundle.doc.timeline;
let span = clips::play_span(t, self.scene.frame, self.timeline.range, self.timeline.clip.as_deref());
self.timeline.roll = None;
self.timeline.flip = None;
self.timeline.player = Some(Player::new(
Instant::now(),
self.scene.frame,
(span.from, span.to),
span.fps,
span.once,
));
self.timeline.playing = format!(
"{} at {} fps{}",
span.what,
span.fps,
if span.once { ", once" } else { "" }
);
Ok(())
}
pub(super) fn stop_playback(&mut self) {
let Some(player) = self.timeline.player.take() else {
return;
};
let played = format!("played {}: {}", self.timeline.playing, player.summary());
self.measure("last play", played.clone());
self.say(Tone::Done, played);
if let Some(frame) = player.shown() {
if frame != self.scene.frame {
self.scene.move_to(frame);
self.timeline.direction = 0;
}
self.timeline.shown_key = Some(self.frames.key(&mut self.scene, frame, false, &self.brushes));
}
self.timeline.moved_at = Instant::now();
}
pub(super) fn shown_frame(&self) -> u32 {
match (&self.timeline.player, self.timeline.roll) {
(Some(p), _) => p.shown().unwrap_or(self.scene.frame),
(None, Some(roll)) => roll,
_ => self.scene.frame,
}
}
pub(super) fn waiting(&self) -> bool {
self.timeline.on_screen != Some(self.scene.frame)
}
pub(super) fn toggle_onion(&mut self) -> Result<()> {
self.scene.onion_on = !self.scene.onion_on;
self.onion_changed()
}
pub(super) fn onion_changed(&mut self) -> Result<()> {
self.scene.onion.wrap = self.timeline.range;
self.invalidate_canvas();
self.frames_changed();
Ok(())
}
pub(super) fn previous_drawing(&self) -> Option<u32> {
let layer = self.scene.active_layer()?;
let frame = self.scene.frame;
let start = layer.cel_at(frame).map_or(frame, |c| c.frame);
let starts: Vec<u32> = layer.cels().iter().map(|c| c.frame).collect();
let earlier = starts.iter().rev().find(|f| **f < start).copied();
match self.timeline.range {
Some((a, b)) if (a..=b).contains(&frame) && earlier.is_none_or(|f| f < a) => starts
.iter()
.rev()
.find(|f| **f > start && **f <= b)
.copied()
.or(earlier),
_ => earlier,
}
}
pub(super) fn flip_and_roll(&mut self, ui: &egui::Ui) -> Result<()> {
let (q, w) = ui.input(|i| (i.key_down(Key::Q), i.key_down(Key::W)));
let x = ui.input(|i| i.pointer.latest_pos()).map(|p| p.x);
match (q, self.timeline.flip.as_ref(), x) {
(true, None, Some(x)) if !self.busy() => {
if self.timeline.player.is_some() {
self.stop_playback();
}
self.timeline.flip = Some(Flip {
origin: self.scene.frame,
x,
});
}
(true, Some(flip), Some(x)) => {
let last = self.scene.bundle.doc.timeline.frames as i64 - 1;
let offset = ((x - flip.x) / FLIP_PX).round() as i64;
let frame = (flip.origin as i64 + offset).clamp(0, last) as u32;
if frame != self.scene.frame {
self.go_to(frame)?;
}
}
(false, Some(_), _) => {
self.timeline.flip = None;
self.timeline.moved_at = Instant::now();
}
_ => {}
}
self.timeline.roll = match w && self.timeline.player.is_none() && !self.busy() {
true => self.timeline.roll.or_else(|| self.previous_drawing()),
false => None,
};
Ok(())
}
pub(super) fn holding_frame_keys(&self) -> bool {
self.timeline.flip.is_some() || self.timeline.roll.is_some()
}
fn active_layer_id(&self) -> Option<String> {
self.scene.active_id()
}
pub(super) fn here(&self) -> Option<(String, Option<(Cel, u32)>)> {
let layer = self.scene.active_layer()?;
if !matches!(layer.kind(), Kind::Paint | Kind::Vector) {
return None;
}
Some((layer.id.clone(), exposed(layer, self.scene.frame)))
}
pub(super) fn drawing_starts(&self) -> Vec<u32> {
self.scene
.active_layer()
.map(|l| l.cels().iter().map(|c| c.frame).collect())
.unwrap_or_default()
}
pub(super) fn next_drawing(&mut self) -> Result<()> {
let Some(layer) = self
.scene
.active_layer()
.filter(|l| matches!(l.kind(), Kind::Paint | Kind::Vector))
.cloned()
else {
return Ok(());
};
let on = self.timeline.on.max(1);
let frame = self.scene.frame;
let frames = self.scene.bundle.doc.timeline.frames;
let mut ops = Vec::new();
let at = match exposed(&layer, frame) {
None => frame,
Some((cel, end)) if end == OPEN => {
let at = cel.frame + on * (frame + 1 - cel.frame).div_ceil(on);
ops.push(Op::Set {
id: cel.id.clone(),
props: Map::from_iter([("hold".to_string(), json!(at - cel.frame))]),
});
at
}
Some((_, end)) => end,
};
let taken = layer.cels().iter().any(|c| c.frame == at);
ops.push(Op::Cel(CelSpec {
action: CelAction::New {
layer: layer.id.clone(),
},
id: None,
frame: Some(at),
hold: Some(on),
insert: taken,
}));
if at + on > frames.max(at + 1) && !taken {
ops.push(Op::Timeline {
fps: None,
frames: Some(at + on),
origin: None,
});
}
if self.timeline_apply(ops)?.is_some() {
self.go_to(at)?;
}
Ok(())
}
pub(super) fn timeline_apply(&mut self, ops: Vec<Op>) -> Result<Option<klad_core::ops::Applied>> {
if ops.is_empty() {
return Ok(None);
}
let start = Instant::now();
match self.scene.apply_with(&ops, &self.brushes) {
Ok((dirty, applied)) => {
self.dirty.extend(dirty);
self.forget_missing_selection();
let text = format!("{} in {:.0} ms", klad_core::bundle::summarize(&ops), ms(start));
self.measure("timeline edit", text.clone());
self.say(Tone::Info, text);
Ok(Some(applied))
}
Err(e) => {
self.say(Tone::Refused, format!("{e:#}"));
Ok(None)
}
}
}
fn cel_op(&mut self, action: CelAction, frame: Option<u32>, insert: bool) -> Result<Option<String>> {
let spec = CelSpec {
action,
id: None,
frame,
hold: None,
insert,
};
Ok(self
.timeline_apply(vec![Op::Cel(spec)])?
.and_then(|a| a.added.first().cloned()))
}
pub(super) fn new_drawing(&mut self) -> Result<()> {
let Some((layer, _)) = self.here() else {
return Ok(());
};
self.cel_op(CelAction::New { layer }, Some(self.scene.frame), false)?;
Ok(())
}
pub(super) fn duplicate_next(&mut self) -> Result<()> {
let Some((_, Some((cel, end)))) = self.here() else {
self.say(Tone::Refused, "nothing to duplicate on this frame");
return Ok(());
};
let frames = self.scene.bundle.doc.timeline.frames;
let at = if end == OPEN { frames.max(cel.frame + 1) } else { end };
if self
.cel_op(CelAction::Dup { cel: cel.id }, None, end != OPEN)?
.is_some()
{
self.go_to(at)?;
}
Ok(())
}
pub(super) fn link_here(&mut self, source: String) -> Result<()> {
self.cel_op(CelAction::Link { cel: source }, Some(self.scene.frame), false)?;
Ok(())
}
pub(super) fn unlink_here(&mut self) -> Result<()> {
if let Some((_, Some((cel, _)))) = self
.here()
.filter(|(_, c)| c.as_ref().is_some_and(|(c, _)| c.link.is_some()))
{
self.cel_op(CelAction::Unlink { cel: cel.id }, None, false)?;
}
Ok(())
}
pub(super) fn delete_here(&mut self) -> Result<()> {
if let Some((_, Some((cel, _)))) = self.here() {
self.timeline_apply(vec![Op::Remove { ids: vec![cel.id] }])?;
}
Ok(())
}
pub(super) fn frames_at(&mut self, insert: bool, every_layer: bool) -> Result<()> {
let Some(layer) = self.active_layer_id() else {
return Ok(());
};
if !insert && self.scene.bundle.doc.timeline.frames == 1 {
return Ok(());
}
let spec = FrameSpec {
insert,
at: self.scene.frame,
count: 1,
layers: (!every_layer).then(|| vec![layer]),
};
self.timeline_apply(vec![Op::Frames(spec)])?;
Ok(())
}
pub(super) fn resize(
&mut self,
layer: &str,
cel: &str,
(start, end, open): (u32, u32, bool),
to: u32,
) -> Result<()> {
let to = to.max(start + 1);
let op = match to.cmp(&end) {
std::cmp::Ordering::Equal => return Ok(()),
std::cmp::Ordering::Greater => Op::Frames(FrameSpec {
insert: true,
at: end - 1,
count: to - end,
layers: Some(vec![layer.to_string()]),
}),
std::cmp::Ordering::Less if open => Op::Set {
id: cel.to_string(),
props: Map::from_iter([("hold".to_string(), json!(to - start))]),
},
std::cmp::Ordering::Less => Op::Frames(FrameSpec {
insert: false,
at: to,
count: end - to,
layers: Some(vec![layer.to_string()]),
}),
};
self.timeline_apply(vec![op])?;
Ok(())
}
pub(super) fn hold(&mut self, delta: i32) -> Result<()> {
let Some((layer, Some((cel, end)))) = self.here() else {
return Ok(());
};
let frames = self.scene.bundle.doc.timeline.frames;
let (open, end) = (end == OPEN, end.min(frames));
if delta < 0 && end - cel.frame <= 1 {
self.say(
Tone::Refused,
"this drawing already shows for one frame; delete it instead".to_string(),
);
return Ok(());
}
let to = (end as i64 + delta as i64).max(cel.frame as i64 + 1) as u32;
self.resize(&layer, &cel.id, (cel.frame, end, open), to)
}
pub(super) fn add_layer(&mut self, kind: &str) -> Result<()> {
let frame = self.scene.frame;
self.add_layer_value(json!({"kind": kind, "cels": [{"frame": frame}]}))
}
pub(super) fn add_layer_value(&mut self, layer: serde_json::Value) -> Result<()> {
let above = self.scene.active.clone();
let owner = match above.last() {
Some(&MASK) => above[..above.len() - 1].to_vec(),
_ => above,
};
let place = match self.scene.bundle.doc.locate_path(&owner) {
Some(layer) => Place {
above: Some(layer.id.clone()),
..Place::default()
},
None => Place::default(),
};
let Some(applied) = self.timeline_apply(vec![Op::AddLayer { layer, place }])? else {
return Ok(());
};
if let Some(Loc::Layer(path)) = applied.added.first().and_then(|id| self.scene.bundle.doc.locate(id)) {
self.activate(path)?;
}
Ok(())
}
fn timeline_rows(&self) -> Vec<LayerRow> {
self.layer_rows(layers::Where::Timeline)
}
fn timeline_header(&mut self, ui: &mut egui::Ui) -> Result<()> {
let t = self.scene.bundle.doc.timeline.clone();
if !ui.memory(|m| m.focused().is_some()) {
self.timeline.fps = t.fps;
self.timeline.length = t.frames;
}
let mut ops = Vec::new();
let mut range = self.timeline.range;
let mut go = None;
let folded = self.settings.layout.timeline_folded;
ui.horizontal_wrapped(|ui| {
let caret = if folded { icon::FOLDED } else { icon::OPEN };
if ui
.add(
egui::Button::new(RichText::new(caret).size(theme::ICON))
.min_size(vec2(theme::TARGET, theme::TARGET)),
)
.hint("fold the timeline to this row, or open it again")
.clicked()
{
self.settings.layout.timeline_folded = !folded;
self.settings_dirty = true;
}
let shown = self.shown_frame();
let mut typed = shown;
let label = ui.label(RichText::new("frame").strong());
let field = ui
.add(egui::DragValue::new(&mut typed).range(0..=t.frames - 1))
.labelled_by(label.id)
.hint("the frame on screen; drag, or double-click and type a frame to go there");
if typed != shown && (field.lost_focus() || field.dragged() || field.changed()) {
go = Some(typed);
}
ui.label(RichText::new(format!("of {}", t.frames)).color(theme::WEAK));
if self.timeline.player.is_none() && ((self.frames.jobs() > 0 && self.waiting()) || self.canvas_loading()) {
ui.label(RichText::new("loading").color(theme::WEAK));
}
[
Cmd::FirstFrame,
Cmd::PrevDrawing,
Cmd::PrevFrame,
Cmd::Play,
Cmd::NextFrame,
Cmd::NextDrawing,
Cmd::LastFrame,
]
.into_iter()
.for_each(|cmd| {
self.command_button(ui, cmd, None);
});
ui.separator();
self.command_button(ui, Cmd::LoopRange, None);
if let Some((a, b)) = range.as_mut() {
ui.add(egui::DragValue::new(a).range(0..=t.frames - 1))
.hint("the loop range's first frame");
ui.label("to");
ui.add(egui::DragValue::new(b).range(0..=t.frames - 1))
.hint("the loop range's last frame");
*b = (*b).max(*a);
}
self.command_button(ui, Cmd::Prepare, None);
if let Some(text) = self.preparing_text() {
ui.label(RichText::new(text).color(theme::WEAK));
}
ui.separator();
self.command_button(ui, Cmd::Onion, None);
self.command_button(ui, Cmd::OnionSettings, None);
ui.separator();
ui.label("shift K on");
[
(Cmd::ExposeOnes, "1s"),
(Cmd::ExposeTwos, "2s"),
(Cmd::ExposeThrees, "3s"),
]
.into_iter()
.for_each(|(cmd, label)| {
self.command_button(ui, cmd, Some(label));
});
ui.separator();
ui.label("fps");
let fps = ui
.add(egui::DragValue::new(&mut self.timeline.fps).range(1..=240))
.hint("frames per second of the document; drag, or double-click and type");
ui.label("length");
let length = ui
.add(egui::DragValue::new(&mut self.timeline.length).range(1..=100_000))
.hint("the timeline's length in frames");
let done = |r: &egui::Response| r.drag_stopped() || r.lost_focus();
if (done(&fps) || done(&length)) && (self.timeline.fps != t.fps || self.timeline.length != t.frames) {
ops.push(Op::Timeline {
fps: (self.timeline.fps != t.fps).then_some(self.timeline.fps),
frames: (self.timeline.length != t.frames).then_some(self.timeline.length),
origin: None,
});
}
ui.label("zoom");
ui.add(egui::Slider::new(&mut self.timeline.cell, 8.0..=40.0).show_value(false))
.hint("the width of a frame in the timeline");
});
self.timeline_apply(ops)?;
if let Some(frame) = go {
self.go_to(frame)?;
}
if range != self.timeline.range {
self.timeline.range = range;
self.onion_changed()?;
}
if folded {
return Ok(());
}
self.selection_toolbar(ui)?;
Ok(())
}
pub(super) fn onion_settings(&mut self, ui: &mut egui::Ui) -> Result<()> {
let mut onion = self.scene.onion.clone();
let mut on = self.scene.onion_on;
ui.checkbox(&mut on, "onion skin (O)")
.hint("see the drawings before (red) and after (green) under the active layer");
ui.horizontal(|ui| {
ui.label("before");
ui.add(egui::DragValue::new(&mut onion.before).range(0..=12))
.hint("how many drawings or frames before this one");
ui.label("after");
ui.add(egui::DragValue::new(&mut onion.after).range(0..=12))
.hint("how many drawings or frames after this one");
});
ui.horizontal(|ui| {
ui.label("count");
ui.selectable_value(&mut onion.by, By::Drawings, "drawings")
.hint("count drawings: each one once, at its nearest distance");
ui.selectable_value(&mut onion.by, By::Frames, "frames")
.hint("count frames: on twos the nearest drawing is two frames off and fainter");
});
ui.add(egui::Slider::new(&mut onion.opacity, 0.05..=1.0).text("opacity"))
.hint("the nearest ghost's opacity");
ui.add(egui::Slider::new(&mut onion.falloff, 0.1..=1.0).text("falloff"))
.hint("each step further keeps this much of the opacity");
ui.checkbox(&mut onion.tint, "tint: red before, green after")
.hint("off: the ghosts keep their own colours");
ui.small("The dot at the right of a layer's name in the timeline shows that layer's onion too.");
if onion != self.scene.onion || on != self.scene.onion_on {
self.scene.onion = onion;
self.scene.onion_on = on;
self.onion_changed()?;
}
Ok(())
}
pub(super) fn draws_into(&self) -> String {
let frame = self.scene.frame;
let frames = self.scene.bundle.doc.timeline.frames;
let Some(layer) = self.scene.active_layer() else {
return "no active layer".into();
};
let name = &layer.name;
if layer.kind() == Kind::Group {
return format!("{name} is a group: pick a paint layer to draw");
}
if layer.kind() == Kind::Adjust {
return format!("{name} is an adjustment layer: it changes what is under it; pick a paint layer to draw");
}
if layer.kind() == Kind::Bones {
return format!(
"{name} is a bones layer: it holds a skeleton (the bone tool, J); pick a paint layer to draw"
);
}
let span = |start: u32, end: u32| match end.min(frames) - start {
1 => format!("frame {start}"),
_ => format!("frames {start} to {}", end.min(frames) - 1),
};
match exposed(layer, frame) {
None => format!("{name}: frame {frame} is empty, a stroke starts a drawing"),
Some((cel, end)) if cel.link.is_some() => {
let source = cel.link.as_deref().unwrap_or_default();
let first = layer
.cels()
.iter()
.find(|c| c.id == source)
.map_or(String::new(), |c| format!(" from frame {}", c.frame));
format!(
"draws on {name}, {}, into the drawing{first}: it shows again here, so it changes wherever it shows",
span(cel.frame, end)
)
}
Some((cel, end)) => format!("draws on {name}, {}", span(cel.frame, end)),
}
}
fn names(&mut self, ui: &mut egui::Ui) -> Result<()> {
let band = clips::band_height(&self.scene.bundle.doc.timeline.clips);
let (strip, _) = ui.allocate_exact_size(vec2(NAMES, band), Sense::hover());
ui.painter().text(
pos2(strip.left() + 4.0, strip.top() + clips::LANE / 2.0),
Align2::LEFT_CENTER,
"clips",
FontId::proportional(11.0),
Color32::GRAY,
);
let (rect, _) = ui.allocate_exact_size(vec2(NAMES, RULER), Sense::hover());
ui.painter().text(
rect.left_center() + vec2(4.0, 0.0),
Align2::LEFT_CENTER,
"layers",
FontId::proportional(11.0),
Color32::GRAY,
);
let rows = self.layer_rows(layers::Where::Timeline);
let mut placed = Vec::new();
let mut responses = Vec::new();
rows.into_iter().for_each(|row| {
let (rect, _) = ui.allocate_exact_size(vec2(NAMES, ROW), Sense::hover());
responses.push(self.layer_row(ui, &row, layers::Where::Timeline, rect));
placed.push((rect, row));
});
self.layer_drags(ui, layers::Where::Timeline, &placed, &responses);
Ok(())
}
fn grid(&mut self, ui: &mut egui::Ui, rows: &[LayerRow]) -> Result<()> {
let doc = &self.scene.bundle.doc;
let frames = doc.timeline.frames;
let cw = self.timeline.cell;
let clip_list = doc.timeline.clips.clone();
let band = clips::band_height(&clip_list);
let size = vec2(frames as f32 * cw + PAST, band + RULER + rows.len() as f32 * ROW);
let (rect, response) = ui.allocate_exact_size(size, Sense::CLICK | Sense::DRAG);
let painter = ui.painter_at(rect);
let top = rect.top() + band;
painter.rect_filled(rect, 0.0, Color32::from_gray(26));
painter.rect_filled(
Rect::from_min_max(pos2(rect.left() + frames as f32 * cw, top), rect.max),
0.0,
Color32::from_gray(18),
);
let strip = Strip {
rect: Rect::from_min_max(rect.min, pos2(rect.right(), top)),
cell: cw,
lanes: clips::lanes(&clip_list),
};
let dragged_span: Vec<(usize, u32, u32)> = match &self.timeline.drag {
Some(Drag::ClipEnd { index, from, to, .. }) => vec![(*index, *from, *to)],
_ => Vec::new(),
};
strip.paint(
&painter,
&clip_list,
doc.timeline.fps,
self.timeline.clip.as_deref(),
&dragged_span,
);
if let Some(Drag::NewClip { from, to }) = &self.timeline.drag {
strip.outline(&painter, *from, *to);
}
let x_of = |f: u32| rect.left() + f as f32 * cw;
let row_rect =
|i: usize| Rect::from_min_size(pos2(rect.left(), top + RULER + i as f32 * ROW), vec2(rect.width(), ROW));
let shown = self.shown_frame();
let step = if cw >= 14.0 { 1 } else { 5 };
(0..frames).for_each(|f| {
let x = x_of(f);
let strong = f % 5 == 0;
painter.line_segment(
[pos2(x, top + RULER), pos2(x, rect.bottom())],
Stroke::new(1.0, Color32::from_gray(if strong { 52 } else { 38 })),
);
if f % step == 0 {
painter.text(
pos2(x + cw / 2.0, top + RULER / 2.0),
Align2::CENTER_CENTER,
f.to_string(),
FontId::monospace(if cw >= 18.0 { 10.0 } else { 9.0 }),
if strong { Color32::LIGHT_GRAY } else { Color32::GRAY },
);
}
});
let ready = &self.buffering.shown;
(0..frames).for_each(|f| {
let at = |y: f32, h: f32| Rect::from_min_size(pos2(x_of(f), top + y), vec2(cw, h));
if ready.watch.contains(&f) {
painter.rect_filled(at(1.0, 3.0), 0.0, Color32::from_rgb(90, 200, 110));
}
if ready.draw.contains(&f) {
painter.rect_filled(at(4.0, 2.0), 0.0, Color32::from_rgb(90, 160, 230));
}
});
if response.hover_pos().is_some_and(|p| p.y >= top && p.y < top + 7.0) {
response.clone().on_hover_text_at_pointer(
"green: the frame's picture is buffered, it shows at once; blue: its drawings are cached, so drawing there starts within seconds. The lightning (prepare frames) fills both",
);
}
let band = match &self.timeline.drag {
Some(Drag::Range { from, to }) => Some(((*from).min(*to), (*from).max(*to))),
_ => self.timeline.range,
};
if let Some((a, b)) = band {
painter.rect_filled(
Rect::from_min_max(pos2(x_of(a), top), pos2(x_of(b + 1), top + RULER)),
0.0,
Color32::from_rgba_unmultiplied(255, 170, 60, 70),
);
painter.line_segment(
[pos2(x_of(a), top + RULER - 1.0), pos2(x_of(b + 1), top + RULER - 1.0)],
Stroke::new(2.0, Color32::from_rgb(255, 170, 60)),
);
}
rows.iter().enumerate().for_each(|(i, row)| {
let r = row_rect(i);
if self.scene.active == row.path {
painter.rect_filled(r, 0.0, Color32::from_gray(36));
}
painter.line_segment(
[r.left_bottom(), r.right_bottom()],
Stroke::new(1.0, Color32::from_gray(40)),
);
let Some(layer) = doc.locate_path(&row.path) else {
return;
};
let numbers = drawing_numbers(layer);
let number = |cel: &str| numbers.get(cel).map_or(String::new(), u32::to_string);
blocks(layer, frames).iter().for_each(|b| {
let end = match &self.timeline.drag {
Some(Drag::Hold { cel, to, .. }) if *cel == b.cel => *to,
_ => b.end,
};
let fill = match (&b.link, layer.kind()) {
(Some(_), _) => Color32::from_rgb(112, 92, 146),
(None, Kind::Vector) => Color32::from_rgb(78, 124, 96),
_ if b.tween => Color32::from_rgb(100, 136, 166),
_ => Color32::from_rgb(76, 104, 140),
};
let label = match &b.link {
Some(source) => format!("->{}", number(source)),
None if b.tween => format!("{}*", number(&b.cel)),
None => number(&b.cel),
};
let moved_to = match &self.timeline.drag {
Some(Drag::Move { cel, from, to }) if *cel == b.cel && from != to => Some(*to),
_ => None,
};
let at = |start: u32, end: u32| {
Rect::from_min_max(
pos2(x_of(start) + 1.0, r.top() + 3.0),
pos2(x_of(end) - 1.0, r.bottom() - 3.0),
)
};
let faded = moved_to.is_some();
paint_block(&painter, at(b.start, end), cw, fill, &label, faded);
if let Some(to) = moved_to {
let ghost = at(to, to + (b.end - b.start));
paint_block(&painter, ghost, cw, fill, &label, false);
painter.rect_stroke(ghost, 3.0, Stroke::new(1.5, Color32::WHITE), egui::StrokeKind::Outside);
}
});
});
let selected = match &self.timeline.drag {
Some(Drag::Select { from, to, first, last }) => {
span_of(rows, (*from, *to), (*first, *last), (*from, *first))
}
_ => self.timeline.span.clone(),
};
if let Some(span) = &selected {
let found: Vec<usize> = rows
.iter()
.enumerate()
.filter(|(_, r)| span.rows.contains(&r.id))
.map(|(i, _)| i)
.collect();
if let (Some(&a), Some(&b)) = (found.first(), found.last()) {
let area = Rect::from_min_max(
pos2(x_of(span.from), row_rect(a).top()),
pos2(x_of(span.to + 1), row_rect(b).bottom()),
);
painter.rect_filled(area, 2.0, Color32::from_rgba_unmultiplied(255, 255, 255, 34));
painter.rect_stroke(
area,
2.0,
Stroke::new(1.5, Color32::from_gray(235)),
egui::StrokeKind::Inside,
);
}
}
painter.rect_filled(
Rect::from_min_size(pos2(x_of(shown), rect.top()), vec2(cw, rect.height())),
0.0,
Color32::from_rgba_unmultiplied(64, 196, 255, 46),
);
painter.line_segment(
[pos2(x_of(shown), rect.top()), pos2(x_of(shown), rect.bottom())],
Stroke::new(1.5, Color32::from_rgb(64, 196, 255)),
);
let geom = Geom {
left: rect.left(),
top,
cell: cw,
frames,
rows: rows.len(),
};
self.timeline.geom = Some(geom);
let row_blocks: Vec<Vec<Block>> = rows
.iter()
.map(|r| doc.locate_path(&r.path).map_or(Vec::new(), |l| blocks(l, frames)))
.collect();
let at = |p: Pos2| -> (u32, Option<usize>) { (geom.frame_at(p.x), geom.row_at(p.y)) };
let pointer = response.interact_pointer_pos().or(response.hover_pos());
let press = ui.input(|i| i.pointer.press_origin());
let on_edge = |p: Pos2| matches!(press_at(&geom, &row_blocks, p), Some(Press::End(..)));
let in_strip = |p: Pos2| p.y < top;
let on_clip_end =
|p: Pos2| in_strip(p) && matches!(strip.hit(&clip_list, p), Some((_, Hit::First | Hit::Last)));
let resizing = matches!(self.timeline.drag, Some(Drag::Hold { .. } | Drag::ClipEnd { .. }));
let hover_end = response.hover_pos().is_some_and(|p| on_edge(p) || on_clip_end(p));
let hover_dot = response
.hover_pos()
.is_some_and(|p| matches!(press_at(&geom, &row_blocks, p), Some(Press::Start(..))));
if resizing || (self.timeline.drag.is_none() && hover_end) {
ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
} else if matches!(self.timeline.drag, Some(Drag::Move { .. })) {
ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);
} else if self.timeline.drag.is_none() && hover_dot {
ui.ctx().set_cursor_icon(egui::CursorIcon::Grab);
}
let mut pick: Option<(u32, Option<usize>)> = None;
let shift = ui.input(|i| i.modifiers.shift);
if response.drag_started()
&& let Some(p) = press.or(pointer)
{
let (f, row) = at(p);
let clip_hit = in_strip(p).then(|| strip.hit(&clip_list, p)).flatten();
if let Some((i, _)) = clip_hit {
self.timeline.clip = Some(clip_list[i].name.clone());
}
self.timeline.drag = match press_at(&geom, &row_blocks, p) {
_ if in_strip(p) => match clip_hit {
Some((i, hit @ (Hit::First | Hit::Last))) => Some(Drag::ClipEnd {
index: i,
name: clip_list[i].name.clone(),
first: hit == Hit::First,
from: clip_list[i].from,
to: clip_list[i].to,
}),
Some(_) => Some(Drag::Scrub),
None => Some(Drag::NewClip { from: f, to: f }),
},
Some(press) => Some(drag_of(&press, shift, |r| rows[r].id.clone())),
None => None,
};
if matches!(
self.timeline.drag,
Some(Drag::Scrub | Drag::Hold { .. } | Drag::Move { .. } | Drag::Select { .. })
) {
pick = Some((f, row));
}
}
if response.dragged()
&& let Some(p) = pointer
{
let edge = ((p.x - rect.left()) / cw).round().max(0.0) as u32;
let (f, under) = at(p);
match &mut self.timeline.drag {
Some(Drag::Scrub) => self.go_to(f)?,
Some(Drag::Select { to, last, .. }) => {
*to = f;
if let Some(r) = under {
*last = r;
}
}
Some(Drag::Range { to, .. }) => *to = f,
Some(Drag::Hold { start, to, .. }) => *to = edge.max(*start + 1),
Some(Drag::Move { to, .. }) => *to = f,
Some(Drag::NewClip { to, .. }) => *to = f,
Some(Drag::ClipEnd {
first: true, from, to, ..
}) => *from = edge.min(*to),
Some(Drag::ClipEnd { from, to, .. }) => *to = edge.saturating_sub(1).max(*from).min(frames - 1),
None => {}
}
}
if response.drag_stopped() {
match self.timeline.drag.take() {
Some(Drag::Range { from, to }) => {
self.timeline.range = Some((from.min(to), from.max(to)));
self.onion_changed()?;
}
Some(Drag::Hold {
layer,
cel,
start,
end,
open,
to,
}) => self.resize(&layer, &cel, (start, end, open), to)?,
Some(Drag::Move { cel, from, to }) if from != to => {
let op = Op::Cel(CelSpec {
action: CelAction::Move { cel },
id: None,
frame: Some(to),
hold: None,
insert: false,
});
if self.timeline_apply(vec![op])?.is_some() {
self.go_to(to)?;
}
}
Some(Drag::NewClip { from, to }) => self.add_clip(from, to)?,
Some(Drag::Select { from, to, first, last }) => {
self.timeline.span = span_of(rows, (from, to), (first, last), (from, first));
}
Some(Drag::ClipEnd { name, from, to, .. }) => self.reach_clip(&name, from, to)?,
_ => {}
}
}
let mut extended = false;
if response.clicked()
&& shift
&& let Some(p) = pointer
&& let (f, Some(r)) = at(p)
{
let anchor = self.timeline.span.as_ref().map_or_else(
|| {
(
self.scene.frame,
rows.iter().position(|row| row.path == self.scene.active).unwrap_or(r),
)
},
|s| s.anchor,
);
self.timeline.span = span_of(rows, (anchor.0, f), (anchor.1, r), anchor);
extended = true;
}
if (response.clicked() || response.secondary_clicked())
&& !extended
&& let Some(p) = pointer
{
if in_strip(p) && response.clicked() {
self.timeline.clip = strip.hit(&clip_list, p).map(|(i, _)| clip_list[i].name.clone());
self.windows.clip = self.timeline.clip.is_some();
}
if response.clicked() {
self.timeline.span = None;
}
pick = Some(at(p));
}
if let Some((f, row)) = pick {
if let Some(path) = row.map(|r| rows[r].path.clone()).filter(|p| *p != self.scene.active) {
let leaf = self
.scene
.bundle
.doc
.locate_path(&path)
.is_some_and(|l| matches!(l.kind(), Kind::Paint | Kind::Vector));
if leaf {
self.activate(path)?;
}
}
self.go_to(f)?;
}
let mut chosen: Option<String> = None;
let mut actions: Vec<Cmd> = Vec::new();
let drawings: Vec<(String, u32)> = self
.scene
.active_layer()
.map(|l| {
l.cels()
.iter()
.filter(|c| c.link.is_none())
.map(|c| (c.id.clone(), c.frame))
.collect()
})
.unwrap_or_default();
let span = self.timeline.span.clone();
let span_keys = span.as_ref().and_then(|s| tweens::keys(&self.scene.bundle.doc, s));
let mut span_choice = None;
let ask = &mut self.timeline.ask;
response.context_menu(|ui| {
[
Cmd::NewDrawing,
Cmd::Duplicate,
Cmd::Unlink,
Cmd::DeleteDrawing,
Cmd::HoldLonger,
Cmd::HoldShorter,
Cmd::InsertFrame,
Cmd::InsertFrameAll,
Cmd::RemoveFrame,
Cmd::RemoveFrameAll,
Cmd::NewClip,
]
.into_iter()
.for_each(|cmd| {
let spec = cmd.spec();
let key = self.bindings.label(cmd);
let label = match key.is_empty() {
true => format!("{} {}", spec.icon, spec.name),
false => format!("{} {} ({key})", spec.icon, spec.name),
};
if ui.button(label).clicked() {
actions.push(cmd);
ui.close();
}
});
ui.menu_button("show a drawing here (link)", |ui| {
drawings.iter().for_each(|(id, frame)| {
if ui.button(format!("the drawing at frame {frame}")).clicked() {
chosen = Some(id.clone());
ui.close();
}
});
});
match &span {
Some(span) => span_choice = tweens::span_menu(ui, span, span_keys, ask),
None => {
ui.separator();
ui.small(
"shift click a cell (or shift drag over cells) to select frames for retiming and in-betweens",
);
}
}
});
if let Some(choice) = span_choice {
self.span_action(choice)?;
}
self.queued.extend(actions);
if let Some(source) = chosen {
self.link_here(source)?;
}
Ok(())
}
pub(super) fn timeline_panel(&mut self, ui: &mut egui::Ui) -> Result<()> {
self.tend_buffer();
self.timeline_header(ui)?;
if self.settings.layout.timeline_folded {
return Ok(());
}
let rows = self.timeline_rows();
let mut result = Ok(());
egui::ScrollArea::vertical()
.id_salt("timeline rows")
.auto_shrink([false, false])
.show(ui, |ui| {
ui.horizontal_top(|ui| {
ui.spacing_mut().item_spacing = vec2(0.0, 0.0);
ui.vertical(|ui| {
if let Err(e) = self.names(ui) {
result = Err(e);
}
});
egui::ScrollArea::horizontal()
.id_salt("timeline frames")
.auto_shrink([false, true])
.show(ui, |ui| {
if let Err(e) = self.grid(ui, &rows) {
result = Err(e);
}
});
});
});
result
}
}
fn drawing_numbers(layer: &klad_core::doc::Layer) -> std::collections::BTreeMap<String, u32> {
let mut drawings: Vec<_> = layer.cels().iter().filter(|c| c.link.is_none()).collect();
drawings.sort_by_key(|c| c.frame);
drawings.iter().zip(1..).map(|(c, n)| (c.id.clone(), n)).collect()
}
fn paint_block(painter: &egui::Painter, block: Rect, cw: f32, fill: Color32, label: &str, faded: bool) {
let fill = if faded { fill.gamma_multiply(0.35) } else { fill };
painter.rect_filled(block, 3.0, fill);
let grips = block.width() > 12.0;
if grips {
[3.0, 6.0].iter().for_each(|dx| {
let x = block.right() - dx;
painter.line_segment(
[pos2(x, block.top() + 3.0), pos2(x, block.bottom() - 3.0)],
Stroke::new(1.0, Color32::from_gray(210)),
);
});
}
let dot = pos2(block.left() - 1.0 + cw / 2.0, block.center().y);
painter.circle_filled(dot, 3.5, if faded { Color32::from_gray(150) } else { Color32::WHITE });
if block.width() > cw * 1.5 {
let room = Rect::from_min_max(
pos2(block.left() - 1.0 + cw, block.top()),
pos2(block.right() - if grips { 9.0 } else { 2.0 }, block.bottom()),
);
painter.with_clip_rect(room.intersect(painter.clip_rect())).text(
room.left_center(),
Align2::LEFT_CENTER,
label,
FontId::monospace(10.0),
Color32::from_gray(if faded { 140 } else { 230 }),
);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn block(cel: &str, start: u32, end: u32) -> Block {
Block {
cel: cel.into(),
link: None,
start,
end,
open: false,
tween: false,
}
}
#[test]
fn a_press_on_the_timeline_starts_the_drag_its_place_asks_for() {
let g = Geom {
left: 100.0,
top: 40.0,
cell: 20.0,
frames: 24,
rows: 2,
};
let rows = vec![vec![block("c1", 0, 4), block("c2", 4, 6)], vec![block("c9", 2, 3)]];
let row0 = 40.0 + RULER + ROW / 2.0;
let row1 = row0 + ROW;
assert_eq!(press_at(&g, &rows, pos2(130.0, 30.0)), None);
assert_eq!(press_at(&g, &rows, pos2(130.0, 45.0)), Some(Press::Ruler(1)));
assert_eq!(
press_at(&g, &rows, pos2(105.0, row0)),
Some(Press::Start(0, rows[0][0].clone()))
);
assert_eq!(press_at(&g, &rows, pos2(150.0, row0)), Some(Press::Cell(0, 2)));
assert_eq!(
press_at(&g, &rows, pos2(102.0, row0 - ROW / 2.0 + 2.0)),
Some(Press::Cell(0, 0))
);
assert_eq!(press_at(&g, &rows, pos2(118.0, row0)), Some(Press::Cell(0, 0)));
assert_eq!(
press_at(&g, &rows, pos2(180.0 - 7.0, row0)),
Some(Press::End(0, rows[0][0].clone()))
);
assert_eq!(
press_at(&g, &rows, pos2(180.0 + 7.0, row0)),
Some(Press::End(0, rows[0][0].clone()))
);
assert_eq!(
press_at(&g, &rows, pos2(195.0, row0)),
Some(Press::Start(0, rows[0][1].clone()))
);
assert_eq!(press_at(&g, &rows, pos2(400.0, row0)), Some(Press::Cell(0, 15)));
assert_eq!(
press_at(&g, &rows, pos2(165.0, row1)),
Some(Press::End(1, rows[1][0].clone()))
);
assert_eq!(press_at(&g, &rows, pos2(130.0, row1 + ROW)), Some(Press::Ruler(1)));
let origin = pos2(180.0 - 4.0, row0);
let moved = origin + vec2(6.0, 0.0);
assert!(matches!(press_at(&g, &rows, origin), Some(Press::End(..))));
assert!(matches!(press_at(&g, &rows, moved), Some(Press::End(..))));
let name = |r: usize| format!("l{r}");
assert_eq!(drag_of(&Press::Ruler(3), false, name), Drag::Scrub);
assert_eq!(drag_of(&Press::Ruler(3), true, name), Drag::Range { from: 3, to: 3 });
assert!(matches!(
drag_of(&Press::Cell(1, 5), false, name),
Drag::Select { from: 5, first: 1, .. }
));
assert!(matches!(drag_of(&Press::Cell(1, 5), true, name), Drag::Select { .. }));
assert!(matches!(
drag_of(&Press::Start(0, rows[0][1].clone()), false, name),
Drag::Move { from: 4, .. }
));
assert!(
matches!(drag_of(&Press::End(0, rows[0][0].clone()), false, name), Drag::Hold { end: 4, ref layer, .. } if layer == "l0")
);
}
}