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

Tidy up NodeNetworkInterface, replacing &[] root network arguments with methods for the document network (#2393) 

* Replace `.selected_nodes(&[])` with `.selected_nodes_in_nested_network()` and `.selected_nodes()`

* Replace `.network(&[])` with `.document_network()` and `.nested_network()`

* Replace `.network_metadata(&[])` with `.document_network_metadata()`
This commit is contained in:
Keavon Chambers 2025-03-07 01:33:24 -08:00 committed by GitHub
parent 22a900b35e
commit c4cf47703a
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
28 changed files with 224 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
editor/src/messages/dialog/dialog_message_handler.rs
View File

@ -85,10 +85,7 @@ impl MessageHandler<DialogMessage, DialogMessageData<'_>> for DialogMessageHandl
.collect();
self.export_dialog.artboards = artboards;
self.export_dialog.has_selection = document
.network_interface
.selected_nodes(&[])
.is_some_and(|selected_nodes| selected_nodes.selected_layers(document.metadata()).next().is_some());
self.export_dialog.has_selection = document.network_interface.selected_nodes().selected_layers(document.metadata()).next().is_some();
self.export_dialog.send_dialog_to_frontend(responses);
}
}

77
editor/src/messages/portfolio/document/document_message_handler.rs
View File

@ -253,7 +253,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
};
let mut added_transaction = false;
for layer in self.network_interface.selected_nodes(&[]).unwrap().selected_unlocked_layers(&self.network_interface) {
for layer in self.network_interface.selected_nodes().selected_unlocked_layers(&self.network_interface) {
let Some(bbox) = self.metadata().bounding_box_viewport(layer) else {
continue;
};
@ -290,7 +290,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
});
}
DocumentMessage::CreateEmptyFolder => {
let selected_nodes = self.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = self.network_interface.selected_nodes();
let id = NodeId::new();
let parent = self
@ -298,7 +298,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
.deepest_common_ancestor(&selected_nodes, &self.selection_network_path, true)
.unwrap_or(LayerNodeIdentifier::ROOT_PARENT);
let insert_index = DocumentMessageHandler::get_calculated_insert_index(self.metadata(), &self.network_interface.selected_nodes(&[]).unwrap(), parent);
let insert_index = DocumentMessageHandler::get_calculated_insert_index(self.metadata(), &self.network_interface.selected_nodes(), parent);
responses.add(DocumentMessage::AddTransaction);
responses.add(GraphOperationMessage::NewCustomLayer {
id,
@ -440,7 +440,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
let center = (max + min) / 2.;
let bbox_trans = DAffine2::from_translation(-center);
let mut added_transaction = false;
for layer in self.network_interface.selected_nodes(&[]).unwrap().selected_unlocked_layers(&self.network_interface) {
for layer in self.network_interface.selected_nodes().selected_unlocked_layers(&self.network_interface) {
if !added_transaction {
responses.add(DocumentMessage::AddTransaction);
added_transaction = true;
@ -463,7 +463,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
let bbox_trans = DAffine2::from_translation(-center);
let mut added_transaction = false;
for layer in self.network_interface.selected_nodes(&[]).unwrap().selected_unlocked_layers(&self.network_interface) {
for layer in self.network_interface.selected_nodes().selected_unlocked_layers(&self.network_interface) {
if !added_transaction {
responses.add(DocumentMessage::AddTransaction);
added_transaction = true;
@ -528,14 +528,14 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
.children(self.metadata())
.filter(|x| self.network_interface.is_artboard(&x.to_node(), &self.selection_network_path))
.collect::<Vec<_>>();
let Some(selected_nodes) = self.network_interface.selected_nodes(&[]) else { return };
let selected_nodes = self.network_interface.selected_nodes();
// Non-artboard (infinite canvas) workflow
if artboards.is_empty() {
let Some(parent) = self.network_interface.deepest_common_ancestor(&selected_nodes, &self.selection_network_path, false) else {
return;
};
let Some(selected_nodes) = &self.network_interface.selected_nodes(&self.selection_network_path) else {
let Some(selected_nodes) = &self.network_interface.selected_nodes_in_nested_network(&self.selection_network_path) else {
return;
};
let insert_index = DocumentMessageHandler::get_calculated_insert_index(self.metadata(), selected_nodes, parent);
@ -608,8 +608,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
// Disallow trying to insert into self.
if self
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_layers(self.metadata())
.any(|layer| parent.ancestors(self.metadata()).any(|ancestor| ancestor == layer))
{
@ -618,8 +617,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
// Artboards can only have `ROOT_PARENT` as the parent.
let any_artboards = self
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_layers(self.metadata())
.any(|layer| self.network_interface.is_artboard(&layer.to_node(), &self.selection_network_path));
if any_artboards && parent != LayerNodeIdentifier::ROOT_PARENT {
@ -629,8 +627,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
// Non-artboards cannot be put at the top level if artboards also exist there
let selected_any_non_artboards = self
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_layers(self.metadata())
.any(|layer| !self.network_interface.is_artboard(&layer.to_node(), &self.selection_network_path));
@ -719,9 +716,8 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
let resize_opposite_corner = ipp.keyboard.key(resize_opposite_corner);
let can_move = |layer| {
self.network_interface
.selected_nodes(&[])
.is_some_and(|selected| selected.layer_visible(layer, &self.network_interface) && !selected.layer_locked(layer, &self.network_interface))
let selected = self.network_interface.selected_nodes();
selected.layer_visible(layer, &self.network_interface) && !selected.layer_locked(layer, &self.network_interface)
};
// Nudge translation without resizing
@ -982,7 +978,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
})
}
DocumentMessage::SelectParentLayer => {
let selected_nodes = self.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = self.network_interface.selected_nodes();
let selected_layers = selected_nodes.selected_layers(self.metadata());
let mut parent_layers = HashSet::new();
@ -1009,8 +1005,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
DocumentMessage::SelectAllLayers => {
let metadata = self.metadata();
let all_layers_except_artboards_invisible_and_locked = metadata.all_layers().filter(|&layer| !self.network_interface.is_artboard(&layer.to_node(), &[])).filter(|&layer| {
self.network_interface.selected_nodes(&[]).unwrap().layer_visible(layer, &self.network_interface)
&& !self.network_interface.selected_nodes(&[]).unwrap().layer_locked(layer, &self.network_interface)
self.network_interface.selected_nodes().layer_visible(layer, &self.network_interface) && !self.network_interface.selected_nodes().layer_locked(layer, &self.network_interface)
});
let nodes = all_layers_except_artboards_invisible_and_locked.map(|layer| layer.to_node()).collect();
responses.add(NodeGraphMessage::SelectedNodesSet { nodes });
@ -1064,7 +1059,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
} else {
if ctrl {
// Toggle selection when holding ctrl
if self.network_interface.selected_nodes(&[]).unwrap().selected_layers_contains(layer, self.metadata()) {
if self.network_interface.selected_nodes().selected_layers_contains(layer, self.metadata()) {
responses.add_front(NodeGraphMessage::SelectedNodesRemove { nodes: vec![id] });
} else {
responses.add_front(NodeGraphMessage::SelectedNodesAdd { nodes: vec![id] });
@ -1106,7 +1101,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
responses.add(NodeGraphMessage::UpdateInSelectedNetwork);
}
DocumentMessage::SetBlendModeForSelectedLayers { blend_mode } => {
for layer in self.network_interface.selected_nodes(&[]).unwrap().selected_layers_except_artboards(&self.network_interface) {
for layer in self.network_interface.selected_nodes().selected_layers_except_artboards(&self.network_interface) {
responses.add(GraphOperationMessage::BlendModeSet { layer, blend_mode });
}
}
@ -1123,7 +1118,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
}
DocumentMessage::SetOpacityForSelectedLayers { opacity } => {
let opacity = opacity.clamp(0., 1.);
for layer in self.network_interface.selected_nodes(&[]).unwrap().selected_layers_except_artboards(&self.network_interface) {
for layer in self.network_interface.selected_nodes().selected_layers_except_artboards(&self.network_interface) {
responses.add(GraphOperationMessage::OpacitySet { layer, opacity });
}
}
@ -1233,7 +1228,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
.into_iter()
.filter(|(node_id, _)|
// Ensure that the layer is in the document network to prevent logging an error
self.network_interface.network(&[]).unwrap().nodes.contains_key(node_id))
self.network_interface.document_network().nodes.contains_key(node_id))
.filter_map(|(node_id, click_targets)| {
self.network_interface.is_layer(&node_id, &[]).then(|| {
let layer = LayerNodeIdentifier::new(node_id, &self.network_interface, &[]);
@ -1448,7 +1443,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
);
// Additional actions if there are any selected layers
if self.network_interface.selected_nodes(&[]).unwrap().selected_layers(self.metadata()).next().is_some() {
if self.network_interface.selected_nodes().selected_layers(self.metadata()).next().is_some() {
let mut select = actions!(DocumentMessageDiscriminant;
DeleteSelectedLayers,
DuplicateSelectedLayers,
@ -1594,8 +1589,7 @@ impl DocumentMessageHandler {
/// Get the combined bounding box of the click targets of the selected visible layers in viewport space
pub fn selected_visible_layers_bounding_box_viewport(&self) -> Option<[DVec2; 2]> {
self.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_visible_layers(&self.network_interface)
.filter_map(|layer| self.metadata().bounding_box_viewport(layer))
.reduce(graphene_core::renderer::Quad::combine_bounds)
@ -1603,15 +1597,14 @@ impl DocumentMessageHandler {
pub fn selected_visible_and_unlock_layers_bounding_box_viewport(&self) -> Option<[DVec2; 2]> {
self.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_visible_and_unlocked_layers(&self.network_interface)
.filter_map(|layer| self.metadata().bounding_box_viewport(layer))
.reduce(graphene_core::renderer::Quad::combine_bounds)
}
pub fn document_network(&self) -> &NodeNetwork {
self.network_interface.network(&[]).unwrap()
self.network_interface.document_network()
}
pub fn metadata(&self) -> &DocumentMetadata {
@ -1778,7 +1771,7 @@ impl DocumentMessageHandler {
}
pub fn current_hash(&self) -> Option<u64> {
self.document_undo_history.iter().last().map(|network| network.network(&[]).unwrap().current_hash())
self.document_undo_history.iter().last().map(|network| network.document_network().current_hash())
}
pub fn is_auto_saved(&self) -> bool {
@ -1827,7 +1820,7 @@ impl DocumentMessageHandler {
/// Finds the parent folder which, based on the current selections, should be the container of any newly added layers.
pub fn new_layer_parent(&self, include_self: bool) -> LayerNodeIdentifier {
let Some(selected_nodes) = self.network_interface.selected_nodes(&self.selection_network_path) else {
let Some(selected_nodes) = self.network_interface.selected_nodes_in_nested_network(&self.selection_network_path) else {
warn!("No selected nodes found in new_layer_parent. Defaulting to ROOT_PARENT.");
return LayerNodeIdentifier::ROOT_PARENT;
};
@ -1875,13 +1868,15 @@ impl DocumentMessageHandler {
}),
GroupFolderType::BooleanOperation(operation) => {
// Get the ID of the one selected layer, if exactly one is selected
let only_selected_layer = network_interface.selected_nodes(&[]).and_then(|selected_nodes| {
let only_selected_layer = {
let selected_nodes = network_interface.selected_nodes();
let mut layers = selected_nodes.selected_layers(network_interface.document_metadata());
match (layers.next(), layers.next()) {
(Some(id), None) => Some(id),
_ => None,
}
});
};
// If there is a single selected layer, check if there is a boolean operation upstream from it
let upstream_boolean_op = only_selected_layer.and_then(|selected_id| {
@ -2141,7 +2136,7 @@ impl DocumentMessageHandler {
pub fn update_layers_panel_control_bar_widgets(&self, responses: &mut VecDeque<Message>) {
// Get an iterator over the selected layers (excluding artboards which don't have an opacity or blend mode).
let selected_nodes = self.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = self.network_interface.selected_nodes();
let selected_layers_except_artboards = selected_nodes.selected_layers_except_artboards(&self.network_interface);
// Look up the current opacity and blend mode of the selected layers (if any), and split the iterator into the first tuple and the rest.
@ -2193,17 +2188,15 @@ impl DocumentMessageHandler {
})
.collect();
let has_selection = self.network_interface.selected_nodes(&[]).unwrap().selected_layers(self.metadata()).next().is_some();
let has_selection = self.network_interface.selected_nodes().selected_layers(self.metadata()).next().is_some();
let selection_all_visible = self
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_layers(self.metadata())
.all(|layer| self.network_interface.is_visible(&layer.to_node(), &[]));
let selection_all_locked = self
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_layers(self.metadata())
.all(|layer| self.network_interface.is_locked(&layer.to_node(), &[]));
@ -2284,7 +2277,7 @@ impl DocumentMessageHandler {
}
pub fn selected_layers_reverse(&mut self, responses: &mut VecDeque<Message>) {
let selected_layers = self.network_interface.selected_nodes(&[]).unwrap();
let selected_layers = self.network_interface.selected_nodes();
let metadata = self.metadata();
let selected_layer_set = selected_layers.selected_layers(metadata).collect::<HashSet<_>>();
@ -2376,7 +2369,7 @@ impl DocumentMessageHandler {
}
pub fn selected_layers_reorder(&mut self, relative_index_offset: isize, responses: &mut VecDeque<Message>) {
let selected_nodes = self.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = self.network_interface.selected_nodes();
let mut selected_layers = selected_nodes.selected_layers(self.metadata());
let first_or_last_selected_layer = match relative_index_offset.signum() {
@ -2506,7 +2499,7 @@ impl<'a> ClickXRayIter<'a> {
/// Handles the checking of the layer to find if it has been clicked
fn check_layer(&mut self, layer: LayerNodeIdentifier) -> XRayResult {
let selected_layers = self.network_interface.selected_nodes(&[]).unwrap();
let selected_layers = self.network_interface.selected_nodes();
// Discard invisible and locked layers
if !selected_layers.layer_visible(layer, self.network_interface) || selected_layers.layer_locked(layer, self.network_interface) {
return XRayResult { clicked: false, use_children: false };

4
editor/src/messages/portfolio/document/graph_operation/graph_operation_message_handler.rs
View File

@ -116,7 +116,7 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageData<'_>> for Gr
network_interface.move_layer_to_stack(artboard_layer, LayerNodeIdentifier::ROOT_PARENT, 0, &[]);
// If there is a non artboard feeding into the primary input of the artboard, move it to the secondary input
let Some(artboard) = network_interface.network(&[]).and_then(|network| network.nodes.get(&id)) else {
let Some(artboard) = network_interface.document_network().nodes.get(&id) else {
log::error!("Artboard not created");
return;
};
@ -218,7 +218,7 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageData<'_>> for Gr
// Go through all artboards and create merge nodes
for artboard in network_interface.all_artboards() {
let node_id = NodeId::new();
let Some(document_node) = network_interface.network(&[]).and_then(|network| network.nodes.get(&artboard.to_node())) else {
let Some(document_node) = network_interface.document_network().nodes.get(&artboard.to_node()) else {
log::error!("Artboard not created");
responses.add(DocumentMessage::AbortTransaction);
return;

10
editor/src/messages/portfolio/document/graph_operation/utility_types.rs
View File

@ -229,11 +229,7 @@ impl<'a> ModifyInputsContext<'a> {
fn get_output_layer(&self) -> Option<LayerNodeIdentifier> {
self.layer_node.or_else(|| {
let Some(network) = self.network_interface.network(&[]) else {
log::error!("Document network does not exist in ModifyInputsContext::get_output_node");
return None;
};
let export_node = network.exports.first().and_then(|export| export.as_node())?;
let export_node = self.network_interface.document_network().exports.first().and_then(|export| export.as_node())?;
if self.network_interface.is_layer(&export_node, &[]) {
Some(LayerNodeIdentifier::new(export_node, self.network_interface, &[]))
} else {
@ -266,7 +262,7 @@ impl<'a> ModifyInputsContext<'a> {
}
let is_traversal_start = |node_id: NodeId| {
self.layer_node.map(|layer| layer.to_node()) == Some(node_id) || self.network_interface.network(&[]).unwrap().exports.iter().any(|export| export.as_node() == Some(node_id))
self.layer_node.map(|layer| layer.to_node()) == Some(node_id) || self.network_interface.document_network().exports.iter().any(|export| export.as_node() == Some(node_id))
};
if !is_traversal_start(upstream_node) && (self.network_interface.is_layer(&upstream_node, &[])) {
@ -373,7 +369,7 @@ impl<'a> ModifyInputsContext<'a> {
let (layer_transform, transform_node_id) = self
.existing_node_id("Transform", false)
.and_then(|transform_node_id| {
let document_node = self.network_interface.network(&[])?.nodes.get(&transform_node_id)?;
let document_node = self.network_interface.document_network().nodes.get(&transform_node_id)?;
Some((transform_utils::get_current_transform(&document_node.inputs), transform_node_id))
})
.unzip();

88
editor/src/messages/portfolio/document/node_graph/node_graph_message_handler.rs
View File

@ -125,11 +125,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
collapsed.0.retain(|&layer| network_interface.document_metadata().layer_exists(layer));
}
NodeGraphMessage::SelectedNodesUpdated => {
let selected_layers = network_interface
.selected_nodes(&[])
.unwrap()
.selected_layers(network_interface.document_metadata())
.collect::<Vec<_>>();
let selected_layers = network_interface.selected_nodes().selected_layers(network_interface.document_metadata()).collect::<Vec<_>>();
if selected_layers.len() <= 1 {
responses.add(DocumentMessage::SetRangeSelectionLayer {
new_layer: selected_layers.first().cloned(),
@ -264,7 +260,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
// Deletes selected_nodes. If `reconnect` is true, then all children nodes (secondary input) of the selected nodes are deleted and the siblings (primary input/output) are reconnected.
// If `reconnect` is false, then only the selected nodes are deleted and not reconnected.
NodeGraphMessage::DeleteSelectedNodes { delete_children } => {
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in DeleteSelectedNodes");
return;
};
@ -361,7 +357,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
}
NodeGraphMessage::MergeSelectedNodes => {
let new_ids = network_interface
.selected_nodes(breadcrumb_network_path)
.selected_nodes_in_nested_network(breadcrumb_network_path)
.unwrap()
.selected_nodes()
.map(|id| (*id, *id))
@ -377,9 +373,10 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
let mut import_connections = Vec::new();
let mut export_connections = Vec::new();
// Scan current nodes top to bottom and find all inputs/outputs connected to nodes that are not in the copied nodes. These will represent the new imports and exports.
let Some(nodes_sorted_top_to_bottom) =
network_interface.nodes_sorted_top_to_bottom(network_interface.selected_nodes(breadcrumb_network_path).unwrap().selected_nodes(), breadcrumb_network_path)
else {
let Some(nodes_sorted_top_to_bottom) = network_interface.nodes_sorted_top_to_bottom(
network_interface.selected_nodes_in_nested_network(breadcrumb_network_path).unwrap().selected_nodes(),
breadcrumb_network_path,
) else {
return;
};
//Ensure that nodes can be grouped by checking if there is an unselected node between selected nodes
@ -676,7 +673,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
}
self.selection_before_pointer_down = network_interface
.selected_nodes(selection_network_path)
.selected_nodes_in_nested_network(selection_network_path)
.map(|selected_nodes| selected_nodes.selected_nodes().cloned().collect())
.unwrap_or_default();
@ -730,7 +727,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
}
if let Some(clicked_id) = clicked_id {
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in PointerDown");
return;
};
@ -952,7 +949,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
log::error!("Selection network path does not match breadcrumb network path in PointerUp");
return;
}
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in PointerUp");
return;
};
@ -1025,7 +1022,10 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
self.shift_without_push = false;
// Reset all offsets to end the rubber banding while dragging
network_interface.unload_stack_dependents_y_offset(selection_network_path);
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else { return };
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in PointerUp");
return;
};
// Only select clicked node if multiple are selected and they were not dragged
if let Some(select_if_not_dragged) = self.select_if_not_dragged {
if drag_start.start_x == point.x
@ -1041,7 +1041,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
}
// Try expand the upstream chain for all layers if there is an eligible node
let Some(network) = network_interface.network(selection_network_path) else { return };
let Some(network) = network_interface.nested_network(selection_network_path) else { return };
for layer in network
.nodes
.keys()
@ -1053,14 +1053,17 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
}
responses.add(NodeGraphMessage::SendGraph);
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else { return };
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in PointerUp");
return;
};
// Check if a single node was dragged onto a wire and that the node was dragged onto the wire
if selected_nodes.selected_nodes_ref().len() == 1 && !self.begin_dragging {
let selected_node_id = selected_nodes.selected_nodes_ref()[0];
let has_primary_output_connection = network_interface
.outward_wires(selection_network_path)
.is_some_and(|outward_wires| outward_wires.get(&OutputConnector::node(selected_node_id, 0)).is_some_and(|outward_wires| !outward_wires.is_empty()));
let Some(network) = network_interface.network(selection_network_path) else {
let Some(network) = network_interface.nested_network(selection_network_path) else {
return;
};
if let Some(selected_node) = network.nodes.get(&selected_node_id) {
@ -1164,7 +1167,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
None
};
if let Some(overlapping_wire) = overlapping_wire {
let Some(network) = network_interface.network(selection_network_path) else {
let Some(network) = network_interface.nested_network(selection_network_path) else {
return;
};
// Ensure connection is to first visible input of selected node. If it does not have an input then do not connect
@ -1390,7 +1393,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
}
}
NodeGraphMessage::ToggleSelectedAsLayersOrNodes => {
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in NodeGraphMessage::ToggleSelectedAsLayersOrNodes");
return;
};
@ -1458,7 +1461,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
network_interface.toggle_preview(node_id, selection_network_path);
}
NodeGraphMessage::ToggleSelectedLocked => {
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in NodeGraphMessage::ToggleSelectedLocked");
return;
};
@ -1476,7 +1479,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
responses.add(NodeGraphMessage::SetLockedOrVisibilitySideEffects { node_ids })
}
NodeGraphMessage::ToggleLocked { node_id } => {
let Some(node_metadata) = network_interface.network_metadata(&[]).unwrap().persistent_metadata.node_metadata.get(&node_id) else {
let Some(node_metadata) = network_interface.document_network_metadata().persistent_metadata.node_metadata.get(&node_id) else {
log::error!("Cannot get node {:?} in NodeGraphMessage::ToggleLocked", node_id);
return;
};
@ -1491,7 +1494,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
network_interface.set_locked(&node_id, selection_network_path, locked);
}
NodeGraphMessage::ToggleSelectedIsPinned => {
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in NodeGraphMessage::ToggleSelectedIsPinned");
return;
};
@ -1507,7 +1510,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
responses.add(NodeGraphMessage::SetLockedOrVisibilitySideEffects { node_ids });
}
NodeGraphMessage::ToggleSelectedVisibility => {
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in NodeGraphMessage::ToggleSelectedLocked");
return;
};
@ -1576,7 +1579,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
.transform_point2(ipp.mouse.position);
let shift = ipp.keyboard.get(crate::messages::tool::tool_messages::tool_prelude::Key::Shift as usize);
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in PointerMove");
return;
};
@ -1670,7 +1673,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
in_selected_network: selection_network_path == breadcrumb_network_path,
}),
NodeGraphMessage::SendSelectedNodes => {
let Some(selected_nodes) = network_interface.selected_nodes(breadcrumb_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(breadcrumb_network_path) else {
log::error!("Could not get selected nodes in NodeGraphMessage::SendSelectedNodes");
return;
};
@ -1680,7 +1683,7 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
});
}
}
let Some(selected_nodes) = network_interface.selected_nodes(selection_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(selection_network_path) else {
log::error!("Could not get selected nodes in NodeGraphMessageHandler");
return;
};
@ -1736,19 +1739,19 @@ impl NodeGraphMessageHandler {
return;
};
let Some(network) = network_interface.network(breadcrumb_network_path) else {
let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
warn!("No network in update_selection_action_buttons");
return;
};
let Some(selected_nodes) = network_interface.selected_nodes(breadcrumb_network_path) else {
let Some(selected_nodes) = network_interface.selected_nodes_in_nested_network(breadcrumb_network_path) else {
warn!("No selected nodes in update_selection_action_buttons");
return;
};
let has_selection = selected_nodes.has_selected_nodes();
let selection_includes_layers = network_interface.selected_nodes(&[]).unwrap().selected_layers(network_interface.document_metadata()).count() > 0;
let selection_all_locked = network_interface.selected_nodes(&[]).unwrap().selected_unlocked_layers(network_interface).count() == 0;
let selection_includes_layers = network_interface.selected_nodes().selected_layers(network_interface.document_metadata()).count() > 0;
let selection_all_locked = network_interface.selected_nodes().selected_unlocked_layers(network_interface).count() == 0;
let selection_all_visible = selected_nodes.selected_nodes().all(|node_id| network_interface.is_visible(node_id, breadcrumb_network_path));
let mut widgets = vec![
@ -1913,7 +1916,7 @@ impl NodeGraphMessageHandler {
/// Collate the properties panel sections for a node graph
pub fn collate_properties(context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
// If the selected nodes are in the document network, use the document network. Otherwise, use the nested network
let Some(selected_nodes) = context.network_interface.selected_nodes(context.selection_network_path) else {
let Some(selected_nodes) = context.network_interface.selected_nodes_in_nested_network(context.selection_network_path) else {
warn!("No selected nodes in collate_properties");
return Vec::new();
};
@ -1958,7 +1961,7 @@ impl NodeGraphMessageHandler {
],
}];
let Some(network) = context.network_interface.network(context.selection_network_path) else {
let Some(network) = context.network_interface.nested_network(context.selection_network_path) else {
warn!("No network in collate_properties");
return Vec::new();
};
@ -2056,7 +2059,7 @@ impl NodeGraphMessageHandler {
}
fn collect_wires(network_interface: &NodeNetworkInterface, breadcrumb_network_path: &[NodeId]) -> Vec<FrontendNodeWire> {
let Some(network) = network_interface.network(breadcrumb_network_path) else {
let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
log::error!("Could not get network when collecting wires");
return Vec::new();
};
@ -2129,7 +2132,7 @@ impl NodeGraphMessageHandler {
};
let mut can_be_layer_lookup = HashSet::new();
let mut position_lookup = HashMap::new();
let Some(network) = network_interface.network(breadcrumb_network_path) else {
let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
log::error!("Could not get nested network when collecting nodes");
return Vec::new();
};
@ -2145,7 +2148,7 @@ impl NodeGraphMessageHandler {
}
}
let mut frontend_inputs_lookup = frontend_inputs_lookup(breadcrumb_network_path, network_interface);
let Some(network) = network_interface.network(breadcrumb_network_path) else {
let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
log::error!("Could not get nested network when collecting nodes");
return Vec::new();
};
@ -2221,7 +2224,7 @@ impl NodeGraphMessageHandler {
connected_to,
});
}
let Some(network) = network_interface.network(breadcrumb_network_path) else {
let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
log::error!("Could not get nested network when collecting nodes");
return Vec::new();
};
@ -2275,7 +2278,7 @@ impl NodeGraphMessageHandler {
fn collect_subgraph_names(network_interface: &mut NodeNetworkInterface, breadcrumb_network_path: &[NodeId]) -> Option<Vec<String>> {
let mut current_network_path = vec![];
let mut current_network = network_interface.network(&current_network_path).unwrap();
let mut current_network = network_interface.nested_network(&current_network_path).unwrap();
let mut subgraph_names = vec!["Document".to_string()];
for node_id in breadcrumb_network_path {
if let Some(node) = current_network.nodes.get(node_id) {
@ -2293,11 +2296,8 @@ impl NodeGraphMessageHandler {
}
fn update_layer_panel(network_interface: &NodeNetworkInterface, selection_network_path: &[NodeId], collapsed: &CollapsedLayers, responses: &mut VecDeque<Message>) {
let Some(selected_nodes) = network_interface.selected_nodes(&[]) else {
log::error!("Could not get selected layers in update_layer_panel");
return;
};
let selected_layers = selected_nodes
let selected_layers = network_interface
.selected_nodes()
.selected_layers(network_interface.document_metadata())
.map(|layer| layer.to_node())
.collect::<HashSet<_>>();
@ -2315,7 +2315,7 @@ impl NodeGraphMessageHandler {
}
}
for (&node_id, node_metadata) in &network_interface.network_metadata(&[]).unwrap().persistent_metadata.node_metadata {
for (&node_id, node_metadata) in &network_interface.document_network_metadata().persistent_metadata.node_metadata {
if node_metadata.persistent_metadata.is_layer() {
let layer = LayerNodeIdentifier::new(node_id, network_interface, &[]);
@ -2449,7 +2449,7 @@ type FrontendInputsLookup = HashMap<NodeId, Vec<Option<InputLookup>>>;
/// Create a lookup hashmap that can be used to create the frontend inputs. This is needed because `input_type` requires a mutable `network_interface`.
fn frontend_inputs_lookup(breadcrumb_network_path: &[NodeId], network_interface: &mut NodeNetworkInterface) -> FrontendInputsLookup {
let Some(network) = network_interface.network(breadcrumb_network_path) else {
let Some(network) = network_interface.nested_network(breadcrumb_network_path) else {
return Default::default();
};
let mut frontend_inputs_lookup = HashMap::new();

9
editor/src/messages/portfolio/document/node_graph/node_properties.rs
View File

@ -101,7 +101,7 @@ pub(crate) fn property_from_type(
log::warn!("A widget failed to be built for node {node_id}, index {index} because the input name could not be determined");
return Err(vec![]);
};
let Some(network) = context.network_interface.network(context.selection_network_path) else {
let Some(network) = context.network_interface.nested_network(context.selection_network_path) else {
log::warn!("A widget failed to be built for node {node_id}, index {index} because the network could not be determined");
return Err(vec![]);
};
@ -1171,7 +1171,10 @@ pub fn centroid_widget(document_node: &DocumentNode, node_id: NodeId, index: usi
}
pub fn get_document_node<'a>(node_id: NodeId, context: &'a NodePropertiesContext<'a>) -> Result<&'a DocumentNode, String> {
let network = context.network_interface.network(context.selection_network_path).ok_or("network not found in get_document_node")?;
let network = context
.network_interface
.nested_network(context.selection_network_path)
.ok_or("network not found in get_document_node")?;
network.nodes.get(&node_id).ok_or(format!("node {node_id} not found in get_document_node"))
}
@ -1818,7 +1821,7 @@ pub(crate) fn rectangle_properties(node_id: NodeId, context: &mut NodeProperties
// let image_size = context
// .executor
// .introspect_node_in_network(
// context.network_interface.network(&[]).unwrap(),
// context.network_interface.document_network().unwrap(),
// &imaginate_node,
// |network| {
// network

6
editor/src/messages/portfolio/document/overlays/utility_functions.rs
View File

@ -42,7 +42,7 @@ pub fn selected_segments(document: &DocumentMessageHandler, shape_editor: &mut S
// TODO: Currently if there are two duplicate layers, both of their segments get overlays
// Adding segments which are are connected to selected anchors
for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()) {
for layer in document.network_interface.selected_nodes().selected_layers(document.metadata()) {
let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else { continue };
for (segment_id, _bezier, start, end) in vector_data.segment_bezier_iter() {
@ -114,7 +114,7 @@ pub fn overlay_bezier_handle_specific_point(
}
pub fn path_overlays(document: &DocumentMessageHandler, draw_handles: DrawHandles, shape_editor: &mut ShapeState, overlay_context: &mut OverlayContext) {
for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()) {
for layer in document.network_interface.selected_nodes().selected_layers(document.metadata()) {
let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else { continue };
let transform = document.metadata().transform_to_viewport(layer);
overlay_context.outline_vector(&vector_data, transform);
@ -167,7 +167,7 @@ pub fn path_overlays(document: &DocumentMessageHandler, draw_handles: DrawHandle
}
pub fn path_endpoint_overlays(document: &DocumentMessageHandler, shape_editor: &mut ShapeState, overlay_context: &mut OverlayContext, preferences: &PreferencesMessageHandler) {
for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()) {
for layer in document.network_interface.selected_nodes().selected_layers(document.metadata()) {
let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else {
continue;
};

2
editor/src/messages/portfolio/document/utility_types/document_metadata.rs
View File

@ -198,7 +198,7 @@ impl LayerNodeIdentifier {
debug_assert!(
network_interface.is_layer(&node_id, network_path),
"Layer identifier constructed from non-layer node {node_id}: {:#?}",
network_interface.network(network_path).unwrap().nodes.get(&node_id)
network_interface.nested_network(network_path).unwrap().nodes.get(&node_id)
);
Self::new_unchecked(node_id)
}

84
editor/src/messages/portfolio/document/utility_types/network_interface.rs
View File

@ -60,19 +60,27 @@ impl PartialEq for NodeNetworkInterface {
// Public immutable getters for the network interface
impl NodeNetworkInterface {
// TODO: Make private and use .field_name getter methods
/// Gets the network of the root document
pub fn document_network(&self) -> &NodeNetwork {
self.network
.nested_network(&[])
.expect("Could not get root document network in NodeNetworkInterface::document_network()")
}
// TODO: Make private and use .field_name getter methods
/// Gets the nested network based on network_path
pub fn network(&self, network_path: &[NodeId]) -> Option<&NodeNetwork> {
pub fn nested_network(&self, network_path: &[NodeId]) -> Option<&NodeNetwork> {
let Some(network) = self.network.nested_network(network_path) else {
log::error!("Could not get nested network with path {network_path:?}");
log::error!("Could not get nested network with path {network_path:?} in NodeNetworkInterface::network");
return None;
};
Some(network)
}
// TODO: Make private and use .field_name getter methods. For example network_interface.inputs(node_id, network_path) rather than getting the node then getting inputs
/// Get the specified document node in the nested network based on node_id and network_path
pub fn document_node(&self, node_id: &NodeId, network_path: &[NodeId]) -> Option<&DocumentNode> {
let network = self.network(network_path)?;
let network = self.nested_network(network_path)?;
let Some(node_metadata) = network.nodes.get(node_id) else {
log::error!("Could not get document node with id {node_id} in network {network_path:?}");
return None;
@ -80,6 +88,10 @@ impl NodeNetworkInterface {
Some(node_metadata)
}
pub fn document_network_metadata(&self) -> &NodeNetworkMetadata {
&self.network_metadata
}
// TODO: Make private and use .field_name getter methods
/// The network metadata should always exist for the current network
pub fn network_metadata(&self, network_path: &[NodeId]) -> Option<&NodeNetworkMetadata> {
@ -108,8 +120,12 @@ impl NodeNetworkInterface {
self.transaction_status
}
pub fn selected_nodes(&self) -> SelectedNodes {
self.selected_nodes_in_nested_network(&[]).unwrap_or_default()
}
/// Get the selected nodes for the network at the network_path
pub fn selected_nodes(&self, network_path: &[NodeId]) -> Option<SelectedNodes> {
pub fn selected_nodes_in_nested_network(&self, network_path: &[NodeId]) -> Option<SelectedNodes> {
let Some(network_metadata) = self.network_metadata(network_path) else {
log::error!("Could not get nested network_metadata in selected_nodes");
return None;
@ -217,7 +233,7 @@ impl NodeNetworkInterface {
/// Check if the specified node id is connected to the output
pub fn connected_to_output(&self, target_node_id: &NodeId, network_path: &[NodeId]) -> bool {
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get network in connected_to_output");
return false;
};
@ -440,7 +456,7 @@ impl NodeNetworkInterface {
}
pub fn input_from_connector(&self, input_connector: &InputConnector, network_path: &[NodeId]) -> Option<&NodeInput> {
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get network in input_from_connector");
return None;
};
@ -825,7 +841,7 @@ impl NodeNetworkInterface {
.input_ports
.iter()
.filter_map(|(export_index, click_target)| {
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get network in frontend_exports");
return None;
};
@ -1073,7 +1089,7 @@ impl NodeNetworkInterface {
/// Returns the root node (the node that the solid line is connect to), or None if no nodes are connected to the output
pub fn root_node(&self, network_path: &[NodeId]) -> Option<RootNode> {
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get network in root_node");
return None;
};
@ -1243,8 +1259,7 @@ impl NodeNetworkInterface {
}
pub fn all_artboards(&self) -> HashSet<LayerNodeIdentifier> {
self.network_metadata(&[])
.unwrap()
self.document_network_metadata()
.persistent_metadata
.node_metadata
.iter()
@ -1269,7 +1284,7 @@ impl NodeNetworkInterface {
log::error!("Currently can only get deepest common ancestor in the document network");
return Vec::new();
}
let Some(selected_nodes) = self.selected_nodes(network_path) else {
let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) else {
log::error!("Could not get selected nodes in deepest_common_ancestor");
return Vec::new();
};
@ -1311,7 +1326,7 @@ impl NodeNetworkInterface {
/// Calculates the selected layer bounds in document space
pub fn selected_bounds_document_space(&self, include_artboards: bool, network_path: &[NodeId]) -> Option<[DVec2; 2]> {
let Some(selected_nodes) = self.selected_nodes(network_path) else {
let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) else {
log::error!("Could not get selected nodes in shallowest_unique_layers");
return None;
};
@ -1325,7 +1340,7 @@ impl NodeNetworkInterface {
/// Layers excluding ones that are children of other layers in the list.
// TODO: Cache this
pub fn shallowest_unique_layers(&self, network_path: &[NodeId]) -> impl Iterator<Item = LayerNodeIdentifier> {
let mut sorted_layers = if let Some(selected_nodes) = self.selected_nodes(network_path) {
let mut sorted_layers = if let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) {
selected_nodes
.selected_layers(self.document_metadata())
.map(|layer| {
@ -1390,7 +1405,7 @@ impl NodeNetworkInterface {
/// Gives an iterator to all nodes connected to the given nodes by all inputs (primary or primary + secondary depending on `only_follow_primary` choice), traversing backwards upstream starting from the given node's inputs.
pub fn upstream_flow_back_from_nodes<'a>(&'a self, mut node_ids: Vec<NodeId>, network_path: &'a [NodeId], mut flow_type: FlowType) -> impl Iterator<Item = NodeId> + 'a {
let (Some(network), Some(network_metadata)) = (self.network(network_path), self.network_metadata(network_path)) else {
let (Some(network), Some(network_metadata)) = (self.nested_network(network_path), self.network_metadata(network_path)) else {
log::error!("Could not get network or network_metadata in upstream_flow_back_from_nodes");
return FlowIter {
stack: Vec::new(),
@ -1748,7 +1763,7 @@ impl NodeNetworkInterface {
// This function always has to be in sync with the selected nodes.
fn load_stack_dependents(&mut self, network_path: &[NodeId]) {
let Some(selected_nodes) = self.selected_nodes(network_path) else {
let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) else {
log::error!("Could not get selected nodes in load_stack_dependents");
return;
};
@ -1951,7 +1966,7 @@ impl NodeNetworkInterface {
log::error!("Could not get nested network_metadata in load_export_ports");
return;
};
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get current network in load_export_ports");
return;
};
@ -2050,7 +2065,7 @@ impl NodeNetworkInterface {
log::error!("Could not get nested network_metadata in load_export_ports");
return;
};
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get current network in load_export_ports");
return;
};
@ -2311,7 +2326,7 @@ impl NodeNetworkInterface {
fn load_outward_wires(&mut self, network_path: &[NodeId]) {
let mut outward_wires = HashMap::new();
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get nested network in load_outward_wires");
return;
};
@ -2601,7 +2616,7 @@ impl NodeNetworkInterface {
}
pub fn try_load_all_node_click_targets(&mut self, network_path: &[NodeId]) {
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get network in load_all_node_click_targets");
return;
};
@ -2718,7 +2733,7 @@ impl NodeNetworkInterface {
}
pub fn unload_all_nodes_click_targets(&mut self, network_path: &[NodeId]) {
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get nested network in unload_all_nodes_click_targets");
return;
};
@ -2737,7 +2752,7 @@ impl NodeNetworkInterface {
// Helper functions for mutable getters
impl NodeNetworkInterface {
pub fn upstream_chain_nodes(&mut self, network_path: &[NodeId]) -> Vec<NodeId> {
let Some(selected_nodes) = self.selected_nodes(network_path) else {
let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) else {
log::error!("Could not get selected nodes in upstream_chain_nodes");
return Vec::new();
};
@ -2895,7 +2910,7 @@ impl NodeNetworkInterface {
log::error!("Could not get nested network_metadata in node_from_click");
return None;
};
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get nested network in node_from_click");
return None;
};
@ -2932,7 +2947,7 @@ impl NodeNetworkInterface {
log::error!("Could not get nested network_metadata in visibility_from_click");
return None;
};
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get nested network in visibility_from_click");
return None;
};
@ -2962,7 +2977,7 @@ impl NodeNetworkInterface {
log::error!("Could not get nested network_metadata in input_connector_from_click");
return None;
};
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get nested network in input_connector_from_click");
return None;
};
@ -2995,7 +3010,7 @@ impl NodeNetworkInterface {
log::error!("Could not get nested network_metadata in output_connector_from_click");
return None;
};
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
log::error!("Could not get nested network in output_connector_from_click");
return None;
};
@ -3068,7 +3083,7 @@ impl NodeNetworkInterface {
/// Get the combined bounding box of the click targets of the selected nodes in the node graph in layer space
pub fn selected_nodes_bounding_box(&mut self, network_path: &[NodeId]) -> Option<[DVec2; 2]> {
let Some(selected_nodes) = self.selected_nodes(network_path) else {
let Some(selected_nodes) = self.selected_nodes_in_nested_network(network_path) else {
log::error!("Could not get selected nodes in selected_nodes_bounding_box_viewport");
return None;
};
@ -3151,9 +3166,7 @@ impl NodeNetworkInterface {
self.document_metadata.structure = HashMap::from_iter([(LayerNodeIdentifier::ROOT_PARENT, NodeRelations::default())]);
// Only load structure if there is a root node
let Some(root_node) = self.root_node(&[]) else {
return;
};
let Some(root_node) = self.root_node(&[]) else { return };
let Some(first_root_layer) = self.upstream_flow_back_from_nodes(vec![root_node.node_id], &[], FlowType::PrimaryFlow).find_map(|node_id| {
if self.is_layer(&node_id, &[]) {
@ -3229,7 +3242,7 @@ impl NodeNetworkInterface {
}
}
let nodes: HashSet<NodeId> = self.network(&[]).unwrap().nodes.keys().cloned().collect::<HashSet<_>>();
let nodes: HashSet<NodeId> = self.document_network().nodes.keys().cloned().collect::<HashSet<_>>();
self.document_metadata.upstream_transforms.retain(|node, _| nodes.contains(node));
self.document_metadata.vector_modify.retain(|node, _| nodes.contains(node));
@ -4573,7 +4586,7 @@ impl NodeNetworkInterface {
}
pub fn toggle_preview(&mut self, toggle_id: NodeId, network_path: &[NodeId]) {
let Some(network) = self.network(network_path) else {
let Some(network) = self.nested_network(network_path) else {
return;
};
// If new_export is None then disconnect
@ -4919,7 +4932,10 @@ impl NodeNetworkInterface {
}
pub fn shift_selected_nodes(&mut self, direction: Direction, shift_without_push: bool, network_path: &[NodeId]) {
let Some(mut node_ids) = self.selected_nodes(network_path).map(|selected_nodes| selected_nodes.selected_nodes().cloned().collect::<HashSet<_>>()) else {
let Some(mut node_ids) = self
.selected_nodes_in_nested_network(network_path)
.map(|selected_nodes| selected_nodes.selected_nodes().cloned().collect::<HashSet<_>>())
else {
log::error!("Could not get selected nodes in shift_selected_nodes");
return;
};
@ -5093,7 +5109,7 @@ impl NodeNetworkInterface {
if *offset == 0 {
return None;
}
if self.selected_nodes(network_path).is_some_and(|selected_nodes| {
if self.selected_nodes_in_nested_network(network_path).is_some_and(|selected_nodes| {
selected_nodes
.selected_nodes()
.any(|selected_node| selected_node == node_id || self.owned_nodes(node_id, network_path).is_some_and(|owned_nodes| owned_nodes.contains(selected_node)))

3
editor/src/messages/portfolio/document/utility_types/transformation.rs
View File

@ -543,8 +543,7 @@ impl<'a> Selected<'a> {
let mut transform = self
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_visible_and_unlocked_layers(self.network_interface)
.find(|layer| !self.network_interface.is_artboard(&layer.to_node(), &[]))
.map(|layer| metadata.transform_to_viewport(layer))

50
editor/src/messages/portfolio/portfolio_message_handler.rs
View File

@ -71,17 +71,13 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
has_active_document = true;
rulers_visible = document.rulers_visible;
node_graph_open = document.is_graph_overlay_open();
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
has_selected_nodes = selected_nodes.selected_nodes().next().is_some();
has_selected_layers = selected_nodes.selected_visible_layers(&document.network_interface).next().is_some();
has_selection_history = document
.network_interface
.network_metadata(&[])
.map(|metadata| {
let metadata = &metadata.persistent_metadata;
(!metadata.selection_undo_history.is_empty(), !metadata.selection_redo_history.is_empty())
})
.unwrap_or((false, false));
has_selection_history = {
let metadata = &document.network_interface.document_network_metadata().persistent_metadata;
(!metadata.selection_undo_history.is_empty(), !metadata.selection_redo_history.is_empty())
};
}
self.menu_bar_message_handler.process_message(
message,
@ -249,13 +245,9 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
buffer.push(CopyBufferEntry {
nodes: active_document.network_interface.copy_nodes(&copy_ids, &[]).collect(),
selected: active_document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_layers_contains(layer, active_document.metadata()),
visible: active_document.network_interface.selected_nodes(&[]).unwrap().layer_visible(layer, &active_document.network_interface),
locked: active_document.network_interface.selected_nodes(&[]).unwrap().layer_locked(layer, &active_document.network_interface),
selected: active_document.network_interface.selected_nodes().selected_layers_contains(layer, active_document.metadata()),
visible: active_document.network_interface.selected_nodes().layer_visible(layer, &active_document.network_interface),
locked: active_document.network_interface.selected_nodes().layer_locked(layer, &active_document.network_interface),
collapsed: false,
});
}
@ -497,7 +489,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
("graphene_std::executor::BlendGpuImageNode", "graphene_std::gpu_nodes::BlendGpuImageNode"),
("graphene_std::raster::SampleNode", "graphene_std::raster::SampleImageNode"),
];
let mut network = document.network_interface.network(&[]).unwrap().clone();
let mut network = document.network_interface.document_network().clone();
network.generate_node_paths(&[]);
let node_ids: Vec<_> = network.recursive_nodes().map(|(&id, node)| (id, node.original_location.path.clone().unwrap())).collect();
@ -506,8 +498,13 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
for (node_id, path) in &node_ids {
let network_path: Vec<_> = path.iter().copied().take(path.len() - 1).collect();
if let Some(DocumentNodeImplementation::ProtoNode(protonode_id)) =
document.network_interface.network(&network_path).unwrap().nodes.get(node_id).map(|node| node.implementation.clone())
if let Some(DocumentNodeImplementation::ProtoNode(protonode_id)) = document
.network_interface
.nested_network(&network_path)
.unwrap()
.nodes
.get(node_id)
.map(|node| node.implementation.clone())
{
for (old, new) in REPLACEMENTS {
let node_path_without_type_args = protonode_id.name.split('<').next();
@ -527,8 +524,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
// Used for upgrading old internal networks for demo artwork nodes. Will reset all node internals for any opened file
for node_id in &document
.network_interface
.network_metadata(&[])
.unwrap()
.document_network_metadata()
.persistent_metadata
.node_metadata
.keys()
@ -537,8 +533,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
{
if let Some(reference) = document
.network_interface
.network_metadata(&[])
.unwrap()
.document_network_metadata()
.persistent_metadata
.node_metadata
.get(node_id)
@ -557,8 +552,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
if document
.network_interface
.network_metadata(&[])
.unwrap()
.document_network_metadata()
.persistent_metadata
.node_metadata
.iter()
@ -567,7 +561,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
document.network_interface.delete_nodes(vec![NodeId(0)], true, &[]);
}
let mut network = document.network_interface.network(&[]).unwrap().clone();
let mut network = document.network_interface.document_network().clone();
network.generate_node_paths(&[]);
let node_ids: Vec<_> = network.recursive_nodes().map(|(&id, node)| (id, node.original_location.path.clone().unwrap())).collect();
@ -577,7 +571,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
let network_path: Vec<_> = path.iter().copied().take(path.len() - 1).collect();
let network_path = &network_path;
let Some(node) = document.network_interface.network(network_path).unwrap().nodes.get(node_id).cloned() else {
let Some(node) = document.network_interface.nested_network(network_path).unwrap().nodes.get(node_id).cloned() else {
log::error!("could not get node in deserialize_document");
continue;
};
@ -1149,7 +1143,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
common.extend(document.actions());
// Extend with actions that must have a selected layer
if document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()).next().is_some() {
if document.network_interface.selected_nodes().selected_layers(document.metadata()).next().is_some() {
common.extend(actions!(PortfolioMessageDiscriminant;
Copy,
Cut,

2
editor/src/messages/tool/common_functionality/compass_rose.rs
View File

@ -19,7 +19,7 @@ impl CompassRose {
layer_transform * bounds_transform
}
pub fn refresh_position(&mut self, document: &DocumentMessageHandler) {
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let mut layers = selected_nodes.selected_visible_and_unlocked_layers(&document.network_interface);
let Some(first) = layers.next() else { return };

2
editor/src/messages/tool/common_functionality/graph_modification_utils.rs
View File

@ -409,7 +409,7 @@ impl<'a> NodeGraphLayer<'a> {
.skip(1)// Skip self
.take_while(|node_id| !self.network_interface.is_layer(node_id,&[]))
.find(|node_id| self.network_interface.reference(node_id,&[]).is_some_and(|reference| *reference == Some(node_name.to_string())))
.and_then(|node_id| self.network_interface.network(&[]).unwrap().nodes.get(&node_id).map(|node| &node.inputs))
.and_then(|node_id| self.network_interface.document_network().nodes.get(&node_id).map(|node| &node.inputs))
}
/// Find a specific input of a node within the layer's primary flow

12
editor/src/messages/tool/common_functionality/pivot.rs
View File

@ -45,7 +45,7 @@ impl Pivot {
/// Recomputes the pivot position and transform.
fn recalculate_pivot(&mut self, document: &DocumentMessageHandler) {
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let mut layers = selected_nodes.selected_visible_and_unlocked_layers(&document.network_interface);
let Some(first) = layers.next() else {
// If no layers are selected then we revert things back to default
@ -67,8 +67,7 @@ impl Pivot {
// If more than one layer is selected we use the AABB with the mean of the pivots
let xy_summation = document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_visible_and_unlocked_layers(&document.network_interface)
.map(|layer| graph_modification_utils::get_viewport_pivot(layer, &document.network_interface))
.reduce(|a, b| a + b)
@ -104,12 +103,7 @@ impl Pivot {
/// Sets the viewport position of the pivot for all selected layers.
pub fn set_viewport_position(&self, position: DVec2, document: &DocumentMessageHandler, responses: &mut VecDeque<Message>) {
for layer in document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_visible_and_unlocked_layers(&document.network_interface)
{
for layer in document.network_interface.selected_nodes().selected_visible_and_unlocked_layers(&document.network_interface) {
let transform = Self::get_layer_pivot_transform(layer, document);
// Only update the pivot when computed position is finite.
if transform.matrix2.determinant().abs() <= f64::EPSILON {

2
editor/src/messages/tool/common_functionality/resize.rs
View File

@ -37,7 +37,7 @@ impl Resize {
return None;
}
if !document.network_interface.network(&[]).unwrap().nodes.contains_key(&layer.to_node()) {
if !document.network_interface.document_network().nodes.contains_key(&layer.to_node()) {
self.layer.take();
return None;
}

3
editor/src/messages/tool/tool_messages/artboard_tool.rs
View File

@ -418,8 +418,7 @@ impl Fsm for ArtboardToolFsmState {
(_, ArtboardToolMessage::UpdateSelectedArtboard) => {
tool_data.selected_artboard = document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_layers(document.metadata())
.find(|layer| document.network_interface.is_artboard(&layer.to_node(), &[]));
self

6
editor/src/messages/tool/tool_messages/brush_tool.rs
View File

@ -264,14 +264,14 @@ impl BrushToolData {
fn load_existing_strokes(&mut self, document: &DocumentMessageHandler) -> Option<LayerNodeIdentifier> {
self.transform = DAffine2::IDENTITY;
if document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()).count() != 1 {
if document.network_interface.selected_nodes().selected_layers(document.metadata()).count() != 1 {
return None;
}
let layer = document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()).next()?;
let layer = document.network_interface.selected_nodes().selected_layers(document.metadata()).next()?;
self.layer = Some(layer);
for node_id in document.network_interface.upstream_flow_back_from_nodes(vec![layer.to_node()], &[], FlowType::HorizontalFlow) {
let Some(node) = document.network_interface.network(&[]).unwrap().nodes.get(&node_id) else {
let Some(node) = document.network_interface.document_network().nodes.get(&node_id) else {
continue;
};
let Some(reference) = document.network_interface.reference(&node_id, &[]) else {

2
editor/src/messages/tool/tool_messages/freehand_tool.rs
View File

@ -210,7 +210,7 @@ impl Fsm for FreehandToolFsmState {
tool_data.weight = tool_options.line_weight;
// Extend an endpoint of the selected path
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let tolerance = crate::consts::SNAP_POINT_TOLERANCE;
if let Some((layer, point, position)) = should_extend(document, input.mouse.position, tolerance, selected_nodes.selected_layers(document.metadata()), preferences) {
tool_data.layer = Some(layer);

8
editor/src/messages/tool/tool_messages/gradient_tool.rs
View File

@ -246,7 +246,7 @@ impl Fsm for GradientToolFsmState {
(_, GradientToolMessage::Overlays(mut overlay_context)) => {
let selected = tool_data.selected_gradient.as_ref();
for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_visible_layers(&document.network_interface) {
for layer in document.network_interface.selected_nodes().selected_visible_layers(&document.network_interface) {
let Some(gradient) = get_gradient(layer, &document.network_interface) else { continue };
let transform = gradient_space_transform(layer, document);
let dragging = selected
@ -323,7 +323,7 @@ impl Fsm for GradientToolFsmState {
self
}
(_, GradientToolMessage::InsertStop) => {
for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_visible_layers(&document.network_interface) {
for layer in document.network_interface.selected_nodes().selected_visible_layers(&document.network_interface) {
let Some(mut gradient) = get_gradient(layer, &document.network_interface) else { continue };
// TODO: This transform is incorrect. I think this is since it is based on the Footprint which has not been updated yet
let transform = gradient_space_transform(layer, document);
@ -362,7 +362,7 @@ impl Fsm for GradientToolFsmState {
let tolerance = (MANIPULATOR_GROUP_MARKER_SIZE * 2.).powi(2);
let mut dragging = false;
for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_visible_layers(&document.network_interface) {
for layer in document.network_interface.selected_nodes().selected_visible_layers(&document.network_interface) {
let Some(gradient) = get_gradient(layer, &document.network_interface) else { continue };
let transform = gradient_space_transform(layer, document);
// Check for dragging step
@ -401,7 +401,7 @@ impl Fsm for GradientToolFsmState {
// Apply the gradient to the selected layer
if let Some(layer) = selected_layer {
if !document.network_interface.selected_nodes(&[]).unwrap().selected_layers_contains(layer, document.metadata()) {
if !document.network_interface.selected_nodes().selected_layers_contains(layer, document.metadata()) {
let nodes = vec![layer.to_node()];
responses.add(NodeGraphMessage::SelectedNodesSet { nodes });

3
editor/src/messages/tool/tool_messages/line_tool.rs
View File

@ -177,8 +177,7 @@ impl Fsm for LineToolFsmState {
tool_data.selected_layers_with_position = document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_visible_and_unlocked_layers(&document.network_interface)
.filter_map(|layer| {
let node_inputs = NodeGraphLayer::new(layer, &document.network_interface).find_node_inputs("Line")?;

4
editor/src/messages/tool/tool_messages/path_tool.rs
View File

@ -769,7 +769,7 @@ impl Fsm for PathToolFsmState {
match (self, event) {
(_, PathToolMessage::SelectionChanged) => {
// Set the newly targeted layers to visible
let target_layers = document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()).collect();
let target_layers = document.network_interface.selected_nodes().selected_layers(document.metadata()).collect();
shape_editor.set_selected_layers(target_layers);
responses.add(OverlaysMessage::Draw);
@ -802,7 +802,7 @@ impl Fsm for PathToolFsmState {
} else {
let mut segment_endpoints: HashMap<SegmentId, Vec<PointId>> = HashMap::new();
for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()) {
for layer in document.network_interface.selected_nodes().selected_layers(document.metadata()) {
let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else { continue };
// The points which are part of only one segment will be rendered

12
editor/src/messages/tool/tool_messages/pen_tool.rs
View File

@ -308,7 +308,7 @@ impl PenToolData {
// When the vector data transform changes, the positions of the points must be recalculated.
fn recalculate_latest_points_position(&mut self, document: &DocumentMessageHandler) {
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let mut selected_layers = selected_nodes.selected_layers(document.metadata());
if let (Some(layer), None) = (selected_layers.next(), selected_layers.next()) {
let Some(vector_data) = document.network_interface.compute_modified_vector(layer) else {
@ -374,7 +374,7 @@ impl PenToolData {
// Get close path
let mut end = None;
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let mut selected_layers = selected_nodes.selected_layers(document.metadata());
let layer = selected_layers.next().filter(|_| selected_layers.next().is_none())?;
let vector_data = document.network_interface.compute_modified_vector(layer)?;
@ -587,7 +587,7 @@ impl PenToolData {
let relative = self.latest_point().map(|point| point.pos);
self.next_point = self.compute_snapped_angle(snap_data, transform, false, mouse, relative, true);
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let mut selected_layers = selected_nodes.selected_layers(document.metadata());
let layer = selected_layers.next().filter(|_| selected_layers.next().is_none())?;
let vector_data = document.network_interface.compute_modified_vector(layer)?;
@ -691,7 +691,7 @@ impl PenToolData {
let snapped = self.snap_manager.free_snap(&SnapData::new(document, input), &point, SnapTypeConfiguration::default());
let viewport = document.metadata().document_to_viewport.transform_point2(snapped.snapped_point_document);
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
self.handle_end = None;
let tolerance = crate::consts::SNAP_POINT_TOLERANCE;
@ -893,7 +893,7 @@ impl Fsm for PenToolFsmState {
..
} = tool_action_data;
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let mut selected_layers = selected_nodes.selected_layers(document.metadata());
let layer = selected_layers.next().filter(|_| selected_layers.next().is_none());
let mut transform = layer.map(|layer| document.metadata().transform_to_document(layer)).unwrap_or_default();
@ -1197,7 +1197,7 @@ impl Fsm for PenToolFsmState {
.descendants(document.metadata())
.filter(|layer| !document.network_interface.is_artboard(&layer.to_node(), &[]));
if let Some((other_layer, _, _)) = should_extend(document, viewport, crate::consts::SNAP_POINT_TOLERANCE, layers, preferences) {
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let mut selected_layers = selected_nodes.selected_layers(document.metadata());
if let Some(current_layer) = selected_layers.next().filter(|current_layer| selected_layers.next().is_none() && *current_layer != other_layer) {
merge_layers(document, current_layer, other_layer, responses);

43
editor/src/messages/tool/tool_messages/select_tool.rs
View File

@ -497,15 +497,14 @@ impl Fsm for SelectToolFsmState {
(_, SelectToolMessage::Overlays(mut overlay_context)) => {
tool_data.snap_manager.draw_overlays(SnapData::new(document, input), &mut overlay_context);
let selected_layers_count = document.network_interface.selected_nodes(&[]).unwrap().selected_unlocked_layers(&document.network_interface).count();
let selected_layers_count = document.network_interface.selected_nodes().selected_unlocked_layers(&document.network_interface).count();
tool_data.selected_layers_changed = selected_layers_count != tool_data.selected_layers_count;
tool_data.selected_layers_count = selected_layers_count;
// Outline selected layers, but not artboards
for layer in document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_visible_and_unlocked_layers(&document.network_interface)
.filter(|layer| !document.network_interface.is_artboard(&layer.to_node(), &[]))
{
@ -526,8 +525,7 @@ impl Fsm for SelectToolFsmState {
// Update bounds
let transform = document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_visible_and_unlocked_layers(&document.network_interface)
.find(|layer| !document.network_interface.is_artboard(&layer.to_node(), &[]))
.map(|layer| document.metadata().transform_to_viewport(layer));
@ -542,8 +540,7 @@ impl Fsm for SelectToolFsmState {
let bounds = document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_visible_and_unlocked_layers(&document.network_interface)
.filter(|layer| !document.network_interface.is_artboard(&layer.to_node(), &[]))
.filter_map(|layer| {
@ -735,7 +732,7 @@ impl Fsm for SelectToolFsmState {
else if !input.keyboard.get(Key::MouseMiddle as usize) {
// Get the layer the user is hovering over
let click = document.click(input);
let not_selected_click = click.filter(|&hovered_layer| !document.network_interface.selected_nodes(&[]).unwrap().selected_layers_contains(hovered_layer, document.metadata()));
let not_selected_click = click.filter(|&hovered_layer| !document.network_interface.selected_nodes().selected_layers_contains(hovered_layer, document.metadata()));
if let Some(layer) = not_selected_click {
overlay_context.outline(document.metadata().layer_outline(layer), document.metadata().transform_to_viewport(layer));
@ -798,12 +795,7 @@ impl Fsm for SelectToolFsmState {
.map(|bounding_box| bounding_box.check_rotate(input.mouse.position))
.unwrap_or_default();
let mut selected: Vec<_> = document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_visible_and_unlocked_layers(&document.network_interface)
.collect();
let mut selected: Vec<_> = document.network_interface.selected_nodes().selected_visible_and_unlocked_layers(&document.network_interface).collect();
let intersection_list = document.click_list(input).collect::<Vec<_>>();
let intersection = document.find_deepest(&intersection_list);
@ -851,7 +843,7 @@ impl Fsm for SelectToolFsmState {
tool_data.layers_dragging.retain(|layer| {
if *layer != LayerNodeIdentifier::ROOT_PARENT {
document.network_interface.network(&[]).unwrap().nodes.contains_key(&layer.to_node())
document.network_interface.document_network().nodes.contains_key(&layer.to_node())
} else {
log::error!("ROOT_PARENT should not be part of layers_dragging");
false
@ -909,7 +901,7 @@ impl Fsm for SelectToolFsmState {
if let Some(bounds) = &mut tool_data.bounding_box_manager {
tool_data.layers_dragging.retain(|layer| {
if *layer != LayerNodeIdentifier::ROOT_PARENT {
document.network_interface.network(&[]).unwrap().nodes.contains_key(&layer.to_node())
document.network_interface.document_network().nodes.contains_key(&layer.to_node())
} else {
log::error!("ROOT_PARENT should not be part of layers_dragging");
false
@ -1041,7 +1033,7 @@ impl Fsm for SelectToolFsmState {
tool_data.layers_dragging.retain(|layer| {
if *layer != LayerNodeIdentifier::ROOT_PARENT {
document.network_interface.network(&[]).unwrap().nodes.contains_key(&layer.to_node())
document.network_interface.document_network().nodes.contains_key(&layer.to_node())
} else {
log::error!("ROOT_PARENT should not be part of layers_dragging");
false
@ -1079,7 +1071,7 @@ impl Fsm for SelectToolFsmState {
tool_data.layers_dragging.retain(|layer| {
if *layer != LayerNodeIdentifier::ROOT_PARENT {
document.network_interface.network(&[]).unwrap().nodes.contains_key(&layer.to_node())
document.network_interface.document_network().nodes.contains_key(&layer.to_node())
} else {
log::error!("ROOT_PARENT should not be part of layers_dragging");
false
@ -1123,7 +1115,7 @@ impl Fsm for SelectToolFsmState {
tool_data.layers_dragging.retain(|layer| {
if *layer != LayerNodeIdentifier::ROOT_PARENT {
document.network_interface.network(&[]).unwrap().nodes.contains_key(&layer.to_node())
document.network_interface.document_network().nodes.contains_key(&layer.to_node())
} else {
log::error!("ROOT_PARENT should not be part of replacement_selected_layers");
false
@ -1277,8 +1269,7 @@ impl Fsm for SelectToolFsmState {
if let Some(path) = intersection.last() {
let replacement_selected_layers: Vec<_> = document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_layers(document.metadata())
.filter(|&layer| !path.starts_with(layer, document.metadata()))
.collect();
@ -1385,7 +1376,7 @@ impl Fsm for SelectToolFsmState {
intersection.into_iter().collect()
};
let current_selected: HashSet<_> = document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()).collect();
let current_selected: HashSet<_> = document.network_interface.selected_nodes().selected_layers(document.metadata()).collect();
let negative_selection = input.keyboard.key(remove_from_selection);
let selection_modified = new_selected != current_selected;
// Negative selection when both Shift and Ctrl are pressed
@ -1431,7 +1422,7 @@ impl Fsm for SelectToolFsmState {
SelectToolFsmState::Ready { selection }
}
(SelectToolFsmState::Ready { .. }, SelectToolMessage::Enter) => {
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let mut selected_layers = selected_nodes.selected_layers(document.metadata());
if let Some(layer) = selected_layers.next() {
@ -1457,7 +1448,7 @@ impl Fsm for SelectToolFsmState {
(_, SelectToolMessage::Abort) => {
tool_data.layers_dragging.retain(|layer| {
if *layer != LayerNodeIdentifier::ROOT_PARENT {
document.network_interface.network(&[]).unwrap().nodes.contains_key(&layer.to_node())
document.network_interface.document_network().nodes.contains_key(&layer.to_node())
} else {
false
}
@ -1601,7 +1592,7 @@ fn drag_shallowest_manipulation(responses: &mut VecDeque<Message>, selected: Vec
let ancestor = layer
.ancestors(document.metadata())
.filter(not_artboard(document))
.find(|&ancestor| document.network_interface.selected_nodes(&[]).unwrap().selected_layers_contains(ancestor, document.metadata()));
.find(|&ancestor| document.network_interface.selected_nodes().selected_layers_contains(ancestor, document.metadata()));
let new_selected = ancestor.unwrap_or_else(|| layer.ancestors(document.metadata()).filter(not_artboard(document)).last().unwrap_or(layer));
tool_data.layers_dragging.retain(|layer| !layer.ancestors(document.metadata()).any(|ancestor| ancestor == new_selected));
@ -1654,7 +1645,7 @@ fn edit_layer_shallowest_manipulation(document: &DocumentMessageHandler, layer:
let Some(new_selected) = layer.ancestors(document.metadata()).filter(not_artboard(document)).find(|ancestor| {
ancestor
.parent(document.metadata())
.is_some_and(|parent| document.network_interface.selected_nodes(&[]).unwrap().selected_layers_contains(parent, document.metadata()))
.is_some_and(|parent| document.network_interface.selected_nodes().selected_layers_contains(parent, document.metadata()))
}) else {
return;
};

2
editor/src/messages/tool/tool_messages/spline_tool.rs
View File

@ -318,7 +318,7 @@ impl Fsm for SplineToolFsmState {
}
}
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let mut selected_layers_except_artboards = selected_nodes.selected_layers_except_artboards(&document.network_interface);
let selected_layer = selected_layers_except_artboards.next().filter(|_| selected_layers_except_artboards.next().is_none());

4
editor/src/messages/tool/tool_messages/text_tool.rs
View File

@ -397,7 +397,7 @@ impl TextToolData {
}
fn can_edit_selected(document: &DocumentMessageHandler) -> Option<LayerNodeIdentifier> {
let selected_nodes = document.network_interface.selected_nodes(&[]).unwrap();
let selected_nodes = document.network_interface.selected_nodes();
let mut selected_layers = selected_nodes.selected_layers(document.metadata());
let layer = selected_layers.next()?;
@ -463,7 +463,7 @@ impl Fsm for TextToolFsmState {
overlay_context.quad(quad, Some(&("#".to_string() + &fill_color)));
} else {
for layer in document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()) {
for layer in document.network_interface.selected_nodes().selected_layers(document.metadata()) {
let Some((text, font, typesetting)) = graph_modification_utils::get_text(layer, &document.network_interface) else {
continue;
};

5
editor/src/messages/tool/transform_layer/transform_layer_message_handler.rs
View File

@ -147,8 +147,7 @@ impl MessageHandler<TransformLayerMessage, TransformData<'_>> for TransformLayer
// TODO: Add support for transforming layer not in the document network
let selected_layers = document
.network_interface
.selected_nodes(&[])
.unwrap()
.selected_nodes()
.selected_layers(document.metadata())
.filter(|&layer| document.network_interface.is_visible(&layer.to_node(), &[]) && !document.network_interface.is_locked(&layer.to_node(), &[]))
.collect::<Vec<_>>();
@ -675,7 +674,7 @@ impl MessageHandler<TransformLayerMessage, TransformData<'_>> for TransformLayer
self.mouse_position = input.mouse.position;
}
TransformLayerMessage::SelectionChanged => {
let target_layers = document.network_interface.selected_nodes(&[]).unwrap().selected_layers(document.metadata()).collect();
let target_layers = document.network_interface.selected_nodes().selected_layers(document.metadata()).collect();
shape_editor.set_selected_layers(target_layers);
}
TransformLayerMessage::TypeBackspace => {

8
editor/src/node_graph_executor.rs
View File

@ -460,7 +460,7 @@ impl NodeGraphExecutor {
pub(crate) fn update_node_graph_instrumented(&mut self, document: &mut DocumentMessageHandler) -> Result<Instrumented, String> {
// We should always invalidate the cache.
self.node_graph_hash = generate_uuid();
let mut network = document.network_interface.network(&[]).unwrap().clone();
let mut network = document.network_interface.document_network().clone();
let instrumented = Instrumented::new(&mut network);
self.sender.send(NodeRuntimeMessage::GraphUpdate(network)).map_err(|e| e.to_string())?;
@ -469,11 +469,11 @@ impl NodeGraphExecutor {
/// Update the cached network if necessary.
fn update_node_graph(&mut self, document: &mut DocumentMessageHandler, ignore_hash: bool) -> Result<(), String> {
let network_hash = document.network_interface.network(&[]).unwrap().current_hash();
let network_hash = document.network_interface.document_network().current_hash();
if network_hash != self.node_graph_hash || ignore_hash {
self.node_graph_hash = network_hash;
self.sender
.send(NodeRuntimeMessage::GraphUpdate(document.network_interface.network(&[]).unwrap().clone()))
.send(NodeRuntimeMessage::GraphUpdate(document.network_interface.document_network().clone()))
.map_err(|e| e.to_string())?;
}
Ok(())
@ -513,7 +513,7 @@ impl NodeGraphExecutor {
/// Evaluates a node graph for export
pub fn submit_document_export(&mut self, document: &mut DocumentMessageHandler, mut export_config: ExportConfig) -> Result<(), String> {
let network = document.network_interface.network(&[]).unwrap().clone();
let network = document.network_interface.document_network().clone();
// Calculate the bounding box of the region to be exported
let bounds = match export_config.bounds {

15
frontend/wasm/src/editor_api.rs
View File

@ -781,8 +781,7 @@ impl EditorHandle {
let document = editor.dispatcher.message_handlers.portfolio_message_handler.active_document_mut().unwrap();
for node in document
.network_interface
.network_metadata(&[])
.unwrap()
.document_network_metadata()
.persistent_metadata
.node_metadata
.iter()
@ -790,7 +789,7 @@ impl EditorHandle {
.map(|(id, _)| *id)
.collect::<Vec<_>>()
{
let Some(document_node) = document.network_interface.network(&[]).unwrap().nodes.get(&node) else {
let Some(document_node) = document.network_interface.document_network().nodes.get(&node) else {
log::error!("Could not get document node in document network");
return;
};
@ -803,8 +802,7 @@ impl EditorHandle {
.is_some_and(|reference| *reference == Some("To Artboard".to_string()))
&& document
.network_interface
.network(&[])
.unwrap()
.document_network()
.nodes
.get(node_id)
.is_some_and(|document_node| document_node.inputs.len() != 6)
@ -854,8 +852,7 @@ impl EditorHandle {
document.network_interface.load_structure();
for node in document
.network_interface
.network_metadata(&[])
.unwrap()
.document_network_metadata()
.persistent_metadata
.node_metadata
.iter()
@ -880,7 +877,7 @@ impl EditorHandle {
if !updated_nodes.insert(transform_node_id) {
return;
}
let Some(inputs) = modify_inputs.network_interface.network(&[]).unwrap().nodes.get(&transform_node_id).map(|node| &node.inputs) else {
let Some(inputs) = modify_inputs.network_interface.document_network().nodes.get(&transform_node_id).map(|node| &node.inputs) else {
log::error!("Could not get transform node in document network");
return;
};
@ -897,7 +894,7 @@ impl EditorHandle {
if !updated_nodes.insert(shape_node_id) {
return;
}
let Some(shape_node) = modify_inputs.network_interface.network(&[]).unwrap().nodes.get(&shape_node_id) else {
let Some(shape_node) = modify_inputs.network_interface.document_network().nodes.get(&shape_node_id) else {
log::error!("Could not get shape node in document network");
return;
};