fork/Graphite
1
0
Fork 0
mirror of https://github.com/GraphiteEditor/Graphite.git synced 2026-09-15 22:28:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Clean up arg order in process_message() so data is last

Browse Source
This commit is contained in:
Keavon Chambers
2023-01-29 04:07:41 -08:00
parent d990110f63
commit 7ab601c0c6
42 changed files with 89 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
editor/src/dispatcher.rs
View File

@@ -106,15 +106,15 @@ impl Dispatcher {
queue.push_back(FrontendMessage::TriggerFontLoad { font, is_default: true }.into());
}
Broadcast(message) => self.message_handlers.broadcast_message_handler.process_message(message, (), &mut queue),
Broadcast(message) => self.message_handlers.broadcast_message_handler.process_message(message, &mut queue, ()),
Debug(message) => {
self.message_handlers.debug_message_handler.process_message(message, (), &mut queue);
self.message_handlers.debug_message_handler.process_message(message, &mut queue, ());
}
Dialog(message) => {
self.message_handlers.dialog_message_handler.process_message(
message,
(&self.message_handlers.portfolio_message_handler, &self.message_handlers.preferences_message_handler),
&mut queue,
(&self.message_handlers.portfolio_message_handler, &self.message_handlers.preferences_message_handler),
);
}
Frontend(message) => {
@@ -131,55 +131,53 @@ impl Dispatcher {
}
}
Globals(message) => {
self.message_handlers.globals_message_handler.process_message(message, (), &mut queue);
self.message_handlers.globals_message_handler.process_message(message, &mut queue, ());
}
InputMapper(message) => {
let actions = self.collect_actions();
self.message_handlers
.input_mapper_message_handler
.process_message(message, (&self.message_handlers.input_preprocessor_message_handler, actions), &mut queue);
.process_message(message, &mut queue, (&self.message_handlers.input_preprocessor_message_handler, actions));
}
InputPreprocessor(message) => {
let keyboard_platform = GLOBAL_PLATFORM.get().copied().unwrap_or_default().as_keyboard_platform_layout();
self.message_handlers.input_preprocessor_message_handler.process_message(message, keyboard_platform, &mut queue);
self.message_handlers.input_preprocessor_message_handler.process_message(message, &mut queue, keyboard_platform);
}
Layout(message) => {
let action_input_mapping = &|action_to_find: &MessageDiscriminant| self.message_handlers.input_mapper_message_handler.action_input_mapping(action_to_find);
self.message_handlers.layout_message_handler.process_message(message, action_input_mapping, &mut queue);
self.message_handlers.layout_message_handler.process_message(message, &mut queue, action_input_mapping);
}
Portfolio(message) => {
self.message_handlers.portfolio_message_handler.process_message(
message,
(&self.message_handlers.input_preprocessor_message_handler, &self.message_handlers.preferences_message_handler),
&mut queue,
(&self.message_handlers.input_preprocessor_message_handler, &self.message_handlers.preferences_message_handler),
);
}
Preferences(message) => {
self.message_handlers.preferences_message_handler.process_message(message, (), &mut queue);
self.message_handlers.preferences_message_handler.process_message(message, &mut queue, ());
}
Tool(message) => {
if let Some(document) = self.message_handlers.portfolio_message_handler.active_document() {
self.message_handlers.tool_message_handler.process_message(
message,
&mut queue,
(
document,
self.message_handlers.portfolio_message_handler.active_document_id().unwrap(),
&self.message_handlers.input_preprocessor_message_handler,
&self.message_handlers.portfolio_message_handler.persistent_data,
),
&mut queue,
);
} else {
warn!("Called ToolMessage without an active document.\nGot {:?}", message);
}
}
Workspace(message) => {
self.message_handlers
.workspace_message_handler
.process_message(message, &self.message_handlers.input_preprocessor_message_handler, &mut queue);
self.message_handlers.workspace_message_handler.process_message(message, &mut queue, ());
}
}

1
editor/src/generate_ts_types.rs
View File

