Font selection for text layers (#585)

* Add font dropdown * Add fonts * Font tool options * Fix tests * Replace http with https * Add variant selection * Do not embed default font * Use proxied font list API * Change default font to Merriweather * Remove outdated comment * Specify font once & load font into foreignobject * Fix tests * Rename variant to font_style * Change TextAreaInput to use FieldInput (WIP, breaks functionality) * Fix textarea functionality * Fix types * Add weight name mapping * Change labeling of "Italic" * Remove commented HTML node * Rename font "name" to "font_family" and "file" "font_file" * Fix errors * Fix fmt Co-authored-by: Keavon Chambers <keavon@keavon.com>
2026-09-24 12:18:12 +08:00 · 2022-04-21 09:50:44 +01:00
parent 916a575446
commit 239aa03453
36 changed files with 1029 additions and 253 deletions
@@ -14,12 +14,50 @@ use kurbo::Affine;
 use serde::{Deserialize, Serialize};
 use std::cmp::max;
 use std::collections::hash_map::DefaultHasher;
+use std::collections::HashMap;
 use std::hash::{Hash, Hasher};

 /// A number that identifies a layer.
 /// This does not technically need to be unique globally, only within a folder.
 pub type LayerId = u64;

+/// A cache of all loaded fonts along with a string of the name of the default font (sent from js)
+#[derive(Debug, Clone, Deserialize, Serialize, Default)]
+pub struct FontCache {
+	data: HashMap<String, Vec<u8>>,
+	default_font: Option<String>,
+}
+impl FontCache {
+	/// Returns the font family name if the font is cached, otherwise returns the default font family name if that is cached
+	pub fn resolve_font<'a>(&'a self, font: Option<&'a String>) -> Option<&'a String> {
+		font.filter(|font| self.loaded_font(font))
+			.map_or(self.default_font.as_ref().filter(|font| self.loaded_font(font)), Some)
+	}
+
+	/// Try to get the bytes for a font
+	pub fn get<'a>(&'a self, font: Option<&String>) -> Option<&'a Vec<u8>> {
+		self.resolve_font(font).and_then(|font| self.data.get(font))
+	}
+
+	/// Check if the font is already loaded
+	pub fn loaded_font(&self, font: &str) -> bool {
+		self.data.contains_key(font)
+	}
+
+	/// Insert a new font into the cache
+	pub fn insert(&mut self, font: String, data: Vec<u8>, is_default: bool) {
+		if is_default {
+			self.default_font = Some(font.clone());
+		}
+		self.data.insert(font, data);
+	}
+
+	/// Checks if the font cache has a default font
+	pub fn has_default(&self) -> bool {
+		self.default_font.is_some()
+	}
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Document {
 	/// The root layer, usually a [FolderLayer](layers::folder_layer::FolderLayer) that contains all other [Layers](layers::layer_info::Layer).
@@ -28,6 +66,7 @@ pub struct Document {
 	/// This identifier is not a hash and is not guaranteed to be equal for equivalent documents.
 	#[serde(skip)]
 	pub state_identifier: DefaultHasher,
+	pub font_cache: FontCache,
 }

 impl Default for Document {
@@ -35,6 +74,7 @@ impl Default for Document {
 		Self {
 			root: Layer::new(LayerDataType::Folder(FolderLayer::default()), DAffine2::IDENTITY.to_cols_array()),
 			state_identifier: DefaultHasher::new(),
+			font_cache: FontCache::default(),
 		}
 	}
 }
@@ -44,7 +84,7 @@ impl Document {
 	pub fn render_root(&mut self, mode: ViewMode) -> String {
 		let mut svg_defs = String::from("<defs>");

-		self.root.render(&mut vec![], mode, &mut svg_defs);
+		self.root.render(&mut vec![], mode, &mut svg_defs, &self.font_cache);

 		svg_defs.push_str("</defs>");

@@ -58,7 +98,7 @@ impl Document {

 	/// Checks whether each layer under `path` intersects with the provided `quad` and adds all intersection layers as paths to `intersections`.
 	pub fn intersects_quad(&self, quad: Quad, path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>) {
-		self.layer(path).unwrap().intersects_quad(quad, path, intersections);
+		self.layer(path).unwrap().intersects_quad(quad, path, intersections, &self.font_cache);
 	}

 	/// Checks whether each layer under the root path intersects with the provided `quad` and returns the paths to all intersecting layers.
@@ -321,13 +361,13 @@ impl Document {
 	pub fn viewport_bounding_box(&self, path: &[LayerId]) -> Result<Option<[DVec2; 2]>, DocumentError> {
 		let layer = self.layer(path)?;
 		let transform = self.multiply_transforms(path)?;
-		Ok(layer.data.bounding_box(transform))
+		Ok(layer.data.bounding_box(transform, &self.font_cache))
 	}

 	pub fn bounding_box_and_transform(&self, path: &[LayerId]) -> Result<Option<([DVec2; 2], DAffine2)>, DocumentError> {
 		let layer = self.layer(path)?;
 		let transform = self.multiply_transforms(&path[..path.len() - 1])?;
-		Ok(layer.data.bounding_box(layer.transform).map(|bounds| (bounds, transform)))
+		Ok(layer.data.bounding_box(layer.transform, &self.font_cache).map(|bounds| (bounds, transform)))
 	}

 	pub fn visible_layers_bounding_box(&self) -> Option<[DVec2; 2]> {
@@ -491,11 +531,13 @@ impl Document {
 				insert_index,
 				transform,
 				text,
-
 				style,
 				size,
+				font_name,
+				font_style,
+				font_file,
 			} => {
-				let layer = Layer::new(LayerDataType::Text(TextLayer::new(text, style, size)), transform);
+				let layer = Layer::new(LayerDataType::Text(TextLayer::new(text, style, size, font_name, font_style, font_file, &self.font_cache)), transform);

 				self.set_layer(&path, layer, insert_index)?;

@@ -520,7 +562,20 @@ impl Document {
 				Some(vec![DocumentChanged])
 			}
 			Operation::SetTextContent { path, new_text } => {
-				self.layer_mut(&path)?.as_text_mut()?.update_text(new_text);
+				// Not using Document::layer_mut is necessary because we alson need to borrow the font cache
+				let mut current_folder = &mut self.root;
+
+				let (layer_path, id) = split_path(&path)?;
+				for id in layer_path {
+					current_folder = current_folder.as_folder_mut()?.layer_mut(*id).ok_or_else(|| DocumentError::LayerNotFound(layer_path.into()))?;
+				}
+				current_folder
+					.as_folder_mut()?
+					.layer_mut(id)
+					.ok_or_else(|| DocumentError::LayerNotFound(path.clone()))?
+					.as_text_mut()?
+					.update_text(new_text, &self.font_cache);
+
 				self.mark_as_dirty(&path)?;

 				Some([vec![DocumentChanged], update_thumbnails_upstream(&path)].concat())
@@ -679,6 +734,30 @@ impl Document {
 					return Err(DocumentError::IndexOutOfBounds);
 				}
 			}
+			Operation::ModifyFont {
+				path,
+				font_family,
+				font_style,
+				font_file,
+				size,
+			} => {
+				// Not using Document::layer_mut is necessary because we alson need to borrow the font cache
+				let mut current_folder = &mut self.root;
+				let (folder_path, id) = split_path(&path)?;
+				for id in folder_path {
+					current_folder = current_folder.as_folder_mut()?.layer_mut(*id).ok_or_else(|| DocumentError::LayerNotFound(folder_path.into()))?;
+				}
+				let layer_mut = current_folder.as_folder_mut()?.layer_mut(id).ok_or_else(|| DocumentError::LayerNotFound(folder_path.into()))?;
+				let text = layer_mut.as_text_mut()?;
+
+				text.font_family = font_family;
+				text.font_style = font_style;
+				text.font_file = font_file;
+				text.size = size;
+				text.regenerate_path(text.load_face(&self.font_cache));
+				self.mark_as_dirty(&path)?;
+				Some([vec![DocumentChanged, LayerChanged { path: path.clone() }], update_thumbnails_upstream(&path)].concat())
+			}
 			Operation::RenameLayer { layer_path: path, new_name: name } => {
 				self.layer_mut(&path)?.name = Some(name);
 				Some(vec![LayerChanged { path }])
@@ -729,12 +808,20 @@ impl Document {
 				self.set_transform_relative_to_viewport(&path, transform)?;
 				self.mark_as_dirty(&path)?;

-				if let LayerDataType::Text(t) = &mut self.layer_mut(&path)?.data {
-					let bezpath = t.to_bez_path();
-					self.layer_mut(&path)?.data = layers::layer_info::LayerDataType::Shape(ShapeLayer::from_bez_path(bezpath, t.style.clone(), true));
+				// Not using Document::layer_mut is necessary because we alson need to borrow the font cache
+				let mut current_folder = &mut self.root;
+				let (folder_path, id) = split_path(&path)?;
+				for id in folder_path {
+					current_folder = current_folder.as_folder_mut()?.layer_mut(*id).ok_or_else(|| DocumentError::LayerNotFound(folder_path.into()))?;
+				}
+				let layer_mut = current_folder.as_folder_mut()?.layer_mut(id).ok_or_else(|| DocumentError::LayerNotFound(folder_path.into()))?;
+
+				if let LayerDataType::Text(t) = &mut layer_mut.data {
+					let bezpath = t.to_bez_path(t.load_face(&self.font_cache));
+					layer_mut.data = layers::layer_info::LayerDataType::Shape(ShapeLayer::from_bez_path(bezpath, t.path_style.clone(), true));
 				}

-				if let LayerDataType::Shape(shape) = &mut self.layer_mut(&path)?.data {
+				if let LayerDataType::Shape(shape) = &mut layer_mut.data {
 					shape.path = bez_path;
 				}
 				Some([vec![DocumentChanged, LayerChanged { path: path.clone() }], update_thumbnails_upstream(&path)].concat())
@@ -795,7 +882,7 @@ impl Document {
 				let layer = self.layer_mut(&path)?;
 				match &mut layer.data {
 					LayerDataType::Shape(s) => s.style = style,
-					LayerDataType::Text(text) => text.style = style,
+					LayerDataType::Text(text) => text.path_style = style,
 					_ => return Err(DocumentError::NotAShape),
 				}
 				self.mark_as_dirty(&path)?;