//! Versioned offline interchange. Contract: docs/interfaces/midra-layout.md. use crate::{ Corner, Geometry, Layout, PositionPoint, formats::{self, Aspect, Crop, Source}, }; use base64::{Engine, engine::general_purpose::STANDARD}; use serde::{Deserialize, Serialize}; use std::{ io::{Read, Write}, path::Path, }; pub const MAX_PROJECT_BYTES: u64 = 96 * 1024 * 1024; pub const DEFAULT_BACKDROP_TITLE: &str = "Example Conference Name"; pub const FORMAT: &str = "beffroi.midra-layout"; #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct Resolution { pub width: u32, pub height: u32, } impl From<[u32; 2]> for Resolution { fn from([width, height]: [u32; 2]) -> Self { Self { width, height } } } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct Input { pub id: usize, pub source_format: Aspect, pub native_resolution: Resolution, pub input_crop: Crop, } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct Layer { pub pivot: [f64; 2], #[serde(deserialize_with = "deserialize_link")] pub midra_link: Option, pub name: String, pub folder: String, pub id: usize, pub source_id: usize, pub bounds: Geometry, pub advanced_crop: Crop, pub visible: bool, pub locked: bool, } fn deserialize_link<'de, D: serde::Deserializer<'de>>( deserializer: D, ) -> Result, D::Error> { Option::::deserialize(deserializer) } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct Reference { pub name: String, pub image_base64: String, pub visible: bool, pub opacity: f32, pub preserve_ratio: bool, pub native_size: bool, pub offset: [f64; 2], } impl Reference { pub fn bytes(&self) -> Result, String> { if self .offset .iter() .any(|v| !v.is_finite() || v.abs() > 1_000_000.0) { return Err("Reference offsets must be finite and within ±1,000,000 pixels.".into()); } if !self.opacity.is_finite() || !(0.0..=1.0).contains(&self.opacity) { return Err("Reference opacity must be between 0 and 1.".into()); } if self.image_base64.len() > 90 * 1024 * 1024 { return Err("Reference image is too large.".into()); } let bytes = STANDARD .decode(&self.image_base64) .map_err(|e| format!("Invalid embedded reference: {e}"))?; if bytes.len() > 64 * 1024 * 1024 { return Err("Reference image exceeds 64 MiB.".into()); } Ok(bytes) } } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct EditorSettings { pub backdrop_title: String, pub selected_layer_ids: Vec, pub position_point: PositionPoint, #[serde(deserialize_with = "deserialize_layer_point")] pub position_layer_point: Option, pub keep_aspect_ratio: bool, pub viewport_zoom: f32, pub viewport_pan: [f32; 2], pub show_source_pattern: bool, pub show_toolbar_icon_names: bool, pub outline_layers: bool, } fn deserialize_layer_point<'de, D: serde::Deserializer<'de>>( deserializer: D, ) -> Result, D::Error> { Option::::deserialize(deserializer) } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct Project { pub format: String, pub version: u32, pub next_layer_id: usize, pub output_resolution: Resolution, pub inputs: Vec, pub layers: Vec, pub references: Vec, pub editor: EditorSettings, } impl Project { pub fn from_layout(layout: &Layout) -> Self { Self { format: FORMAT.into(), version: 10, next_layer_id: layout.next_id, output_resolution: layout.formats.output.into(), inputs: (0..layout.formats.sources.len()) .map(|i| { let source = layout.formats.sources[i]; Input { id: i + 1, source_format: source.aspect, native_resolution: source.native.into(), input_crop: source.input_crop, } }) .collect(), layers: (0..layout.layers.len()) .map(|i| Layer { pivot: layout.info[i].pivot, midra_link: layout.info[i].midra_link.clone(), name: layout.info[i].name.clone(), folder: layout.info[i].folder.clone(), id: layout.info[i].id, source_id: layout.formats.source_for[i] + 1, bounds: layout.layers[i], advanced_crop: layout.formats.advanced[i], visible: layout.visible[i], locked: layout.locked[i], }) .collect(), references: Vec::new(), editor: EditorSettings { backdrop_title: DEFAULT_BACKDROP_TITLE.into(), selected_layer_ids: layout .selected_indices() .into_iter() .map(|i| layout.info[i].id) .collect(), position_point: PositionPoint::TopLeft, position_layer_point: None, keep_aspect_ratio: true, viewport_zoom: 1.0, viewport_pan: [0.0; 2], show_source_pattern: false, show_toolbar_icon_names: false, outline_layers: false, }, } } /// Build a fresh document only after validating the entire file. No history is restored. pub fn layout(&self) -> Result { if self.format != FORMAT || self.version != 10 { return Err( "Unsupported project format/version; expected beffroi.midra-layout version 10." .into(), ); } if self.editor.backdrop_title.chars().count() > 128 || self.editor.backdrop_title.chars().any(char::is_control) { return Err("Backdrop title must be a single line of at most 128 characters.".into()); } let output = [self.output_resolution.width, self.output_resolution.height]; formats::validate_resolution(output)?; let mut layout = Layout::default(); if self.layers.is_empty() || self.layers.len() > 256 || self.inputs.is_empty() || self.inputs.len() > 1024 { return Err("Projects require 1–256 layers and 1–1024 input slots.".into()); } let count = self.layers.len(); layout.layers = vec![ Geometry { x: 0.0, y: 0.0, width: 640.0, height: 360.0 }; count ]; layout.info.clear(); layout.next_id = self.next_layer_id; layout.selected = vec![false; count]; layout.visible = vec![true; count]; layout.locked = vec![false; count]; layout.formats.sources = vec![Source::default(); self.inputs.len()]; layout.formats.source_for = vec![0; count]; layout.formats.advanced = vec![Crop::default(); count]; layout.formats.output = output; for (i, input) in self.inputs.iter().enumerate() { if input.id != i + 1 { return Err("Input IDs must be consecutive starting at 1.".into()); } let source = Source { aspect: input.source_format, native: [ input.native_resolution.width, input.native_resolution.height, ], input_crop: input.input_crop, }; source.input()?; layout.formats.sources[i] = source; } for (i, layer) in self.layers.iter().enumerate() { if layer.id == 0 || layer.id >= self.next_layer_id || layout.info.iter().any(|old| old.id == layer.id) || !(1..=self.inputs.len()).contains(&layer.source_id) || layer.name.trim().is_empty() || layer.name.chars().count() > 128 || layer.folder.chars().count() > 128 { return Err("Invalid layer identity, name, folder or source ID.".into()); } if let Some(link) = &layer.midra_link { link.validate()?; } crate::validate_pivot(layer.pivot)?; layout.info.push(crate::LayerInfo { pivot: layer.pivot, midra_link: layer.midra_link.clone(), id: layer.id, name: layer.name.clone(), folder: layer.folder.clone(), }); layer.bounds.validate()?; layout.layers[i] = layer.bounds; layout.formats.source_for[i] = layer.source_id - 1; layout.formats.advanced[i] = layer.advanced_crop; layout.formats.mapping(i, layer.bounds)?; layout.visible[i] = layer.visible; layout.locked[i] = layer.locked; } let e = &self.editor; if !e.viewport_zoom.is_finite() || !(0.0001..=256.0).contains(&e.viewport_zoom) || e.viewport_pan .iter() .any(|v| !v.is_finite() || v.abs() > 1e9) { return Err("Invalid viewport camera settings.".into()); } layout.selected = vec![false; count]; for &id in &e.selected_layer_ids { let index = layout .info .iter() .position(|info| info.id == id) .ok_or("Unknown selected layer ID")?; if layout.selected[index] || !layout.selectable(index) { return Err("Selected layer IDs must be unique, visible, unlocked layers.".into()); } layout.selected[index] = true; } if self.references.len() > 32 { return Err("A project supports up to 32 reference images.".into()); } let mut reference_bytes = 0; for r in &self.references { reference_bytes += r.bytes()?.len(); } if reference_bytes > 64 * 1024 * 1024 { return Err("Reference images exceed the combined 64 MiB limit.".into()); } Ok(layout) } pub fn to_json(&self) -> Result { self.layout()?; serde_json::to_string_pretty(self) .map(|s| s + "\n") .map_err(|e| e.to_string()) } pub fn from_json(text: &str) -> Result { if text.len() as u64 > MAX_PROJECT_BYTES { return Err("Project exceeds 96 MiB.".into()); } // Version 1 predates toolbar captions. Migrate only that known schema; // current files still require every field and reject unknown fields. #[derive(Deserialize)] struct Header { version: u32, } let header: Header = serde_json::from_str(text).map_err(|e| format!("Invalid project JSON: {e}"))?; if !(1..=10).contains(&header.version) { return Err("Unsupported project version; expected versions 1–10.".into()); } let mut migrated: serde_json::Value = if header.version == 1 || header.version == 2 { let mut value: serde_json::Value = serde_json::from_str(text).map_err(|e| format!("Invalid project JSON: {e}"))?; if header.version == 1 { let editor = value .get_mut("editor") .and_then(|v| v.as_object_mut()) .ok_or("Invalid version 1 editor settings.")?; if editor.contains_key("show_toolbar_icon_names") { return Err("Unexpected toolbar captions setting in version 1 project.".into()); } editor.insert("show_toolbar_icon_names".into(), false.into()); } if value.get("next_layer_id").is_some() { return Err("Unexpected identity counter in old project.".into()); } if value .get("inputs") .and_then(|v| v.as_array()) .is_none_or(|v| v.len() != 2) { return Err("Legacy projects must have two inputs.".into()); } let layers = value .get_mut("layers") .and_then(|v| v.as_array_mut()) .ok_or("Missing layers")?; if layers.len() != 2 { return Err("Legacy projects must have two layers.".into()); } for (i, layer) in layers.iter_mut().enumerate() { if layer.get("name").is_some() || layer.get("folder").is_some() || layer.get("id").and_then(|v| v.as_u64()) != Some((i + 1) as u64) { return Err("Invalid legacy layer fields".into()); } layer["name"] = if i == 0 { "Presenter" } else { "Slides" }.into(); layer["folder"] = "".into(); } value["next_layer_id"] = 3.into(); value["version"] = 3.into(); value } else { serde_json::from_str(text).map_err(|e| format!("Invalid project JSON: {e}"))? }; if (1..=3).contains(&header.version) { let editor = migrated .get_mut("editor") .and_then(|v| v.as_object_mut()) .ok_or("Missing editor settings")?; if editor.contains_key("outline_layers") { return Err("Unexpected outline setting in old project".into()); } editor.insert("outline_layers".into(), false.into()); if let Some(reference) = migrated .get_mut("reference") .and_then(|v| v.as_object_mut()) { if reference.contains_key("native_size") || reference.contains_key("offset") { return Err("Unexpected placement fields in old project".into()); } reference.insert("native_size".into(), false.into()); reference.insert("offset".into(), serde_json::json!([0.0, 0.0])); } migrated["version"] = 4.into(); } if (1..=4).contains(&header.version) { for layer in migrated["layers"].as_array_mut().ok_or("Missing layers")? { let layer = layer.as_object_mut().ok_or("Invalid layer")?; if layer.contains_key("midra_link") { return Err("Unexpected Midra link in old project".into()); } layer.insert("midra_link".into(), serde_json::Value::Null); } migrated["version"] = 5.into(); } if (1..=5).contains(&header.version) { let editor = migrated["editor"] .as_object_mut() .ok_or("Missing editor settings")?; if editor.contains_key("position_point") { return Err("Unexpected position point in old project".into()); } let corner = editor .remove("position_corner") .ok_or("Missing position corner")?; serde_json::from_value::(corner.clone()) .map_err(|e| format!("Invalid position corner: {e}"))?; editor.insert("position_point".into(), corner); migrated["version"] = 6.into(); } if (1..=6).contains(&header.version) { let editor = migrated["editor"] .as_object_mut() .ok_or("Missing editor settings")?; if editor.contains_key("backdrop_title") { return Err("Unexpected backdrop title in old project".into()); } editor.insert("backdrop_title".into(), DEFAULT_BACKDROP_TITLE.into()); migrated["version"] = 7.into(); } if (1..=7).contains(&header.version) { let editor = migrated["editor"] .as_object_mut() .ok_or("Missing editor settings")?; if editor.contains_key("position_layer_point") { return Err("Unexpected layer position point in old project".into()); } editor.insert("position_layer_point".into(), serde_json::Value::Null); migrated["version"] = 8.into(); } if (1..=8).contains(&header.version) { for layer in migrated["layers"].as_array_mut().ok_or("Missing layers")? { let layer = layer.as_object_mut().ok_or("Invalid layer")?; if layer.contains_key("pivot") { return Err("Unexpected layer pivot in old project".into()); } layer.insert("pivot".into(), serde_json::json!([0.5, 0.5])); } migrated["version"] = 9.into(); } if (1..=9).contains(&header.version) { let object = migrated.as_object_mut().ok_or("Invalid project")?; if object.contains_key("references") { return Err("Unexpected reference collection in old project".into()); } let reference = object .remove("reference") .ok_or("Missing reference field")?; object.insert( "references".into(), if reference.is_null() { serde_json::json!([]) } else { serde_json::json!([reference]) }, ); object.insert("version".into(), 10.into()); } let p: Self = serde_json::from_value(migrated).map_err(|e| format!("Invalid project JSON: {e}"))?; p.layout()?; Ok(p) } pub fn read(path: &Path) -> Result { let mut text = String::new(); std::fs::File::open(path) .map_err(|e| e.to_string())? .take(MAX_PROJECT_BYTES + 1) .read_to_string(&mut text) .map_err(|e| e.to_string())?; Self::from_json(&text) } /// Geometry exchange only: pixel-rounded rectangles, no device commands or hidden metadata. pub fn to_svg(&self, visible_only: bool) -> Result { self.svg_filtered(visible_only, None) } /// Export exactly the chosen stable IDs, preserving document stacking order. pub fn to_svg_ids(&self, ids: &[usize]) -> Result { if ids.is_empty() || ids.iter().enumerate().any(|(i, id)| { ids[..i].contains(id) || !self.layers.iter().any(|layer| layer.id == *id) }) { return Err("Choose distinct existing layer IDs to export.".into()); } self.svg_filtered(false, Some(ids)) } fn svg_filtered(&self, visible_only: bool, ids: Option<&[usize]>) -> Result { self.layout()?; if visible_only && self.layers.iter().all(|l| !l.visible) { return Err("No visible layers to export.".into()); } let w = self.output_resolution.width; let h = self.output_resolution.height; let mut svg = format!( "\nMidra Layout geometry\n" ); for layer in &self.layers { if (visible_only && !layer.visible) || ids.is_some_and(|ids| !ids.contains(&layer.id)) { continue; } let g = layer.bounds; if g.width.round() < 1.0 || g.height.round() < 1.0 { return Err("A layer rounds to zero pixels; enlarge it before SVG export.".into()); } svg.push_str(&format!("\n",layer.id,crate::export_pixels(g.x),crate::export_pixels(g.y),crate::export_pixels(g.width),crate::export_pixels(g.height))); } svg.push_str("\n"); Ok(svg) } } /// Same-directory temporary write and atomic publication. Existing files require explicit consent. pub fn write_file(path: &Path, contents: &[u8], overwrite: bool) -> Result<(), String> { let parent = path .parent() .filter(|p| !p.as_os_str().is_empty()) .unwrap_or(Path::new(".")); let mut file = tempfile::NamedTempFile::new_in(parent).map_err(|e| e.to_string())?; file.write_all(contents) .and_then(|_| file.as_file().sync_all()) .map_err(|e| e.to_string())?; if overwrite { file.persist(path).map_err(|e| e.to_string())?; } else { file.persist_noclobber(path).map_err(|e| e.to_string())?; } Ok(()) }