Add size preset icon box for single and multiple layers

This commit is contained in:
Dandaedre 2026-11-17 14:55:04 +01:00
parent c54a3fd4aa
commit 328bb722ff
Signed by: Dandaedre
GPG Key ID: 440C6592E8A26D99
21 changed files with 848 additions and 17 deletions

2
Cargo.lock generated
View File

@ -548,7 +548,7 @@ dependencies = [
[[package]]
name = "canvas-pilot"
version = "0.9.27"
version = "0.9.28"
dependencies = [
"base64",
"craft-dwg",

View File

@ -4,7 +4,7 @@ default-members = ["crates/canvas-pilot"]
resolver = "3"
[workspace.package]
version = "0.9.27"
version = "0.9.28"
edition = "2024"
license = "MIT"
repository = "https://proxy.dandaedre.com/gitea/idle-org/canvas-pilot"

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "Crop & mask",
"ui.canvas": "Canvas",
"theme.packs": "Theme packs",
"theme.install-pack": "Install theme pack…"
"theme.install-pack": "Install theme pack…",
"preset.fullscreen": "Fullscreen",
"preset.quarter": "Quarter",
"preset.tiling": "Tiling",
"preset.portrait": "Portrait",
"preset.landscape": "Landscape"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "Tondado kaj masko",
"ui.canvas": "Kanvaso",
"theme.packs": "Temaj pakoj",
"theme.install-pack": "Instali teman pakon…"
"theme.install-pack": "Instali teman pakon…",
"preset.fullscreen": "Plenekrane",
"preset.quarter": "Kvarono",
"preset.tiling": "Kahelado",
"preset.portrait": "Vertikale",
"preset.landscape": "Horizontale"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "Recorte y máscara",
"ui.canvas": "Lienzo",
"theme.packs": "Paquetes de temas",
"theme.install-pack": "Instalar paquete de temas…"
"theme.install-pack": "Instalar paquete de temas…",
"preset.fullscreen": "Pantalla completa",
"preset.quarter": "Cuarto",
"preset.tiling": "Mosaico",
"preset.portrait": "Vertical",
"preset.landscape": "Horizontal"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "Recadrage et masque",
"ui.canvas": "Canevas",
"theme.packs": "Packs de thèmes",
"theme.install-pack": "Installer un pack de thèmes…"
"theme.install-pack": "Installer un pack de thèmes…",
"preset.fullscreen": "Plein écran",
"preset.quarter": "Quart",
"preset.tiling": "Mosaïque",
"preset.portrait": "Portrait",
"preset.landscape": "Paysage"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "Περικοπὴ καὶ κάλυμμα",
"ui.canvas": "Πίναξ",
"theme.packs": "Δέσμαι θεμάτων",
"theme.install-pack": "Ἐγκατάστησον δέσμην θεμάτων…"
"theme.install-pack": "Ἐγκατάστησον δέσμην θεμάτων…",
"preset.fullscreen": "Ὅλη ὀθόνη",
"preset.quarter": "Τέταρτον",
"preset.tiling": "Πλακόστρωσις",
"preset.portrait": "Ὄρθιον",
"preset.landscape": "Πλάγιον"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "क्रॉप और मास्क",
"ui.canvas": "कैनवास",
"theme.packs": "थीम पैक",
"theme.install-pack": "थीम पैक स्थापित करें…"
"theme.install-pack": "थीम पैक स्थापित करें…",
"preset.fullscreen": "पूर्ण स्क्रीन",
"preset.quarter": "चौथाई",
"preset.tiling": "टाइल व्यवस्था",
"preset.portrait": "लंबवत",
"preset.landscape": "क्षैतिज"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "クロップとマスク",
"ui.canvas": "キャンバス",
"theme.packs": "テーマパック",
"theme.install-pack": "テーマパックをインストール…"
"theme.install-pack": "テーマパックをインストール…",
"preset.fullscreen": "全画面",
"preset.quarter": "4分の1",
"preset.tiling": "タイル配置",
"preset.portrait": "縦向き",
"preset.landscape": "横向き"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "क्रप र मास्क",
"ui.canvas": "क्यानभास",
"theme.packs": "थिम प्याकहरू",
"theme.install-pack": "थिम प्याक स्थापना गर्नुहोस्…"
"theme.install-pack": "थिम प्याक स्थापना गर्नुहोस्…",
"preset.fullscreen": "पूरा पर्दा",
"preset.quarter": "चौथाइ",
"preset.tiling": "टाइल मिलान",
"preset.portrait": "ठाडो",
"preset.landscape": "तेर्सो"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "Recorte e máscara",
"ui.canvas": "Tela",
"theme.packs": "Pacotes de temas",
"theme.install-pack": "Instalar pacote de temas…"
"theme.install-pack": "Instalar pacote de temas…",
"preset.fullscreen": "Ecrã inteiro",
"preset.quarter": "Quarto",
"preset.tiling": "Mosaico",
"preset.portrait": "Retrato",
"preset.landscape": "Paisagem"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "ครอบตัดและมาสก์",
"ui.canvas": "พื้นที่ทำงาน",
"theme.packs": "แพ็กธีม",
"theme.install-pack": "ติดตั้งแพ็กธีม…"
"theme.install-pack": "ติดตั้งแพ็กธีม…",
"preset.fullscreen": "เต็มหน้าจอ",
"preset.quarter": "หนึ่งส่วนสี่",
"preset.tiling": "เรียงกระเบื้อง",
"preset.portrait": "แนวตั้ง",
"preset.landscape": "แนวนอน"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "kipisi en len",
"ui.canvas": "supa sitelen",
"theme.packs": "kulupu kule",
"theme.install-pack": "o pana e kulupu kule…"
"theme.install-pack": "o pana e kulupu kule…",
"preset.fullscreen": "selo ale",
"preset.quarter": "kipisi pi tu tu",
"preset.tiling": "kulupu leko",
"preset.portrait": "poka sewi",
"preset.landscape": "poka lili"
}

View File

@ -488,5 +488,10 @@
"ui.crop-mask": "裁剪与遮罩",
"ui.canvas": "画布",
"theme.packs": "主题包",
"theme.install-pack": "安装主题包…"
"theme.install-pack": "安装主题包…",
"preset.fullscreen": "全屏",
"preset.quarter": "四分之一",
"preset.tiling": "平铺",
"preset.portrait": "纵向",
"preset.landscape": "横向"
}

