use crate::model::chart::Anchor;
use std::hash::{DefaultHasher, Hash, Hasher};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Image {
pub name: String,
pub description: String,
pub anchor: Anchor,
pub format: ImageFormat,
pub data: Vec<u8>,
pub origin: Option<ImageOrigin>,
}
impl Image {
#[must_use]
pub fn new(data: Vec<u8>, anchor: Anchor) -> Option<Self> {
let format = ImageFormat::sniff(&data)?;
Some(Self {
name: String::new(),
description: String::new(),
anchor,
format,
data,
origin: None,
})
}
#[must_use]
pub fn is_unchanged(&self) -> bool {
self.origin.as_ref().is_some_and(|o| {
o.name == self.name
&& o.description == self.description
&& o.anchor == self.anchor
&& !o.data_changed(&self.data)
})
}
pub(crate) fn settle(&mut self) {
if let Some(origin) = &mut self.origin {
origin.anchor = self.anchor;
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ImageFormat {
Png,
Jpeg,
Gif,
Bmp,
Tiff,
Emf,
Wmf,
Svg,
}
impl ImageFormat {
#[must_use]
pub fn sniff(data: &[u8]) -> Option<Self> {
let starts = |magic: &[u8]| data.starts_with(magic);
Some(if starts(b"\x89PNG\r\n\x1a\n") {
Self::Png
} else if starts(&[0xFF, 0xD8, 0xFF]) {
Self::Jpeg
} else if starts(b"GIF87a") || starts(b"GIF89a") {
Self::Gif
} else if starts(b"BM") {
Self::Bmp
} else if starts(b"II*\0") || starts(b"MM\0*") {
Self::Tiff
} else if data.get(40..44) == Some(b" EMF") {
Self::Emf
} else if starts(&[0xD7, 0xCD, 0xC6, 0x9A]) || starts(&[0x01, 0x00, 0x09, 0x00]) {
Self::Wmf
} else if is_svg(data) {
Self::Svg
} else {
return None;
})
}
#[must_use]
pub fn from_extension(path: &str) -> Option<Self> {
let extension = path.rsplit_once('.')?.1.to_ascii_lowercase();
Some(match extension.as_str() {
"png" => Self::Png,
"jpg" | "jpeg" | "jpe" => Self::Jpeg,
"gif" => Self::Gif,
"bmp" | "dib" => Self::Bmp,
"tif" | "tiff" => Self::Tiff,
"emf" => Self::Emf,
"wmf" => Self::Wmf,
"svg" => Self::Svg,
_ => return None,
})
}
#[must_use]
pub const fn extension(self) -> &'static str {
match self {
Self::Png => "png",
Self::Jpeg => "jpeg",
Self::Gif => "gif",
Self::Bmp => "bmp",
Self::Tiff => "tiff",
Self::Emf => "emf",
Self::Wmf => "wmf",
Self::Svg => "svg",
}
}
#[must_use]
pub const fn content_type(self) -> &'static str {
match self {
Self::Png => "image/png",
Self::Jpeg => "image/jpeg",
Self::Gif => "image/gif",
Self::Bmp => "image/bmp",
Self::Tiff => "image/tiff",
Self::Emf => "image/x-emf",
Self::Wmf => "image/x-wmf",
Self::Svg => "image/svg+xml",
}
}
}
fn is_svg(data: &[u8]) -> bool {
let head = &data[..data.len().min(1024)];
let Ok(text) = core::str::from_utf8(head) else {
return false;
};
let mut rest = text.trim_start_matches('\u{feff}').trim_start();
while let Some(after) = rest.strip_prefix("<?").or_else(|| rest.strip_prefix("<!")) {
let Some(end) = after.find('>') else {
return false;
};
rest = after[end + 1..].trim_start();
}
rest.starts_with("<svg")
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ImageOrigin {
pub(crate) drawing: String,
pub(crate) id: u32,
pub(crate) grouped: bool,
pub(crate) name: String,
pub(crate) description: String,
pub(crate) anchor: Anchor,
pub(crate) data_len: usize,
pub(crate) data_hash: u64,
}
impl ImageOrigin {
#[must_use]
pub fn drawing(&self) -> &str {
&self.drawing
}
#[must_use]
pub const fn grouped(&self) -> bool {
self.grouped
}
pub(crate) fn data_changed(&self, data: &[u8]) -> bool {
data.len() != self.data_len || hash(data) != self.data_hash
}
}
pub(crate) fn hash(data: &[u8]) -> u64 {
let mut hasher = DefaultHasher::new();
data.hash(&mut hasher);
hasher.finish()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn formats_are_told_by_their_bytes() {
assert_eq!(
ImageFormat::sniff(b"\x89PNG\r\n\x1a\n...."),
Some(ImageFormat::Png)
);
assert_eq!(
ImageFormat::sniff(&[0xFF, 0xD8, 0xFF, 0xE0]),
Some(ImageFormat::Jpeg)
);
assert_eq!(ImageFormat::sniff(b"GIF89a"), Some(ImageFormat::Gif));
assert_eq!(
ImageFormat::sniff(b"<?xml version=\"1.0\"?>\n<!-- x --><svg xmlns=\"\"/>"),
Some(ImageFormat::Svg)
);
assert_eq!(ImageFormat::sniff(b"<html>"), None);
assert_eq!(ImageFormat::sniff(b""), None);
}
#[test]
fn an_image_read_and_left_alone_is_unchanged() {
let mut image = Image::new(b"GIF89a".to_vec(), Anchor::default()).unwrap();
assert!(!image.is_unchanged(), "made in code");
image.origin = Some(ImageOrigin {
drawing: "xl/drawings/drawing1.xml".into(),
id: 2,
grouped: false,
name: String::new(),
description: String::new(),
anchor: Anchor::default(),
data_len: 6,
data_hash: hash(b"GIF89a"),
});
assert!(image.is_unchanged());
image.data = b"GIF87a".to_vec();
assert!(!image.is_unchanged(), "same length, other bytes");
}
}