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::overlay_message_handler::OverlayMessageHandler;
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::{ASYMPTOTIC_EFFECT, FILE_EXPORT_SUFFIX, FILE_SAVE_SUFFIX, SCALE_EFFECT, SCROLLBAR_SPACING};
@ -24,7 +24,7 @@ use kurbo::PathSeg;
use log::warn;
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)]
pub enum FlipAxis {
@ -69,8 +69,8 @@ pub struct DocumentMessageHandler {
pub document_redo_history: Vec<DocumentSave>,
pub saved_document_identifier: u64,
pub name: String,
#[serde(with = "vectorize_layerdata")]
pub layer_data: HashMap<Vec<LayerId>, LayerData>,
#[serde(with = "vectorize_layer_metadata")]
pub layer_metadata: HashMap<Vec<LayerId>, LayerMetadata>,
layer_range_selection_reference: Vec<LayerId>,
#[serde(skip)]
movement_handler: MovementMessageHandler,
@ -90,7 +90,7 @@ impl Default for DocumentMessageHandler {
document_redo_history: Vec::new(),
name: String::from("Untitled Document"),
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(),
movement_handler: MovementMessageHandler::default(),
overlay_message_handler: OverlayMessageHandler::default(),
@ -111,9 +111,9 @@ pub enum DocumentMessage {
DispatchOperation(Box<DocumentOperation>),
#[child]
Overlay(OverlayMessage),
UpdateLayerData {
path: Vec<LayerId>,
layer_data_entry: LayerData,
UpdateLayerMetadata {
layer_path: Vec<LayerId>,
layer_metadata: LayerMetadata,
},
SetSelectedLayers(Vec<Vec<LayerId>>),
AddSelectedLayers(Vec<Vec<LayerId>>),
@ -217,7 +217,7 @@ impl DocumentMessageHandler {
fn select_layer(&mut self, path: &[LayerId]) -> Option<Message> {
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()?;
(!path.is_empty()).then(|| FrontendMessage::UpdateLayer { data }.into())
}
@ -269,12 +269,8 @@ impl DocumentMessageHandler {
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]> {
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]> {
@ -293,7 +289,7 @@ impl DocumentMessageHandler {
LayerDataType::Shape(_) => (),
LayerDataType::Folder(ref folder) => {
path.push(*id);
if self.layer_data(path).expanded {
if self.layer_metadata(path).expanded {
structure.push(space);
self.serialize_structure(folder, structure, data, path);
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
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.
@ -347,14 +343,13 @@ impl DocumentMessageHandler {
// Compute the indices for each layer to be able to sort them
let mut layers_with_indices: Vec<(Vec<LayerId>, Vec<usize>)> = self
.layer_data
.layer_metadata
.iter()
// '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| {
// Currently it is possible that layer_data contains layers that are don't actually exist (has been partially fixed in #281)
// and thus 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
// TODO: Currently it is possible that `layer_metadata` contains layers that are don't actually exist (has been partially fixed in #281) and thus
// 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.
match self.graphene_document.indices_for_path(&path) {
Err(err) => {
warn!("layers_sorted: Could not get indices for the layer {:?}: {:?}", path, err);
@ -385,23 +380,23 @@ impl DocumentMessageHandler {
self.layers_sorted(Some(false))
}
pub fn layer_data(&self, path: &[LayerId]) -> &LayerData {
self.layer_data.get(path).expect("Layerdata does not exist")
pub fn layer_metadata(&self, path: &[LayerId]) -> &LayerMetadata {
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 {
Self::layer_data_mut_no_borrow_self(&mut self.layer_data, path)
pub fn layer_metadata_mut(&mut self, path: &[LayerId]) -> &mut LayerMetadata {
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 {
layer_data
pub fn layer_metadata_mut_no_borrow_self<'a>(layer_metadata: &'a mut HashMap<Vec<LayerId>, LayerMetadata>, path: &[LayerId]) -> &'a mut LayerMetadata {
layer_metadata
.get_mut(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>) {
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
responses.push_back(DocumentsMessage::UpdateOpenDocumentsList.into());
@ -418,10 +413,10 @@ impl DocumentMessageHandler {
responses.push_back(DocumentsMessage::UpdateOpenDocumentsList.into());
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 layer_data = std::mem::replace(&mut self.layer_data, layer_data);
self.document_redo_history.push((document, layer_data));
let layer_metadata = std::mem::replace(&mut self.layer_metadata, layer_metadata);
self.document_redo_history.push((document, layer_metadata));
Ok(())
}
None => Err(EditorError::NoTransactionInProgress),
@ -433,10 +428,10 @@ impl DocumentMessageHandler {
responses.push_back(DocumentsMessage::UpdateOpenDocumentsList.into());
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 layer_data = std::mem::replace(&mut self.layer_data, layer_data);
self.document_undo_history.push((document, layer_data));
let layer_metadata = std::mem::replace(&mut self.layer_metadata, layer_metadata);
self.document_undo_history.push((document, layer_metadata));
Ok(())
}
None => Err(EditorError::NoTransactionInProgress),
@ -465,7 +460,7 @@ impl DocumentMessageHandler {
}
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 entry = layer_panel_entry(&data, self.graphene_document.multiply_transforms(&path)?, layer, path);
Ok(entry)
@ -481,14 +476,14 @@ impl DocumentMessageHandler {
}
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
.graphene_document
.generate_transform_across_scope(path, Some(self.graphene_document.root.transform.inverse()))
.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),
TransformLayers(message) => self
.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()),
StartTransaction => self.backup(responses),
RollbackTransaction => {
@ -512,8 +507,11 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
}
CommitTransaction => (),
Overlay(message) => {
self.overlay_message_handler
.process_action(message, (Self::layer_data_mut_no_borrow_self(&mut self.layer_data, &[]), &self.graphene_document, ipp), responses);
self.overlay_message_handler.process_action(
message,
(Self::layer_metadata_mut_no_borrow_self(&mut self.layer_metadata, &[]), &self.graphene_document, ipp),
responses,
);
// responses.push_back(OverlayMessage::RenderOverlays.into());
}
ExportDocument => {
@ -588,7 +586,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
}
SetBlendModeForSelectedLayers(blend_mode) => {
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());
}
}
@ -605,12 +603,12 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
responses.push_back(ToolMessage::DocumentIsDirty.into());
}
ToggleLayerExpansion(path) => {
self.layer_data_mut(&path).expanded ^= true;
self.layer_metadata_mut(&path).expanded ^= true;
responses.push_back(DocumentStructureChanged.into());
responses.push_back(LayerChanged(path).into())
}
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(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 shift && last_selection_exists {
// Fill the selection range
self.layer_data
self.layer_metadata
.iter()
.filter(|(target, _)| self.graphene_document.layer_is_between(target, &selected, &self.layer_range_selection_reference))
.for_each(|(layer_path, _)| {
@ -651,7 +649,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
} else {
if ctrl {
// Toggle selection when holding ctrl
let layer = self.layer_data_mut(&selected);
let layer = self.layer_metadata_mut(&selected);
layer.selected = !layer.selected;
responses.push_back(LayerChanged(selected.clone()).into());
} else {
@ -672,12 +670,13 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
}
}
}
UpdateLayerData { path, layer_data_entry } => {
self.layer_data.insert(path, layer_data_entry);
UpdateLayerMetadata { layer_path: path, layer_metadata } => {
self.layer_metadata.insert(path, layer_metadata);
}
SetSelectedLayers(paths) => {
self.layer_data.iter_mut().filter(|(_, layer_data)| layer_data.selected).for_each(|(path, layer_data)| {
layer_data.selected = false;
let selected = self.layer_metadata.iter_mut().filter(|(_, layer_metadata)| layer_metadata.selected);
selected.for_each(|(path, layer_metadata)| {
layer_metadata.selected = false;
responses.push_back(LayerChanged(path.clone()).into())
});
@ -692,7 +691,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
responses.push_back(ToolMessage::DocumentIsDirty.into());
}
DebugPrintDocument => {
log::debug!("{:#?}\n{:#?}", self.graphene_document, self.layer_data);
log::debug!("{:#?}\n{:#?}", self.graphene_document, self.layer_metadata);
}
SelectAllLayers => {
let all_layer_paths = self.all_layers();
@ -737,11 +736,11 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
match &response {
DocumentResponse::FolderChanged { path } => responses.push_back(FolderChanged(path.clone()).into()),
DocumentResponse::DeletedLayer { path } => {
self.layer_data.remove(path);
self.layer_metadata.remove(path);
}
DocumentResponse::LayerChanged { path } => responses.push_back(LayerChanged(path.clone()).into()),
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());
self.layer_range_selection_reference = path.clone();
responses.push_back(SetSelectedLayers(vec![path.clone()]).into());
@ -953,9 +952,9 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
.into(),
);
responses.push_back(
DocumentMessage::UpdateLayerData {
path: destination_path,
layer_data_entry: *self.layer_data(&target_layer),
DocumentMessage::UpdateLayerMetadata {
layer_path: destination_path,
layer_metadata: *self.layer_metadata(&target_layer),
}
.into(),
);
@ -983,7 +982,7 @@ impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHand
MoveLayerInTree,
);
if self.layer_data.values().any(|data| data.selected) {
if self.layer_metadata.values().any(|data| data.selected) {
let select = actions!(DocumentMessageDiscriminant;
DeleteSelectedLayers,
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::frontend::frontend_message_handler::FrontendDocumentDetails;
use crate::input::InputPreprocessor;
@ -68,7 +68,7 @@ pub struct DocumentsMessageHandler {
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CopyBufferEntry {
layer: Layer,
layer_data: LayerData,
layer_metadata: LayerMetadata,
}
impl DocumentsMessageHandler {
@ -121,7 +121,7 @@ impl DocumentsMessageHandler {
responses.extend(
new_document
.layer_data
.layer_metadata
.keys()
.filter_map(|path| new_document.layer_panel_entry_from_path(path))
.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(RenderDocument.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());
}
}
@ -262,7 +262,7 @@ impl MessageHandler<DocumentsMessage, &InputPreprocessor> for DocumentsMessageHa
responses.push_back(FrontendMessage::RemoveAutoSaveDocument { document_id: id }.into());
responses.push_back(RenderDocument.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());
}
}
@ -356,9 +356,9 @@ impl MessageHandler<DocumentsMessage, &InputPreprocessor> for DocumentsMessageHa
self.copy_buffer[clipboard as usize].clear();
for path in paths {
let document = self.active_document();
match (document.graphene_document.layer(&path).map(|t| t.clone()), *document.layer_data(&path)) {
(Ok(layer), layer_data) => {
self.copy_buffer[clipboard as usize].push(CopyBufferEntry { layer, layer_data });
match (document.graphene_document.layer(&path).map(|t| t.clone()), *document.layer_metadata(&path)) {
(Ok(layer), layer_metadata) => {
self.copy_buffer[clipboard as usize].push(CopyBufferEntry { layer, layer_metadata });
}
(Err(e), _) => warn!("Could not access selected layer {:?}: {:?}", path, e),
}
@ -399,9 +399,9 @@ impl MessageHandler<DocumentsMessage, &InputPreprocessor> for DocumentsMessageHa
.into(),
);
responses.push_back(
DocumentMessage::UpdateLayerData {
path: destination_path,
layer_data_entry: entry.layer_data,
DocumentMessage::UpdateLayerMetadata {
layer_path: destination_path,
layer_metadata: entry.layer_metadata,
}
.into(),
);
@ -431,7 +431,7 @@ impl MessageHandler<DocumentsMessage, &InputPreprocessor> for DocumentsMessageHa
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;
Copy,
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 as DocumentLayerData, LayerDataType};
use graphene::layers::{style::ViewMode, BlendMode, Layer, LayerData, LayerDataType};
use graphene::LayerId;
use serde::{ser::SerializeStruct, Deserialize, Serialize};
use std::fmt;
use glam::{DAffine2, DVec2};
use serde::{ser::SerializeStruct, Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Copy)]
pub struct LayerData {
pub struct LayerMetadata {
pub selected: bool,
pub expanded: bool,
}
impl LayerData {
pub fn new(expanded: bool) -> LayerData {
LayerData { selected: false, expanded }
impl LayerMetadata {
pub fn new(expanded: bool) -> LayerMetadata {
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 name = layer.name.clone().unwrap_or_else(|| format!("Unnamed {}", layer_type));
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,
opacity: layer.opacity,
layer_type: (&layer.data).into(),
layer_data: *layer_data,
layer_metadata: *layer_metadata,
path,
thumbnail,
}
@ -85,7 +87,7 @@ pub struct LayerPanelEntry {
pub blend_mode: BlendMode,
pub opacity: f64,
pub layer_type: LayerDataTypeDiscriminant,
pub layer_data: LayerData,
pub layer_metadata: LayerMetadata,
pub path: Vec<LayerId>,
pub thumbnail: String,
}

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

@ -4,10 +4,10 @@ pub mod layer_panel;
mod movement_handler;
mod overlay_message_handler;
mod transform_layer_handler;
mod vectorize_layerdata;
mod vectorize_layer_metadata;
#[doc(inline)]
pub use document_file::LayerData;
pub use document_file::LayerMetadata;
#[doc(inline)]
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::*;
use crate::document::{DocumentMessage, LayerData};
use crate::document::{DocumentMessage, LayerMetadata};
use crate::input::InputPreprocessor;
use crate::message_prelude::*;
use graphene::document::Document;
@ -29,9 +29,9 @@ pub struct OverlayMessageHandler {
overlay_path_mapping: HashMap<Vec<LayerId>, Vec<LayerId>>,
}
impl MessageHandler<OverlayMessage, (&mut LayerData, &Document, &InputPreprocessor)> for OverlayMessageHandler {
fn process_action(&mut self, message: OverlayMessage, _data: (&mut LayerData, &Document, &InputPreprocessor), responses: &mut VecDeque<Message>) {
// let (layer_data, document, ipp) = data;
impl MessageHandler<OverlayMessage, (&mut LayerMetadata, &Document, &InputPreprocessor)> for OverlayMessageHandler {
fn process_action(&mut self, message: OverlayMessage, _data: (&mut LayerMetadata, &Document, &InputPreprocessor), responses: &mut VecDeque<Message>) {
// let (layer_metadata, document, ipp) = data;
use OverlayMessage::*;
match message {
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::*;
use super::LayerData;
use super::LayerMetadata;
use crate::consts::{ROTATE_SNAP_ANGLE, SCALE_SNAP_INTERVAL, SLOWING_DIVISOR};
use crate::input::keyboard::Key;
@ -25,11 +25,11 @@ impl<'a> Selected<'a> {
pub fn new(
original_transforms: &'a mut OriginalTransforms,
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>,
document: &'a mut Document,
) -> 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 {
if !original_transforms.contains_key::<Vec<LayerId>>(path) {
original_transforms.insert(path.clone(), document.layer(path).unwrap().transform);
@ -394,12 +394,12 @@ pub struct TransformLayerMessageHandler {
pivot: DVec2,
}
impl MessageHandler<TransformLayerMessage, (&mut HashMap<Vec<LayerId>, LayerData>, &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>) {
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>, LayerMetadata>, &mut Document, &InputPreprocessor), responses: &mut VecDeque<Message>) {
use TransformLayerMessage::*;
let (layer_data, document, ipp) = data;
let mut selected = Selected::new(&mut self.original_transforms, &mut self.pivot, layer_data, responses, document);
let (layer_metadata, document, ipp) = data;
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| {
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
v-if="layer.layer_type === LayerTypeOptions.Folder"
class="node-connector"
:class="{ expanded: layer.layer_data.expanded }"
:class="{ expanded: layer.layer_metadata.expanded }"
@click.stop="handleNodeConnectorClick(layer.path)"
></button>
<div v-else class="node-connector-missing"></div>
<div
class="layer"
:class="{ selected: layer.layer_data.selected }"
:class="{ selected: layer.layer_metadata.selected }"
:style="{ marginLeft: layerIndent(layer) }"
@click.shift.exact.stop="selectLayer(layer, false, true)"
@click.shift.ctrl.exact.stop="selectLayer(layer, true, true)"
@ -336,7 +336,7 @@ export default defineComponent({
},
async clearSelection() {
this.layers.forEach((layer) => {
layer.layer_data.selected = false;
layer.layer_metadata.selected = false;
});
},
closest(tree: HTMLElement, clientY: number): [BigUint64Array, boolean, Node] {
@ -446,7 +446,7 @@ export default defineComponent({
}
},
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) {
this.blendModeSelectedIndex = 0;
@ -467,7 +467,7 @@ export default defineComponent({
},
setOpacityForSelectedLayers() {
// 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) {
this.opacity = 100;

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

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

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

@ -18,18 +18,11 @@ use serde::{Deserialize, Serialize};
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)]
pub enum LayerDataType {
Folder(Folder),
Shape(Shape),
}
impl LayerDataType {
pub fn inner(&self) -> &dyn LayerData {
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 {
fn render(&mut self, svg: &mut String, transforms: &mut Vec<glam::DAffine2>, view_mode: ViewMode) {
self.inner_mut().render(svg, transforms, view_mode)