View File

@ -21,6 +21,8 @@ mod ratio_ui;
mod recovery_ui;
#[path = "reference_ui.rs"]
mod reference_ui;
#[path = "size_presets_ui.rs"]
mod size_presets_ui;
#[path = "viewport_guides.rs"]
mod viewport_guides;
use canvas_pilot::import::{DetectedShape, ImportDocument, parse_values};
@ -78,6 +80,7 @@ pub struct Editor {
ratio_edit: ratio_ui::RatioEdit,
ratio_layer: Option<usize>,
resize_mode: ResizeMode,
size_tiles: [u16; 2],
grid_tool: Option<u32>,
pivot_tool: bool,
pivot_drag: Option<(usize, Layout)>,
@ -404,6 +407,7 @@ impl Default for Editor {
ratio_edit: Default::default(),
ratio_layer: None,
resize_mode: ResizeMode::Individual,
size_tiles: [2, 2],
grid_tool: None,
pivot_tool: false,
pivot_drag: None,
@ -2905,6 +2909,11 @@ impl Editor {
}
let button = |index: usize| buttons[index].translate(r.min.to_vec2());
let extra_height = toolbar_bottom - 56.0;
self.size_preset_toolbar(
ui,
[button(17), button(18), button(19), button(20), button(21)],
names,
);
if toolbar_icon(ui, button(13), "Output format", ToolbarIcon::Output).clicked() {
self.output_draft = Some(OutputDraft::new(output));
}
@ -4516,8 +4525,8 @@ enum ToolbarIcon {
}
// Keep related tools together when wrapping; reserve caption space per group.
fn toolbar_groups(width: f32, captions: bool) -> ([Rect; 17], Vec<Rect>, f32) {
let mut buttons = [Rect::NOTHING; 17];
fn toolbar_groups(width: f32, captions: bool) -> ([Rect; 22], Vec<Rect>, f32) {
let mut buttons = [Rect::NOTHING; 22];
let mut groups = Vec::new();
let mut x = 24.0;
let mut y = 20.0;
@ -4529,13 +4538,15 @@ fn toolbar_groups(width: f32, captions: bool) -> ([Rect; 17], Vec<Rect>, f32) {
&[6, 7, 8, 9],
&[10, 11, 16, 12],
&[13, 14],
&[17, 18, 19, 20, 21],
] {
let cell_width = |slot| match slot {
0 | 15 => 68.0,
11 => 56.0,
8 | 9 if captions => 80.0,
8 | 9 | 17..=21 if captions => 80.0,
_ if captions => 56.0,
1 | 10 | 14 => 44.0,
17..=21 => 34.0,
_ => 36.0,
};
let group_width = slots.iter().map(|&slot| cell_width(slot)).sum::<f32>() + 8.0;
@ -5739,6 +5750,7 @@ mod tests {
&[6, 7, 8, 9],
&[10, 11, 16, 12],
&[13, 14],
&[17, 18, 19, 20, 21],
] {
assert!(
slots

View File

@ -13,6 +13,7 @@ pub mod import;
pub mod input_proposal;
pub mod interchange;
pub mod project;
pub mod size_presets;
pub mod snapping;
#[cfg(all(feature = "vendor_formats", not(feature = "no_proprietary")))]
mod vendor_formats;

View File

@ -0,0 +1,105 @@
//! Explicit size presets in output-screen pixels, committed as one geometry edit.
use crate::{Geometry, Layout};
/// Position and size selected layers without routing sources or changing stacking.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SizePreset {
/// Every selected layer covers the output screen.
Fullscreen,
/// One half-width, half-height layer at a position in a 3×3 alignment grid.
Quarter { column: u8, row: u8 },
/// Fill cells left-to-right, top-to-bottom; excess layers repeat cells.
Tiles { columns: u16, rows: u16 },
/// Put the shorter dimension on X, preserving top-left position.
Portrait,
/// Put the longer dimension on X, preserving top-left position.
Landscape,
}
impl Layout {
/// Apply a preset in layer-list order, including members of collapsed folders.
/// All affected geometry/crop changes succeed together and share one Undo step.
pub fn apply_size_preset(&mut self, preset: SizePreset) -> Result<(), String> {
let selected = self.selected_indices();
if selected.is_empty() {
return Err("Select at least one layer for a size preset.".into());
}
if selected.iter().any(|&i| !self.selectable(i)) {
return Err("Unlock and show selected layers before resizing them.".into());
}
match preset {
SizePreset::Quarter { column, row } if column > 2 || row > 2 || selected.len() != 1 => {
return Err("Choose one layer and a position in the 3×3 quarter grid.".into());
}
SizePreset::Tiles { columns, rows }
if !(1..=256).contains(&columns) || !(1..=256).contains(&rows) =>
{
return Err("Use 1–256 columns and rows.".into());
}
_ => {}
}
let mut seen = std::collections::BTreeSet::new();
let mut order = Vec::new();
for i in (0..self.layers.len()).rev() {
let folder = &self.info[i].folder;
if folder.is_empty() {
if self.selected[i] {
order.push(i);
}
} else if seen.insert(folder.clone()) {
order.extend(
self.folder_members(folder)
.into_iter()
.rev()
.filter(|&j| self.selected[j]),
);
}
}
let [width, height] = self.formats.output.map(f64::from);
let mut next = self.layers.clone();
for (position, i) in order.into_iter().enumerate() {
let original = next[i];
next[i] = match preset {
SizePreset::Fullscreen => Geometry {
x: 0.0,
y: 0.0,
width,
height,
},
SizePreset::Quarter { column, row } => Geometry {
x: f64::from(column) * width / 4.0,
y: f64::from(row) * height / 4.0,
width: width / 2.0,
height: height / 2.0,
},
SizePreset::Tiles { columns, rows } => {
let column = position
% (usize::from(columns) * usize::from(rows))
% usize::from(columns);
let row = position % (usize::from(columns) * usize::from(rows))
/ usize::from(columns);
let cell_width = width / f64::from(columns);
let cell_height = height / f64::from(rows);
Geometry {
x: column as f64 * cell_width,
y: row as f64 * cell_height,
width: cell_width,
height: cell_height,
}
}
SizePreset::Portrait => Geometry {
width: original.width.min(original.height),
height: original.width.max(original.height),
..original
},
SizePreset::Landscape => Geometry {
width: original.width.max(original.height),
height: original.width.min(original.height),
..original
},
};
}
self.finish_drag();
self.commit(next)
}
}

View File

@ -0,0 +1,393 @@
use super::*;
use canvas_pilot::size_presets::SizePreset;
#[derive(Clone, Copy)]
enum Icon {
Fullscreen,
Quarter,
Tiles,
Portrait,
Landscape,
}
impl Icon {
fn key(self) -> &'static str {
match self {
Self::Fullscreen => "preset.fullscreen",
Self::Quarter => "preset.quarter",
Self::Tiles => "preset.tiling",
Self::Portrait => "preset.portrait",
Self::Landscape => "preset.landscape",
}
}
}
fn paint_icon(ui: &egui::Ui, rect: Rect, icon: Icon, enabled: bool) {
let palette = theme::palette(ui.ctx());
let color = if enabled {
palette.text
} else {
palette.muted.gamma_multiply(0.5)
};
let stroke = Stroke::new(1.5, color);
let center = rect.center();
let size = match icon {
Icon::Portrait => Vec2::new(13.0, 22.0),
Icon::Landscape => Vec2::new(24.0, 13.0),
_ => Vec2::new(24.0, 18.0),
};
let screen = Rect::from_center_size(center, size);
ui.painter()
.rect_stroke(screen, 1.0, stroke, StrokeKind::Inside);
match icon {
Icon::Fullscreen => {
ui.painter().rect_filled(
screen.shrink(4.0),
0.0,
palette.cyan.gamma_multiply(if enabled { 0.9 } else { 0.3 }),
);
}
Icon::Quarter | Icon::Tiles => {
let columns = if matches!(icon, Icon::Tiles) { 3 } else { 2 };
for column in 1..columns {
let x = screen.left() + screen.width() * column as f32 / columns as f32;
ui.painter().line_segment(
[Pos2::new(x, screen.top()), Pos2::new(x, screen.bottom())],
stroke,
);
}
ui.painter()
.line_segment([screen.left_center(), screen.right_center()], stroke);
ui.painter().rect_filled(
Rect::from_min_size(
screen.min + Vec2::splat(2.0),
Vec2::new(
screen.width() / columns as f32 - 3.0,
screen.height() / 2.0 - 3.0,
),
),
0.0,
palette.cyan.gamma_multiply(if enabled { 0.9 } else { 0.3 }),
);
}
Icon::Portrait | Icon::Landscape => {
ui.painter().line_segment(
[screen.min + Vec2::splat(4.0), screen.max - Vec2::splat(4.0)],
stroke,
);
}
}
}
impl Editor {
fn size_presets_enabled(&self) -> bool {
!self.layout.selected_indices().is_empty()
&& !self.layout.dragging()
&& !self
.format_draft
.as_ref()
.is_some_and(|draft| draft.pending(&self.layout))
&& !(self.fields_edited && self.fields_pending())
&& !self.ratio_edit.dirty
}
fn apply_size_preset(&mut self, preset: SizePreset) {
if !self.size_presets_enabled() {
return;
}
match self.layout.apply_size_preset(preset) {
Ok(()) => {
if self.format_draft.is_some() {
self.format_draft = self
.layout
.selected()
.map(|i| FormatDraft::new(&self.layout, i));
}
self.sync();
}
Err(error) => self.error = error,
}
}
pub(super) fn size_preset_toolbar(
&mut self,
ui: &mut egui::Ui,
rects: [Rect; 5],
captions: bool,
) {
let enabled = self.size_presets_enabled();
let palette = theme::palette(ui.ctx());
for (rect, icon) in rects.into_iter().zip([
Icon::Fullscreen,
Icon::Quarter,
Icon::Tiles,
Icon::Portrait,
Icon::Landscape,
]) {
let label = tr(ui.ctx(), icon.key());
let response = ui
.add_enabled_ui(enabled, |ui| {
let response = ui.interact(
rect,
egui::Id::new(("size-preset", icon.key())),
egui::Sense::click(),
);
response.widget_info(|| {
egui::WidgetInfo::labeled(egui::WidgetType::Button, enabled, &label)
});
if response.hovered() || response.has_focus() {
ui.painter()
.rect_filled(rect.shrink(1.0), 3.0, palette.purple);
}
paint_icon(ui, rect, icon, enabled);
response
})
.inner;
if matches!(icon, Icon::Quarter | Icon::Tiles) {
egui::Popup::menu(&response)
.close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
.show(|ui| {
if matches!(icon, Icon::Quarter) {
self.quarter_presets_menu(ui);
} else {
self.tiling_presets_menu(ui);
}
});
} else if response.clicked() {
self.apply_size_preset(match icon {
Icon::Fullscreen => SizePreset::Fullscreen,
Icon::Portrait => SizePreset::Portrait,
_ => SizePreset::Landscape,
});
}
response.on_hover_text(if enabled {
label.clone()
} else {
format!("{label} — select layers and finish pending numeric edits first")
});
if captions {
ui.painter().text(
rect.center_bottom() + Vec2::new(0.0, 7.0),
Align2::CENTER_TOP,
label,
FontId::proportional(11.0),
palette.muted,
);
}
}
}
fn quarter_presets_menu(&mut self, ui: &mut egui::Ui) {
let count = self.layout.selected_indices().len();
ui.label(tr(ui.ctx(), "preset.quarter"));
if count == 1 {
let labels = [
["Top left", "Top middle", "Top right"],
["Middle left", "Center", "Middle right"],
["Bottom left", "Bottom middle", "Bottom right"],
];
for (row, labels) in labels.into_iter().enumerate() {
ui.horizontal(|ui| {
for (column, label) in labels.into_iter().enumerate() {
let (_, rect) = ui.allocate_space(Vec2::new(48.0, 38.0));
let response = ui.interact(
rect,
egui::Id::new(("quarter-position", column, row)),
egui::Sense::click(),
);
let p = theme::palette(ui.ctx());
let screen = rect.shrink(5.0);
ui.painter().rect_stroke(
screen,
1.0,
Stroke::new(1.0, p.text),
StrokeKind::Inside,
);
let quarter = Rect::from_min_size(
screen.min
+ Vec2::new(
column as f32 * screen.width() / 4.0,
row as f32 * screen.height() / 4.0,
),
screen.size() / 2.0,
);
ui.painter().rect_filled(
quarter,
0.0,
if response.hovered() { p.amber } else { p.cyan },
);
response.widget_info(|| {
egui::WidgetInfo::labeled(egui::WidgetType::Button, true, label)
});
if response.on_hover_text(label).clicked() {
self.apply_size_preset(SizePreset::Quarter {
column: column as u8,
row: row as u8,
});
ui.close();
}
}
});
}
} else {
if count == 2 {
for (label, columns, rows) in [("Up / Down", 1, 2), ("Left / Right", 2, 1)] {
if ui.button(label).clicked() {
self.apply_size_preset(SizePreset::Tiles { columns, rows });
ui.close();
}
}
}
if count >= 3 && ui.button("Four quarters").clicked() {
self.apply_size_preset(SizePreset::Tiles {
columns: 2,
rows: 2,
});
ui.close();
}
if count > 4 {
ui.weak("After the fourth layer, quarter positions repeat.");
}
ui.weak("Layer-list order: left to right, then top to bottom.");
}
}
fn tiling_presets_menu(&mut self, ui: &mut egui::Ui) {
ui.label(tr(ui.ctx(), "preset.tiling"));
ui.horizontal(|ui| {
ui.label("X (columns)");
ui.add(egui::DragValue::new(&mut self.size_tiles[0]).range(1..=256));
ui.label("Y (rows)");
ui.add(egui::DragValue::new(&mut self.size_tiles[1]).range(1..=256));
});
let count = self.layout.selected_indices().len();
let [columns, rows] = self.size_tiles;
ui.label(format!(
"{count} selected layers · {} cells",
u32::from(columns) * u32::from(rows)
));
ui.weak("Layer-list order: left to right, then top to bottom.");
if count > usize::from(columns) * usize::from(rows) {
ui.weak("More layers than cells: positions repeat and layers overlap.");
}
if ui
.add_enabled(
self.size_presets_enabled(),
egui::Button::new("Apply tiling"),
)
.clicked()
{
self.apply_size_preset(SizePreset::Tiles { columns, rows });
ui.close();
}
}
}
#[cfg(test)]
mod tests {
use super::super::tests::{click_text, frame, mouse};
use super::*;
fn click_id(app: &mut Editor, ctx: &egui::Context, id: egui::Id) {
frame(app, ctx, vec![]);
frame(app, ctx, vec![]);
let point = ctx.read_response(id).unwrap().rect.center();
frame(
app,
ctx,
vec![egui::Event::PointerMoved(point), mouse(point, true)],
);
frame(app, ctx, vec![mouse(point, false)]);
}
fn icon(app: &mut Editor, ctx: &egui::Context, key: &str) {
click_id(app, ctx, egui::Id::new(("size-preset", key)));
}
#[test]
fn icon_box_applies_single_quarter_fullscreen_and_orientation() {
let ctx = egui::Context::default();
let mut app = Editor::default();
app.layout.select(Some(1));
app.sync();
icon(&mut app, &ctx, "preset.quarter");
click_id(
&mut app,
&ctx,
egui::Id::new(("quarter-position", 2_usize, 2_usize)),
);
assert_eq!(
app.layout.layers()[1],
Geometry {
x: 960.0,
y: 540.0,
width: 960.0,
height: 540.0
}
);
icon(&mut app, &ctx, "preset.portrait");
assert_eq!(
app.layout.layers()[1],
Geometry {
x: 960.0,
y: 540.0,
width: 540.0,
height: 960.0
}
);
icon(&mut app, &ctx, "preset.landscape");
assert_eq!(app.layout.layers()[1].width, 960.0);
icon(&mut app, &ctx, "preset.fullscreen");
assert_eq!(
app.layout.layers()[1],
Geometry {
x: 0.0,
y: 0.0,
width: 1920.0,
height: 1080.0
}
);
app.layout.undo();
assert_eq!(app.layout.layers()[1].x, 960.0);
}
#[test]
fn multi_selection_submenu_changes_with_count_and_tiling_uses_requested_grid() {
let ctx = egui::Context::default();
let mut app = Editor::default();
app.layout.set_selection([true, true]);
app.sync();
icon(&mut app, &ctx, "preset.quarter");
let output = frame(&mut app, &ctx, vec![]);
assert!(!output.shapes.iter().any(|shape| matches!(&shape.shape, egui::Shape::Text(text) if text.galley.text() == "Four quarters")));
click_text(&mut app, &ctx, "Left / Right");
assert_eq!(app.layout.layers()[1].width, 960.0);
assert_eq!(app.layout.layers()[0].x, 960.0);
for _ in 0..3 {
app.layout.add_layer().unwrap();
}
app.layout.set_selection([true; 5]);
app.sync();
icon(&mut app, &ctx, "preset.quarter");
let output = frame(&mut app, &ctx, vec![]);
assert!(!output.shapes.iter().any(|shape| matches!(&shape.shape, egui::Shape::Text(text) if text.galley.text() == "Left / Right")));
click_text(&mut app, &ctx, "Four quarters");
assert_eq!(app.layout.layers()[0], app.layout.layers()[4]);
app.size_tiles = [3, 2];
icon(&mut app, &ctx, "preset.tiling");
click_text(&mut app, &ctx, "Apply tiling");
assert_eq!(app.layout.layers()[4].width, 640.0);
assert_eq!(app.layout.layers()[4].height, 540.0);
assert_eq!(app.layout.layers()[0].x, 640.0);
assert_eq!(app.layout.layers()[0].y, 540.0);
}
#[test]
fn empty_selection_and_pending_numeric_values_disable_presets() {
let ctx = egui::Context::default();
let mut app = Editor::default();
app.layout.select(None);
app.sync();
let before = app.project();
icon(&mut app, &ctx, "preset.fullscreen");
assert_eq!(app.project(), before);
app.layout.select(Some(1));
app.sync();
app.fields[0] = "-".into();
app.fields_edited = true;
let before = app.project();
app.apply_size_preset(SizePreset::Fullscreen);
assert_eq!(app.project(), before);
assert_eq!(app.fields[0], "-");
}
}

View File

@ -0,0 +1,221 @@
use canvas_pilot::{DeviceLink, Geometry, Layout, project::Project, size_presets::SizePreset};
fn close(a: f64, b: f64) {
assert!((a - b).abs() < 1e-8, "{a} != {b}");
}
#[test]
fn full_screen_and_nine_quarter_positions_use_exact_output_dimensions() {
let mut layout = Layout::default();
layout.set_output([1919, 1079]).unwrap();
layout.select(Some(0));
let unselected = layout.layers()[1];
for row in 0..3 {
for column in 0..3 {
let before = Project::from_layout(&layout);
layout
.apply_size_preset(SizePreset::Quarter { column, row })
.unwrap();
let g = layout.layers()[0];
assert_eq!(
g,
Geometry {
x: column as f64 * 479.75,
y: row as f64 * 269.75,
width: 959.5,
height: 539.5
}
);
assert_eq!(layout.layers()[1], unselected);
layout.undo();
assert_eq!(Project::from_layout(&layout), before);
}
}
layout.set_selection([true, true]);
let before = Project::from_layout(&layout);
layout.apply_size_preset(SizePreset::Fullscreen).unwrap();
for g in layout.layers() {
assert_eq!(
*g,
Geometry {
x: 0.0,
y: 0.0,
width: 1919.0,
height: 1079.0
}
);
}
layout.undo();
assert_eq!(Project::from_layout(&layout), before);
layout.redo();
assert_eq!(layout.layers()[0], layout.layers()[1]);
}
#[test]
fn tiling_follows_folder_list_order_and_repeats_cells_without_reordering() {
let mut layout = Layout::default();
for _ in 0..4 {
layout.add_layer().unwrap();
}
layout.assign_folder(&[1, 4], "Cameras").unwrap();
layout.set_selection([true; 6]);
layout
.set_device_link(
0,
Some(DeviceLink {
family: Default::default(),
screen: "1".into(),
layer: "1".into(),
}),
)
.unwrap();
layout
.set_mask(
0,
canvas_pilot::formats::Mask {
left: 0.1,
..Default::default()
},
)
.unwrap();
let before = Project::from_layout(&layout);
let formats = layout.formats().clone();
let identities: Vec<_> = (0..6).map(|i| layout.layer_info(i).clone()).collect();
layout
.apply_size_preset(SizePreset::Tiles {
columns: 2,
rows: 2,
})
.unwrap();
for (slot, id) in [6, 5, 4, 1, 3, 2].into_iter().enumerate() {
let i = (0..6).find(|&i| layout.layer_info(i).id == id).unwrap();
assert_eq!(
layout.layers()[i],
Geometry {
x: (slot % 2) as f64 * 960.0,
y: ((slot % 4) / 2) as f64 * 540.0,
width: 960.0,
height: 540.0
}
);
}
assert_eq!(layout.formats().sources, formats.sources);
assert_eq!(layout.formats().source_for, formats.source_for);
assert_eq!(layout.formats().masks, formats.masks);
assert_eq!(layout.formats().layer_fit, formats.layer_fit);
assert_eq!(
(0..6)
.map(|i| layout.layer_info(i).clone())
.collect::<Vec<_>>(),
identities
);
layout.undo();
assert_eq!(Project::from_layout(&layout), before);
}
#[test]
fn halves_and_fractional_tiling_preserve_grid_edges() {
let mut layout = Layout::default();
layout.set_selection([true, true]);
layout
.apply_size_preset(SizePreset::Tiles {
columns: 1,
rows: 2,
})
.unwrap();
assert_eq!(
layout.layers()[1],
Geometry {
x: 0.0,
y: 0.0,
width: 1920.0,
height: 540.0
}
);
assert_eq!(layout.layers()[0].y, 540.0);
layout
.apply_size_preset(SizePreset::Tiles {
columns: 2,
rows: 1,
})
.unwrap();
assert_eq!(
layout.layers()[1],
Geometry {
x: 0.0,
y: 0.0,
width: 960.0,
height: 1080.0
}
);
assert_eq!(layout.layers()[0].x, 960.0);
layout.add_layer().unwrap();
layout.set_selection([true; 3]);
layout.set_output([1001, 777]).unwrap();
layout
.apply_size_preset(SizePreset::Tiles {
columns: 3,
rows: 1,
})
.unwrap();
close(layout.layers()[0].x + layout.layers()[0].width, 1001.0);
close(
layout.layers()[1].x + layout.layers()[1].width,
layout.layers()[0].x,
);
close(layout.layers()[2].width, 1001.0 / 3.0);
}
#[test]
fn orientation_changes_only_dimensions_and_repeated_orientation_is_noop() {
let mut layout = Layout::default();
layout.set_selection([true, true]);
let original = layout.layers().clone();
let formats = layout.formats().clone();
layout.apply_size_preset(SizePreset::Portrait).unwrap();
for (i, g) in layout.layers().iter().enumerate() {
assert_eq!([g.x, g.y], [original[i].x, original[i].y]);
assert_eq!([g.width, g.height], [original[i].height, original[i].width]);
}
layout.apply_size_preset(SizePreset::Portrait).unwrap();
layout.undo();
assert_eq!(*layout.layers(), original);
assert_eq!(*layout.formats(), formats);
layout.redo();
layout.apply_size_preset(SizePreset::Landscape).unwrap();
assert_eq!(*layout.layers(), original);
}
#[test]
fn preset_validation_and_hidden_locked_layers_cannot_partially_change_document() {
let mut layout = Layout::default();
layout.set_selection([true, true]);
let before = Project::from_layout(&layout);
for preset in [
SizePreset::Tiles {
columns: 0,
rows: 2,
},
SizePreset::Tiles {
columns: 257,
rows: 1,
},
SizePreset::Quarter { column: 1, row: 1 },
] {
assert!(layout.apply_size_preset(preset).is_err());
assert_eq!(Project::from_layout(&layout), before);
}
layout.set_locked(0, true);
let protected = layout.layers()[0];
layout.apply_size_preset(SizePreset::Fullscreen).unwrap();
assert_eq!(layout.layers()[0], protected);
layout.set_visible(1, false);
assert!(layout.apply_size_preset(SizePreset::Fullscreen).is_err());
layout.set_visible(1, true);
layout.select(Some(1));
assert!(
layout
.apply_size_preset(SizePreset::Quarter { column: 3, row: 0 })
.is_err()
);
}

View File

@ -4,6 +4,16 @@
## Unreleased
### v0.9.28
- Added a toolbar icon box for selected-layer Fullscreen, Quarter, X/Y Tiling,
Portrait and Landscape presets. Quarter offers nine positions for one layer,
halves for two and four quarters for larger selections. Overflow repeats cells
with an explanation; placement follows the layer list, including folder members.
- Presets retain fractional geometry, preserve source/link/mask identity and commit
atomically with crop adjustment in one Undo step. Orientation keeps top-left
positions; explicit preset sizes override manual aspect-ratio locking.
### v0.9.27
- Enter now finishes viewport crop/mask editing, including clean Crop/Mask

View File

@ -39,6 +39,35 @@ not affect device links or source assignments. All document edits support Undo.
*Use the Layer tab for precise dimensions; the inspector keeps the selected layer in view. The header still uses the former Midra Layout name.*
## Size preset icon box
The toolbar's size preset icon box works on the selected visible, unlocked layers:
- **Fullscreen:** place every selected layer at the output's top-left and set its
width and height to the full output size. Multiple layers overlap intentionally.
- **Quarter:** with one layer, choose one of nine positions: top/middle/bottom and
left/center/right. The layer is half the output width and half its height.
With two selected layers, choose **Up / Down** halves or **Left / Right** halves.
With three or more, choose **Four quarters**. Selections over four repeat the
quarter positions, so extra layers overlap earlier ones.
- **Tiling:** set **X (columns)** and **Y (rows)**, then **Apply tiling**. Layers fill
cells left to right, then top to bottom. Empty cells remain empty; if there are
more layers than cells, positions repeat and the menu explains the overlap.
- **Portrait / Landscape:** swap each layer's dimensions only when needed for
that orientation. Its top-left position stays unchanged; square layers stay square.
This changes the box dimensions, not the rotation of the source picture.
Placement follows the layer list from top to bottom, including selected members
of collapsed folders. Presets use the output dimensions and preserve fractional
pixels for odd screen sizes or uneven tile divisions. These explicit sizes override
the manual aspect-ratio lock. Tiling counts range from 1 to 256 on each axis and
are retained for the current session.
Each operation is one Undo step, including any crop adjustment from resizing.
Sources, masks, layer names, folders, stacking and device links remain unchanged;
no device transfer occurs. Finish pending numeric/property edits before applying
a preset. Hover an icon for its name, or enable toolbar icon names in Options.
## Move and edit layers
- Click a layer or its list entry to select it alone. **Shift-click** toggles that