2bc41aeb8602
drag.rs
use std::collections::HashSet;
use std::hash::Hash;
use super::{Paint, Rect, Response, Stroke, StrokeKind, Tokens, Ui, Vec2};
/// What panels drag onto art and onto each other. One payload type, so the canvas has one drop
/// handler for all of them (`canvas::panel_drop`); a chip of a dragged paint follows the pointer.
#[derive(Clone, Debug, PartialEq)]
pub enum PanelDrag {
/// A paint: Swatches panel tiles, a Fill/Stroke proxy, a Recent Colors chip, a Color Guide
/// color or the Gradient panel's thumbnail. Art it is dropped on takes `params` (`{swatch}`, `{color}`, `{gradient}`…;
/// null for a colour group, which paints nothing) through the active proxy's
/// `paint.setFill`/`paint.setStroke`; the Gradient panel's ramp takes its colour as a stop; the
/// Swatches panel moves `rows`, or makes a swatch of a paint dragged from elsewhere. `library`:
/// the Libraries panel colour it is (library id, colour name), which that panel moves to where
/// it is dropped.
Paint { paint: Paint, params: serde_json::Value, rows: Option<SwatchRows>, library: Option<(String, String)> },
/// The Appearance panel's thumbnail: art it is dropped on takes object `0`'s appearance
/// (`appearance.copyFrom`); the Graphic Styles panel makes a style of it, or with Alt held
/// replaces the style it is dropped on with it (`graphicStyle.redefine`).
Appearance(vectorcraft_doc::NodeId),
/// A Graphic Styles panel style: art it is dropped on takes it (`graphicStyle.apply` with its
/// `ids`); the panel moves it to where it is dropped, or with Alt held replaces the style it is
/// dropped on with its look (`graphicStyle.redefine` with `from`).
GraphicStyle(String),
/// The selected art, dragged off the canvas with the Selection tool: the Graphic Styles panel
/// makes a style of the first object (`graphicStyle.new`), or with Alt held replaces the style
/// it is dropped on with that object's look (`graphicStyle.redefine`), the Symbols panel a symbol of it all
/// (`symbol.new`), the Swatches panel a pattern swatch of a copy (`object.pattern.make`) and the
/// Brushes panel an Art brush (`brush.new`).
Art(Vec<vectorcraft_doc::NodeId>),
/// A Symbols panel symbol (`document`: the uid of the document whose panel it was dragged
/// from): the canvas places an instance of it centered where it is dropped, adding the symbol
/// first when another document is active by then (`symbol.placeFromDocument`).
Symbol { document: u64, name: String },
/// A symbol of a symbol library panel (`name`: its name in `library`): the canvas adds it to the
/// document's Symbols and places an instance where it is dropped (`symbol.addFromLibrary` with
/// `place`).
LibrarySymbol { library: String, name: String },
/// A Brushes panel brush (`def`: its definition, for the chip at the pointer): the path it is
/// dropped on takes it (`brush.apply`); dropped where there is no art, a scatter, art or pattern
/// brush places a copy of its art there (`brush.placeArt`).
Brush { name: String, def: serde_json::Value },
/// A brush of a brush library panel (`name`: its name in `library`): the path it is dropped on
/// takes it (`brush.addFromLibrary` with `apply`), and the Brushes panel adds it.
LibraryBrush { library: String, name: String },
/// A Libraries panel graphic (`item`: its id in `library`): the canvas places a copy centred
/// where it is dropped (`library.use`); the panel moves it to where it is dropped.
LibraryGraphic { library: String, item: String },
/// A Libraries panel text style (`item`: its name in `library`), which the panel moves to where
/// it is dropped.
LibraryItem { library: String, kind: vectorcraft_engine::cmd::library::ItemKind, item: String },
/// A Libraries panel group, by its header, which the panel moves to where it is dropped.
LibraryGroup { library: String, group: String },
}
/// A panel list `zone` that takes art dragged off the canvas: outlined while art is held over it;
/// → the dragged ids when the primary button is released there (the release of another button
/// ends the drag).
pub fn art_drop(ui: &Ui, zone: &Response) -> Option<Vec<u64>> {
let drag = zone.dnd_hover_payload::<PanelDrag>()?;
let PanelDrag::Art(ids) = &*drag else { return None };
ui.painter().rect_stroke(zone.rect, 0.0, Stroke::new(1.5, Tokens::get(ui.ctx()).accent), StrokeKind::Inside);
if !ui.input(|i| i.pointer.button_released(egui::PointerButton::Primary)) {
return None;
}
zone.dnd_release_payload::<PanelDrag>().map(|_| ids.iter().map(|id| id.0).collect())
}
/// Key of the document whose art a [`PanelDrag::Art`] carries.
fn art_doc_id() -> egui::Id {
egui::Id::unique("panel-drag-art-doc")
}
/// Start (or keep up) a panel drag of the art `ids` of document `uid`, dragged off its canvas.
pub fn drag_art(ctx: &egui::Context, uid: u64, ids: Vec<vectorcraft_doc::NodeId>) {
ctx.data_mut(|d| d.insert_temp(art_doc_id(), uid));
egui::DragAndDrop::set_payload(ctx, PanelDrag::Art(ids));
}
/// The document (`uid`) whose art the last [`drag_art`] carried.
pub fn art_drag_doc(ctx: &egui::Context) -> Option<u64> {
ctx.data(|d| d.get_temp::<u64>(art_doc_id()))
}
/// The Swatches panel rows a drag from that panel moves: the swatch, None, Registration or colour
/// group under the pointer when the drag started (`grabbed`) and `names`, the panel selection when
/// the grabbed one is part of it (only colour groups, or only swatches, like the grabbed one), in
/// panel order.
#[derive(Clone, Debug, PartialEq)]
pub struct SwatchRows {
pub grabbed: String,
pub names: Vec<String>,
/// The names are colour groups.
pub groups: bool,
}
impl PanelDrag {
/// `paint` dragged from a Fill/Stroke proxy, a Recent Colors chip, a Color Guide color or the
/// Gradient panel's thumbnail. A gradient carries no placement: it fits the art it lands on (freeform points are
/// placed afresh there, coloured like the dragged ones).
pub fn paint(mut paint: Paint) -> Self {
if let Paint::Gradient(g) = &mut paint {
g.geom = None;
g.freeform = None;
}
Self::Paint { params: crate::panels::paint_params(&paint), paint, rows: None, library: None }
}
/// The dragged colour (a solid paint's), which the Gradient panel's ramp takes.
pub fn color(&self) -> Option<vectorcraft_color::Color> {
match self {
Self::Paint { paint, .. } => paint.color(),
_ => None,
}
}
}
/// Make `resp` (which senses drags) a source of the [`PanelDrag`] `drag` builds when a drag with the
/// primary button starts on it. A secondary or middle drag carries nothing.
pub fn drag_source(ui: &Ui, resp: &Response, drag: impl FnOnce() -> PanelDrag) {
if resp.drag_started_by(egui::PointerButton::Primary) {
egui::DragAndDrop::set_payload(ui.ctx(), drag());
}
}
/// What a click on a row of a list whose rows highlight (the Layers and Appearance panels) means.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum RowClick<K> {
/// Highlight only this row (a plain click).
Only(K),
/// Highlight this row, or take its highlight off (Ctrl/Cmd).
Toggle(K),
/// Highlight these rows instead, listed top-down (Shift).
Range(Vec<K>),
/// Highlight these rows too, listed top-down (Shift+Ctrl/Cmd).
AddRange(Vec<K>),
}
impl<K> RowClick<K> {
/// Does the clicked row become the anchor Shift ranges start from? Every click but a Shift range.
pub fn moves_anchor(&self) -> bool {
matches!(self, Self::Only(_) | Self::Toggle(_))
}
}
/// What a click on row `clicked` with modifiers `m` means, the rows listed top-down in `order`:
/// Shift ranges from `anchor` (else from the last of the `highlighted` rows) and Shift+Ctrl/Cmd adds
/// the range; Ctrl/Cmd toggles the row; a plain click, or Shift with no start in `order`, highlights
/// only it (Ctrl/Cmd: toggles it).
pub fn row_click<K: Copy + PartialEq>(order: &[K], highlighted: &[K], anchor: Option<K>, clicked: K, m: egui::Modifiers) -> RowClick<K> {
let at = |k: K| order.iter().position(|r| *r == k);
if m.shift
&& let Some(a) = anchor.or(highlighted.last().copied())
&& let (Some(i), Some(j)) = (at(a), at(clicked))
{
let range = order.get(i.min(j)..=i.max(j)).unwrap_or_default().to_vec();
return if m.command { RowClick::AddRange(range) } else { RowClick::Range(range) };
}
if m.command { RowClick::Toggle(clicked) } else { RowClick::Only(clicked) }
}
/// Apply `click` to the `highlighted` rows, kept in highlight order as `layer.highlight` keeps the
/// Layers panel's: a toggled row is appended (or taken off, even the last one), a range replaces the
/// rows or adds those not there yet, top-down.
pub fn apply_row_click<K: Copy + Eq + Hash>(highlighted: &mut Vec<K>, click: &RowClick<K>) {
let add = |rows: &mut Vec<K>, add: &[K]| {
let mut held: HashSet<K> = rows.iter().copied().collect();
for k in add {
if held.insert(*k) {
rows.push(*k);
}
}
};
match click {
RowClick::Only(k) => *highlighted = vec![*k],
RowClick::Toggle(k) if highlighted.contains(k) => highlighted.retain(|r| r != k),
RowClick::Toggle(k) => highlighted.push(*k),
RowClick::Range(rows) => {
highlighted.clear();
add(highlighted, rows);
}
RowClick::AddRange(rows) => add(highlighted, rows),
}
}
/// Dimmed copies of dragged rows ([`drag_ghost`]) are drawn at this opacity.
pub const DRAG_GHOST_OPACITY: f32 = 0.5;
/// Which of the dragged rows the dimmed copy shows: the first of them in highlight order (`dragged`),
/// as the Layers panel has always done, else the grabbed one. The one place to change it (to show the
/// grabbed row, say) for both panels.
pub fn ghost_row<K: Copy>(dragged: &[K], grabbed: K) -> K {
dragged.first().copied().unwrap_or(grabbed)
}
/// A dimmed copy of a dragged row at `rect`, above everything else, with the grabbing cursor (the
/// Layers and Appearance panels): the highlighted row's fill and an accent edge; `contents` draws
/// the row's own contents on it.
pub fn drag_ghost(ctx: &egui::Context, id: egui::Id, rect: Rect, contents: impl FnOnce(&Ui, Rect)) {
let t = Tokens::get(ctx);
// A plain Ui on the tooltip layer, not an Area: a new Area is invisible for a frame and fades in.
let mut ui = Ui::new(ctx.clone(), id, egui::UiBuilder::new().layer_id(egui::LayerId::new(egui::Order::Tooltip, id)).max_rect(rect));
ui.set_opacity(DRAG_GHOST_OPACITY);
ui.painter().rect_filled(rect, 0.0, t.row_selected);
ui.painter().rect_stroke(rect, 0.0, Stroke::new(1.0, t.accent), StrokeKind::Inside);
ctx.set_cursor_icon(egui::CursorIcon::Grabbing);
contents(&ui, rect);
}
/// The outline a panel button shows while dragged rows hang over it and it would take them (the
/// Layers panel's trash and New Layer, the Appearance panel's Duplicate and Delete).
pub fn drop_target_outline(ui: &Ui, rect: Rect) {
ui.painter().rect_stroke(rect, 3.0, Stroke::new(1.5, Tokens::get(ui.ctx()).accent), StrokeKind::Inside);
}
/// A small document rendered to a texture at the screen's pixel density (stroke previews: brushes,
/// arrowheads), transparent where nothing paints. `build` makes the `w`×`h` pt document only when
/// the texture for `key` at this size isn't cached yet.
pub fn doc_preview(ui: &Ui, key: &str, size: Vec2, build: impl FnOnce(f64, f64) -> Option<vectorcraft_doc::Document>) -> Option<egui::TextureHandle> {
use std::cell::RefCell;
use std::collections::HashMap;
thread_local! {
static RENDERER: RefCell<vectorcraft_render::Renderer> = RefCell::new(vectorcraft_render::Renderer::new());
static CACHE: crate::graphics::TexCache<HashMap<String, egui::TextureHandle>> = crate::graphics::TexCache::default();
}
let ppp = ui.ctx().pixels_per_point() as f64;
let (w, h) = (size.x as f64, size.y as f64);
let key = format!("{w}x{h}@{ppp}:{key}");
if let Some(t) = CACHE.with(|c| c.borrow().get(&key).cloned()) {
return Some(t);
}
let doc = build(w, h)?;
let img = RENDERER.with(|r| r.borrow_mut().render_region(&doc, vectorcraft_geom::Rect::new(0.0, 0.0, w, h), ppp, false));
let color = crate::canvas::color_image(&img);
let tex = ui.ctx().load_texture(format!("preview-{key}"), color, egui::TextureOptions::LINEAR);
CACHE.with(|c| {
let mut c = c.borrow_mut();
if c.len() > 256 {
c.clear();
}
c.insert(key, tex.clone());
});
Some(tex)
}
#[cfg(test)]
mod row_click_tests {
use egui::Modifiers;
use super::{RowClick, apply_row_click, row_click};
const ROWS: [u32; 5] = [10, 20, 30, 40, 50];
const SHIFT_CMD: Modifiers = Modifiers { shift: true, command: true, ..Modifiers::NONE };
/// A plain click highlights only the clicked row and Ctrl/Cmd toggles it; both move the anchor.
#[test]
fn a_plain_click_highlights_only_the_row_and_ctrl_toggles_it() {
assert_eq!(row_click(&ROWS, &[20, 40], Some(20), 30, Modifiers::NONE), RowClick::Only(30));
assert_eq!(row_click(&ROWS, &[20, 40], Some(20), 30, Modifiers::COMMAND), RowClick::Toggle(30));
// Neither moves past the anchor rules: both make the clicked row the new anchor.
assert!(RowClick::Only(30).moves_anchor() && RowClick::Toggle(30).moves_anchor());
}
/// Shift highlights the range from the anchor and Shift+Ctrl/Cmd adds it; neither moves the anchor.
#[test]
fn shift_ranges_from_the_anchor_and_shift_ctrl_adds_the_range() {
// Top-down order whichever way the range runs.
assert_eq!(row_click(&ROWS, &[40], Some(40), 20, Modifiers::SHIFT), RowClick::Range(vec![20, 30, 40]));
assert_eq!(row_click(&ROWS, &[20], Some(20), 40, SHIFT_CMD), RowClick::AddRange(vec![20, 30, 40]));
assert!(!RowClick::Range(vec![20]).moves_anchor() && !RowClick::AddRange(vec![20]).moves_anchor());
}
/// Without an anchor, Shift starts at the last highlighted row, or acts as a plain click when none is.
#[test]
fn without_an_anchor_shift_starts_at_the_last_highlighted_row_else_acts_as_a_plain_click() {
assert_eq!(row_click(&ROWS, &[10, 50], None, 30, Modifiers::SHIFT), RowClick::Range(vec![30, 40, 50]));
assert_eq!(row_click(&ROWS, &[], None, 30, Modifiers::SHIFT), RowClick::Only(30));
assert_eq!(row_click(&ROWS, &[], None, 30, SHIFT_CMD), RowClick::Toggle(30));
// An anchor (or last row) that isn't in the list: as without one.
assert_eq!(row_click(&ROWS, &[99], Some(99), 30, Modifiers::SHIFT), RowClick::Only(30));
}
/// Applied clicks keep the rows in highlight order, as `layer.highlight` does.
#[test]
fn applying_a_click_keeps_highlight_order_as_layer_highlight_does() {
let applied = |mut rows: Vec<u32>, c: RowClick<u32>| {
apply_row_click(&mut rows, &c);
rows
};
assert_eq!(applied(vec![40, 20], RowClick::Only(30)), [30]);
// Toggling appends in click order; a highlighted row (even the last) goes off.
assert_eq!(applied(vec![40, 20], RowClick::Toggle(10)), [40, 20, 10]);
assert_eq!(applied(vec![40, 20], RowClick::Toggle(40)), [20]);
assert_eq!(applied(vec![40], RowClick::Toggle(40)), Vec::<u32>::new());
// A range replaces the rows, or adds the ones not there yet, top-down.
assert_eq!(applied(vec![50], RowClick::Range(vec![20, 30])), [20, 30]);
assert_eq!(applied(vec![30, 50], RowClick::AddRange(vec![20, 30, 40])), [30, 50, 20, 40]);
}
/// A large range gives the rows a search of the highlighted rows for each id gives, in the same
/// order, with repeated ids and rows already highlighted kept once.
#[test]
fn a_large_range_applies_as_a_search_of_the_rows_for_each_id_does() {
let searched = |mut rows: Vec<u32>, range: &[u32]| {
for k in range {
if !rows.contains(k) {
rows.push(*k);
}
}
rows
};
let mut range: Vec<u32> = (0..5_000).collect();
range.extend([7, 4_999, 0]);
let before = vec![4_000, 9_000, 2, 9_000];
let mut added = before.clone();
apply_row_click(&mut added, &RowClick::AddRange(range.clone()));
assert_eq!(added, searched(before.clone(), &range));
assert_eq!(added.len(), 5_002, "the 5,000 ids, the row outside the range and its repeat");
let mut set = before;
apply_row_click(&mut set, &RowClick::Range(range.clone()));
assert_eq!(set, searched(Vec::new(), &range));
assert_eq!(set.len(), 5_000);
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.