jess
/
Graphite
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename Editor's LayerData to LayerMetadata

This commit is contained in:
Keavon Chambers 2021-12-31 00:02:29 -08:00
parent 5b3cbb30fc
commit 6662a9a04f
10 changed files with 105 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
editor/src/document/document_file.rs
View File

@ -5,7 +5,7 @@ pub use super::layer_panel::*;
use super::movement_handler::{MovementMessage, MovementMessageHandler}; use super::movement_handler::{MovementMessage, MovementMessageHandler};
use super::overlay_message_handler::OverlayMessageHandler; use super::overlay_message_handler::OverlayMessageHandler;
use super::transform_layer_handler::{TransformLayerMessage, TransformLayerMessageHandler}; use super::transform_layer_handler::{TransformLayerMessage, TransformLayerMessageHandler};
use super::vectorize_layerdata; use super::vectorize_layer_metadata;
use crate::consts::DEFAULT_DOCUMENT_NAME; use crate::consts::DEFAULT_DOCUMENT_NAME;
use crate::consts::{ASYMPTOTIC_EFFECT, FILE_EXPORT_SUFFIX, FILE_SAVE_SUFFIX, SCALE_EFFECT, SCROLLBAR_SPACING}; use crate::consts::{ASYMPTOTIC_EFFECT, FILE_EXPORT_SUFFIX, FILE_SAVE_SUFFIX, SCALE_EFFECT, SCROLLBAR_SPACING};
@ -24,7 +24,7 @@ use kurbo::PathSeg;
use log::warn; use log::warn;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
type DocumentSave = (GrapheneDocument, HashMap<Vec<LayerId>, LayerData>); type DocumentSave = (GrapheneDocument, HashMap<Vec<LayerId>, LayerMetadata>);
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, Hash)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, Hash)]
pub enum FlipAxis { pub enum FlipAxis {
@ -69,8 +69,8 @@ pub struct DocumentMessageHandler {
pub document_redo_history: Vec<DocumentSave>, pub document_redo_history: Vec<DocumentSave>,
pub saved_document_identifier: u64, pub saved_document_identifier: u64,
pub name: String, pub name: String,
#[serde(with = "vectorize_layerdata")] #[serde(with = "vectorize_layer_metadata")]
pub layer_data: HashMap<Vec<LayerId>, LayerData>, pub layer_metadata: HashMap<Vec<LayerId>, LayerMetadata>,
layer_range_selection_reference: Vec<LayerId>, layer_range_selection_reference: Vec<LayerId>,
#[serde(skip)] #[serde(skip)]
movement_handler: MovementMessageHandler, movement_handler: MovementMessageHandler,
@ -90,7 +90,7 @@ impl Default for DocumentMessageHandler {
document_redo_history: Vec::new(), document_redo_history: Vec::new(),
name: String::from("Untitled Document"), name: String::from("Untitled Document"),
saved_document_identifier: 0, saved_document_identifier: 0,
layer_data: vec![(vec![], LayerData::new(true))].into_iter().collect(), layer_metadata: vec![(vec![], LayerMetadata::new(true))].into_iter().collect(),
layer_range_selection_reference: Vec::new(), layer_range_selection_reference: Vec::new(),
movement_handler: MovementMessageHandler::default(), movement_handler: MovementMessageHandler::default(),
overlay_message_handler: OverlayMessageHandler::default(), overlay_message_handler: OverlayMessageHandler::default(),
@ -111,9 +111,9 @@ pub enum DocumentMessage {
DispatchOperation(Box<DocumentOperation>), DispatchOperation(Box<DocumentOperation>),
#[child] #[child]
Overlay(OverlayMessage), Overlay(OverlayMessage),
UpdateLayerData { UpdateLayerMetadata {
path: Vec<LayerId>, layer_path: Vec<LayerId>,
layer_data_entry: LayerData, layer_metadata: LayerMetadata,
}, },
SetSelectedLayers(Vec<Vec<LayerId>>), SetSelectedLayers(Vec<Vec<LayerId>>),
AddSelectedLayers(Vec<Vec<LayerId>>), AddSelectedLayers(Vec<Vec<LayerId>>),
@ -217,7 +217,7 @@ impl DocumentMessageHandler {
fn select_layer(&mut self, path: &[LayerId]) -> Option<Message> { fn select_layer(&mut self, path: &[LayerId]) -> Option<Message> {
println!("Select_layer fail: {:?}", self.all_layers_sorted()); println!("Select_layer fail: {:?}", self.all_layers_sorted());
self.layer_data_mut(path).selected = true; self.layer_metadata_mut(path).selected = true;
let data = self.layer_panel_entry(path.to_vec()).ok()?; let data = self.layer_panel_entry(path.to_vec()).ok()?;
(!path.is_empty()).then(|| FrontendMessage::UpdateLayer { data }.into()) (!path.is_empty()).then(|| FrontendMessage::UpdateLayer { data }.into())
} }
@ -269,12 +269,8 @@ impl DocumentMessageHandler {
shapes.collect::<Vec<VectorManipulatorShape>>() shapes.collect::<Vec<VectorManipulatorShape>>()
} }
pub fn create_layer_data(&mut self, path: &[LayerId]) {
self.layer_data.insert(path.to_vec(), LayerData::new(true));
}
pub fn selected_layers(&self) -> impl Iterator<Item = &[LayerId]> { pub fn selected_layers(&self) -> impl Iterator<Item = &[LayerId]> {
self.layer_data.iter().filter_map(|(path, data)| data.selected.then(|| path.as_slice())) self.layer_metadata.iter().filter_map(|(path, data)| data.selected.then(|| path.as_slice()))
} }
pub fn selected_visible_layers(&self) -> impl Iterator<Item = &[LayerId]> { pub fn selected_visible_layers(&self) -> impl Iterator<Item = &[LayerId]> {
@ -293,7 +289,7 @@ impl DocumentMessageHandler {
LayerDataType::Shape(_) => (), LayerDataType::Shape(_) => (),
LayerDataType::Folder(ref folder) => { LayerDataType::Folder(ref folder) => {
path.push(*id); path.push(*id);
if self.layer_data(path).expanded { if self.layer_metadata(path).expanded {
structure.push(space); structure.push(space);
self.serialize_structure(folder, structure, data, path); self.serialize_structure(folder, structure, data, path);
space = 0; space = 0;
@ -339,7 +335,7 @@ impl DocumentMessageHandler {
/// Returns an unsorted list of all layer paths including folders at all levels, except the document's top-level root folder itself /// Returns an unsorted list of all layer paths including folders at all levels, except the document's top-level root folder itself
pub fn all_layers(&self) -> Vec<Vec<LayerId>> { pub fn all_layers(&self) -> Vec<Vec<LayerId>> {
self.layer_data.keys().filter(|path| !path.is_empty()).cloned().collect() self.layer_metadata.keys().filter(|path| !path.is_empty()).cloned().collect()
} }
/// Returns the paths to all layers in order, optionally including only selected or non-selected layers. /// Returns the paths to all layers in order, optionally including only selected or non-selected layers.
@ -347,14 +343,13 @@ impl DocumentMessageHandler {
// Compute the indices for each layer to be able to sort them // Compute the indices for each layer to be able to sort them
let mut layers_with_indices: Vec<(Vec<LayerId>, Vec<usize>)> = self let mut layers_with_indices: Vec<(Vec<LayerId>, Vec<usize>)> = self
.layer_data .layer_metadata
.iter() .iter()
// 'path.len() > 0' filters out root layer since it has no indices // 'path.len() > 0' filters out root layer since it has no indices
.filter_map(|(path, data)| (!path.is_empty() && (data.selected == selected.unwrap_or(data.selected))).then(|| path.clone())) .filter_map(|(path, data)| (!path.is_empty() && (data.selected == selected.unwrap_or(data.selected))).then(|| path.clone()))
.filter_map(|path| { .filter_map(|path| {
// Currently it is possible that layer_data contains layers that are don't actually exist (has been partially fixed in #281) // TODO: Currently it is possible that `layer_metadata` contains layers that are don't actually exist (has been partially fixed in #281) and thus
// and thus indices_for_path can return an error. We currently skip these layers and log a warning. // TODO: `indices_for_path` can return an error. We currently skip these layers and log a warning. Once this problem is solved this code can be simplified.
// Once this problem is solved this code can be simplified
match self.graphene_document.indices_for_path(&path) { match self.graphene_document.indices_for_path(&path) {
Err(err) => { Err(err) => {
warn!("layers_sorted: Could not get indices for the layer {:?}: {:?}", path, err); warn!("layers_sorted: Could not get indices for the layer {:?}: {:?}", path, err);
@ -385,23 +380,23 @@ impl DocumentMessageHandler {
self.layers_sorted(Some(false)) self.layers_sorted(Some(false))
} }
pub fn layer_data(&self, path: &[LayerId]) -> &LayerData { pub fn layer_metadata(&self, path: &[LayerId]) -> &LayerMetadata {
self.layer_data.get(path).expect("Layerdata does not exist") self.layer_metadata.get(path).unwrap_or_else(|| panic!("Editor's layer metadata for {:?} does not exist", path))
} }
pub fn layer_data_mut(&mut self, path: &[LayerId]) -> &mut LayerData { pub fn layer_metadata_mut(&mut self, path: &[LayerId]) -> &mut LayerMetadata {
Self::layer_data_mut_no_borrow_self(&mut self.layer_data, path) Self::layer_metadata_mut_no_borrow_self(&mut self.layer_metadata, path)
} }
pub fn layer_data_mut_no_borrow_self<'a>(layer_data: &'a mut HashMap<Vec<LayerId>, LayerData>, path: &[LayerId]) -> &'a mut LayerData { pub fn layer_metadata_mut_no_borrow_self<'a>(layer_metadata: &'a mut HashMap<Vec<LayerId>, LayerMetadata>, path: &[LayerId]) -> &'a mut LayerMetadata {
layer_data layer_metadata
.get_mut(path) .get_mut(path)
.unwrap_or_else(|| panic!("Layer data cannot be found because the path {:?} does not exist", path)) .unwrap_or_else(|| panic!("Layer data cannot be found because the path {:?} does not exist", path))
} }
pub fn backup(&mut self, responses: &mut VecDeque<Message>) { pub fn backup(&mut self, responses: &mut VecDeque<Message>) {
self.document_redo_history.clear(); self.document_redo_history.clear();
self.document_undo_history.push((self.graphene_document.clone(), self.layer_data.clone())); self.document_undo_history.push((self.graphene_document.clone(), self.layer_metadata.clone()));
// Push the UpdateOpenDocumentsList message to the bus in order to update the save status of the open documents // Push the UpdateOpenDocumentsList message to the bus in order to update the save status of the open documents
responses.push_back(DocumentsMessage::UpdateOpenDocumentsList.into()); responses.push_back(DocumentsMessage::UpdateOpenDocumentsList.into());
@ -418,10 +413,10 @@ impl DocumentMessageHandler {
responses.push_back(DocumentsMessage::UpdateOpenDocumentsList.into()); responses.push_back(DocumentsMessage::UpdateOpenDocumentsList.into());
match self.document_undo_history.pop() { match self.document_undo_history.pop() {
Some((document, layer_data)) => { Some((document, layer_metadata)) => {
let document = std::mem::replace(&mut self.graphene_document, document); let document = std::mem::replace(&mut self.graphene_document, document);
let layer_data = std::mem::replace(&mut self.layer_data, layer_data); let layer_metadata = std::mem::replace(&mut self.layer_metadata, layer_metadata);
self.document_redo_history.push((document, layer_data)); self.document_redo_history.push((document, layer_metadata));
Ok(()) Ok(())
} }
None => Err(EditorError::NoTransactionInProgress), None => Err(EditorError::NoTransactionInProgress),
@ -433,10 +428,10 @@ impl DocumentMessageHandler {
responses.push_back(DocumentsMessage::UpdateOpenDocumentsList.into()); responses.push_back(DocumentsMessage::UpdateOpenDocumentsList.into());
match self.document_redo_history.pop() { match self.document_redo_history.pop() {
Some((document, layer_data)) => { Some((document, layer_metadata)) => {
let document = std::mem::replace(&mut self.graphene_document, document); let document = std::mem::replace(&mut self.graphene_document, document);
let layer_data = std::mem::replace(&mut self.layer_data, layer_data); let layer_metadata = std::mem::replace(&mut self.layer_metadata, layer_metadata);
self.document_undo_history.push((document, layer_data)); self.document_undo_history.push((document, layer_metadata));
Ok(()) Ok(())
} }
None => Err(EditorError::NoTransactionInProgress), None => Err(EditorError::NoTransactionInProgress),
@ -465,7 +460,7 @@ impl DocumentMessageHandler {
} }
pub fn layer_panel_entry(&mut self, path: Vec<LayerId>) -> Result<LayerPanelEntry, EditorError> { pub fn layer_panel_entry(&mut self, path: Vec<LayerId>) -> Result<LayerPanelEntry, EditorError> {
let data: LayerData = *self.layer_data_mut(&path); let data: LayerMetadata = *self.layer_metadata_mut(&path);
let layer = self.graphene_document.layer(&path)?; let layer = self.graphene_document.layer(&path)?;
let entry = layer_panel_entry(&data, self.graphene_document.multiply_transforms(&path)?, layer, path); let entry = layer_panel_entry(&data, self.graphene_document.multiply_transforms(&path)?, layer, path);
Ok(entry) Ok(entry)
@ -481,14 +476,14 @@ impl DocumentMessageHandler {
} }
pub fn layer_panel_entry_from_path(&self, path: &[LayerId]) -> Option<LayerPanelEntry> { pub fn layer_panel_entry_from_path(&self, path: &[LayerId]) -> Option<LayerPanelEntry> {
let layer_data = self.layer_data(path); let layer_metadata = self.layer_metadata(path);
let transform = self let transform = self
.graphene_document .graphene_document
.generate_transform_across_scope(path, Some(self.graphene_document.root.transform.inverse())) .generate_transform_across_scope(path, Some(self.graphene_document.root.transform.inverse()))
.ok()?; .ok()?;
let layer = self.graphene_document.layer(path).ok()?; let layer = self.graphene_document.layer(path).ok()?;
Some(layer_panel_entry(layer_data, transform, layer, path.to_vec())) Some(layer_panel_entry(layer_metadata, transform, layer, path.to_vec()))
} }
} }
@ -499,7 +494,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
Movement(message) => self.movement_handler.process_action(message, (&self.graphene_document, ipp), responses), Movement(message) => self.movement_handler.process_action(message, (&self.graphene_document, ipp), responses),
TransformLayers(message) => self TransformLayers(message) => self
.transform_layer_handler .transform_layer_handler
.process_action(message, (&mut self.layer_data, &mut self.graphene_document, ipp), responses), .process_action(message, (&mut self.layer_metadata, &mut self.graphene_document, ipp), responses),
DeleteLayer(path) => responses.push_back(DocumentOperation::DeleteLayer { path }.into()), DeleteLayer(path) => responses.push_back(DocumentOperation::DeleteLayer { path }.into()),
StartTransaction => self.backup(responses), StartTransaction => self.backup(responses),
RollbackTransaction => { RollbackTransaction => {
@ -512,8 +507,11 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
} }
CommitTransaction => (), CommitTransaction => (),
Overlay(message) => { Overlay(message) => {
self.overlay_message_handler self.overlay_message_handler.process_action(
.process_action(message, (Self::layer_data_mut_no_borrow_self(&mut self.layer_data, &[]), &self.graphene_document, ipp), responses); message,
(Self::layer_metadata_mut_no_borrow_self(&mut self.layer_metadata, &[]), &self.graphene_document, ipp),
responses,
);
// responses.push_back(OverlayMessage::RenderOverlays.into()); // responses.push_back(OverlayMessage::RenderOverlays.into());
} }
ExportDocument => { ExportDocument => {
@ -588,7 +586,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
} }
SetBlendModeForSelectedLayers(blend_mode) => { SetBlendModeForSelectedLayers(blend_mode) => {
self.backup(responses); self.backup(responses);
for path in self.layer_data.iter().filter_map(|(path, data)| data.selected.then(|| path.clone())) { for path in self.layer_metadata.iter().filter_map(|(path, data)| data.selected.then(|| path.clone())) {
responses.push_back(DocumentOperation::SetLayerBlendMode { path, blend_mode }.into()); responses.push_back(DocumentOperation::SetLayerBlendMode { path, blend_mode }.into());
} }
} }
@ -605,12 +603,12 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
responses.push_back(ToolMessage::DocumentIsDirty.into()); responses.push_back(ToolMessage::DocumentIsDirty.into());
} }
ToggleLayerExpansion(path) => { ToggleLayerExpansion(path) => {
self.layer_data_mut(&path).expanded ^= true; self.layer_metadata_mut(&path).expanded ^= true;
responses.push_back(DocumentStructureChanged.into()); responses.push_back(DocumentStructureChanged.into());
responses.push_back(LayerChanged(path).into()) responses.push_back(LayerChanged(path).into())
} }
SetLayerExpansion(path, is_expanded) => { SetLayerExpansion(path, is_expanded) => {
self.layer_data_mut(&path).expanded = is_expanded; self.layer_metadata_mut(&path).expanded = is_expanded;
responses.push_back(DocumentStructureChanged.into()); responses.push_back(DocumentStructureChanged.into());
responses.push_back(LayerChanged(path).into()) responses.push_back(LayerChanged(path).into())
} }
@ -642,7 +640,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
// If we have shift pressed and a layer already selected then fill the range // If we have shift pressed and a layer already selected then fill the range
if shift && last_selection_exists { if shift && last_selection_exists {
// Fill the selection range // Fill the selection range
self.layer_data self.layer_metadata
.iter() .iter()
.filter(|(target, _)| self.graphene_document.layer_is_between(target, &selected, &self.layer_range_selection_reference)) .filter(|(target, _)| self.graphene_document.layer_is_between(target, &selected, &self.layer_range_selection_reference))
.for_each(|(layer_path, _)| { .for_each(|(layer_path, _)| {
@ -651,7 +649,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
} else { } else {
if ctrl { if ctrl {
// Toggle selection when holding ctrl // Toggle selection when holding ctrl
let layer = self.layer_data_mut(&selected); let layer = self.layer_metadata_mut(&selected);
layer.selected = !layer.selected; layer.selected = !layer.selected;
responses.push_back(LayerChanged(selected.clone()).into()); responses.push_back(LayerChanged(selected.clone()).into());
} else { } else {
@ -672,12 +670,13 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
} }
} }
} }
UpdateLayerData { path, layer_data_entry } => { UpdateLayerMetadata { layer_path: path, layer_metadata } => {
self.layer_data.insert(path, layer_data_entry); self.layer_metadata.insert(path, layer_metadata);
} }
SetSelectedLayers(paths) => { SetSelectedLayers(paths) => {
self.layer_data.iter_mut().filter(|(_, layer_data)| layer_data.selected).for_each(|(path, layer_data)| { let selected = self.layer_metadata.iter_mut().filter(|(_, layer_metadata)| layer_metadata.selected);
layer_data.selected = false; selected.for_each(|(path, layer_metadata)| {
layer_metadata.selected = false;
responses.push_back(LayerChanged(path.clone()).into()) responses.push_back(LayerChanged(path.clone()).into())
}); });
@ -692,7 +691,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
responses.push_back(ToolMessage::DocumentIsDirty.into()); responses.push_back(ToolMessage::DocumentIsDirty.into());
} }
DebugPrintDocument => { DebugPrintDocument => {
log::debug!("{:#?}\n{:#?}", self.graphene_document, self.layer_data); log::debug!("{:#?}\n{:#?}", self.graphene_document, self.layer_metadata);
} }
SelectAllLayers => { SelectAllLayers => {
let all_layer_paths = self.all_layers(); let all_layer_paths = self.all_layers();
@ -737,11 +736,11 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
match &response { match &response {
DocumentResponse::FolderChanged { path } => responses.push_back(FolderChanged(path.clone()).into()), DocumentResponse::FolderChanged { path } => responses.push_back(FolderChanged(path.clone()).into()),
DocumentResponse::DeletedLayer { path } => { DocumentResponse::DeletedLayer { path } => {
self.layer_data.remove(path); self.layer_metadata.remove(path);
} }
DocumentResponse::LayerChanged { path } => responses.push_back(LayerChanged(path.clone()).into()), DocumentResponse::LayerChanged { path } => responses.push_back(LayerChanged(path.clone()).into()),
DocumentResponse::CreatedLayer { path } => { DocumentResponse::CreatedLayer { path } => {
self.layer_data.insert(path.clone(), LayerData::new(false)); self.layer_metadata.insert(path.clone(), LayerMetadata::new(false));
responses.push_back(LayerChanged(path.clone()).into()); responses.push_back(LayerChanged(path.clone()).into());
self.layer_range_selection_reference = path.clone(); self.layer_range_selection_reference = path.clone();
responses.push_back(SetSelectedLayers(vec![path.clone()]).into()); responses.push_back(SetSelectedLayers(vec![path.clone()]).into());
@ -953,9 +952,9 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
.into(), .into(),
); );
responses.push_back( responses.push_back(
DocumentMessage::UpdateLayerData { DocumentMessage::UpdateLayerMetadata {
path: destination_path, layer_path: destination_path,
layer_data_entry: *self.layer_data(&target_layer), layer_metadata: *self.layer_metadata(&target_layer),
} }
.into(), .into(),
); );
@ -983,7 +982,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
MoveLayerInTree, MoveLayerInTree,
); );
if self.layer_data.values().any(|data| data.selected) { if self.layer_metadata.values().any(|data| data.selected) {
let select = actions!(DocumentMessageDiscriminant; let select = actions!(DocumentMessageDiscriminant;
DeleteSelectedLayers, DeleteSelectedLayers,
DuplicateSelectedLayers, DuplicateSelectedLayers,

24
editor/src/document/document_message_handler.rs
View File

@ -1,4 +1,4 @@
use super::{DocumentMessageHandler, LayerData}; use super::{DocumentMessageHandler, LayerMetadata};
use crate::consts::DEFAULT_DOCUMENT_NAME; use crate::consts::DEFAULT_DOCUMENT_NAME;
use crate::frontend::frontend_message_handler::FrontendDocumentDetails; use crate::frontend::frontend_message_handler::FrontendDocumentDetails;
use crate::input::InputPreprocessor; use crate::input::InputPreprocessor;
@ -68,7 +68,7 @@ pub struct DocumentsMessageHandler {
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CopyBufferEntry { pub struct CopyBufferEntry {
layer: Layer, layer: Layer,
layer_data: LayerData, layer_metadata: LayerMetadata,
} }
impl DocumentsMessageHandler { impl DocumentsMessageHandler {
@ -121,7 +121,7 @@ impl DocumentsMessageHandler {
responses.extend( responses.extend(
new_document new_document
.layer_data .layer_metadata
.keys() .keys()
.filter_map(|path| new_document.layer_panel_entry_from_path(path)) .filter_map(|path| new_document.layer_panel_entry_from_path(path))
.map(|entry| FrontendMessage::UpdateLayer { data: entry }.into()) .map(|entry| FrontendMessage::UpdateLayer { data: entry }.into())
@ -193,7 +193,7 @@ impl MessageHandler<DocumentsMessage, &InputPreprocessor> for DocumentsMessageHa
responses.push_back(FrontendMessage::SetActiveDocument { document_id: id }.into()); responses.push_back(FrontendMessage::SetActiveDocument { document_id: id }.into());
responses.push_back(RenderDocument.into()); responses.push_back(RenderDocument.into());
responses.push_back(DocumentMessage::DocumentStructureChanged.into()); responses.push_back(DocumentMessage::DocumentStructureChanged.into());
for layer in self.active_document().layer_data.keys() { for layer in self.active_document().layer_metadata.keys() {
responses.push_back(DocumentMessage::LayerChanged(layer.clone()).into()); responses.push_back(DocumentMessage::LayerChanged(layer.clone()).into());
} }
} }
@ -262,7 +262,7 @@ impl MessageHandler<DocumentsMessage, &InputPreprocessor> for DocumentsMessageHa
responses.push_back(FrontendMessage::RemoveAutoSaveDocument { document_id: id }.into()); responses.push_back(FrontendMessage::RemoveAutoSaveDocument { document_id: id }.into());
responses.push_back(RenderDocument.into()); responses.push_back(RenderDocument.into());
responses.push_back(DocumentMessage::DocumentStructureChanged.into()); responses.push_back(DocumentMessage::DocumentStructureChanged.into());
for layer in self.active_document().layer_data.keys() { for layer in self.active_document().layer_metadata.keys() {
responses.push_back(DocumentMessage::LayerChanged(layer.clone()).into()); responses.push_back(DocumentMessage::LayerChanged(layer.clone()).into());
} }
} }
@ -356,9 +356,9 @@ impl MessageHandler<DocumentsMessage, &InputPreprocessor> for DocumentsMessageHa
self.copy_buffer[clipboard as usize].clear(); self.copy_buffer[clipboard as usize].clear();
for path in paths { for path in paths {
let document = self.active_document(); let document = self.active_document();
match (document.graphene_document.layer(&path).map(|t| t.clone()), *document.layer_data(&path)) { match (document.graphene_document.layer(&path).map(|t| t.clone()), *document.layer_metadata(&path)) {
(Ok(layer), layer_data) => { (Ok(layer), layer_metadata) => {
self.copy_buffer[clipboard as usize].push(CopyBufferEntry { layer, layer_data }); self.copy_buffer[clipboard as usize].push(CopyBufferEntry { layer, layer_metadata });
} }
(Err(e), _) => warn!("Could not access selected layer {:?}: {:?}", path, e), (Err(e), _) => warn!("Could not access selected layer {:?}: {:?}", path, e),
} }
@ -399,9 +399,9 @@ impl MessageHandler<DocumentsMessage, &InputPreprocessor> for DocumentsMessageHa
.into(), .into(),
); );
responses.push_back( responses.push_back(
DocumentMessage::UpdateLayerData { DocumentMessage::UpdateLayerMetadata {
path: destination_path, layer_path: destination_path,
layer_data_entry: entry.layer_data, layer_metadata: entry.layer_metadata,
} }
.into(), .into(),
); );
@ -431,7 +431,7 @@ impl MessageHandler<DocumentsMessage, &InputPreprocessor> for DocumentsMessageHa
Paste, Paste,
); );
if self.active_document().layer_data.values().any(|data| data.selected) { if self.active_document().layer_metadata.values().any(|data| data.selected) {
let select = actions!(DocumentsMessageDiscriminant; let select = actions!(DocumentsMessageDiscriminant;
Copy, Copy,
Cut, Cut,

22
editor/src/document/layer_panel.rs
View File

@ -1,22 +1,24 @@
use glam::{DAffine2, DVec2}; use graphene::layers::{style::ViewMode, BlendMode, Layer, LayerData, LayerDataType};
use graphene::layers::{style::ViewMode, BlendMode, Layer, LayerData as DocumentLayerData, LayerDataType};
use graphene::LayerId; use graphene::LayerId;
use serde::{ser::SerializeStruct, Deserialize, Serialize};
use std::fmt; use std::fmt;
use glam::{DAffine2, DVec2};
use serde::{ser::SerializeStruct, Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Copy)] #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Copy)]
pub struct LayerData { pub struct LayerMetadata {
pub selected: bool, pub selected: bool,
pub expanded: bool, pub expanded: bool,
} }
impl LayerData { impl LayerMetadata {
pub fn new(expanded: bool) -> LayerData { pub fn new(expanded: bool) -> LayerMetadata {
LayerData { selected: false, expanded } LayerMetadata { selected: false, expanded }
} }
} }
pub fn layer_panel_entry(layer_data: &LayerData, transform: DAffine2, layer: &Layer, path: Vec<LayerId>) -> LayerPanelEntry { pub fn layer_panel_entry(layer_metadata: &LayerMetadata, transform: DAffine2, layer: &Layer, path: Vec<LayerId>) -> LayerPanelEntry {
let layer_type: LayerDataTypeDiscriminant = (&layer.data).into(); let layer_type: LayerDataTypeDiscriminant = (&layer.data).into();
let name = layer.name.clone().unwrap_or_else(|| format!("Unnamed {}", layer_type)); let name = layer.name.clone().unwrap_or_else(|| format!("Unnamed {}", layer_type));
let arr = layer.data.bounding_box(transform).unwrap_or([DVec2::ZERO, DVec2::ZERO]); let arr = layer.data.bounding_box(transform).unwrap_or([DVec2::ZERO, DVec2::ZERO]);
@ -45,7 +47,7 @@ pub fn layer_panel_entry(layer_data: &LayerData, transform: DAffine2, layer: &La
blend_mode: layer.blend_mode, blend_mode: layer.blend_mode,
opacity: layer.opacity, opacity: layer.opacity,
layer_type: (&layer.data).into(), layer_type: (&layer.data).into(),
layer_data: *layer_data, layer_metadata: *layer_metadata,
path, path,
thumbnail, thumbnail,
} }
@ -85,7 +87,7 @@ pub struct LayerPanelEntry {
pub blend_mode: BlendMode, pub blend_mode: BlendMode,
pub opacity: f64, pub opacity: f64,
pub layer_type: LayerDataTypeDiscriminant, pub layer_type: LayerDataTypeDiscriminant,
pub layer_data: LayerData, pub layer_metadata: LayerMetadata,
pub path: Vec<LayerId>, pub path: Vec<LayerId>,
pub thumbnail: String, pub thumbnail: String,
} }

4
editor/src/document/mod.rs
View File

@ -4,10 +4,10 @@ pub mod layer_panel;
mod movement_handler; mod movement_handler;
mod overlay_message_handler; mod overlay_message_handler;
mod transform_layer_handler; mod transform_layer_handler;
mod vectorize_layerdata; mod vectorize_layer_metadata;
#[doc(inline)] #[doc(inline)]
pub use document_file::LayerData; pub use document_file::LayerMetadata;
#[doc(inline)] #[doc(inline)]
pub use document_file::{AlignAggregate, AlignAxis, DocumentMessage, DocumentMessageDiscriminant, DocumentMessageHandler, FlipAxis, VectorManipulatorSegment, VectorManipulatorShape}; pub use document_file::{AlignAggregate, AlignAxis, DocumentMessage, DocumentMessageDiscriminant, DocumentMessageHandler, FlipAxis, VectorManipulatorSegment, VectorManipulatorShape};

8
editor/src/document/overlay_message_handler.rs
View File

@ -1,5 +1,5 @@
pub use crate::document::layer_panel::*; pub use crate::document::layer_panel::*;
use crate::document::{DocumentMessage, LayerData}; use crate::document::{DocumentMessage, LayerMetadata};
use crate::input::InputPreprocessor; use crate::input::InputPreprocessor;
use crate::message_prelude::*; use crate::message_prelude::*;
use graphene::document::Document; use graphene::document::Document;
@ -29,9 +29,9 @@ pub struct OverlayMessageHandler {
overlay_path_mapping: HashMap<Vec<LayerId>, Vec<LayerId>>, overlay_path_mapping: HashMap<Vec<LayerId>, Vec<LayerId>>,
} }
impl MessageHandler<OverlayMessage, (&mut LayerData, &Document, &InputPreprocessor)> for OverlayMessageHandler { impl MessageHandler<OverlayMessage, (&mut LayerMetadata, &Document, &InputPreprocessor)> for OverlayMessageHandler {
fn process_action(&mut self, message: OverlayMessage, _data: (&mut LayerData, &Document, &InputPreprocessor), responses: &mut VecDeque<Message>) { fn process_action(&mut self, message: OverlayMessage, _data: (&mut LayerMetadata, &Document, &InputPreprocessor), responses: &mut VecDeque<Message>) {
// let (layer_data, document, ipp) = data; // let (layer_metadata, document, ipp) = data;
use OverlayMessage::*; use OverlayMessage::*;
match message { match message {
DispatchOperation(operation) => match self.overlays_graphene_document.handle_operation(&operation) { DispatchOperation(operation) => match self.overlays_graphene_document.handle_operation(&operation) {

14
editor/src/document/transform_layer_handler.rs
View File

@ -1,6 +1,6 @@
pub use super::layer_panel::*; pub use super::layer_panel::*;
use super::LayerData; use super::LayerMetadata;
use crate::consts::{ROTATE_SNAP_ANGLE, SCALE_SNAP_INTERVAL, SLOWING_DIVISOR}; use crate::consts::{ROTATE_SNAP_ANGLE, SCALE_SNAP_INTERVAL, SLOWING_DIVISOR};
use crate::input::keyboard::Key; use crate::input::keyboard::Key;
@ -25,11 +25,11 @@ impl<'a> Selected<'a> {
pub fn new( pub fn new(
original_transforms: &'a mut OriginalTransforms, original_transforms: &'a mut OriginalTransforms,
pivot: &'a mut DVec2, pivot: &'a mut DVec2,
layer_data: &'a mut HashMap<Vec<LayerId>, LayerData>, layer_metadata: &'a mut HashMap<Vec<LayerId>, LayerMetadata>,
responses: &'a mut VecDeque<Message>, responses: &'a mut VecDeque<Message>,
document: &'a mut Document, document: &'a mut Document,
) -> Self { ) -> Self {
let selected = layer_data.iter().filter_map(|(layer_path, data)| data.selected.then(|| layer_path.to_owned())).collect(); let selected = layer_metadata.iter().filter_map(|(layer_path, data)| data.selected.then(|| layer_path.to_owned())).collect();
for path in &selected { for path in &selected {
if !original_transforms.contains_key::<Vec<LayerId>>(path) { if !original_transforms.contains_key::<Vec<LayerId>>(path) {
original_transforms.insert(path.clone(), document.layer(path).unwrap().transform); original_transforms.insert(path.clone(), document.layer(path).unwrap().transform);
@ -394,12 +394,12 @@ pub struct TransformLayerMessageHandler {
pivot: DVec2, pivot: DVec2,
} }
impl MessageHandler<TransformLayerMessage, (&mut HashMap<Vec<LayerId>, LayerData>, &mut Document, &InputPreprocessor)> for TransformLayerMessageHandler { impl MessageHandler<TransformLayerMessage, (&mut HashMap<Vec<LayerId>, LayerMetadata>, &mut Document, &InputPreprocessor)> for TransformLayerMessageHandler {
fn process_action(&mut self, message: TransformLayerMessage, data: (&mut HashMap<Vec<LayerId>, LayerData>, &mut Document, &InputPreprocessor), responses: &mut VecDeque<Message>) { fn process_action(&mut self, message: TransformLayerMessage, data: (&mut HashMap<Vec<LayerId>, LayerMetadata>, &mut Document, &InputPreprocessor), responses: &mut VecDeque<Message>) {
use TransformLayerMessage::*; use TransformLayerMessage::*;
let (layer_data, document, ipp) = data; let (layer_metadata, document, ipp) = data;
let mut selected = Selected::new(&mut self.original_transforms, &mut self.pivot, layer_data, responses, document); let mut selected = Selected::new(&mut self.original_transforms, &mut self.pivot, layer_metadata, responses, document);
let mut begin_operation = |operation: Operation, typing: &mut Typing, mouse_position: &mut DVec2, start_mouse: &mut DVec2| { let mut begin_operation = |operation: Operation, typing: &mut Typing, mouse_position: &mut DVec2, start_mouse: &mut DVec2| {
if !(operation == Operation::None) { if !(operation == Operation::None) {

0
editor/src/document/vectorize_layerdata.rs → editor/src/document/vectorize_layer_metadata.rs
View File

10
frontend/src/components/panels/LayerTree.vue
View File

@ -28,13 +28,13 @@
<button <button
v-if="layer.layer_type === LayerTypeOptions.Folder" v-if="layer.layer_type === LayerTypeOptions.Folder"
class="node-connector" class="node-connector"
:class="{ expanded: layer.layer_data.expanded }" :class="{ expanded: layer.layer_metadata.expanded }"
@click.stop="handleNodeConnectorClick(layer.path)" @click.stop="handleNodeConnectorClick(layer.path)"
></button> ></button>
<div v-else class="node-connector-missing"></div> <div v-else class="node-connector-missing"></div>
<div <div
class="layer" class="layer"
:class="{ selected: layer.layer_data.selected }" :class="{ selected: layer.layer_metadata.selected }"
:style="{ marginLeft: layerIndent(layer) }" :style="{ marginLeft: layerIndent(layer) }"
@click.shift.exact.stop="selectLayer(layer, false, true)" @click.shift.exact.stop="selectLayer(layer, false, true)"
@click.shift.ctrl.exact.stop="selectLayer(layer, true, true)" @click.shift.ctrl.exact.stop="selectLayer(layer, true, true)"
@ -336,7 +336,7 @@ export default defineComponent({
}, },
async clearSelection() { async clearSelection() {
this.layers.forEach((layer) => { this.layers.forEach((layer) => {
layer.layer_data.selected = false; layer.layer_metadata.selected = false;
}); });
}, },
closest(tree: HTMLElement, clientY: number): [BigUint64Array, boolean, Node] { closest(tree: HTMLElement, clientY: number): [BigUint64Array, boolean, Node] {
@ -446,7 +446,7 @@ export default defineComponent({
} }
}, },
setBlendModeForSelectedLayers() { setBlendModeForSelectedLayers() {
const selected = this.layers.filter((layer) => layer.layer_data.selected); const selected = this.layers.filter((layer) => layer.layer_metadata.selected);
if (selected.length < 1) { if (selected.length < 1) {
this.blendModeSelectedIndex = 0; this.blendModeSelectedIndex = 0;
@ -467,7 +467,7 @@ export default defineComponent({
}, },
setOpacityForSelectedLayers() { setOpacityForSelectedLayers() {
// todo figure out why this is here // todo figure out why this is here
const selected = this.layers.filter((layer) => layer.layer_data.selected); const selected = this.layers.filter((layer) => layer.layer_metadata.selected);
if (selected.length < 1) { if (selected.length < 1) {
this.opacity = 100; this.opacity = 100;

6
frontend/src/dispatcher/js-messages.ts
View File

@ -284,13 +284,13 @@ export class LayerPanelEntry {
@Transform(({ value }) => new BigUint64Array(value)) @Transform(({ value }) => new BigUint64Array(value))
path!: BigUint64Array; path!: BigUint64Array;
@Type(() => LayerData) @Type(() => LayerMetadata)
layer_data!: LayerData; layer_metadata!: LayerMetadata;
thumbnail!: string; thumbnail!: string;
} }
export class LayerData { export class LayerMetadata {
expanded!: boolean; expanded!: boolean;
selected!: boolean; selected!: boolean;

13
graphene/src/layers/mod.rs
View File

@ -18,18 +18,11 @@ use serde::{Deserialize, Serialize};
use std::fmt::Write; use std::fmt::Write;
pub trait LayerData {
fn render(&mut self, svg: &mut String, transforms: &mut Vec<glam::DAffine2>, view_mode: ViewMode);
fn intersects_quad(&self, quad: Quad, path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>);
fn bounding_box(&self, transform: glam::DAffine2) -> Option<[DVec2; 2]>;
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)] #[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub enum LayerDataType { pub enum LayerDataType {
Folder(Folder), Folder(Folder),
Shape(Shape), Shape(Shape),
} }
impl LayerDataType { impl LayerDataType {
pub fn inner(&self) -> &dyn LayerData { pub fn inner(&self) -> &dyn LayerData {
match self { match self {
@ -46,6 +39,12 @@ impl LayerDataType {
} }
} }
pub trait LayerData {
fn render(&mut self, svg: &mut String, transforms: &mut Vec<glam::DAffine2>, view_mode: ViewMode);
fn intersects_quad(&self, quad: Quad, path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>);
fn bounding_box(&self, transform: glam::DAffine2) -> Option<[DVec2; 2]>;
}
impl LayerData for LayerDataType { impl LayerData for LayerDataType {
fn render(&mut self, svg: &mut String, transforms: &mut Vec<glam::DAffine2>, view_mode: ViewMode) { fn render(&mut self, svg: &mut String, transforms: &mut Vec<glam::DAffine2>, view_mode: ViewMode) {
self.inner_mut().render(svg, transforms, view_mode) self.inner_mut().render(svg, transforms, view_mode)