@@ -1,6 +1,7 @@
/// Running this test will generate a `types.ts` file at the root of the repo,
/// containing every type annotated with `specta::Type`
// #[cfg(all(test, feature = "specta-export"))]
#[ignore]
#[test]
fn generate_ts_types() {
use crate::messages::prelude::FrontendMessage;

2
editor/src/messages/broadcast/broadcast_message_handler.rs
View File

@@ -7,7 +7,7 @@ pub struct BroadcastMessageHandler {
impl MessageHandler<BroadcastMessage, ()> for BroadcastMessageHandler {
#[remain::check]
fn process_message(&mut self, message: BroadcastMessage, _data: (), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: BroadcastMessage, responses: &mut VecDeque<Message>, _data: ()) {
#[remain::sorted]
match message {
// Sub-messages

2
editor/src/messages/debug/debug_message_handler.rs
View File

@@ -8,7 +8,7 @@ pub struct DebugMessageHandler {
impl MessageHandler<DebugMessage, ()> for DebugMessageHandler {
#[remain::check]
fn process_message(&mut self, message: DebugMessage, _data: (), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: DebugMessage, responses: &mut VecDeque<Message>, _data: ()) {
match message {
DebugMessage::ToggleTraceLogs => {
if log::max_level() == log::LevelFilter::Debug {

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

@@ -12,15 +12,15 @@ pub struct DialogMessageHandler {
impl MessageHandler<DialogMessage, (&PortfolioMessageHandler, &PreferencesMessageHandler)> for DialogMessageHandler {
#[remain::check]
fn process_message(&mut self, message: DialogMessage, (portfolio, preferences): (&PortfolioMessageHandler, &PreferencesMessageHandler), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: DialogMessage, responses: &mut VecDeque<Message>, (portfolio, preferences): (&PortfolioMessageHandler, &PreferencesMessageHandler)) {
#[remain::sorted]
match message {
#[remain::unsorted]
DialogMessage::ExportDialog(message) => self.export_dialog.process_message(message, (), responses),
DialogMessage::ExportDialog(message) => self.export_dialog.process_message(message, responses, ()),
#[remain::unsorted]
DialogMessage::NewDocumentDialog(message) => self.new_document_dialog.process_message(message, (), responses),
DialogMessage::NewDocumentDialog(message) => self.new_document_dialog.process_message(message, responses, ()),
#[remain::unsorted]
DialogMessage::PreferencesDialog(message) => self.preferences_dialog.process_message(message, preferences, responses),
DialogMessage::PreferencesDialog(message) => self.preferences_dialog.process_message(message, responses, preferences),
DialogMessage::CloseAllDocumentsWithConfirmation => {
let dialog = simple_dialogs::CloseAllDocumentsDialog;

2
editor/src/messages/dialog/export_dialog/export_dialog_message_handler.rs
View File

@@ -20,7 +20,7 @@ pub struct ExportDialogMessageHandler {
}
impl MessageHandler<ExportDialogMessage, ()> for ExportDialogMessageHandler {
fn process_message(&mut self, message: ExportDialogMessage, _data: (), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ExportDialogMessage, responses: &mut VecDeque<Message>, _data: ()) {
match message {
ExportDialogMessage::FileName(name) => self.file_name = name,
ExportDialogMessage::FileType(export_type) => self.file_type = export_type,

2
editor/src/messages/dialog/new_document_dialog/new_document_dialog_message_handler.rs
View File

@@ -16,7 +16,7 @@ pub struct NewDocumentDialogMessageHandler {
}
impl MessageHandler<NewDocumentDialogMessage, ()> for NewDocumentDialogMessageHandler {
fn process_message(&mut self, message: NewDocumentDialogMessage, _data: (), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: NewDocumentDialogMessage, responses: &mut VecDeque<Message>, _data: ()) {
match message {
NewDocumentDialogMessage::Name(name) => self.name = name,
NewDocumentDialogMessage::Infinite(infinite) => self.infinite = infinite,

2
editor/src/messages/dialog/preferences_dialog/preferences_dialog_message_handler.rs
View File

@@ -10,7 +10,7 @@ use crate::messages::prelude::*;
pub struct PreferencesDialogMessageHandler {}
impl MessageHandler<PreferencesDialogMessage, &PreferencesMessageHandler> for PreferencesDialogMessageHandler {
fn process_message(&mut self, message: PreferencesDialogMessage, preferences: &PreferencesMessageHandler, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: PreferencesDialogMessage, responses: &mut VecDeque<Message>, preferences: &PreferencesMessageHandler) {
match message {
PreferencesDialogMessage::Confirm => {}
}

2
editor/src/messages/globals/globals_message_handler.rs
View File

@@ -5,7 +5,7 @@ pub struct GlobalsMessageHandler {}
impl MessageHandler<GlobalsMessage, ()> for GlobalsMessageHandler {
#[remain::check]
fn process_message(&mut self, message: GlobalsMessage, _data: (), _responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: GlobalsMessage, _responses: &mut VecDeque<Message>, _data: ()) {
match message {
GlobalsMessage::SetPlatform { platform } => {
if GLOBAL_PLATFORM.get() != Some(&platform) {

2
editor/src/messages/input_mapper/input_mapper_message_handler.rs
View File

@@ -11,7 +11,7 @@ pub struct InputMapperMessageHandler {
}
impl MessageHandler<InputMapperMessage, (&InputPreprocessorMessageHandler, ActionList)> for InputMapperMessageHandler {
fn process_message(&mut self, message: InputMapperMessage, (input, actions): (&InputPreprocessorMessageHandler, ActionList), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: InputMapperMessage, responses: &mut VecDeque<Message>, (input, actions): (&InputPreprocessorMessageHandler, ActionList)) {
if let Some(message) = self.mapping.match_input_message(message, &input.keyboard, actions) {
responses.push_back(message);
}

14
editor/src/messages/input_preprocessor/input_preprocessor_message_handler.rs
View File

@@ -17,9 +17,7 @@ pub struct InputPreprocessorMessageHandler {
impl MessageHandler<InputPreprocessorMessage, KeyboardPlatformLayout> for InputPreprocessorMessageHandler {
#[remain::check]
fn process_message(&mut self, message: InputPreprocessorMessage, data: KeyboardPlatformLayout, responses: &mut VecDeque<Message>) {
let keyboard_platform = data;
fn process_message(&mut self, message: InputPreprocessorMessage, responses: &mut VecDeque<Message>, keyboard_platform: KeyboardPlatformLayout) {
#[remain::sorted]
match message {
InputPreprocessorMessage::BoundsOfViewports { bounds_of_viewports } => {
@@ -197,7 +195,7 @@ mod test {
let mut responses = VecDeque::new();
input_preprocessor.process_message(message, KeyboardPlatformLayout::Standard, &mut responses);
input_preprocessor.process_message(message, &mut responses, KeyboardPlatformLayout::Standard);
assert!(input_preprocessor.keyboard.get(Key::Alt as usize));
assert_eq!(responses.pop_front(), Some(InputMapperMessage::KeyDown(Key::Alt).into()));
@@ -213,7 +211,7 @@ mod test {
let mut responses = VecDeque::new();
input_preprocessor.process_message(message, KeyboardPlatformLayout::Standard, &mut responses);
input_preprocessor.process_message(message, &mut responses, KeyboardPlatformLayout::Standard);
assert!(input_preprocessor.keyboard.get(Key::Control as usize));
assert_eq!(responses.pop_front(), Some(InputMapperMessage::KeyDown(Key::Control).into()));
@@ -229,7 +227,7 @@ mod test {
let mut responses = VecDeque::new();
input_preprocessor.process_message(message, KeyboardPlatformLayout::Standard, &mut responses);
input_preprocessor.process_message(message, &mut responses, KeyboardPlatformLayout::Standard);
assert!(input_preprocessor.keyboard.get(Key::Shift as usize));
assert_eq!(responses.pop_front(), Some(InputMapperMessage::KeyDown(Key::Shift).into()));
@@ -246,7 +244,7 @@ mod test {
let mut responses = VecDeque::new();
input_preprocessor.process_message(message, KeyboardPlatformLayout::Standard, &mut responses);
input_preprocessor.process_message(message, &mut responses, KeyboardPlatformLayout::Standard);
assert!(!input_preprocessor.keyboard.get(Key::Control as usize));
assert_eq!(responses.pop_front(), Some(InputMapperMessage::KeyUp(Key::Control).into()));
@@ -262,7 +260,7 @@ mod test {
let mut responses = VecDeque::new();
input_preprocessor.process_message(message, KeyboardPlatformLayout::Standard, &mut responses);
input_preprocessor.process_message(message, &mut responses, KeyboardPlatformLayout::Standard);
assert!(input_preprocessor.keyboard.get(Key::Control as usize));
assert!(input_preprocessor.keyboard.get(Key::Shift as usize));

4
editor/src/messages/layout/layout_message_handler.rs
View File

@@ -45,9 +45,7 @@ impl LayoutMessageHandler {
impl<F: Fn(&MessageDiscriminant) -> Vec<KeysGroup>> MessageHandler<LayoutMessage, F> for LayoutMessageHandler {
#[remain::check]
fn process_message(&mut self, message: LayoutMessage, data: F, responses: &mut std::collections::VecDeque<Message>) {
let action_input_mapping = data;
fn process_message(&mut self, message: LayoutMessage, responses: &mut std::collections::VecDeque<Message>, action_input_mapping: F) {
use LayoutMessage::*;
#[remain::sorted]
match message {

2
editor/src/messages/portfolio/document/artboard/artboard_message_handler.rs
View File

@@ -20,7 +20,7 @@ pub struct ArtboardMessageHandler {
impl MessageHandler<ArtboardMessage, &FontCache> for ArtboardMessageHandler {
#[remain::check]
fn process_message(&mut self, message: ArtboardMessage, font_cache: &FontCache, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ArtboardMessage, responses: &mut VecDeque<Message>, font_cache: &FontCache) {
use ArtboardMessage::*;
#[remain::sorted]

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

@@ -109,8 +109,8 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
fn process_message(
&mut self,
message: DocumentMessage,
(document_id, ipp, persistent_data, preferences): (u64, &InputPreprocessorMessageHandler, &PersistentData, &PreferencesMessageHandler),
responses: &mut VecDeque<Message>,
(document_id, ipp, persistent_data, preferences): (u64, &InputPreprocessorMessageHandler, &PersistentData, &PreferencesMessageHandler),
) {
use DocumentMessage::*;
@@ -177,21 +177,21 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
},
#[remain::unsorted]
Artboard(message) => {
self.artboard_message_handler.process_message(message, &persistent_data.font_cache, responses);
self.artboard_message_handler.process_message(message, responses, &persistent_data.font_cache);
}
#[remain::unsorted]
Navigation(message) => {
self.navigation_handler.process_message(message, (&self.document_legacy, ipp), responses);
self.navigation_handler.process_message(message, responses, (&self.document_legacy, ipp));
}
#[remain::unsorted]
Overlays(message) => {
self.overlays_message_handler
.process_message(message, (self.overlays_visible, &persistent_data.font_cache, ipp), responses);
.process_message(message, responses, (self.overlays_visible, &persistent_data.font_cache, ipp));
}
#[remain::unsorted]
TransformLayer(message) => {
self.transform_layer_handler
.process_message(message, (&mut self.layer_metadata, &mut self.document_legacy, ipp, &persistent_data.font_cache), responses);
.process_message(message, responses, (&mut self.layer_metadata, &mut self.document_legacy, ipp, &persistent_data.font_cache));
}
#[remain::unsorted]
PropertiesPanel(message) => {
@@ -202,12 +202,12 @@ impl MessageHandler<DocumentMessage, (u64, &InputPreprocessorMessageHandler, &Pe
node_graph_message_handler: &self.node_graph_handler,
};
self.properties_panel_message_handler
.process_message(message, (persistent_data, properties_panel_message_handler_data), responses);
.process_message(message, responses, (persistent_data, properties_panel_message_handler_data));
}
#[remain::unsorted]
NodeGraph(message) => {
let selected_layers = &mut self.layer_metadata.iter().filter_map(|(path, data)| data.selected.then_some(path.as_slice()));
self.node_graph_handler.process_message(message, (&mut self.document_legacy, selected_layers), responses);
self.node_graph_handler.process_message(message, responses, (&mut self.document_legacy, selected_layers));
}
// Messages
@@ -1074,7 +1074,7 @@ impl DocumentMessageHandler {
.to_cols_array()
.iter()
.enumerate()
.fold(String::new(), |accum, (i, entry)| accum + &(entry.to_string() + if i == 5 { "" } else { "," }));
.fold(String::new(), |acc, (i, entry)| acc + &(entry.to_string() + if i == 5 { "" } else { "," }));
let svg = format!(
r#"<svg xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="none" viewBox="0 0 1 1" width="{}" height="{}">{}{}<g transform="matrix({})">{}{}</g></svg>"#,
size.x, size.y, "\n", outside_artboards, matrix, artboards, artwork

2
editor/src/messages/portfolio/document/navigation/navigation_message_handler.rs
View File

@@ -50,7 +50,7 @@ impl Default for NavigationMessageHandler {
impl MessageHandler<NavigationMessage, (&Document, &InputPreprocessorMessageHandler)> for NavigationMessageHandler {
#[remain::check]
fn process_message(&mut self, message: NavigationMessage, (document, ipp): (&Document, &InputPreprocessorMessageHandler), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: NavigationMessage, responses: &mut VecDeque<Message>, (document, ipp): (&Document, &InputPreprocessorMessageHandler)) {
use NavigationMessage::*;
#[remain::sorted]

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

@@ -184,12 +184,12 @@ impl NodeGraphMessageHandler {
let is_hidden = self.selected_nodes.iter().any(|id| network.disabled.contains(id));
// Check if multiple nodes are selected
let mutliple_nodes = selected_nodes.next().is_some();
let multiple_nodes = selected_nodes.next().is_some();
// Generate the enable or disable button accordingly
let hide_button = WidgetHolder::new(Widget::TextButton(TextButton {
label: if is_hidden { "Show" } else { "Hide" }.to_string(),
tooltip: if is_hidden { "Show node" } else { "Hide node" }.to_string() + if mutliple_nodes { "s" } else { "" },
tooltip: if is_hidden { "Show node" } else { "Hide node" }.to_string() + if multiple_nodes { "s" } else { "" },
tooltip_shortcut: action_keys!(NodeGraphMessageDiscriminant::ToggleHidden),
on_update: WidgetCallback::new(move |_| NodeGraphMessage::ToggleHidden.into()),
..Default::default()
@@ -203,7 +203,7 @@ impl NodeGraphMessageHandler {
// Is this node the current output
let is_output = network.output == node_id;
// Don't show stop previewing button on the origional output node
// Don't show stop previewing button on the original output node
if !(is_output && network.previous_output.filter(|&id| id != self.selected_nodes[0]).is_none()) {
let output_button = WidgetHolder::new(Widget::TextButton(TextButton {
label: if is_output { "End Preview" } else { "Preview" }.to_string(),
@@ -386,7 +386,7 @@ impl NodeGraphMessageHandler {
impl MessageHandler<NodeGraphMessage, (&mut Document, &mut dyn Iterator<Item = &[LayerId]>)> for NodeGraphMessageHandler {
#[remain::check]
fn process_message(&mut self, message: NodeGraphMessage, (document, selected): (&mut Document, &mut dyn Iterator<Item = &[LayerId]>), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: NodeGraphMessage, responses: &mut VecDeque<Message>, (document, selected): (&mut Document, &mut dyn Iterator<Item = &[LayerId]>)) {
#[remain::sorted]
match message {
NodeGraphMessage::CloseNodeGraph => {
@@ -416,7 +416,7 @@ impl MessageHandler<NodeGraphMessage, (&mut Document, &mut dyn Iterator<Item = &
return;
};
let Some((input_index, _)) = input_node.inputs.iter().enumerate().filter(|input|input.1.is_exposed()).nth(input_node_connector_index) else {
error!("Failed to find actual index of connector indes {input_node_connector_index} on node {input_node:#?}");
error!("Failed to find actual index of connector index {input_node_connector_index} on node {input_node:#?}");
return;
};

2
editor/src/messages/portfolio/document/overlays/overlays_message_handler.rs
View File

@@ -11,7 +11,7 @@ pub struct OverlaysMessageHandler {
impl MessageHandler<OverlaysMessage, (bool, &FontCache, &InputPreprocessorMessageHandler)> for OverlaysMessageHandler {
#[remain::check]
fn process_message(&mut self, message: OverlaysMessage, (overlays_visible, font_cache, ipp): (bool, &FontCache, &InputPreprocessorMessageHandler), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: OverlaysMessage, responses: &mut VecDeque<Message>, (overlays_visible, font_cache, ipp): (bool, &FontCache, &InputPreprocessorMessageHandler)) {
use OverlaysMessage::*;
#[remain::sorted]

2
editor/src/messages/portfolio/document/properties_panel/properties_panel_message_handler.rs
View File

@@ -19,7 +19,7 @@ pub struct PropertiesPanelMessageHandler {
impl<'a> MessageHandler<PropertiesPanelMessage, (&PersistentData, PropertiesPanelMessageHandlerData<'a>)> for PropertiesPanelMessageHandler {
#[remain::check]
fn process_message(&mut self, message: PropertiesPanelMessage, (persistent_data, data): (&PersistentData, PropertiesPanelMessageHandlerData), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: PropertiesPanelMessage, responses: &mut VecDeque<Message>, (persistent_data, data): (&PersistentData, PropertiesPanelMessageHandlerData)) {
let PropertiesPanelMessageHandlerData {
artwork_document,
artboard_document,

2
editor/src/messages/portfolio/document/transform_layer/transform_layer_message_handler.rs
View File

@@ -28,7 +28,7 @@ pub struct TransformLayerMessageHandler {
type TransformData<'a> = (&'a mut HashMap<Vec<LayerId>, LayerMetadata>, &'a mut Document, &'a InputPreprocessorMessageHandler, &'a FontCache);
impl<'a> MessageHandler<TransformLayerMessage, TransformData<'a>> for TransformLayerMessageHandler {
#[remain::check]
fn process_message(&mut self, message: TransformLayerMessage, (layer_metadata, document, ipp, font_cache): TransformData, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: TransformLayerMessage, responses: &mut VecDeque<Message>, (layer_metadata, document, ipp, font_cache): TransformData) {
use TransformLayerMessage::*;
let selected_layers = layer_metadata.iter().filter_map(|(layer_path, data)| data.selected.then_some(layer_path)).collect::<Vec<_>>();

2
editor/src/messages/portfolio/menu_bar/menu_bar_message_handler.rs
View File

@@ -10,7 +10,7 @@ pub struct MenuBarMessageHandler {}
impl MessageHandler<MenuBarMessage, ()> for MenuBarMessageHandler {
#[remain::check]
fn process_message(&mut self, message: MenuBarMessage, _data: (), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: MenuBarMessage, responses: &mut VecDeque<Message>, _data: ()) {
use MenuBarMessage::*;
#[remain::sorted]

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

@@ -36,17 +36,17 @@ pub struct PortfolioMessageHandler {
impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &PreferencesMessageHandler)> for PortfolioMessageHandler {
#[remain::check]
fn process_message(&mut self, message: PortfolioMessage, (ipp, preferences): (&InputPreprocessorMessageHandler, &PreferencesMessageHandler), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: PortfolioMessage, responses: &mut VecDeque<Message>, (ipp, preferences): (&InputPreprocessorMessageHandler, &PreferencesMessageHandler)) {
#[remain::sorted]
match message {
// Sub-messages
#[remain::unsorted]
PortfolioMessage::MenuBar(message) => self.menu_bar_message_handler.process_message(message, (), responses),
PortfolioMessage::MenuBar(message) => self.menu_bar_message_handler.process_message(message, responses, ()),
#[remain::unsorted]
PortfolioMessage::Document(message) => {
if let Some(document_id) = self.active_document_id {
if let Some(document) = self.documents.get_mut(&document_id) {
document.process_message(message, (document_id, ipp, &self.persistent_data, preferences), responses)
document.process_message(message, responses, (document_id, ipp, &self.persistent_data, preferences))
}
}
}
@@ -55,7 +55,7 @@ impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &Prefer
#[remain::unsorted]
PortfolioMessage::DocumentPassMessage { document_id, message } => {
if let Some(document) = self.documents.get_mut(&document_id) {
document.process_message(message, (document_id, ipp, &self.persistent_data, preferences), responses)
document.process_message(message, responses, (document_id, ipp, &self.persistent_data, preferences))
}
}
PortfolioMessage::AutoSaveActiveDocument => {
@@ -749,7 +749,7 @@ impl PortfolioMessageHandler {
let size_estimate = (image_width * image_height * 4) as usize;
let mut result_bytes = Vec::with_capacity(size_estimate);
result_bytes.extend(image.data.into_iter().flat_map(|colour| colour.to_rgba8()));
result_bytes.extend(image.data.into_iter().flat_map(|color| color.to_rgba8()));
let mut output: ImageBuffer<Rgba<u8>, _> = image::ImageBuffer::from_raw(image_width, image_height, result_bytes).ok_or_else(|| "Invalid image size".to_string())?;
if let Some(size) = resize {
let size = size.as_uvec2();

2
editor/src/messages/preferences/preferences_message_handler.rs
View File

@@ -19,7 +19,7 @@ impl Default for PreferencesMessageHandler {
impl MessageHandler<PreferencesMessage, ()> for PreferencesMessageHandler {
#[remain::check]
fn process_message(&mut self, message: PreferencesMessage, _data: (), responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: PreferencesMessage, responses: &mut VecDeque<Message>, _data: ()) {
match message {
PreferencesMessage::Load { preferences } => {
if let Ok(deserialized_preferences) = serde_json::from_str::<PreferencesMessageHandler>(&preferences) {

14
editor/src/messages/tool/tool_message_handler.rs
View File

@@ -18,8 +18,8 @@ impl MessageHandler<ToolMessage, (&DocumentMessageHandler, u64, &InputPreprocess
fn process_message(
&mut self,
message: ToolMessage,
(document, document_id, input, persistent_data): (&DocumentMessageHandler, u64, &InputPreprocessorMessageHandler, &PersistentData),
responses: &mut VecDeque<Message>,
(document, document_id, input, persistent_data): (&DocumentMessageHandler, u64, &InputPreprocessorMessageHandler, &PersistentData),
) {
#[remain::sorted]
match message {
@@ -73,12 +73,12 @@ impl MessageHandler<ToolMessage, (&DocumentMessageHandler, u64, &InputPreprocess
let mut send_abort_to_tool = |tool_type, update_hints_and_cursor: bool| {
if let Some(tool) = tool_data.tools.get_mut(&tool_type) {
if let Some(tool_abort_message) = tool.event_to_message_map().tool_abort {
tool.process_message(tool_abort_message, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
tool.process_message(tool_abort_message, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
}
if update_hints_and_cursor {
tool.process_message(ToolMessage::UpdateHints, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
tool.process_message(ToolMessage::UpdateCursor, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
tool.process_message(ToolMessage::UpdateHints, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
tool.process_message(ToolMessage::UpdateCursor, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
}
}
};
@@ -134,10 +134,10 @@ impl MessageHandler<ToolMessage, (&DocumentMessageHandler, u64, &InputPreprocess
// Set initial hints and cursor
tool_data
.active_tool_mut()
.process_message(ToolMessage::UpdateHints, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
.process_message(ToolMessage::UpdateHints, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
tool_data
.active_tool_mut()
.process_message(ToolMessage::UpdateCursor, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
.process_message(ToolMessage::UpdateCursor, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
}
ToolMessage::RefreshToolOptions => {
let tool_data = &mut self.tool_state.tool_data;
@@ -196,7 +196,7 @@ impl MessageHandler<ToolMessage, (&DocumentMessageHandler, u64, &InputPreprocess
if let Some(tool) = tool_data.tools.get_mut(&tool_type) {
if tool_type == tool_data.active_tool_type {
tool.process_message(tool_message, (document, document_id, document_data, input, &persistent_data.font_cache), responses);
tool.process_message(tool_message, responses, (document, document_id, document_data, input, &persistent_data.font_cache));
}
}
}

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

@@ -59,8 +59,8 @@ impl ToolMetadata for ArtboardTool {
}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for ArtboardTool {
fn process_message(&mut self, message: ToolMessage, transition_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
self.fsm_state.process_event(message, &mut self.data, transition_data, &(), responses, false);
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
self.fsm_state.process_event(message, &mut self.data, tool_data, &(), responses, false);
}
advertise_actions!(ArtboardToolMessageDiscriminant;

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

@@ -50,8 +50,8 @@ impl ToolMetadata for EllipseTool {
impl PropertyHolder for EllipseTool {}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for EllipseTool {
fn process_message(&mut self, message: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
self.fsm_state.process_event(message, &mut self.data, data, &(), responses, true);
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
self.fsm_state.process_event(message, &mut self.data, tool_data, &(), responses, true);
}
fn actions(&self) -> ActionList {

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

@@ -44,8 +44,8 @@ impl ToolMetadata for EyedropperTool {
impl PropertyHolder for EyedropperTool {}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for EyedropperTool {
fn process_message(&mut self, message: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
self.fsm_state.process_event(message, &mut self.data, data, &(), responses, true);
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
self.fsm_state.process_event(message, &mut self.data, tool_data, &(), responses, true);
}
advertise_actions!(EyedropperToolMessageDiscriminant;

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

@@ -47,8 +47,8 @@ impl ToolMetadata for FillTool {
impl PropertyHolder for FillTool {}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for FillTool {
fn process_message(&mut self, message: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
self.fsm_state.process_event(message, &mut self.data, data, &(), responses, true);
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
self.fsm_state.process_event(message, &mut self.data, tool_data, &(), responses, true);
}
advertise_actions!(FillToolMessageDiscriminant;

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

@@ -83,7 +83,7 @@ impl PropertyHolder for FreehandTool {
}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for FreehandTool {
fn process_message(&mut self, message: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
if let ToolMessage::Freehand(FreehandToolMessage::UpdateOptions(action)) = message {
match action {
FreehandToolMessageOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,
@@ -91,7 +91,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for FreehandTool
return;
}
self.fsm_state.process_event(message, &mut self.data, data, &self.options, responses, true);
self.fsm_state.process_event(message, &mut self.data, tool_data, &self.options, responses, true);
}
fn actions(&self) -> ActionList {

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

@@ -77,7 +77,7 @@ impl ToolMetadata for GradientTool {
}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for GradientTool {
fn process_message(&mut self, message: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
if let ToolMessage::Gradient(GradientToolMessage::UpdateOptions(action)) = message {
match action {
GradientOptionsUpdate::Type(gradient_type) => {
@@ -91,7 +91,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for GradientTool
return;
}
self.fsm_state.process_event(message, &mut self.data, data, &self.options, responses, false);
self.fsm_state.process_event(message, &mut self.data, tool_data, &self.options, responses, false);
}
advertise_actions!(GradientToolMessageDiscriminant;

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

@@ -38,7 +38,7 @@ pub enum ImaginateToolMessage {
impl PropertyHolder for ImaginateTool {}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for ImaginateTool {
fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, true);
}

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

@@ -83,7 +83,7 @@ impl PropertyHolder for LineTool {
}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for LineTool {
fn process_message(&mut self, message: ToolMessage, transition_data: ToolActionHandlerData<'a>, messages: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, messages: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
if let ToolMessage::Line(LineToolMessage::UpdateOptions(action)) = message {
match action {
LineOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,
@@ -91,7 +91,7 @@ impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for LineTool {
return;
}
self.fsm_state.process_event(message, &mut self.tool_data, transition_data, &self.options, messages, true);
self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &self.options, messages, true);
}
fn actions(&self) -> ActionList {

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

@@ -51,7 +51,7 @@ impl ToolMetadata for NavigateTool {
impl PropertyHolder for NavigateTool {}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for NavigateTool {
fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, true);
}

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

@@ -37,7 +37,7 @@ pub enum NodeGraphFrameToolMessage {
impl PropertyHolder for NodeGraphFrameTool {}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for NodeGraphFrameTool {
fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, true);
}

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

@@ -61,7 +61,7 @@ impl ToolMetadata for PathTool {
impl PropertyHolder for PathTool {}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for PathTool {
fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, true);
}

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

@@ -98,7 +98,7 @@ impl PropertyHolder for PenTool {
}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for PenTool {
fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
if let ToolMessage::Pen(PenToolMessage::UpdateOptions(action)) = message {
match action {
PenOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,

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

@@ -38,7 +38,7 @@ pub enum RectangleToolMessage {
impl PropertyHolder for RectangleTool {}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for RectangleTool {
fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, true);
}

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

@@ -197,7 +197,7 @@ impl PropertyHolder for SelectTool {
}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for SelectTool {
fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
self.fsm_state.process_event(message, &mut self.tool_data, tool_data, &(), responses, false);
if self.tool_data.pivot.should_refresh_pivot_position() {

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

@@ -81,7 +81,7 @@ impl PropertyHolder for ShapeTool {
}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for ShapeTool {
fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
if let ToolMessage::Shape(ShapeToolMessage::UpdateOptions(action)) = message {
match action {
ShapeOptionsUpdate::Vertices(vertices) => self.options.vertices = vertices,

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

@@ -87,7 +87,7 @@ impl PropertyHolder for SplineTool {
}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for SplineTool {
fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
if let ToolMessage::Spline(SplineToolMessage::UpdateOptions(action)) = message {
match action {
SplineOptionsUpdate::LineWeight(line_weight) => self.options.line_weight = line_weight,

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

@@ -127,7 +127,7 @@ impl PropertyHolder for TextTool {
}
impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for TextTool {
fn process_message(&mut self, message: ToolMessage, tool_data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: ToolMessage, responses: &mut VecDeque<Message>, tool_data: ToolActionHandlerData<'a>) {
if let ToolMessage::Text(TextToolMessage::UpdateOptions(action)) = message {
match action {
TextOptionsUpdate::Font { family, style } => {

4
editor/src/messages/workspace/workspace_message_handler.rs
View File

@@ -5,9 +5,9 @@ pub struct WorkspaceMessageHandler {
node_graph_visible: bool,
}
impl MessageHandler<WorkspaceMessage, &InputPreprocessorMessageHandler> for WorkspaceMessageHandler {
impl MessageHandler<WorkspaceMessage, ()> for WorkspaceMessageHandler {
#[remain::check]
fn process_message(&mut self, message: WorkspaceMessage, _ipp: &InputPreprocessorMessageHandler, responses: &mut VecDeque<Message>) {
fn process_message(&mut self, message: WorkspaceMessage, responses: &mut VecDeque<Message>, _data: ()) {
use WorkspaceMessage::*;
#[remain::sorted]

2
editor/src/utility_traits.rs
View File

@@ -10,7 +10,7 @@ where
<M::Discriminant as TransitiveChild>::TopParent: TransitiveChild<Parent = <M::Discriminant as TransitiveChild>::TopParent, TopParent = <M::Discriminant as TransitiveChild>::TopParent> + AsMessage,
{
/// Return true if the Action is consumed.
fn process_message(&mut self, message: M, data: D, responses: &mut VecDeque<Message>);
fn process_message(&mut self, message: M, responses: &mut VecDeque<Message>, data: D);
fn actions(&self) -> ActionList;
}