2bc41aeb8602
webexport.rs
//! File โ Export โ Save for Web (Legacy): an optimised web image โ GIF, JPEG, PNG-8 or PNG-24 โ
//! of an artboard or of the art, or one image per slice with an HTML page placing them, plus the
//! named settings the dialog and `webExport.presets.*` keep ([`WebSettings`], [`WebPreset`]).
//!
//! The pipeline: [`render`] draws the region once (straight RGBA at the output size); [`optimize`]
//! turns pixels into a file with the settings (palette reduction and the colour table's edits, web
//! snap, lossy, JPEG quality, metadata); [`decode`] reads a file back for the dialog's preview, so
//! what the preview shows and the size it reports are what Save writes. Slices are cut from the one
//! rendering, each optimised on its own.
use std::collections::HashSet;
use serde::de::Error as _;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{Value, json};
use vectorcraft_doc::slices::SliceArea;
use vectorcraft_doc::{CellAlign, CellVAlign, Document, NodeId, NodeKind, SliceKind};
use vectorcraft_geom::Rect;
use vectorcraft_render::AntiAlias;
use vectorcraft_render::encode::quantize::{self, Dither, Indexed, PaletteOptions, Reduction};
use vectorcraft_render::encode::web::{self, ColorSort};
use vectorcraft_render::encode::{gif, jpeg, png};
use super::{CommandSpec, Result, Session, always, bad, bool_or, cmd, f64_or, has_doc, str_param, unique_name_from};
const C: &str = "document.exportForWeb";
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
"document.exportForWeb",
"Save for Web",
[],
None,
"{path?, preset?: a webExport.presets name (its settings, then these keys), format?: gif (default)|jpg|png8|png24, reduction?: perceptual|selective (default)|adaptive|web|blackWhite|gray (gif/png8, as the next five), colors?: 128 (2โ256), dither?: none|diffusion (default)|pattern|noise, ditherAmount?: 100, webSnap?: 0 (0โ100 %: colours that close to a web-safe one become it), lossy?: 0 (0โ100, gif), colorTable?: {locked?: [\"#rrggbb\"โฆ] (kept when reducing), transparent?: [\"#rrggbb\"โฆ] (become transparent), webShift?: [\"#rrggbb\"โฆ] (become web-safe), sort?: none|hue|luminance|popularity, deleted?: [\"#rrggbb\"โฆ] (taken out of the table: their pixels take the nearest color left, and at least one color stays), customPalette?: [\"#rrggbb\"โฆ] (a fixed palette used instead of the reduction's, at most `colors` entries, its transparent colors taking one slot together; a new reduction without colorTable clears it and deleted), shifted?: {\"#source\": \"#rrggbb\"โฆ} (each source color is written as the color given, wherever it is in the image; kept when reducing as a locked color is, before the locked ones, while one palette slot is left for the reduction; at most 256; a source the table does not hold shifts nothing; a color shifted to itself is removed; a shifted color is not web-shifted, and a transparent one stays transparent; GIF lossy moves no pixel into or out of a shifted color)} (colours as the preview's colors[].source; #rrggbbaa and #rgba are refused here and in matte), transparency?: true (gif/png8/png24), matte?: white (default)|black|none|\"#rrggbb\" (what edges blend into; jpg and opaque png24: the background), interlaced?: false (gif/png8/png24), quality?: 60 (jpg: 0โ100), progressive?: false (jpg), optimized?: true (jpg), embedProfile?: false (jpg: sRGB profile), width?: px | height?: px | percent?: 100 (the image size, proportional; width wins over height, height over percent), antiAlias?: none|art (default)|type, clipToArtboard?: true (the artboard; false: the art and the slices), artboard?: 0 (0-based), convertToSrgb?: true (PNG files say they are sRGB), metadata?: none|copyright (default)|contact|all (File Info written as PNG text, a GIF or JPEG comment), slices?: all (default)|selected|none (one image per slice: images/<slice name>.<ext>), output?: images (default)|html (an HTML page placing the image or slices, <stem>.html)} โ {path, files: [pathโฆ], bytes (total), width, height, warnings: [] or [a note that an image couldn't be decoded and is missing from the image]}; no path โ {files: [{name, dataBase64}], bytes, width, height, warnings} (names such as page.html, images/page_01.gif). A single image without HTML is written at path itself",
has_doc,
export
),
cmd!(
query "document.exportForWeb.preview",
"Save for Web Preview",
[],
None,
"{โฆthe settings of document.exportForWeb (preset?, format?โฆ), slice?: n (1-based, from slice.list; default the whole image), kbps?: 56.6 (connection speed for the download time), image?: false (also the optimised file as dataBase64)} what Save writes for the whole image (or one slice) โ {format, width, height, bytes (exactly the file's size), seconds (to download at kbps), kbps, colors?: [{color: \"#rrggbb\", source: \"#rrggbb\" (the colour the reduction made, as colorTable lists it), transparent, locked, webShifted, shifted (by colorTable.shifted; also locked), webSafe}] (gif/png8: the colour table in file order), mappedToTransparent?: [\"#rrggbb\"โฆ], slices: images an export writes, warnings (as document.exportForWeb's), dataBase64?}",
has_doc,
preview
),
cmd!(
query "webExport.optimizeToFileSize",
"Optimize to File Size",
[],
None,
"{desiredK: the desired file size in K (1024 bytes; above 0, at most 1048576), startWith?: current (default: the format given, its JPEG quality or GIF/PNG-8 colors lowered; GIF then takes lossy 100)|auto (GIF for art with transparency or at most 256 colors (blended over the matte without transparency), else JPEG; the other one when the first can't reach the size and the art is opaque), use?: allSlices (default: the image, or the image slices' files together)|eachSlice (every image slice's file)|currentSlice (the `slice` given, else the selected image slice, else the first), slice?: n (1-based, from slice.list), preset?, โฆthe settings of document.exportForWeb} the settings whose files fit in the size, searched by encoding at most 32 trial settings (each one encodes every image it measures); slices share one setting, which every scope changes โ {targetBytes, achieved (false: no setting tried fits, and settings are the smallest one found), bytes (as use measures them), format, settings, trials, images, warnings}; writes nothing and changes no remembered setting",
has_doc,
optimize_to_file_size
),
cmd!(
query "webExport.settings",
"Save for Web Settings",
[],
None,
"{reset?: false, preset?, โฆthe settings of document.exportForWeb} remember settings for the Save for Web dialog (it opens on them): the keys given change the remembered ones, a preset replaces them, reset goes back to the defaults; {} reads them โ {settings}",
always,
settings
),
cmd!(
query "webExport.presets.list",
"Save for Web Presets",
[],
None,
"{} โ {presets: [{name, builtIn, settings}]} the built-in presets, then the saved ones; any name works as `preset` in document.exportForWeb",
always,
presets_list
),
cmd!(
query "webExport.presets.save",
"Save Save for Web Preset",
[],
None,
"{name, newName?: rename it, preset?: start from this preset (default: the saved preset `name`, else the defaults), settings?: {โฆ}, โฆthe settings of document.exportForWeb} create or change a saved preset (built-in ones can't change) โ {name, settings, created}",
always,
presets_save
),
cmd!(
query "webExport.presets.delete",
"Delete Save for Web Preset",
[],
None,
"{name} delete a saved preset (built-in ones stay) โ {deleted: name}",
always,
presets_delete
),
]
}
// ---------- settings ----------
/// Enums of the render crate written in settings by id.
trait Keyed: Sized + Copy {
fn key(self) -> &'static str;
fn parse(s: &str) -> Option<Self>;
const KEYS: &'static str;
}
impl Keyed for Reduction {
fn key(self) -> &'static str {
self.id()
}
fn parse(s: &str) -> Option<Self> {
Self::from_id(s)
}
const KEYS: &'static str = "perceptual, selective, adaptive, web, blackWhite or gray";
}
impl Keyed for Dither {
fn key(self) -> &'static str {
self.id()
}
fn parse(s: &str) -> Option<Self> {
Self::from_id(s)
}
const KEYS: &'static str = "none, diffusion, pattern or noise";
}
impl Keyed for AntiAlias {
fn key(self) -> &'static str {
self.id()
}
fn parse(s: &str) -> Option<Self> {
Self::from_id(s)
}
const KEYS: &'static str = "none, art or type";
}
impl Keyed for ColorSort {
fn key(self) -> &'static str {
self.id()
}
fn parse(s: &str) -> Option<Self> {
Self::from_id(s)
}
const KEYS: &'static str = "none, hue, luminance or popularity";
}
fn ser_key<T: Keyed, S: Serializer>(v: &T, s: S) -> std::result::Result<S::Ok, S::Error> {
s.serialize_str(v.key())
}
fn de_key<'de, T: Keyed, D: Deserializer<'de>>(d: D) -> std::result::Result<T, D::Error> {
let s = String::deserialize(d)?;
T::parse(&s).ok_or_else(|| D::Error::custom(format!("`{s}`: {}", T::KEYS)))
}
/// A size in pixels: a number, rounded to whole pixels (`300.0` is 300).
fn de_pixels<'de, D: Deserializer<'de>>(d: D) -> std::result::Result<Option<u32>, D::Error> {
let Some(v) = Option::<f64>::deserialize(d)? else { return Ok(None) };
let px = v.round();
if !(px.is_finite() && px >= 0.0 && px <= f64::from(u32::MAX)) {
return Err(D::Error::custom(format!("{v} is not a size in pixels")));
}
// In range and whole: the cast is exact.
Ok(Some(px as u32))
}
/// The file format.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum WebFormat {
#[default]
Gif,
#[serde(alias = "jpeg")]
Jpg,
Png8,
Png24,
}
impl WebFormat {
pub const ALL: [WebFormat; 4] = [WebFormat::Gif, WebFormat::Jpg, WebFormat::Png8, WebFormat::Png24];
pub fn id(self) -> &'static str {
match self {
WebFormat::Gif => "gif",
WebFormat::Jpg => "jpg",
WebFormat::Png8 => "png8",
WebFormat::Png24 => "png24",
}
}
pub fn label(self) -> &'static str {
match self {
WebFormat::Gif => "GIF",
WebFormat::Jpg => "JPEG",
WebFormat::Png8 => "PNG-8",
WebFormat::Png24 => "PNG-24",
}
}
pub fn ext(self) -> &'static str {
match self {
WebFormat::Gif => "gif",
WebFormat::Jpg => "jpg",
WebFormat::Png8 | WebFormat::Png24 => "png",
}
}
/// A palette format (colour reduction, colour table).
pub fn palette(self) -> bool {
matches!(self, WebFormat::Gif | WebFormat::Png8)
}
}
/// Which File Info goes into the files.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum WebMetadata {
None,
#[default]
Copyright,
/// The copyright and the author.
Contact,
All,
}
impl WebMetadata {
pub const ALL: [WebMetadata; 4] = [WebMetadata::None, WebMetadata::Copyright, WebMetadata::Contact, WebMetadata::All];
pub fn key(self) -> &'static str {
match self {
WebMetadata::None => "none",
WebMetadata::Copyright => "copyright",
WebMetadata::Contact => "contact",
WebMetadata::All => "all",
}
}
pub fn label(self) -> &'static str {
match self {
WebMetadata::None => "None",
WebMetadata::Copyright => "Copyright",
WebMetadata::Contact => "Copyright and Contact Info",
WebMetadata::All => "All",
}
}
/// Whether File Info entry `keyword` (as [`vectorcraft_doc::Metadata::png_text`] names it) goes in.
fn keeps(self, keyword: &str) -> bool {
match self {
WebMetadata::None => false,
WebMetadata::Copyright => keyword.starts_with("Copyright"),
WebMetadata::Contact => keyword.starts_with("Copyright") || keyword == "Author",
WebMetadata::All => true,
}
}
}
/// Which slices get images.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum SliceScope {
#[default]
All,
Selected,
/// One image, slices or not.
None,
}
impl SliceScope {
pub const ALL: [SliceScope; 3] = [SliceScope::All, SliceScope::Selected, SliceScope::None];
pub fn key(self) -> &'static str {
match self {
SliceScope::All => "all",
SliceScope::Selected => "selected",
SliceScope::None => "none",
}
}
pub fn label(self) -> &'static str {
match self {
SliceScope::All => "All Slices",
SliceScope::Selected => "Selected Slices",
SliceScope::None => "No Slices",
}
}
}
/// What Save writes.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum WebOutput {
#[default]
Images,
/// An HTML page placing the images too.
Html,
}
impl WebOutput {
pub const ALL: [WebOutput; 2] = [WebOutput::Images, WebOutput::Html];
pub fn key(self) -> &'static str {
match self {
WebOutput::Images => "images",
WebOutput::Html => "html",
}
}
pub fn label(self) -> &'static str {
match self {
WebOutput::Images => "Images Only",
WebOutput::Html => "HTML and Images",
}
}
}
/// The colour table's edits of a palette format, by the colours the reduction makes (the
/// preview's `colors[].source`).
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ColorTable {
/// Kept when the colours are reduced further.
pub locked: Vec<String>,
/// Become transparent.
pub transparent: Vec<String>,
/// Become their nearest web-safe colour.
pub web_shift: Vec<String>,
#[serde(serialize_with = "ser_key", deserialize_with = "de_key")]
pub sort: ColorSort,
/// Taken out of the table: their pixels take the nearest color left. A deleted color is no
/// longer locked, transparent or web-shifted.
pub deleted: Vec<String>,
/// A fixed palette (a Custom table) used instead of the reduction's own: the colors of the
/// table when the first color was deleted. Empty: the reduction makes the palette.
pub custom_palette: Vec<String>,
/// Colors shifted by hand: each source color (`#rrggbb`) and the color it is written as. A
/// shifted color is locked, and a source the table does not hold shifts nothing.
pub shifted: std::collections::BTreeMap<String, String>,
}
/// A color shifted by hand: (source, color written).
type Shift = ([u8; 3], [u8; 3]);
/// The most colours a colour table list holds.
const MAX_TABLE: usize = 256;
/// The error for a deletion that would leave the color table no color for the pixels.
pub const KEEP_ONE: &str = "colorTable.deleted: at least one color has to stay in the color table";
impl ColorTable {
/// Whether the table is a Custom one: a color was deleted or the palette is fixed.
pub fn is_custom(&self) -> bool {
!self.deleted.is_empty() || !self.custom_palette.is_empty()
}
fn colors(list: &[String], what: &str) -> std::result::Result<Vec<[u8; 3]>, String> {
if list.len() > MAX_TABLE {
return Err(format!("colorTable.{what}: at most {MAX_TABLE} colours"));
}
list.iter().map(|h| Self::rgb(h).ok_or_else(|| format!("colorTable.{what}: `{h}` is not a colour such as \"#ff8800\""))).collect()
}
/// The colors shifted by hand as (source, color written). An error names a value that is not a
/// color such as `#ff8800`, two keys that name one color, or more than 256 entries.
fn shifts(&self) -> std::result::Result<Vec<Shift>, String> {
// One entry past the limit is enough for `colors` to refuse a longer map.
let (keys, values): (Vec<String>, Vec<String>) = self.shifted.iter().take(MAX_TABLE + 1).map(|(k, v)| (k.clone(), v.clone())).unzip();
let sources = Self::colors(&keys, "shifted")?;
let to = Self::colors(&values, "shifted")?;
for (i, (s, k)) in sources.iter().zip(&keys).enumerate() {
if sources[..i].contains(s) {
return Err(format!("colorTable.shifted: `{k}` names a color another key names"));
}
}
Ok(sources.into_iter().zip(to).collect())
}
/// `h` as RGB; `None` when it is not a color such as `#ff8800`.
fn rgb(h: &str) -> Option<[u8; 3]> {
vectorcraft_color::Color::from_hex(h).filter(|_| !super::hex_with_alpha(h)).map(|c| {
let [r, g, b, _] = c.to_rgba8(1.0);
[r, g, b]
})
}
}
/// Save for Web's settings: the params of `document.exportForWeb`, a preset's content and what the
/// dialog opens on.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct WebSettings {
pub format: WebFormat,
#[serde(serialize_with = "ser_key", deserialize_with = "de_key")]
pub reduction: Reduction,
/// Most palette entries, 2โ256.
pub colors: u16,
#[serde(serialize_with = "ser_key", deserialize_with = "de_key")]
pub dither: Dither,
/// 0โ100.
pub dither_amount: u8,
/// Keep transparent pixels transparent (GIF, PNG-8, PNG-24).
pub transparency: bool,
/// What partly transparent edges blend into (JPEG and opaque PNG-24: the background): `white`,
/// `black`, `none` or `#rrggbb`.
pub matte: String,
pub interlaced: bool,
/// 0โ100 %: palette colours that close to a web-safe colour become it.
pub web_snap: u8,
/// 0โ100: lossy GIF compression.
pub lossy: u8,
pub color_table: ColorTable,
/// JPEG quality 0โ100.
pub quality: u8,
pub progressive: bool,
/// Optimised Huffman tables (smaller JPEG files).
pub optimized: bool,
/// JPEG: embed the sRGB profile.
pub embed_profile: bool,
/// The image width in pixels (the height follows).
#[serde(deserialize_with = "de_pixels")]
pub width: Option<u32>,
/// The image height in pixels (the width follows).
#[serde(deserialize_with = "de_pixels")]
pub height: Option<u32>,
/// The image size in percent of the art's size in points.
pub percent: Option<f64>,
#[serde(serialize_with = "ser_key", deserialize_with = "de_key")]
pub anti_alias: AntiAlias,
/// The artboard (else the visible art and the slices).
pub clip_to_artboard: bool,
/// 0-based (default the first).
pub artboard: Option<usize>,
/// PNG files say their colours are sRGB (what the renderer draws).
pub convert_to_srgb: bool,
pub metadata: WebMetadata,
pub slices: SliceScope,
pub output: WebOutput,
}
impl Default for WebSettings {
fn default() -> Self {
Self {
format: WebFormat::Gif,
reduction: Reduction::Selective,
colors: 128,
dither: Dither::Diffusion,
dither_amount: 100,
transparency: true,
matte: "white".into(),
interlaced: false,
web_snap: 0,
lossy: 0,
color_table: ColorTable::default(),
quality: 60,
progressive: false,
optimized: true,
embed_profile: false,
width: None,
height: None,
percent: None,
anti_alias: AntiAlias::Art,
clip_to_artboard: true,
artboard: None,
convert_to_srgb: true,
metadata: WebMetadata::Copyright,
slices: SliceScope::All,
output: WebOutput::Images,
}
}
}
impl WebSettings {
/// `self` with the settings keys of `p` (other keys are ignored: params carry `path`, `kbps`โฆ).
pub fn merged(&self, p: &Value) -> std::result::Result<Self, String> {
let mut v = serde_json::to_value(self).map_err(|e| e.to_string())?;
if let (Some(obj), Some(over)) = (v.as_object_mut(), p.as_object()) {
for (k, val) in over {
if let Some(slot) = obj.get_mut(k) {
*slot = val.clone();
}
}
}
let mut s: WebSettings = serde_json::from_value(v).map_err(|e| format!("Save for Web settings: {e}"))?;
// Another reduction makes a new palette: the deletions and the fixed palette go, unless
// the params give the color table too.
if p.get("reduction").is_some() && p.get("colorTable").is_none() && s.reduction != self.reduction {
s.color_table.deleted.clear();
s.color_table.custom_palette.clear();
}
s.checked()
}
/// Reject values no image can have.
fn checked(mut self) -> std::result::Result<Self, String> {
self.colors = self.colors.clamp(2, 256);
self.dither_amount = self.dither_amount.min(100);
self.web_snap = self.web_snap.min(100);
self.lossy = self.lossy.min(100);
self.quality = self.quality.min(100);
if let Some(p) = self.percent.filter(|p| !(p.is_finite() && *p > 0.0 && *p <= 6400.0)) {
return Err(format!("percent must be above 0 and at most 6400, not {p}"));
}
if self.width == Some(0) || self.height == Some(0) {
return Err("width and height are at least 1 pixel".into());
}
self.matte_rgb()?;
let table = &mut self.color_table;
for (list, what) in
[(&table.locked, "locked"), (&table.transparent, "transparent"), (&table.web_shift, "webShift"), (&table.custom_palette, "customPalette")]
{
ColorTable::colors(list, what)?;
}
// A deleted color is no longer locked, transparent, web-shifted or shifted.
let deleted = ColorTable::colors(&table.deleted, "deleted")?;
if !deleted.is_empty() {
for list in [&mut table.locked, &mut table.transparent, &mut table.web_shift] {
list.retain(|h| ColorTable::rgb(h).is_none_or(|c| !deleted.contains(&c)));
}
}
// Shifts are kept as `#rrggbb` in lowercase; a color shifted to itself is not shifted, and
// a color shifted by hand is not web-shifted.
let shifts: Vec<Shift> = table.shifts()?.into_iter().filter(|(s, to)| s != to && !deleted.contains(s)).collect();
table.web_shift.retain(|h| ColorTable::rgb(h).is_none_or(|c| !shifts.iter().any(|(s, _)| *s == c)));
table.shifted = shifts.into_iter().map(|(s, to)| (hex(s), hex(to))).collect();
Ok(self)
}
/// The matte as RGB (`None`: none).
pub fn matte_rgb(&self) -> std::result::Result<Option<[u8; 3]>, String> {
super::fileio::background(&json!(self.matte)).map_err(|e| format!("matte: {e}"))
}
/// The JSON the commands return (and presets store).
pub fn to_json(&self) -> Value {
serde_json::to_value(self).unwrap_or(Value::Null)
}
}
/// A named set of settings: built in, or saved in the preferences ([`crate::Prefs::web_export_presets`]).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WebPreset {
pub name: String,
#[serde(default)]
pub settings: WebSettings,
}
/// The built-in presets (made here, named by what they do).
pub fn builtin_presets() -> Vec<WebPreset> {
let d = WebSettings::default;
let preset = |name: &str, settings: WebSettings| WebPreset { name: name.into(), settings };
vec![
preset("GIF, 128 colours", d()),
preset("GIF, 32 colours, no dither", WebSettings { colors: 32, dither: Dither::None, ..d() }),
preset("GIF, web-safe colours", WebSettings { reduction: Reduction::Web, colors: 256, dither: Dither::None, ..d() }),
preset("JPEG, quality 80", WebSettings { format: WebFormat::Jpg, quality: 80, ..d() }),
preset("JPEG, quality 50", WebSettings { format: WebFormat::Jpg, quality: 50, ..d() }),
preset("JPEG, quality 25", WebSettings { format: WebFormat::Jpg, quality: 25, ..d() }),
preset("PNG-8, 64 colours", WebSettings { format: WebFormat::Png8, colors: 64, ..d() }),
preset("PNG-24", WebSettings { format: WebFormat::Png24, ..d() }),
]
}
fn saved_index(saved: &[WebPreset], name: &str) -> Option<usize> {
saved.iter().position(|p| p.name.eq_ignore_ascii_case(name.trim()))
}
fn is_builtin(name: &str) -> bool {
builtin_presets().iter().any(|p| p.name.eq_ignore_ascii_case(name.trim()))
}
impl Session {
/// Every Save for Web preset: the built-in ones, then the saved ones.
pub fn web_presets(&self) -> Vec<WebPreset> {
let mut v = builtin_presets();
v.extend(self.prefs.web_export_presets.iter().cloned());
v
}
/// The settings `p` asks for: its `preset` (else `base`) with its settings keys.
pub fn web_settings_over(&self, base: &WebSettings, p: &Value) -> std::result::Result<WebSettings, String> {
let start = match p.get("preset").and_then(Value::as_str) {
Some(name) => {
let key = name.trim();
self.web_presets()
.into_iter()
.find(|q| q.name.eq_ignore_ascii_case(key))
.ok_or_else(|| format!("unknown preset `{name}` (see webExport.presets.list)"))?
.settings
}
None => base.clone(),
};
start.merged(p)
}
/// The settings of a `document.exportForWeb` call: the defaults (or its preset) with its keys.
pub fn web_settings(&self, p: &Value) -> std::result::Result<WebSettings, String> {
self.web_settings_over(&WebSettings::default(), p)
}
/// What the Save for Web dialog opens on: the remembered settings, else the defaults.
pub fn last_web_settings(&self) -> WebSettings {
self.prefs.web_export_settings.clone().unwrap_or_default()
}
}
// ---------- the pipeline ----------
/// The region an export covers and its pixels per point.
pub fn region(doc: &Document, s: &WebSettings) -> std::result::Result<(Rect, f64), String> {
let r = if s.clip_to_artboard {
let i = s.artboard.unwrap_or(0);
doc.artboards.get(i).map(|a| a.rect).ok_or_else(|| format!("no artboard {i} (0-based; the document has {})", doc.artboards.len()))?
} else {
let slices = if s.slices == SliceScope::None { vec![] } else { doc.slice_layout() };
slices
.iter()
.fold(vectorcraft_render::encode::art_bounds(doc), |acc, a| vectorcraft_geom::union_opt(acc, Some(a.rect)))
.ok_or("nothing to save: the document has no visible art")?
};
let scale = match (s.width, s.height, s.percent) {
(Some(w), _, _) => f64::from(w) / r.width(),
(None, Some(h), _) => f64::from(h) / r.height(),
(None, None, Some(p)) => p / 100.0,
_ => 1.0,
};
vectorcraft_render::raster_size(r, scale)?;
Ok((r, scale))
}
/// A rendering of the region an export covers, before optimisation.
#[derive(Clone, Debug)]
pub struct WebRender {
/// Straight RGBA, `width`ร`height`.
pub rgba: Vec<u8>,
pub width: u32,
pub height: u32,
pub region: Rect,
/// Pixels per point.
pub scale: f64,
}
/// Draw what `s` exports of `doc` (template layers left out; on white when the document's
/// background is white).
pub fn render(doc: &Document, s: &WebSettings) -> std::result::Result<WebRender, String> {
let doc = doc.without_edit_modes();
let (region, scale) = region(&doc, s)?;
let page = (doc.setup.background == vectorcraft_doc::Background::White).then_some([255; 4]);
let opts = vectorcraft_render::RenderOptions {
background: page,
skip_templates: true,
anti_alias: s.anti_alias,
precise: true,
supersample: true,
..Default::default()
};
let img = vectorcraft_render::Renderer::new().render_region_with(&doc, region, scale, &opts);
Ok(WebRender { rgba: img.to_straight(), width: img.width, height: img.height, region, scale })
}
/// One entry of a palette format's colour table.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TableColor {
/// As written.
pub color: [u8; 3],
/// As the reduction made it (what the colour table's lists name).
pub source: [u8; 3],
pub transparent: bool,
pub locked: bool,
pub web_shifted: bool,
/// Shifted by hand (`colorTable.shifted`): written as `color` instead of `source`.
pub shifted: bool,
}
/// An optimised image file.
#[derive(Clone, Debug, Default)]
pub struct Optimized {
pub bytes: Vec<u8>,
pub width: u32,
pub height: u32,
/// The colour table (palette formats), in file order.
pub colors: Vec<TableColor>,
/// The colour table's colours that became transparent.
pub mapped: Vec<[u8; 3]>,
/// For [`preview`]: the same pixels in a file every decoder reads (a JPEG with optimised
/// Huffman tables decodes wrongly in the `image` crate's decoder; a baseline one of the same
/// quality has the same pixels). Empty when `bytes` serves.
display: Vec<u8>,
}
impl Optimized {
/// The file the preview decodes ([`decode`]).
pub fn display(&self) -> &[u8] {
if self.display.is_empty() { &self.bytes } else { &self.display }
}
}
/// `#rrggbb`.
pub fn hex([r, g, b]: [u8; 3]) -> String {
vectorcraft_color::Color::rgb8(r, g, b).to_hex()
}
/// `rgba` (straight, `w`ร`h`) flattened on `matte`.
fn flatten(rgba: &[u8], matte: [u8; 3]) -> impl Iterator<Item = [u8; 3]> + '_ {
rgba.as_chunks::<4>().0.iter().map(move |p| {
let a = u32::from(p[3]);
[0, 1, 2].map(|i| ((u32::from(p[i]) * a + u32::from(matte[i]) * (255 - a) + 127) / 255) as u8)
})
}
/// The File Info text `s.metadata` lets into the files: `(keyword, text)`.
fn metadata(doc: &Document, s: &WebSettings) -> Vec<(&'static str, String)> {
doc.metadata.png_text(doc.info_title()).into_iter().filter(|(k, _)| s.metadata.keeps(k)).map(|(k, v)| (k, v.into_owned())).collect()
}
/// Encode straight RGBA pixels (`w`ร`h`) as `s` says; `doc` gives the metadata.
pub fn optimize(doc: &Document, rgba: &[u8], w: u32, h: u32, s: &WebSettings) -> std::result::Result<Optimized, String> {
encode(doc, rgba, w, h, s, false)
}
/// [`optimize`] for the dialog's preview: also what [`Optimized::display`] decodes.
pub fn preview_image(doc: &Document, rgba: &[u8], w: u32, h: u32, s: &WebSettings) -> std::result::Result<Optimized, String> {
encode(doc, rgba, w, h, s, true)
}
fn encode(doc: &Document, rgba: &[u8], w: u32, h: u32, s: &WebSettings, preview: bool) -> std::result::Result<Optimized, String> {
if rgba.len() as u64 != u64::from(w) * u64::from(h) * 4 || w == 0 || h == 0 {
return Err("Save for Web: the image is empty".into());
}
let matte = s.matte_rgb()?;
let meta = metadata(doc, s);
let comment = || meta.iter().map(|(k, v)| format!("{k}: {v}")).collect::<Vec<_>>().join("\n");
let png_extras = |file: Vec<u8>| {
let file = if s.convert_to_srgb { png::with_srgb(file) } else { file };
let text: Vec<(&str, std::borrow::Cow<str>)> = meta.iter().map(|(k, v)| (*k, v.as_str().into())).collect();
png::with_text(file, &text)
};
let png_options = png::PngOptions { ppi: Some(72.0), interlaced: s.interlaced };
let mut out = Optimized { width: w, height: h, ..Default::default() };
out.bytes = match s.format {
WebFormat::Jpg => {
let rgb: Vec<u8> = flatten(rgba, matte.unwrap_or([255; 3])).flatten().collect();
let method = match (s.progressive, s.optimized) {
(true, _) => jpeg::Method::Progressive,
(false, true) => jpeg::Method::Optimized,
(false, false) => jpeg::Method::Baseline,
};
let o = jpeg::JpegOptions { color_model: jpeg::ColorModel::Rgb, method, scans: 3, embed_icc: s.embed_profile };
if preview && method == jpeg::Method::Optimized {
let baseline = jpeg::JpegOptions { method: jpeg::Method::Baseline, embed_icc: false, ..o.clone() };
out.display = jpeg::encode(&rgb, w, h, s.quality, None, &baseline)?;
}
web::jpeg_comment(jpeg::encode(&rgb, w, h, s.quality, Some(72.0), &o)?, &comment())
}
WebFormat::Png24 => {
let file = match (s.transparency, matte.unwrap_or([255; 3])) {
(true, _) => png::encode(rgba, w, h, &png_options)?,
(false, m) => {
let opaque: Vec<u8> = flatten(rgba, m).flat_map(|[r, g, b]| [r, g, b, 255]).collect();
png::encode(&opaque, w, h, &png_options)?
}
};
png_extras(file)
}
WebFormat::Gif | WebFormat::Png8 => {
let PaletteImage { ix, colors, mapped } = palette_image(rgba, w, h, s, matte)?;
out.colors = colors;
out.mapped = mapped;
match s.format {
WebFormat::Gif => web::gif_comment(gif::encode(&ix, s.interlaced)?, &comment()),
_ => png_extras(png::encode_indexed(&ix, &png_options)?),
}
}
};
Ok(out)
}
/// A palette format's image with the colour table's edits.
struct PaletteImage {
ix: Indexed,
/// Its colour table.
colors: Vec<TableColor>,
/// The colours mapped to transparent.
mapped: Vec<[u8; 3]>,
}
fn palette_image(rgba: &[u8], w: u32, h: u32, s: &WebSettings, matte: Option<[u8; 3]>) -> std::result::Result<PaletteImage, String> {
let table = &s.color_table;
let locked = ColorTable::colors(&table.locked, "locked")?;
let to_clear = ColorTable::colors(&table.transparent, "transparent")?;
let shift = ColorTable::colors(&table.web_shift, "webShift")?;
let by_hand = table.shifts()?;
let shifted_to = |src: &[u8; 3]| by_hand.iter().find(|(s, _)| s == src).map(|(_, to)| *to);
// A color shifted by hand is kept when the colors are reduced, as a locked one is, and takes
// one of the slots kept for them before the locked colors do.
let kept: Vec<[u8; 3]> = by_hand.iter().map(|(s, _)| *s).chain(locked.iter().copied()).collect();
let o = PaletteOptions {
colors: s.colors,
reduction: s.reduction,
dither: s.dither,
dither_amount: s.dither_amount,
transparency: s.transparency,
matte,
};
let mut ix = reduced(rgba, w, h, s, &o, &kept)?;
// Map to transparent works on the colours the reduction made.
let before = ix.palette.clone();
let clear = ix.transparent.map(usize::from);
let mapped: Vec<[u8; 3]> = before.iter().enumerate().filter(|(i, c)| Some(*i) != clear && to_clear.contains(c)).map(|(_, c)| *c).collect();
let remap = web::to_transparent(&mut ix, |i| Some(i) != clear && before.get(i).is_some_and(|c| to_clear.contains(c)));
let mut sources = ix.palette.clone();
for (old, new) in remap.iter().enumerate() {
if let (Some(n), Some(c)) = (new, before.get(old))
&& let Some(slot) = sources.get_mut(usize::from(*n))
{
*slot = *c;
}
}
// Web shift and web snap (locked colors and colors shifted by hand stay as they are).
let clear = ix.transparent.map(usize::from);
for (i, c) in ix.palette.iter_mut().enumerate() {
let src = sources.get(i).copied().unwrap_or(*c);
if Some(i) == clear || shifted_to(&src).is_some() || locked.contains(&src) {
continue;
}
if shift.contains(&src) {
*c = quantize::web_safe(*c);
} else if let Some(snapped) = web::snap(*c, s.web_snap) {
*c = snapped;
}
}
// Lossy compares the pixels with the colors written for them, and moves no pixel into or out of
// a color shifted by hand.
if s.format == WebFormat::Gif {
let fixed: Vec<u8> = sources.iter().enumerate().filter(|(_, c)| shifted_to(c).is_some()).filter_map(|(i, _)| u8::try_from(i).ok()).collect();
web::lossy(&mut ix, rgba, s.lossy, &fixed);
}
// The colors shifted by hand.
for (i, c) in ix.palette.iter_mut().enumerate() {
if Some(i) != clear
&& let Some(to) = sources.get(i).and_then(shifted_to)
{
*c = to;
}
}
let order = web::sort(&mut ix, table.sort);
let sources: Vec<[u8; 3]> = order.iter().map(|&i| sources.get(i).copied().unwrap_or_default()).collect();
let colors = ix
.palette
.iter()
.zip(&sources)
.enumerate()
.map(|(i, (c, src))| {
let transparent = ix.transparent == u8::try_from(i).ok();
let shifted = !transparent && shifted_to(src).is_some();
TableColor {
color: *c,
source: *src,
transparent,
locked: locked.contains(src) || shifted,
web_shifted: shift.contains(src) && !shifted,
shifted,
}
})
.collect();
Ok(PaletteImage { ix, colors, mapped })
}
/// The pixels reduced to the palette `s` gives: the reduction's own (`locked` kept), or the
/// color table's fixed one, without the deleted colors. The pixels of a deleted color take the
/// nearest color left, with `o`'s dither. A deletion has to leave a color that is not mapped to
/// transparent. A fixed palette keeps its colors mapped to transparent, which take one slot of
/// `colors` together, and its first opaque colors that fit in the rest.
fn reduced(rgba: &[u8], w: u32, h: u32, s: &WebSettings, o: &PaletteOptions, locked: &[[u8; 3]]) -> std::result::Result<Indexed, String> {
let table = &s.color_table;
let deleted = ColorTable::colors(&table.deleted, "deleted")?;
let custom = ColorTable::colors(&table.custom_palette, "customPalette")?;
let to_clear = ColorTable::colors(&table.transparent, "transparent")?;
let opaque_left = |left: &[[u8; 3]]| left.iter().any(|c| !to_clear.contains(c));
if custom.is_empty() {
let ix = quantize::quantize_locked(rgba, w, h, o, locked);
let clear = ix.transparent.map(usize::from);
let gone = |i: usize, c: &[u8; 3]| Some(i) != clear && deleted.contains(c);
if !ix.palette.iter().enumerate().any(|(i, c)| gone(i, c)) {
return Ok(ix);
}
let left: Vec<[u8; 3]> = ix.palette.iter().enumerate().filter(|&(i, c)| Some(i) != clear && !deleted.contains(c)).map(|(_, c)| *c).collect();
if left.is_empty() || !opaque_left(&left) {
return Err(KEEP_ONE.into());
}
return Ok(quantize::quantize_to(rgba, w, h, o, &left));
}
// A fixed palette holds at most `colors` entries, the transparent one included.
let has_clear = s.transparency && rgba.as_chunks::<4>().0.iter().any(|p| p[3] < 128);
let removed = custom.iter().any(|c| deleted.contains(c));
let mut left: Vec<[u8; 3]> = vec![];
for c in custom {
if !deleted.contains(&c) && !left.contains(&c) {
left.push(c);
}
}
if left.is_empty() || (removed && !opaque_left(&left)) {
return Err(KEEP_ONE.into());
}
// The colors mapped to transparent all become the one transparent entry, so together they take
// one slot, and the opaque colors fill the rest in palette order. When no pixel takes one of
// them and no pixel is transparent, that slot goes to the next opaque color instead.
let kept = fixed_palette(&left, &to_clear, s.colors, has_clear, true);
let mut ix = quantize::quantize_to(rgba, w, h, o, &kept);
clear_dropped(&mut ix, rgba, o, &kept, &left, &to_clear);
if !has_clear && !ix.palette.iter().any(|c| to_clear.contains(c)) && left.iter().any(|c| to_clear.contains(c)) {
return Ok(quantize::quantize_to(rgba, w, h, o, &fixed_palette(&left, &to_clear, s.colors, has_clear, false)));
}
Ok(ix)
}
/// The entries of the fixed palette `left` that fit in `colors`. With `clear`, the colors in
/// `to_clear` are kept and take one slot together; without it they are left out. The list holds
/// at most 256 entries, less one when `has_clear` (the transparent pixels' entry).
fn fixed_palette(left: &[[u8; 3]], to_clear: &[[u8; 3]], colors: u16, has_clear: bool, clear: bool) -> Vec<[u8; 3]> {
let any_clear = clear && left.iter().any(|c| to_clear.contains(c));
let total = 256 - usize::from(has_clear);
let mut room = (usize::from(colors.clamp(2, 256)) - usize::from(has_clear || any_clear)).min(total - usize::from(any_clear));
let opaque = left.iter().filter(|c| !to_clear.contains(c)).count().min(room);
let mut clear_room = if clear { total - opaque } else { 0 };
left.iter()
.copied()
.filter(|c| {
let slots = if to_clear.contains(c) { &mut clear_room } else { &mut room };
let keep = *slots > 0;
*slots = slots.saturating_sub(1);
keep
})
.collect()
}
/// Makes transparent the pixels of `ix` whose nearest color is a color of `left` mapped to
/// transparent (`to_clear`) that does not fit in the fixed palette `kept`. Such a pixel takes the
/// transparent entry, or an entry mapped to transparent, which Map to Transparent clears later.
fn clear_dropped(ix: &mut Indexed, rgba: &[u8], o: &PaletteOptions, kept: &[[u8; 3]], left: &[[u8; 3]], to_clear: &[[u8; 3]]) {
let dropped: Vec<[u8; 3]> = left.iter().filter(|c| to_clear.contains(c) && !kept.contains(c)).copied().collect();
if dropped.is_empty() {
return;
}
let all: Vec<[u8; 3]> = kept.iter().chain(&dropped).copied().collect();
let near = quantize::nearest_entries(rgba, o, &all);
if !near.iter().any(|n| n.is_some_and(|n| n >= kept.len())) {
return;
}
let entry = match ix.transparent.or_else(|| ix.palette.iter().position(|c| to_clear.contains(c)).and_then(|i| u8::try_from(i).ok())) {
Some(i) => i,
None => {
// A kept color mapped to transparent that no pixel took; at most 255 entries are used then.
let (Some(c), Ok(i)) = (kept.iter().find(|c| to_clear.contains(c)), u8::try_from(ix.palette.len())) else {
return;
};
ix.palette.push(*c);
i
}
};
for (v, n) in ix.indices.iter_mut().zip(&near) {
if n.is_some_and(|n| n >= kept.len()) {
*v = entry;
}
}
}
/// An optimised image as straight RGBA โ `(pixels, width, height)` (the dialog's preview).
pub fn decode(o: &Optimized) -> std::result::Result<(Vec<u8>, u32, u32), String> {
let img = craft_image_codecs::decode(o.display()).map_err(|e| format!("the optimised image can't be read back: {e}"))?;
let (w, h) = img.dimensions();
Ok((img.to_rgba8(), w, h))
}
/// Seconds to download `bytes` at `kbps` kilobits per second.
pub fn download_seconds(bytes: usize, kbps: f64) -> f64 {
if kbps > 0.0 { bytes as f64 * 8.0 / (kbps * 1000.0) } else { 0.0 }
}
/// Connection speeds the dialog offers (kilobits per second).
pub const SPEEDS: [f64; 8] = [28.8, 56.6, 128.0, 256.0, 512.0, 1024.0, 2048.0, 8192.0];
// ---------- slices and the HTML page ----------
/// One slice as written: its area in image pixels and what its cell holds.
struct Cell<'a> {
area: &'a SliceArea,
/// Pixel rectangle `[x0, y0, x1, y1]` in the image.
px: [u32; 4],
}
/// The slices of `doc` that get cells (`selected`: the selected slice ids for
/// [`SliceScope::Selected`]), in pixels of `r`. Empty when the document has none (or `s` says none).
fn cells<'a>(areas: &'a [SliceArea], selected: &[NodeId], s: &WebSettings, r: &WebRender) -> std::result::Result<Vec<Cell<'a>>, String> {
if s.slices == SliceScope::None {
return Ok(vec![]);
}
let edge = |v: f64, o: f64, max: u32| ((v - o) * r.scale).round().clamp(0.0, f64::from(max)) as u32;
let out: Vec<Cell> = areas
.iter()
.filter(|a| s.slices == SliceScope::All || a.id.is_some_and(|id| selected.contains(&id)))
.map(|a| Cell {
area: a,
px: [
edge(a.rect.x0, r.region.x0, r.width),
edge(a.rect.y0, r.region.y0, r.height),
edge(a.rect.x1, r.region.x0, r.width),
edge(a.rect.y1, r.region.y0, r.height),
],
})
.filter(|c| c.px[2] > c.px[0] && c.px[3] > c.px[1])
.collect();
if out.is_empty() && s.slices == SliceScope::Selected {
return Err("no selected slice in the image: select slices, or save all of them".into());
}
Ok(out)
}
/// The pixels of `px` (`[x0, y0, x1, y1]`) of `r`.
fn crop(r: &WebRender, [x0, y0, x1, y1]: [u32; 4]) -> Vec<u8> {
let stride = r.width as usize * 4;
(y0..y1)
.flat_map(|y| r.rgba.get(y as usize * stride + x0 as usize * 4..y as usize * stride + x1 as usize * 4).unwrap_or_default())
.copied()
.collect()
}
/// What an export writes, by name relative to its folder.
pub struct WebFile {
pub name: String,
pub bytes: Vec<u8>,
}
/// The images folder of HTML and sliced output.
const IMAGES: &str = "images";
/// The files of an export of `doc` named after `stem`: one image (`<stem>.<ext>`), or one per
/// slice (`images/<slice name>.<ext>`), and with HTML output the page (`<stem>.html`, its image in
/// `images/`). The page comes first. Returns the image size too.
pub fn export_files(doc: &Document, selected: &[NodeId], s: &WebSettings, stem: &str) -> std::result::Result<(Vec<WebFile>, (u32, u32)), String> {
let r = render(doc, s)?;
let areas = doc.slice_layout();
let cells = cells(&areas, selected, s, &r)?;
let ext = s.format.ext();
let html = s.output == WebOutput::Html;
let mut images = vec![];
// (cell, image file name) for the page.
let mut placed: Vec<(Option<&Cell>, Option<String>)> = vec![];
if cells.is_empty() {
let name = if html { format!("{IMAGES}/{stem}.{ext}") } else { format!("{stem}.{ext}") };
images.push(WebFile { name: name.clone(), bytes: optimize(doc, &r.rgba, r.width, r.height, s)?.bytes });
placed.push((None, Some(name)));
} else {
let mut taken = HashSet::new();
// Per base, where the suffix search resumes, so many slices of one name don't each count up from 2.
let mut next = std::collections::HashMap::new();
for c in &cells {
let kind = c.area.id.and_then(|id| doc.slice_options(id)).map(|o| o.kind).unwrap_or_default();
if kind != SliceKind::Image {
placed.push((Some(c), None));
continue;
}
let base: String = doc.slice_name(c.area).chars().map(|ch| if ch.is_alphanumeric() || "-_.".contains(ch) { ch } else { '-' }).collect();
// A slice named after a Windows device (`aux`, `NUL`โฆ) gets a `-` after the device name.
let file = |base: &str| super::fileio::safe_file_name(&format!("{base}.{ext}"));
let base = unique_name_from(&base, &mut next, |n| taken.contains(&file(n).to_lowercase()));
taken.insert(file(&base).to_lowercase());
let name = format!("{IMAGES}/{}", file(&base));
let [x0, y0, x1, y1] = c.px;
images.push(WebFile { name: name.clone(), bytes: optimize(doc, &crop(&r, c.px), x1 - x0, y1 - y0, s)?.bytes });
placed.push((Some(c), Some(name)));
}
}
let mut files = vec![];
if html {
files.push(WebFile { name: format!("{stem}.html"), bytes: page(doc, stem, (r.width, r.height), &placed, s).into_bytes() });
}
files.extend(images);
Ok((files, (r.width, r.height)))
}
/// The HTML page placing the image or the slices (absolutely positioned, so overlapping slices
/// stack as laid out).
fn page(doc: &Document, stem: &str, (w, h): (u32, u32), placed: &[(Option<&Cell>, Option<String>)], s: &WebSettings) -> String {
use super::fileio::imagemap::attr;
use std::fmt::Write as _;
let id = attr(stem);
let mut out = String::new();
let _ = writeln!(out, "<!DOCTYPE html>\n<html>\n<head>\n<meta charset=\"utf-8\">\n<title>{id}</title>");
let _ = writeln!(out, "<style>\nbody {{ margin: 0; }}\n.slices {{ position: relative; width: {w}px; height: {h}px; }}");
let _ = writeln!(
out,
".slices > * {{ position: absolute; display: block; overflow: hidden; }}\n.slices img {{ display: block; border: 0; }}\n</style>"
);
let _ = writeln!(out, "</head>\n<body>\n<div class=\"slices\" id=\"{id}\">");
let matte = s.matte_rgb().ok().flatten().map(hex).unwrap_or_default();
for (cell, image) in placed {
let [x0, y0, x1, y1] = cell.map_or([0, 0, w, h], |c| c.px);
let (cw, ch) = (x1 - x0, y1 - y0);
let pos = format!("left: {x0}px; top: {y0}px; width: {cw}px; height: {ch}px;");
let o = cell.and_then(|c| c.area.id).and_then(|i| doc.slice_options(i)).cloned().unwrap_or_default();
match image {
Some(src) => {
let img = format!("<img src=\"{}\" width=\"{cw}\" height=\"{ch}\" alt=\"{}\">", attr(src), attr(&o.alt));
if o.url.is_empty() {
let _ = writeln!(out, "<div style=\"{pos}\">{img}</div>");
} else {
let target = if o.target.is_empty() { String::new() } else { format!(" target=\"{}\"", attr(&o.target)) };
let title = if o.message.is_empty() { String::new() } else { format!(" title=\"{}\"", attr(&o.message)) };
let _ = writeln!(out, "<a href=\"{}\"{target}{title} style=\"{pos}\">{img}</a>", attr(&o.url));
}
}
None => {
let bg = match o.background.as_str() {
"" => String::new(),
"matte" if !matte.is_empty() => format!(" background: {matte};"),
c if c.starts_with('#') => format!(" background: {};", attr(c)),
_ => String::new(),
};
let justify = match o.h_align {
CellAlign::Center => "center",
CellAlign::Right => "flex-end",
_ => "flex-start",
};
let align = match o.v_align {
CellVAlign::Middle => "center",
CellVAlign::Bottom => "flex-end",
CellVAlign::Baseline => "baseline",
_ => "flex-start",
};
// No Image: the cell's text as it is (HTML allowed); HTML Text: the type's text.
let text = match o.kind {
SliceKind::HtmlText => cell
.and_then(|c| c.area.id)
.and_then(|i| doc.node(i))
.and_then(|n| match &n.kind {
NodeKind::Text(t) => Some(t.plain_text().split(['\n', '\r', '\u{2029}']).map(attr).collect::<Vec<_>>().join("<br>")),
_ => None,
})
.unwrap_or_default(),
_ => o.text.clone(),
};
let _ = writeln!(out, "<div style=\"{pos}{bg} display: flex; justify-content: {justify}; align-items: {align};\">{text}</div>");
}
}
}
out.push_str("</div>\n</body>\n</html>\n");
out
}
// ---------- commands ----------
fn export(s: &mut Session, p: &Value) -> Result<Value> {
let settings = s.web_settings(p).map_err(|e| bad(C, e))?;
let st = s.doc()?;
let selected = super::slices::selected_slices(&st.doc, &st.selection);
let path = str_param(p, "path").filter(|p| !p.trim().is_empty());
let stem = match path {
Some(p) => super::fileio::file_stem(p),
// Without a path the files are named after the title, following Windows' file-naming rules.
None => super::fileio::safe_file_name(&super::fileio::file_stem(&st.doc.title)),
};
let stem = if stem.trim().is_empty() { "Untitled".to_string() } else { stem };
let failed = vectorcraft_render::decode_failures();
let (files, (width, height)) = export_files(&st.doc, &selected, &settings, &stem).map_err(|e| bad(C, e))?;
let warnings = undecoded(failed);
let total: usize = files.iter().map(|f| f.bytes.len()).sum();
let Some(path) = path else {
let rows: Vec<Value> = files.iter().map(|f| json!({ "name": f.name, "dataBase64": vectorcraft_format::base64_encode(&f.bytes) })).collect();
return Ok(json!({ "files": rows, "bytes": total, "width": width, "height": height, "warnings": warnings }));
};
// Siblings keep the path's own separators.
let dir = &path[..path.rfind(['/', '\\']).map_or(0, |i| i + 1)];
if files.iter().any(|f| f.name.contains('/')) {
super::fileio::create_dir(&format!("{dir}{IMAGES}"))?;
}
let mut written = vec![];
for f in &files {
// A lone image goes where it was asked to.
let target = if files.len() == 1 && !f.name.contains('/') { path.to_string() } else { format!("{dir}{}", f.name) };
super::fileio::write_file(&target, &f.bytes)?;
written.push(target);
}
Ok(json!({ "path": written.first(), "files": written, "bytes": total, "width": width, "height": height, "warnings": warnings }))
}
/// The warnings of a rendering that started when this thread's decode failure count was `failed`:
/// the note the raster exports add (`fileio::encode::encode_all_of`) when an image has failed to
/// decode since then and so is missing from the image.
fn undecoded(failed: u64) -> Vec<&'static str> {
super::rasterfx::undecoded_warning(failed).into_iter().collect()
}
fn preview(s: &mut Session, p: &Value) -> Result<Value> {
const P: &str = "document.exportForWeb.preview";
let settings = s.web_settings(p).map_err(|e| bad(P, e))?;
let kbps = f64_or(p, "kbps", 56.6);
if !(kbps.is_finite() && kbps > 0.0) {
return Err(bad(P, format!("kbps must be a positive number, not {kbps}")));
}
let st = s.doc()?;
let doc = &st.doc;
let failed = vectorcraft_render::decode_failures();
let r = render(doc, &settings).map_err(|e| bad(P, e))?;
let warnings = undecoded(failed);
let areas = doc.slice_layout();
let selected = super::slices::selected_slices(doc, &st.selection);
let cells = cells(&areas, &selected, &settings, &r).map_err(|e| bad(P, e))?;
let images = cells.iter().filter(|c| c.area.id.and_then(|id| doc.slice_options(id)).is_none_or(|o| o.kind == SliceKind::Image)).count().max(1);
let o = match p.get("slice").and_then(Value::as_u64) {
Some(n) => {
let c = cells.iter().find(|c| c.area.number as u64 == n).ok_or_else(|| bad(P, format!("no slice {n} in the image (see slice.list)")))?;
let [x0, y0, x1, y1] = c.px;
optimize(doc, &crop(&r, c.px), x1 - x0, y1 - y0, &settings)
}
None => optimize(doc, &r.rgba, r.width, r.height, &settings),
}
.map_err(|e| bad(P, e))?;
let mut out = json!({
"format": settings.format.id(), "width": o.width, "height": o.height, "bytes": o.bytes.len(),
"seconds": download_seconds(o.bytes.len(), kbps), "kbps": kbps, "slices": images, "warnings": warnings,
});
if settings.format.palette() {
out["colors"] = o
.colors
.iter()
.map(|c| {
json!({
"color": hex(c.color), "source": hex(c.source), "transparent": c.transparent, "locked": c.locked,
"webShifted": c.web_shifted, "shifted": c.shifted, "webSafe": quantize::web_safe(c.color) == c.color,
})
})
.collect();
out["mappedToTransparent"] = o.mapped.iter().map(|c| json!(hex(*c))).collect();
}
if bool_or(p, "image", false) {
out["dataBase64"] = json!(vectorcraft_format::base64_encode(&o.bytes));
}
Ok(out)
}
// ---------- Optimize to File Size ----------
/// The most trial settings `webExport.optimizeToFileSize` encodes. Each trial encodes every image
/// it measures once.
pub const OPTIMIZE_TRIALS: usize = 32;
/// The largest desired file size, in K (1 GiB).
pub const MAX_DESIRED_K: f64 = 1_048_576.0;
/// Where Optimize to File Size starts.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum StartWith {
/// The current format, with its JPEG quality or palette colors lowered.
Current,
/// GIF or JPEG, by the image's content.
Auto,
}
/// The pixels `px` (`[x0, y0, x1, y1]`) of `r` as an image: borrowed when `px` is the whole render,
/// else a copy.
fn file_pixels(r: &WebRender, px: [u32; 4]) -> std::borrow::Cow<'_, [u8]> {
if px == [0, 0, r.width, r.height] { std::borrow::Cow::Borrowed(r.rgba.as_slice()) } else { std::borrow::Cow::Owned(crop(r, px)) }
}
/// The settings Optimize to File Size found.
#[derive(Clone, Debug)]
pub struct SizeFit {
pub settings: WebSettings,
/// The size the settings give the measured images.
pub bytes: usize,
/// Whether `bytes` is within the target.
pub achieved: bool,
/// The trial settings encoded.
pub trials: usize,
}
/// The files a search measures and the trials it has left.
struct Trials<'a> {
doc: &'a Document,
r: &'a WebRender,
/// The pixels (`[x0, y0, x1, y1]`) of each file in `r`.
files: &'a [[u32; 4]],
/// Measure the largest file (else the files together).
each: bool,
left: usize,
used: usize,
}
impl Trials<'_> {
/// The size `s` gives the files, encoded one at a time; `None` when no trial is left.
fn size(&mut self, s: &WebSettings) -> std::result::Result<Option<usize>, String> {
if self.left == 0 {
return Ok(None);
}
self.left -= 1;
self.used += 1;
let mut out = 0usize;
for &px in self.files {
let n = optimize(self.doc, &file_pixels(self.r, px), px[2] - px[0], px[3] - px[1], s)?.bytes.len();
out = if self.each { out.max(n) } else { out.saturating_add(n) };
}
Ok(Some(out))
}
}
/// `(settings, bytes)` of a trial.
pub type Trial = (WebSettings, usize);
/// Keep `(s, n)` in `smallest` when it is the smallest trial so far.
fn keep_smallest(smallest: &mut Option<Trial>, s: WebSettings, n: usize) {
if smallest.as_ref().is_none_or(|(_, b)| n < *b) {
*smallest = Some((s, n));
}
}
/// The values [`highest_within`] measures spread over its range before it narrows a step.
pub const OPTIMIZE_SAMPLES: u16 = 6;
/// Measures the size a setting gives; `None` when no trial is left.
pub type MeasureSize<'a> = dyn FnMut(&WebSettings) -> std::result::Result<Option<usize>, String> + 'a;
/// The highest value in `lo..hi` that `set` gives `start` whose size is within `target`, when the
/// value `hi` is over it. A lower value can give a larger file, so the search measures up to
/// [`OPTIMIZE_SAMPLES`] values spread over the range, from `hi - 1` down, stops at the first that
/// fits, and halves the step between it and the measured value above it, keeping the highest value
/// measured within `target`. `None` when no value measured fits or no trial is left; the trials over
/// the target go to `smallest`.
pub fn highest_within(
size: &mut MeasureSize,
start: &WebSettings,
(lo, hi): (u16, u16),
set: fn(&mut WebSettings, u16),
target: usize,
smallest: &mut Option<Trial>,
) -> std::result::Result<Option<Trial>, String> {
let with = |v: u16| {
let mut s = start.clone();
set(&mut s, v);
s
};
if lo >= hi {
return Ok(None);
}
let span = u32::from(hi - lo);
let samples = u32::from(OPTIMIZE_SAMPLES).min(span);
let (mut above, mut found) = (hi, None);
for i in (0..samples).rev() {
let step = if samples == 1 { 0 } else { (span - 1) * i / (samples - 1) };
let v = lo.saturating_add(u16::try_from(step).unwrap_or(0));
let s = with(v);
let Some(n) = size(&s)? else { return Ok(None) };
if n <= target {
found = Some((v, (s, n)));
break;
}
keep_smallest(smallest, s, n);
above = v;
}
let Some((mut lo, mut best)) = found else { return Ok(None) };
let mut hi = above;
while hi - lo > 1 {
let mid = lo + (hi - lo) / 2;
let s = with(mid);
let Some(n) = size(&s)? else { break };
if n <= target {
lo = mid;
best = (s, n);
} else {
keep_smallest(smallest, s, n);
hi = mid;
}
}
Ok(Some(best))
}
/// Sets the JPEG quality, for [`highest_within`].
pub fn set_quality(s: &mut WebSettings, v: u16) {
s.quality = u8::try_from(v).unwrap_or(100);
}
/// Sets the palette colors, for [`highest_within`].
pub fn set_colors(s: &mut WebSettings, v: u16) {
s.colors = v;
}
/// The best settings of `start`'s format within `target`: `start` when it fits, else the highest
/// JPEG quality or the most palette colors [`highest_within`] finds that fit, and for GIF, when none
/// is found, lossy 100 with the most colors that fit. When nothing tried fits, the smallest trial, not achieved.
/// `None` when no trial is left.
fn search_format(t: &mut Trials, start: &WebSettings, target: usize) -> std::result::Result<Option<SizeFit>, String> {
let fit = |(settings, bytes): Trial, achieved: bool| SizeFit { settings, bytes, achieved, trials: 0 };
let Some(n) = t.size(start)? else { return Ok(None) };
if n <= target {
return Ok(Some(fit((start.clone(), n), true)));
}
let mut smallest = Some((start.clone(), n));
let found = match start.format {
WebFormat::Jpg => highest_within(&mut |s: &WebSettings| t.size(s), start, (1, u16::from(start.quality)), set_quality, target, &mut smallest)?,
WebFormat::Gif | WebFormat::Png8 => {
match highest_within(&mut |s: &WebSettings| t.size(s), start, (2, start.colors), set_colors, target, &mut smallest)? {
None if start.format == WebFormat::Gif && start.lossy < 100 => {
let lossy = WebSettings { lossy: 100, ..start.clone() };
match t.size(&lossy)? {
Some(n) if n <= target => Some((lossy, n)),
Some(n) => {
keep_smallest(&mut smallest, lossy.clone(), n);
highest_within(&mut |s: &WebSettings| t.size(s), &lossy, (2, lossy.colors), set_colors, target, &mut smallest)?
}
None => None,
}
}
found => found,
}
}
WebFormat::Png24 => None,
};
Ok(match (found, smallest) {
(Some(f), _) => Some(fit(f, true)),
(None, Some(s)) => Some(fit(s, false)),
(None, None) => None,
})
}
/// The format Auto Select GIF/JPEG starts with, and whether the files (`[x0, y0, x1, y1]` of `r`)
/// are opaque: GIF for files with transparent pixels (when `transparency` keeps them) or at most
/// 256 colors, else JPEG. The colors counted are the ones the files are written with: without
/// `transparency`, the pixels blended over `matte`.
fn auto_format(r: &WebRender, files: &[[u32; 4]], transparency: bool, matte: [u8; 3]) -> (WebFormat, bool) {
let stride = r.width as usize * 4;
let row =
move |y: u32, x0: u32, x1: u32| r.rgba.get(y as usize * stride + x0 as usize * 4..y as usize * stride + x1 as usize * 4).unwrap_or_default();
let pixels = || files.iter().flat_map(move |&[x0, y0, x1, y1]| (y0..y1).flat_map(move |y| row(y, x0, x1).as_chunks::<4>().0.iter()));
let opaque = !transparency || pixels().all(|p| p[3] == 255);
if !opaque {
return (WebFormat::Gif, false);
}
let mut seen = HashSet::new();
// An opaque pixel blends to itself.
let few = pixels().all(|p| {
seen.insert(flatten(p, matte).next().unwrap_or_default());
seen.len() <= 256
});
(if few { WebFormat::Gif } else { WebFormat::Jpg }, true)
}
/// Optimize to File Size: the settings, from `s`, whose files (the pixels `[x0, y0, x1, y1]` of
/// `r`) fit in `target` bytes, measured together, or with `each` the largest one. At most
/// [`OPTIMIZE_TRIALS`] trial settings are encoded, and a trial encodes the files one at a time.
pub fn optimize_to_size(
doc: &Document,
r: &WebRender,
files: &[[u32; 4]],
s: &WebSettings,
start: StartWith,
each: bool,
target: usize,
) -> std::result::Result<SizeFit, String> {
let mut t = Trials { doc, r, files, each, left: OPTIMIZE_TRIALS, used: 0 };
let with = |format: WebFormat| WebSettings { format, ..s.clone() };
let found = match start {
_ if files.is_empty() => None,
StartWith::Current => search_format(&mut t, s, target)?,
StartWith::Auto => {
let (first, opaque) = auto_format(r, files, s.transparency, s.matte_rgb()?.unwrap_or([255; 3]));
let other = if first == WebFormat::Gif { WebFormat::Jpg } else { WebFormat::Gif };
match search_format(&mut t, &with(first), target)? {
Some(a) if !a.achieved && opaque => match search_format(&mut t, &with(other), target)? {
Some(b) if b.achieved || b.bytes < a.bytes => Some(b),
_ => Some(a),
},
a => a,
}
}
};
let mut best = found.ok_or("Optimize to File Size: there is no image to measure")?;
best.trials = t.used;
Ok(best)
}
fn optimize_to_file_size(s: &mut Session, p: &Value) -> Result<Value> {
const O: &str = "webExport.optimizeToFileSize";
let k = p
.get("desiredK")
.and_then(Value::as_f64)
.filter(|k| k.is_finite() && *k > 0.0 && *k <= MAX_DESIRED_K)
.ok_or_else(|| bad(O, "give `desiredK`, the desired file size in K (1024 bytes): a number above 0 and at most 1048576"))?;
let target = ((k * 1024.0).floor() as usize).max(1);
let start = match p.get("startWith").map(Value::as_str) {
None | Some(Some("current")) => StartWith::Current,
Some(Some("auto")) => StartWith::Auto,
Some(_) => return Err(bad(O, "`startWith` is `current` or `auto`")),
};
let scope = match p.get("use").map(Value::as_str) {
None if p.get("slice").is_some() => "currentSlice",
None => "allSlices",
Some(Some(u @ ("allSlices" | "eachSlice" | "currentSlice"))) => u,
Some(_) => return Err(bad(O, "`use` is `allSlices`, `eachSlice` or `currentSlice`")),
};
let slice = match p.get("slice").map(|v| v.as_u64().filter(|n| *n >= 1 && scope == "currentSlice")) {
None => None,
Some(Some(n)) => Some(n),
Some(None) => return Err(bad(O, "`slice` is a slice number from `slice.list`, with `use: currentSlice`")),
};
let settings = s.web_settings(p).map_err(|e| bad(O, e))?;
let st = s.doc()?;
let doc = &st.doc;
let failed = vectorcraft_render::decode_failures();
let r = render(doc, &settings).map_err(|e| bad(O, e))?;
let warnings = undecoded(failed);
let areas = doc.slice_layout();
let selected = super::slices::selected_slices(doc, &st.selection);
let cells = cells(&areas, &selected, &settings, &r).map_err(|e| bad(O, e))?;
let image_cells: Vec<&Cell> =
cells.iter().filter(|c| c.area.id.and_then(|id| doc.slice_options(id)).is_none_or(|o| o.kind == SliceKind::Image)).collect();
let picked: Vec<&Cell> = match (scope, slice) {
("currentSlice", Some(n)) => {
let c = image_cells.iter().find(|c| c.area.number as u64 == n);
vec![*c.ok_or_else(|| bad(O, format!("no slice {n} in the image (see slice.list)")))?]
}
("currentSlice", None) => {
image_cells.iter().find(|c| c.area.id.is_some_and(|id| selected.contains(&id))).or(image_cells.first()).copied().into_iter().collect()
}
_ => image_cells,
};
let files: Vec<[u32; 4]> = if cells.is_empty() { vec![[0, 0, r.width, r.height]] } else { picked.iter().map(|c| c.px).collect() };
let fit = optimize_to_size(doc, &r, &files, &settings, start, scope == "eachSlice", target).map_err(|e| bad(O, e))?;
Ok(json!({
"targetBytes": target, "achieved": fit.achieved, "bytes": fit.bytes, "format": fit.settings.format.id(),
"settings": fit.settings.to_json(), "trials": fit.trials, "images": files.len(), "warnings": warnings,
}))
}
fn settings(s: &mut Session, p: &Value) -> Result<Value> {
const S: &str = "webExport.settings";
let base = if bool_or(p, "reset", false) { WebSettings::default() } else { s.last_web_settings() };
let next = s.web_settings_over(&base, p).map_err(|e| bad(S, e))?;
if p.as_object().is_some_and(|o| !o.is_empty()) {
s.prefs.web_export_settings = Some(next.clone());
}
Ok(json!({ "settings": next.to_json() }))
}
fn presets_list(s: &mut Session, _: &Value) -> Result<Value> {
let rows = builtin_presets()
.into_iter()
.map(|p| (p, true))
.chain(s.prefs.web_export_presets.iter().cloned().map(|p| (p, false)))
.map(|(p, builtin)| json!({ "name": p.name, "builtIn": builtin, "settings": p.settings.to_json() }));
Ok(json!({ "presets": rows.collect::<Vec<_>>() }))
}
fn presets_save(s: &mut Session, p: &Value) -> Result<Value> {
const S: &str = "webExport.presets.save";
let name = str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).ok_or_else(|| bad(S, "give the preset a `name`"))?.to_string();
if is_builtin(&name) {
return Err(bad(S, format!("`{name}` is a built-in preset and can't change: save it under another name")));
}
let at = saved_index(&s.prefs.web_export_presets, &name);
let base = at.and_then(|i| s.prefs.web_export_presets.get(i)).map(|q| q.settings.clone()).unwrap_or_default();
// Settings at the top level, or in `settings`.
let mut keys = p.as_object().cloned().unwrap_or_default();
if let Some(Value::Object(inner)) = keys.remove("settings") {
keys.extend(inner);
}
let settings = s.web_settings_over(&base, &Value::Object(keys)).map_err(|e| bad(S, e))?;
let name = match str_param(p, "newName").map(str::trim) {
Some("") => return Err(bad(S, "`newName` is empty")),
Some(n) if is_builtin(n) || saved_index(&s.prefs.web_export_presets, n).is_some_and(|i| Some(i) != at) => {
return Err(bad(S, format!("a preset named `{n}` exists")));
}
Some(n) => n.to_string(),
None => at.and_then(|i| s.prefs.web_export_presets.get(i)).map_or(name, |q| q.name.clone()),
};
let preset = WebPreset { name: name.clone(), settings: settings.clone() };
match at.and_then(|i| s.prefs.web_export_presets.get_mut(i)) {
Some(slot) => *slot = preset,
None => s.prefs.web_export_presets.push(preset),
}
Ok(json!({ "name": name, "settings": settings.to_json(), "created": at.is_none() }))
}
fn presets_delete(s: &mut Session, p: &Value) -> Result<Value> {
const S: &str = "webExport.presets.delete";
let name = str_param(p, "name").ok_or_else(|| bad(S, "missing `name`"))?;
if is_builtin(name) {
return Err(bad(S, format!("`{name}` is a built-in preset and stays")));
}
let i = saved_index(&s.prefs.web_export_presets, name).ok_or_else(|| bad(S, format!("no saved preset named `{name}`")))?;
Ok(json!({ "deleted": s.prefs.web_export_presets.remove(i).name }))
}
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.