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

Remove `remain` alphabetical sorting enforcement macros (#1647) 

remove `remain`

Co-authored-by: 0HyperCube <78500760+0HyperCube@users.noreply.github.com>
This commit is contained in:
Karthik Prakash 2024-03-06 22:13:51 +05:30 committed by GitHub
parent a47fff905e
commit 0c60fd95fa
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
53 changed files with 21 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Cargo.lock generated
View File

@ -2453,7 +2453,6 @@ dependencies = [
"log", "log",
"num_enum 0.6.1", "num_enum 0.6.1",
"once_cell", "once_cell",
"remain",
"serde", "serde",
"serde_json", "serde_json",
"specta", "specta",
@ -4755,17 +4754,6 @@ version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f" checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
[[package]]
name = "remain"
version = "0.2.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ad9f2390298a947ee0aa6073d440e221c0726188cfbcdf9604addb6ee393eb4a"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.52",
]
[[package]] [[package]]
name = "renderdoc-sys" name = "renderdoc-sys"
version = "1.1.0" version = "1.1.0"

1
Cargo.toml
View File

@ -44,7 +44,6 @@ reqwest = { version = "0.11", features = ["rustls", "rustls-tls", "json"] }
futures = "0.3" futures = "0.3"
log = { version = "0.4" } log = { version = "0.4" }
bitflags = { version = "2.4", features = ["serde"] } bitflags = { version = "2.4", features = ["serde"] }
remain = "0.2.2"
derivative = "2.2.0" derivative = "2.2.0"
tempfile = "3" tempfile = "3"
thiserror = "1.0" thiserror = "1.0"

1
editor/Cargo.toml
View File

@ -34,7 +34,6 @@ serde_json = { workspace = true }
graphite-proc-macros = { path = "../proc-macros" } graphite-proc-macros = { path = "../proc-macros" }
bezier-rs = { workspace = true } bezier-rs = { workspace = true }
glam = { workspace = true, features = ["serde", "debug-glam-assert"] } glam = { workspace = true, features = ["serde", "debug-glam-assert"] }
remain = { workspace = true }
derivative = { workspace = true } derivative = { workspace = true }
specta.workspace = true specta.workspace = true
image = { workspace = true, features = ["bmp", "png"] } image = { workspace = true, features = ["bmp", "png"] }

5
editor/src/dispatcher.rs
View File

@ -12,7 +12,6 @@ pub struct Dispatcher {
pub message_handlers: DispatcherMessageHandlers, pub message_handlers: DispatcherMessageHandlers,
} }
#[remain::sorted]
#[derive(Debug, Default)] #[derive(Debug, Default)]
pub struct DispatcherMessageHandlers { pub struct DispatcherMessageHandlers {
broadcast_message_handler: BroadcastMessageHandler, broadcast_message_handler: BroadcastMessageHandler,
@ -57,7 +56,6 @@ impl Dispatcher {
} }
} }
#[remain::check]
pub fn handle_message<T: Into<Message>>(&mut self, message: T) { pub fn handle_message<T: Into<Message>>(&mut self, message: T) {
use Message::*; use Message::*;
@ -86,11 +84,8 @@ impl Dispatcher {
let mut queue = VecDeque::new(); let mut queue = VecDeque::new();
// Process the action by forwarding it to the relevant message handler, or saving the FrontendMessage to be sent to the frontend // Process the action by forwarding it to the relevant message handler, or saving the FrontendMessage to be sent to the frontend
#[remain::sorted]
match message { match message {
#[remain::unsorted]
NoOp => {} NoOp => {}
#[remain::unsorted]
Init => { Init => {
// Load persistent data from the browser database // Load persistent data from the browser database
queue.add(FrontendMessage::TriggerLoadAutoSaveDocuments); queue.add(FrontendMessage::TriggerLoadAutoSaveDocuments);

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

@ -2,12 +2,10 @@ use crate::messages::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, Broadcast)] #[impl_message(Message, Broadcast)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
pub enum BroadcastMessage { pub enum BroadcastMessage {
// Sub-messages // Sub-messages
#[remain::unsorted]
#[child] #[child]
TriggerEvent(BroadcastEvent), TriggerEvent(BroadcastEvent),

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

@ -6,12 +6,9 @@ pub struct BroadcastMessageHandler {
} }
impl MessageHandler<BroadcastMessage, ()> for BroadcastMessageHandler { impl MessageHandler<BroadcastMessage, ()> for BroadcastMessageHandler {
#[remain::check]
fn process_message(&mut self, message: BroadcastMessage, responses: &mut VecDeque<Message>, _data: ()) { fn process_message(&mut self, message: BroadcastMessage, responses: &mut VecDeque<Message>, _data: ()) {
#[remain::sorted]
match message { match message {
// Sub-messages // Sub-messages
#[remain::unsorted]
BroadcastMessage::TriggerEvent(event) => { BroadcastMessage::TriggerEvent(event) => {
for message in self.listeners.entry(event).or_default() { for message in self.listeners.entry(event).or_default() {
responses.add_front(message.clone()) responses.add_front(message.clone())

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

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

4
editor/src/messages/dialog/dialog_message.rs
View File

@ -2,18 +2,14 @@ use crate::messages::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, Dialog)] #[impl_message(Message, Dialog)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
pub enum DialogMessage { pub enum DialogMessage {
// Sub-messages // Sub-messages
#[remain::unsorted]
#[child] #[child]
ExportDialog(ExportDialogMessage), ExportDialog(ExportDialogMessage),
#[remain::unsorted]
#[child] #[child]
NewDocumentDialog(NewDocumentDialogMessage), NewDocumentDialog(NewDocumentDialogMessage),
#[remain::unsorted]
#[child] #[child]
PreferencesDialog(PreferencesDialogMessage), PreferencesDialog(PreferencesDialogMessage),

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

@ -17,15 +17,10 @@ pub struct DialogData<'a> {
} }
impl MessageHandler<DialogMessage, DialogData<'_>> for DialogMessageHandler { impl MessageHandler<DialogMessage, DialogData<'_>> for DialogMessageHandler {
#[remain::check]
fn process_message(&mut self, message: DialogMessage, responses: &mut VecDeque<Message>, DialogData { portfolio, preferences }: DialogData) { fn process_message(&mut self, message: DialogMessage, responses: &mut VecDeque<Message>, DialogData { portfolio, preferences }: DialogData) {
#[remain::sorted]
match message { match message {
#[remain::unsorted]
DialogMessage::ExportDialog(message) => self.export_dialog.process_message(message, responses, portfolio), DialogMessage::ExportDialog(message) => self.export_dialog.process_message(message, responses, portfolio),
#[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, responses, preferences), DialogMessage::PreferencesDialog(message) => self.preferences_dialog.process_message(message, responses, preferences),
DialogMessage::CloseAllDocumentsWithConfirmation => { DialogMessage::CloseAllDocumentsWithConfirmation => {

1
editor/src/messages/frontend/frontend_message.rs
View File

@ -11,7 +11,6 @@ use graphene_core::text::Font;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, Frontend)] #[impl_message(Message, Frontend)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum FrontendMessage { pub enum FrontendMessage {

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

@ -4,7 +4,6 @@ use crate::messages::prelude::*;
pub struct GlobalsMessageHandler {} pub struct GlobalsMessageHandler {}
impl MessageHandler<GlobalsMessage, ()> for GlobalsMessageHandler { impl MessageHandler<GlobalsMessage, ()> for GlobalsMessageHandler {
#[remain::check]
fn process_message(&mut self, message: GlobalsMessage, _responses: &mut VecDeque<Message>, _data: ()) { fn process_message(&mut self, message: GlobalsMessage, _responses: &mut VecDeque<Message>, _data: ()) {
match message { match message {
GlobalsMessage::SetPlatform { platform } => { GlobalsMessage::SetPlatform { platform } => {

6
editor/src/messages/input_mapper/input_mapper_message.rs
View File

@ -3,24 +3,18 @@ use crate::messages::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, KeyMappingMessage, Lookup)] #[impl_message(Message, KeyMappingMessage, Lookup)]
#[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize)] #[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize)]
pub enum InputMapperMessage { pub enum InputMapperMessage {
// Sub-messages // Sub-messages
#[remain::unsorted]
#[child] #[child]
KeyDown(Key), KeyDown(Key),
#[remain::unsorted]
#[child] #[child]
KeyUp(Key), KeyUp(Key),
#[remain::unsorted]
#[child] #[child]
KeyDownNoRepeat(Key), KeyDownNoRepeat(Key),
#[remain::unsorted]
#[child] #[child]
KeyUpNoRepeat(Key), KeyUpNoRepeat(Key),
#[remain::unsorted]
#[child] #[child]
DoubleClick(MouseButton), DoubleClick(MouseButton),

3
editor/src/messages/input_mapper/key_mapping/key_mapping_message.rs
View File

@ -2,7 +2,6 @@ use crate::messages::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, KeyMapping)] #[impl_message(Message, KeyMapping)]
#[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize)] #[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize)]
pub enum KeyMappingMessage { pub enum KeyMappingMessage {
@ -12,11 +11,9 @@ pub enum KeyMappingMessage {
ModifyMapping(MappingVariant), ModifyMapping(MappingVariant),
} }
#[remain::sorted]
#[impl_message(Message, KeyMappingMessage, ModifyMapping)] #[impl_message(Message, KeyMappingMessage, ModifyMapping)]
#[derive(PartialEq, Eq, Clone, Debug, Default, Hash, Serialize, Deserialize)] #[derive(PartialEq, Eq, Clone, Debug, Default, Hash, Serialize, Deserialize)]
pub enum MappingVariant { pub enum MappingVariant {
#[remain::unsorted]
#[default] #[default]
Default, Default,

1
editor/src/messages/input_preprocessor/input_preprocessor_message.rs
View File

@ -4,7 +4,6 @@ use crate::messages::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, InputPreprocessor)] #[impl_message(Message, InputPreprocessor)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
pub enum InputPreprocessorMessage { pub enum InputPreprocessorMessage {

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

@ -13,9 +13,7 @@ pub struct InputPreprocessorMessageHandler {
} }
impl MessageHandler<InputPreprocessorMessage, KeyboardPlatformLayout> for InputPreprocessorMessageHandler { impl MessageHandler<InputPreprocessorMessage, KeyboardPlatformLayout> for InputPreprocessorMessageHandler {
#[remain::check]
fn process_message(&mut self, message: InputPreprocessorMessage, responses: &mut VecDeque<Message>, keyboard_platform: KeyboardPlatformLayout) { fn process_message(&mut self, message: InputPreprocessorMessage, responses: &mut VecDeque<Message>, keyboard_platform: KeyboardPlatformLayout) {
#[remain::sorted]
match message { match message {
InputPreprocessorMessage::BoundsOfViewports { bounds_of_viewports } => { InputPreprocessorMessage::BoundsOfViewports { bounds_of_viewports } => {
assert_eq!(bounds_of_viewports.len(), 1, "Only one viewport is currently supported"); assert_eq!(bounds_of_viewports.len(), 1, "Only one viewport is currently supported");

1
editor/src/messages/layout/layout_message.rs
View File

@ -3,7 +3,6 @@ use crate::messages::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, Layout)] #[impl_message(Message, Layout)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
pub enum LayoutMessage { pub enum LayoutMessage {

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

@ -271,10 +271,8 @@ impl LayoutMessageHandler {
} }
impl<F: Fn(&MessageDiscriminant) -> Vec<KeysGroup>> MessageHandler<LayoutMessage, F> for LayoutMessageHandler { impl<F: Fn(&MessageDiscriminant) -> Vec<KeysGroup>> MessageHandler<LayoutMessage, F> for LayoutMessageHandler {
#[remain::check]
fn process_message(&mut self, message: LayoutMessage, responses: &mut std::collections::VecDeque<Message>, action_input_mapping: F) { fn process_message(&mut self, message: LayoutMessage, responses: &mut std::collections::VecDeque<Message>, action_input_mapping: F) {
use LayoutMessage::*; use LayoutMessage::*;
#[remain::sorted]
match message { match message {
ResendActiveWidget { layout_target, widget_id } => { ResendActiveWidget { layout_target, widget_id } => {
// Find the updated diff based on the specified layout target // Find the updated diff based on the specified layout target
@ -345,13 +343,11 @@ impl LayoutMessageHandler {
} }
/// Send a diff to the frontend based on the layout target. /// Send a diff to the frontend based on the layout target.
#[remain::check]
fn send_diff(&self, mut diff: Vec<WidgetDiff>, layout_target: LayoutTarget, responses: &mut VecDeque<Message>, action_input_mapping: &impl Fn(&MessageDiscriminant) -> Vec<KeysGroup>) { fn send_diff(&self, mut diff: Vec<WidgetDiff>, layout_target: LayoutTarget, responses: &mut VecDeque<Message>, action_input_mapping: &impl Fn(&MessageDiscriminant) -> Vec<KeysGroup>) {
diff.iter_mut().for_each(|diff| diff.new_value.apply_keyboard_shortcut(action_input_mapping)); diff.iter_mut().for_each(|diff| diff.new_value.apply_keyboard_shortcut(action_input_mapping));
trace!("{layout_target:?} diff {diff:#?}"); trace!("{layout_target:?} diff {diff:#?}");
#[remain::sorted]
let message = match layout_target { let message = match layout_target {
LayoutTarget::DialogButtons => FrontendMessage::UpdateDialogButtons { layout_target, diff }, LayoutTarget::DialogButtons => FrontendMessage::UpdateDialogButtons { layout_target, diff },
LayoutTarget::DialogColumn1 => FrontendMessage::UpdateDialogColumn1 { layout_target, diff }, LayoutTarget::DialogColumn1 => FrontendMessage::UpdateDialogColumn1 { layout_target, diff },
@ -367,7 +363,6 @@ impl LayoutMessageHandler {
LayoutTarget::ToolShelf => FrontendMessage::UpdateToolShelfLayout { layout_target, diff }, LayoutTarget::ToolShelf => FrontendMessage::UpdateToolShelfLayout { layout_target, diff },
LayoutTarget::WorkingColors => FrontendMessage::UpdateWorkingColorsLayout { layout_target, diff }, LayoutTarget::WorkingColors => FrontendMessage::UpdateWorkingColorsLayout { layout_target, diff },
#[remain::unsorted]
LayoutTarget::LayoutTargetLength => panic!("`LayoutTargetLength` is not a valid Layout Target and is used for array indexing"), LayoutTarget::LayoutTargetLength => panic!("`LayoutTargetLength` is not a valid Layout Target and is used for array indexing"),
}; };
responses.add(message); responses.add(message);

4
editor/src/messages/layout/utility_types/layout_widget.rs
View File

@ -20,7 +20,6 @@ impl core::fmt::Display for WidgetId {
} }
} }
#[remain::sorted]
#[derive(PartialEq, Clone, Debug, Hash, Eq, Copy, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Hash, Eq, Copy, Serialize, Deserialize, specta::Type)]
#[repr(u8)] #[repr(u8)]
pub enum LayoutTarget { pub enum LayoutTarget {
@ -53,7 +52,6 @@ pub enum LayoutTarget {
// KEEP THIS ENUM LAST // KEEP THIS ENUM LAST
// This is a marker that is used to define an array that is used to hold widgets // This is a marker that is used to define an array that is used to hold widgets
#[remain::unsorted]
LayoutTargetLength, LayoutTargetLength,
} }
@ -292,7 +290,6 @@ impl<'a> Iterator for WidgetIterMut<'a> {
pub type SubLayout = Vec<LayoutGroup>; pub type SubLayout = Vec<LayoutGroup>;
#[remain::sorted]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, specta::Type)] #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, specta::Type)]
pub enum LayoutGroup { pub enum LayoutGroup {
#[serde(rename = "column")] #[serde(rename = "column")]
@ -475,7 +472,6 @@ impl<T> Default for WidgetCallback<T> {
} }
} }
#[remain::sorted]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, specta::Type)] #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, specta::Type)]
pub enum Widget { pub enum Widget {
BreadcrumbTrailButtons(BreadcrumbTrailButtons), BreadcrumbTrailButtons(BreadcrumbTrailButtons),

3
editor/src/messages/message.rs
View File

@ -4,13 +4,10 @@ use graphite_proc_macros::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message] #[impl_message]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Message { pub enum Message {
#[remain::unsorted]
NoOp, NoOp,
#[remain::unsorted]
Init, Init,
#[child] #[child]

6
editor/src/messages/portfolio/document/document_message.rs
View File

@ -12,24 +12,18 @@ use graphene_core::Color;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, PortfolioMessage, Document)] #[impl_message(Message, PortfolioMessage, Document)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
pub enum DocumentMessage { pub enum DocumentMessage {
// Sub-messages // Sub-messages
#[remain::unsorted]
#[child] #[child]
Navigation(NavigationMessage), Navigation(NavigationMessage),
#[remain::unsorted]
#[child] #[child]
Overlays(OverlaysMessage), Overlays(OverlaysMessage),
#[remain::unsorted]
#[child] #[child]
PropertiesPanel(PropertiesPanelMessage), PropertiesPanel(PropertiesPanelMessage),
#[remain::unsorted]
#[child] #[child]
NodeGraph(NodeGraphMessage), NodeGraph(NodeGraphMessage),
#[remain::unsorted]
#[child] #[child]
GraphOperation(GraphOperationMessage), GraphOperation(GraphOperationMessage),

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

@ -235,7 +235,6 @@ pub struct DocumentInputs<'a> {
} }
impl MessageHandler<DocumentMessage, DocumentInputs<'_>> for DocumentMessageHandler { impl MessageHandler<DocumentMessage, DocumentInputs<'_>> for DocumentMessageHandler {
#[remain::check]
fn process_message(&mut self, message: DocumentMessage, responses: &mut VecDeque<Message>, document_inputs: DocumentInputs) { fn process_message(&mut self, message: DocumentMessage, responses: &mut VecDeque<Message>, document_inputs: DocumentInputs) {
let DocumentInputs { let DocumentInputs {
document_id, document_id,
@ -245,10 +244,8 @@ impl MessageHandler<DocumentMessage, DocumentInputs<'_>> for DocumentMessageHand
} = document_inputs; } = document_inputs;
use DocumentMessage::*; use DocumentMessage::*;
#[remain::sorted]
match message { match message {
// Sub-messages // Sub-messages
#[remain::unsorted]
Navigation(message) => { Navigation(message) => {
let document_bounds = self.metadata().document_bounds_viewport_space(); let document_bounds = self.metadata().document_bounds_viewport_space();
self.navigation_handler.process_message( self.navigation_handler.process_message(
@ -257,11 +254,9 @@ impl MessageHandler<DocumentMessage, DocumentInputs<'_>> for DocumentMessageHand
(&self.metadata, document_bounds, ipp, self.selected_visible_layers_bounding_box_viewport(), &mut self.navigation), (&self.metadata, document_bounds, ipp, self.selected_visible_layers_bounding_box_viewport(), &mut self.navigation),
); );
} }
#[remain::unsorted]
Overlays(message) => { Overlays(message) => {
self.overlays_message_handler.process_message(message, responses, (self.overlays_visible, ipp)); self.overlays_message_handler.process_message(message, responses, (self.overlays_visible, ipp));
} }
#[remain::unsorted]
PropertiesPanel(message) => { PropertiesPanel(message) => {
let properties_panel_message_handler_data = PropertiesPanelMessageHandlerData { let properties_panel_message_handler_data = PropertiesPanelMessageHandlerData {
node_graph_message_handler: &self.node_graph_handler, node_graph_message_handler: &self.node_graph_handler,
@ -274,7 +269,6 @@ impl MessageHandler<DocumentMessage, DocumentInputs<'_>> for DocumentMessageHand
self.properties_panel_message_handler self.properties_panel_message_handler
.process_message(message, responses, (persistent_data, properties_panel_message_handler_data)); .process_message(message, responses, (persistent_data, properties_panel_message_handler_data));
} }
#[remain::unsorted]
NodeGraph(message) => { NodeGraph(message) => {
self.node_graph_handler.process_message( self.node_graph_handler.process_message(
message, message,
@ -291,7 +285,6 @@ impl MessageHandler<DocumentMessage, DocumentInputs<'_>> for DocumentMessageHand
}, },
); );
} }
#[remain::unsorted]
GraphOperation(message) => GraphOperationMessageHandler.process_message( GraphOperation(message) => GraphOperationMessageHandler.process_message(
message, message,
responses, responses,

1
editor/src/messages/portfolio/document/navigation/navigation_message.rs
View File

@ -4,7 +4,6 @@ use crate::messages::prelude::*;
use glam::DVec2; use glam::DVec2;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, DocumentMessage, Navigation)] #[impl_message(Message, DocumentMessage, Navigation)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
pub enum NavigationMessage { pub enum NavigationMessage {

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

@ -49,7 +49,6 @@ impl Default for NavigationMessageHandler {
} }
impl MessageHandler<NavigationMessage, (&DocumentMetadata, Option<[DVec2; 2]>, &InputPreprocessorMessageHandler, Option<[DVec2; 2]>, &mut PTZ)> for NavigationMessageHandler { impl MessageHandler<NavigationMessage, (&DocumentMetadata, Option<[DVec2; 2]>, &InputPreprocessorMessageHandler, Option<[DVec2; 2]>, &mut PTZ)> for NavigationMessageHandler {
#[remain::check]
fn process_message( fn process_message(
&mut self, &mut self,
message: NavigationMessage, message: NavigationMessage,
@ -60,7 +59,6 @@ impl MessageHandler<NavigationMessage, (&DocumentMetadata, Option<[DVec2; 2]>, &
let old_zoom = ptz.zoom; let old_zoom = ptz.zoom;
#[remain::sorted]
match message { match message {
DecreaseCanvasZoom { center_on_mouse } => { DecreaseCanvasZoom { center_on_mouse } => {
let new_scale = *VIEWPORT_ZOOM_LEVELS.iter().rev().find(|scale| **scale < ptz.zoom).unwrap_or(&ptz.zoom); let new_scale = *VIEWPORT_ZOOM_LEVELS.iter().rev().find(|scale| **scale < ptz.zoom).unwrap_or(&ptz.zoom);

1
editor/src/messages/portfolio/document/properties_panel/properties_panel_message.rs
View File

@ -2,7 +2,6 @@ use crate::messages::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, DocumentMessage, PropertiesPanel)] #[impl_message(Message, DocumentMessage, PropertiesPanel)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
pub enum PropertiesPanelMessage { pub enum PropertiesPanelMessage {

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

@ -8,7 +8,6 @@ use crate::messages::prelude::*;
pub struct PropertiesPanelMessageHandler; pub struct PropertiesPanelMessageHandler;
impl<'a> MessageHandler<PropertiesPanelMessage, (&PersistentData, PropertiesPanelMessageHandlerData<'a>)> for PropertiesPanelMessageHandler { impl<'a> MessageHandler<PropertiesPanelMessage, (&PersistentData, PropertiesPanelMessageHandlerData<'a>)> for PropertiesPanelMessageHandler {
#[remain::check]
fn process_message(&mut self, message: PropertiesPanelMessage, responses: &mut VecDeque<Message>, (persistent_data, data): (&PersistentData, PropertiesPanelMessageHandlerData)) { fn process_message(&mut self, message: PropertiesPanelMessage, responses: &mut VecDeque<Message>, (persistent_data, data): (&PersistentData, PropertiesPanelMessageHandlerData)) {
use PropertiesPanelMessage::*; use PropertiesPanelMessage::*;

1
editor/src/messages/portfolio/menu_bar/menu_bar_message.rs
View File

@ -2,7 +2,6 @@ use crate::messages::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, PortfolioMessage, MenuBar)] #[impl_message(Message, PortfolioMessage, MenuBar)]
#[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize)] #[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize)]
pub enum MenuBarMessage { pub enum MenuBarMessage {

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

@ -10,14 +10,12 @@ pub struct MenuBarMessageHandler {
} }
impl MessageHandler<MenuBarMessage, (bool, bool)> for MenuBarMessageHandler { impl MessageHandler<MenuBarMessage, (bool, bool)> for MenuBarMessageHandler {
#[remain::check]
fn process_message(&mut self, message: MenuBarMessage, responses: &mut VecDeque<Message>, (has_active_document, rulers_visible): (bool, bool)) { fn process_message(&mut self, message: MenuBarMessage, responses: &mut VecDeque<Message>, (has_active_document, rulers_visible): (bool, bool)) {
use MenuBarMessage::*; use MenuBarMessage::*;
self.has_active_document = has_active_document; self.has_active_document = has_active_document;
self.rulers_visible = rulers_visible; self.rulers_visible = rulers_visible;
#[remain::sorted]
match message { match message {
SendLayout => self.send_layout(responses, LayoutTarget::MenuBar), SendLayout => self.send_layout(responses, LayoutTarget::MenuBar),
} }

4
editor/src/messages/portfolio/portfolio_message.rs
View File

@ -7,20 +7,16 @@ use graphene_core::text::Font;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, Portfolio)] #[impl_message(Message, Portfolio)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
pub enum PortfolioMessage { pub enum PortfolioMessage {
// Sub-messages // Sub-messages
#[remain::unsorted]
#[child] #[child]
MenuBar(MenuBarMessage), MenuBar(MenuBarMessage),
#[remain::unsorted]
#[child] #[child]
Document(DocumentMessage), Document(DocumentMessage),
// Messages // Messages
#[remain::unsorted]
DocumentPassMessage { DocumentPassMessage {
document_id: DocumentId, document_id: DocumentId,
message: DocumentMessage, message: DocumentMessage,

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

@ -27,12 +27,9 @@ pub struct PortfolioMessageHandler {
} }
impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &PreferencesMessageHandler)> for PortfolioMessageHandler { impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &PreferencesMessageHandler)> for PortfolioMessageHandler {
#[remain::check]
fn process_message(&mut self, message: PortfolioMessage, responses: &mut VecDeque<Message>, (ipp, preferences): (&InputPreprocessorMessageHandler, &PreferencesMessageHandler)) { fn process_message(&mut self, message: PortfolioMessage, responses: &mut VecDeque<Message>, (ipp, preferences): (&InputPreprocessorMessageHandler, &PreferencesMessageHandler)) {
#[remain::sorted]
match message { match message {
// Sub-messages // Sub-messages
#[remain::unsorted]
PortfolioMessage::MenuBar(message) => { PortfolioMessage::MenuBar(message) => {
let mut has_active_document = false; let mut has_active_document = false;
let mut rulers_visible = false; let mut rulers_visible = false;
@ -44,7 +41,6 @@ impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &Prefer
self.menu_bar_message_handler.process_message(message, responses, (has_active_document, rulers_visible)); self.menu_bar_message_handler.process_message(message, responses, (has_active_document, rulers_visible));
} }
#[remain::unsorted]
PortfolioMessage::Document(message) => { PortfolioMessage::Document(message) => {
if let Some(document_id) = self.active_document_id { if let Some(document_id) = self.active_document_id {
if let Some(document) = self.documents.get_mut(&document_id) { if let Some(document) = self.documents.get_mut(&document_id) {
@ -60,7 +56,6 @@ impl MessageHandler<PortfolioMessage, (&InputPreprocessorMessageHandler, &Prefer
} }
// Messages // Messages
#[remain::unsorted]
PortfolioMessage::DocumentPassMessage { document_id, message } => { PortfolioMessage::DocumentPassMessage { document_id, message } => {
if let Some(document) = self.documents.get_mut(&document_id) { if let Some(document) = self.documents.get_mut(&document_id) {
let document_inputs = DocumentInputs { let document_inputs = DocumentInputs {

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

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

51
editor/src/messages/tool/tool_message.rs
View File

@ -5,120 +5,79 @@ use graphene_core::raster::color::Color;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, Tool)] #[impl_message(Message, Tool)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
pub enum ToolMessage { pub enum ToolMessage {
// Sub-messages // Sub-messages
#[remain::unsorted]
#[child] #[child]
TransformLayer(TransformLayerMessage), TransformLayer(TransformLayerMessage),
#[remain::unsorted]
#[child] #[child]
Select(SelectToolMessage), Select(SelectToolMessage),
#[remain::unsorted]
#[child] #[child]
Artboard(ArtboardToolMessage), Artboard(ArtboardToolMessage),
#[remain::unsorted]
#[child] #[child]
Navigate(NavigateToolMessage), Navigate(NavigateToolMessage),
#[remain::unsorted]
#[child] #[child]
Eyedropper(EyedropperToolMessage), Eyedropper(EyedropperToolMessage),
#[remain::unsorted]
#[child] #[child]
Fill(FillToolMessage), Fill(FillToolMessage),
#[remain::unsorted]
#[child] #[child]
Gradient(GradientToolMessage), Gradient(GradientToolMessage),
#[remain::unsorted]
#[child] #[child]
Path(PathToolMessage), Path(PathToolMessage),
#[remain::unsorted]
#[child] #[child]
Pen(PenToolMessage), Pen(PenToolMessage),
#[remain::unsorted]
#[child] #[child]
Freehand(FreehandToolMessage), Freehand(FreehandToolMessage),
#[remain::unsorted]
#[child] #[child]
Spline(SplineToolMessage), Spline(SplineToolMessage),
#[remain::unsorted]
#[child] #[child]
Line(LineToolMessage), Line(LineToolMessage),
#[remain::unsorted]
#[child] #[child]
Rectangle(RectangleToolMessage), Rectangle(RectangleToolMessage),
#[remain::unsorted]
#[child] #[child]
Ellipse(EllipseToolMessage), Ellipse(EllipseToolMessage),
#[remain::unsorted]
#[child] #[child]
Polygon(PolygonToolMessage), Polygon(PolygonToolMessage),
#[remain::unsorted]
#[child] #[child]
Text(TextToolMessage), Text(TextToolMessage),
#[remain::unsorted]
#[child] #[child]
Brush(BrushToolMessage), Brush(BrushToolMessage),
// #[remain::unsorted] // // #[child]
// #[child]
// Heal(HealToolMessage), // Heal(HealToolMessage),
// #[remain::unsorted] // // #[child]
// #[child]
// Clone(CloneToolMessage), // Clone(CloneToolMessage),
// #[remain::unsorted] // // #[child]
// #[child]
// Patch(PatchToolMessage), // Patch(PatchToolMessage),
// #[remain::unsorted] // // #[child]
// #[child]
// Relight(RelightToolMessage), // Relight(RelightToolMessage),
// #[remain::unsorted] // // #[child]
// #[child]
// Detail(DetailToolMessage), // Detail(DetailToolMessage),
#[remain::unsorted]
#[child] #[child]
Imaginate(ImaginateToolMessage), Imaginate(ImaginateToolMessage),
// Messages // Messages
#[remain::unsorted]
ActivateToolSelect, ActivateToolSelect,
#[remain::unsorted]
ActivateToolArtboard, ActivateToolArtboard,
#[remain::unsorted]
ActivateToolNavigate, ActivateToolNavigate,
#[remain::unsorted]
ActivateToolEyedropper, ActivateToolEyedropper,
#[remain::unsorted]
ActivateToolText, ActivateToolText,
#[remain::unsorted]
ActivateToolFill, ActivateToolFill,
#[remain::unsorted]
ActivateToolGradient, ActivateToolGradient,
#[remain::unsorted]
ActivateToolPath, ActivateToolPath,
#[remain::unsorted]
ActivateToolPen, ActivateToolPen,
#[remain::unsorted]
ActivateToolFreehand, ActivateToolFreehand,
#[remain::unsorted]
ActivateToolSpline, ActivateToolSpline,
#[remain::unsorted]
ActivateToolLine, ActivateToolLine,
#[remain::unsorted]
ActivateToolRectangle, ActivateToolRectangle,
#[remain::unsorted]
ActivateToolEllipse, ActivateToolEllipse,
#[remain::unsorted]
ActivateToolPolygon, ActivateToolPolygon,
#[remain::unsorted]
ActivateToolBrush, ActivateToolBrush,
#[remain::unsorted]
ActivateToolImaginate, ActivateToolImaginate,
ActivateTool { ActivateTool {

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

@ -17,7 +17,6 @@ pub struct ToolMessageHandler {
} }
impl MessageHandler<ToolMessage, (&DocumentMessageHandler, DocumentId, &InputPreprocessorMessageHandler, &PersistentData, &NodeGraphExecutor)> for ToolMessageHandler { impl MessageHandler<ToolMessage, (&DocumentMessageHandler, DocumentId, &InputPreprocessorMessageHandler, &PersistentData, &NodeGraphExecutor)> for ToolMessageHandler {
#[remain::check]
fn process_message( fn process_message(
&mut self, &mut self,
message: ToolMessage, message: ToolMessage,
@ -26,49 +25,30 @@ impl MessageHandler<ToolMessage, (&DocumentMessageHandler, DocumentId, &InputPre
) { ) {
let font_cache = &persistent_data.font_cache; let font_cache = &persistent_data.font_cache;
#[remain::sorted]
match message { match message {
// Messages // Messages
#[remain::unsorted]
ToolMessage::TransformLayer(message) => self ToolMessage::TransformLayer(message) => self
.transform_layer_handler .transform_layer_handler
.process_message(message, responses, (document, input, &self.tool_state.tool_data, &mut self.shape_editor)), .process_message(message, responses, (document, input, &self.tool_state.tool_data, &mut self.shape_editor)),
#[remain::unsorted]
ToolMessage::ActivateToolSelect => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Select }), ToolMessage::ActivateToolSelect => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Select }),
#[remain::unsorted]
ToolMessage::ActivateToolArtboard => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Artboard }), ToolMessage::ActivateToolArtboard => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Artboard }),
#[remain::unsorted]
ToolMessage::ActivateToolNavigate => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Navigate }), ToolMessage::ActivateToolNavigate => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Navigate }),
#[remain::unsorted]
ToolMessage::ActivateToolEyedropper => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Eyedropper }), ToolMessage::ActivateToolEyedropper => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Eyedropper }),
#[remain::unsorted]
ToolMessage::ActivateToolText => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Text }), ToolMessage::ActivateToolText => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Text }),
#[remain::unsorted]
ToolMessage::ActivateToolFill => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Fill }), ToolMessage::ActivateToolFill => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Fill }),
#[remain::unsorted]
ToolMessage::ActivateToolGradient => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Gradient }), ToolMessage::ActivateToolGradient => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Gradient }),
#[remain::unsorted]
ToolMessage::ActivateToolPath => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Path }), ToolMessage::ActivateToolPath => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Path }),
#[remain::unsorted]
ToolMessage::ActivateToolPen => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Pen }), ToolMessage::ActivateToolPen => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Pen }),
#[remain::unsorted]
ToolMessage::ActivateToolFreehand => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Freehand }), ToolMessage::ActivateToolFreehand => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Freehand }),
#[remain::unsorted]
ToolMessage::ActivateToolSpline => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Spline }), ToolMessage::ActivateToolSpline => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Spline }),
#[remain::unsorted]
ToolMessage::ActivateToolLine => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Line }), ToolMessage::ActivateToolLine => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Line }),
#[remain::unsorted]
ToolMessage::ActivateToolRectangle => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Rectangle }), ToolMessage::ActivateToolRectangle => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Rectangle }),
#[remain::unsorted]
ToolMessage::ActivateToolEllipse => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Ellipse }), ToolMessage::ActivateToolEllipse => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Ellipse }),
#[remain::unsorted]
ToolMessage::ActivateToolPolygon => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Polygon }), ToolMessage::ActivateToolPolygon => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Polygon }),
#[remain::unsorted]
ToolMessage::ActivateToolBrush => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Brush }), ToolMessage::ActivateToolBrush => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Brush }),
#[remain::unsorted]
ToolMessage::ActivateToolImaginate => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Imaginate }), ToolMessage::ActivateToolImaginate => responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Imaginate }),
ToolMessage::ActivateTool { tool_type } => { ToolMessage::ActivateTool { tool_type } => {
@ -241,7 +221,6 @@ impl MessageHandler<ToolMessage, (&DocumentMessageHandler, DocumentId, &InputPre
} }
// Sub-messages // Sub-messages
#[remain::unsorted]
tool_message => { tool_message => {
let tool_type = match &tool_message { let tool_type = match &tool_message {
ToolMessage::UpdateCursor | ToolMessage::UpdateHints => self.tool_state.tool_data.active_tool_type, ToolMessage::UpdateCursor | ToolMessage::UpdateHints => self.tool_state.tool_data.active_tool_type,

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

@ -15,27 +15,18 @@ pub struct ArtboardTool {
data: ArtboardToolData, data: ArtboardToolData,
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Artboard)] #[impl_message(Message, ToolMessage, Artboard)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum ArtboardToolMessage { pub enum ArtboardToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
// Tool-specific messages // Tool-specific messages
DeleteSelected, DeleteSelected,
NudgeSelected { NudgeSelected { delta_x: f64, delta_y: f64 },
delta_x: f64,
delta_y: f64,
},
PointerDown, PointerDown,
PointerMove { PointerMove { constrain_axis_or_aspect: Key, center: Key },
constrain_axis_or_aspect: Key,
center: Key,
},
PointerUp, PointerUp,
} }

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

@ -51,14 +51,11 @@ impl Default for BrushOptions {
} }
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Brush)] #[impl_message(Message, ToolMessage, Brush)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum BrushToolMessage { pub enum BrushToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
WorkingColorChanged, WorkingColorChanged,
// Tool-specific messages // Tool-specific messages
@ -68,7 +65,6 @@ pub enum BrushToolMessage {
UpdateOptions(BrushToolMessageOptionsUpdate), UpdateOptions(BrushToolMessageOptionsUpdate),
} }
#[remain::sorted]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum BrushToolMessageOptionsUpdate { pub enum BrushToolMessageOptionsUpdate {
BlendMode(BlendMode), BlendMode(BlendMode),

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

@ -33,7 +33,6 @@ impl Default for EllipseToolOptions {
} }
} }
#[remain::sorted]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum EllipseOptionsUpdate { pub enum EllipseOptionsUpdate {
FillColor(Option<Color>), FillColor(Option<Color>),
@ -44,25 +43,18 @@ pub enum EllipseOptionsUpdate {
WorkingColors(Option<Color>, Option<Color>), WorkingColors(Option<Color>, Option<Color>),
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Ellipse)] #[impl_message(Message, ToolMessage, Ellipse)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum EllipseToolMessage { pub enum EllipseToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
WorkingColorChanged, WorkingColorChanged,
// Tool-specific messages // Tool-specific messages
DragStart, DragStart,
DragStop, DragStop,
PointerMove { PointerMove { center: Key, lock_ratio: Key },
center: Key,
lock_ratio: Key,
},
UpdateOptions(EllipseOptionsUpdate), UpdateOptions(EllipseOptionsUpdate),
} }

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

@ -7,12 +7,10 @@ pub struct EyedropperTool {
data: EyedropperToolData, data: EyedropperToolData,
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Eyedropper)] #[impl_message(Message, ToolMessage, Eyedropper)]
#[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)]
pub enum EyedropperToolMessage { pub enum EyedropperToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Abort, Abort,
// Tool-specific messages // Tool-specific messages

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

@ -7,7 +7,6 @@ pub struct FillTool {
fsm_state: FillToolFsmState, fsm_state: FillToolFsmState,
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Fill)] #[impl_message(Message, ToolMessage, Fill)]
#[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)]
pub enum FillToolMessage { pub enum FillToolMessage {

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

@ -39,16 +39,12 @@ impl Default for FreehandOptions {
} }
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Freehand)] #[impl_message(Message, ToolMessage, Freehand)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum FreehandToolMessage { pub enum FreehandToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
WorkingColorChanged, WorkingColorChanged,
// Tool-specific messages // Tool-specific messages
@ -58,7 +54,6 @@ pub enum FreehandToolMessage {
UpdateOptions(FreehandOptionsUpdate), UpdateOptions(FreehandOptionsUpdate),
} }
#[remain::sorted]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum FreehandOptionsUpdate { pub enum FreehandOptionsUpdate {
FillColor(Option<Color>), FillColor(Option<Color>),

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

@ -19,28 +19,22 @@ pub struct GradientOptions {
gradient_type: GradientType, gradient_type: GradientType,
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Gradient)] #[impl_message(Message, ToolMessage, Gradient)]
#[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)]
pub enum GradientToolMessage { pub enum GradientToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
// Tool-specific messages // Tool-specific messages
DeleteStop, DeleteStop,
InsertStop, InsertStop,
PointerDown, PointerDown,
PointerMove { PointerMove { constrain_axis: Key },
constrain_axis: Key,
},
PointerUp, PointerUp,
UpdateOptions(GradientOptionsUpdate), UpdateOptions(GradientOptionsUpdate),
} }
#[remain::sorted]
#[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)]
pub enum GradientOptionsUpdate { pub enum GradientOptionsUpdate {
Type(GradientType), Type(GradientType),

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

@ -11,21 +11,16 @@ pub struct ImaginateTool {
tool_data: ImaginateToolData, tool_data: ImaginateToolData,
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Imaginate)] #[impl_message(Message, ToolMessage, Imaginate)]
#[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)]
pub enum ImaginateToolMessage { pub enum ImaginateToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Abort, Abort,
// Tool-specific messages // Tool-specific messages
DragStart, DragStart,
DragStop, DragStop,
Resize { Resize { center: Key, lock_ratio: Key },
center: Key,
lock_ratio: Key,
},
} }
impl LayoutHolder for ImaginateTool { impl LayoutHolder for ImaginateTool {

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

@ -32,30 +32,21 @@ impl Default for LineOptions {
} }
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Line)] #[impl_message(Message, ToolMessage, Line)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum LineToolMessage { pub enum LineToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
WorkingColorChanged, WorkingColorChanged,
// Tool-specific messages // Tool-specific messages
DragStart, DragStart,
DragStop, DragStop,
PointerMove { PointerMove { center: Key, lock_angle: Key, snap_angle: Key },
center: Key,
lock_angle: Key,
snap_angle: Key,
},
UpdateOptions(LineOptionsUpdate), UpdateOptions(LineOptionsUpdate),
} }
#[remain::sorted]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum LineOptionsUpdate { pub enum LineOptionsUpdate {
LineWeight(f64), LineWeight(f64),

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

@ -6,22 +6,15 @@ pub struct NavigateTool {
tool_data: NavigateToolData, tool_data: NavigateToolData,
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Navigate)] #[impl_message(Message, ToolMessage, Navigate)]
#[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)]
pub enum NavigateToolMessage { pub enum NavigateToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Abort, Abort,
// Tool-specific messages // Tool-specific messages
ClickZoom { ClickZoom { zoom_in: bool },
zoom_in: bool, PointerMove { snap_angle: Key, snap_zoom: Key },
},
PointerMove {
snap_angle: Key,
snap_zoom: Key,
},
RotateCanvasBegin, RotateCanvasBegin,
TransformCanvasEnd, TransformCanvasEnd,
TranslateCanvasBegin, TranslateCanvasBegin,

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

@ -19,16 +19,12 @@ pub struct PathTool {
tool_data: PathToolData, tool_data: PathToolData,
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Path)] #[impl_message(Message, ToolMessage, Path)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum PathToolMessage { pub enum PathToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
#[remain::unsorted]
SelectionChanged, SelectionChanged,
// Tool-specific messages // Tool-specific messages

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

@ -39,29 +39,20 @@ impl Default for PenOptions {
} }
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Pen)] #[impl_message(Message, ToolMessage, Pen)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum PenToolMessage { pub enum PenToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
SelectionChanged, SelectionChanged,
#[remain::unsorted]
WorkingColorChanged, WorkingColorChanged,
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
// Tool-specific messages // Tool-specific messages
Confirm, Confirm,
DragStart, DragStart,
DragStop, DragStop,
PointerMove { PointerMove { snap_angle: Key, break_handle: Key, lock_angle: Key },
snap_angle: Key,
break_handle: Key,
lock_angle: Key,
},
Redo, Redo,
Undo, Undo,
UpdateOptions(PenOptionsUpdate), UpdateOptions(PenOptionsUpdate),
@ -75,7 +66,6 @@ enum PenToolFsmState {
PlacingAnchor, PlacingAnchor,
} }
#[remain::sorted]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum PenOptionsUpdate { pub enum PenOptionsUpdate {
FillColor(Option<Color>), FillColor(Option<Color>),

10
editor/src/messages/tool/tool_messages/polygon_tool.rs
View File

@ -37,25 +37,18 @@ impl Default for PolygonOptions {
} }
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Polygon)] #[impl_message(Message, ToolMessage, Polygon)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum PolygonToolMessage { pub enum PolygonToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
WorkingColorChanged, WorkingColorChanged,
// Tool-specific messages // Tool-specific messages
DragStart, DragStart,
DragStop, DragStop,
PointerMove { PointerMove { center: Key, lock_ratio: Key },
center: Key,
lock_ratio: Key,
},
UpdateOptions(PolygonOptionsUpdate), UpdateOptions(PolygonOptionsUpdate),
} }
@ -65,7 +58,6 @@ pub enum PrimitiveShapeType {
Star = 1, Star = 1,
} }
#[remain::sorted]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum PolygonOptionsUpdate { pub enum PolygonOptionsUpdate {
FillColor(Option<Color>), FillColor(Option<Color>),

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

@ -33,7 +33,6 @@ impl Default for RectangleToolOptions {
} }
} }
#[remain::sorted]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum RectangleOptionsUpdate { pub enum RectangleOptionsUpdate {
FillColor(Option<Color>), FillColor(Option<Color>),
@ -44,25 +43,18 @@ pub enum RectangleOptionsUpdate {
WorkingColors(Option<Color>, Option<Color>), WorkingColors(Option<Color>, Option<Color>),
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Rectangle)] #[impl_message(Message, ToolMessage, Rectangle)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum RectangleToolMessage { pub enum RectangleToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
WorkingColorChanged, WorkingColorChanged,
// Tool-specific messages // Tool-specific messages
DragStart, DragStart,
DragStop, DragStop,
PointerMove { PointerMove { center: Key, lock_ratio: Key },
center: Key,
lock_ratio: Key,
},
UpdateOptions(RectangleOptionsUpdate), UpdateOptions(RectangleOptionsUpdate),
} }

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

@ -30,7 +30,6 @@ pub struct SelectOptions {
nested_selection_behavior: NestedSelectionBehavior, nested_selection_behavior: NestedSelectionBehavior,
} }
#[remain::sorted]
#[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize, specta::Type)]
pub enum SelectOptionsUpdate { pub enum SelectOptionsUpdate {
NestedSelectionBehavior(NestedSelectionBehavior), NestedSelectionBehavior(NestedSelectionBehavior),
@ -60,32 +59,22 @@ pub struct SelectToolPointerKeys {
pub duplicate: Key, pub duplicate: Key,
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Select)] #[impl_message(Message, ToolMessage, Select)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum SelectToolMessage { pub enum SelectToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
// Tool-specific messages // Tool-specific messages
DragStart { DragStart { add_to_selection: Key, select_deepest: Key },
add_to_selection: Key, DragStop { remove_from_selection: Key },
select_deepest: Key,
},
DragStop {
remove_from_selection: Key,
},
EditLayer, EditLayer,
Enter, Enter,
PointerMove(SelectToolPointerKeys), PointerMove(SelectToolPointerKeys),
PointerOutsideViewport(SelectToolPointerKeys), PointerOutsideViewport(SelectToolPointerKeys),
SelectOptions(SelectOptionsUpdate), SelectOptions(SelectOptionsUpdate),
SetPivot { SetPivot { position: PivotPosition },
position: PivotPosition,
},
ShiftViewport, ShiftViewport,
} }

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

@ -34,16 +34,12 @@ impl Default for SplineOptions {
} }
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Spline)] #[impl_message(Message, ToolMessage, Spline)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum SplineToolMessage { pub enum SplineToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
CanvasTransformed, CanvasTransformed,
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
WorkingColorChanged, WorkingColorChanged,
// Tool-specific messages // Tool-specific messages
@ -62,7 +58,6 @@ enum SplineToolFsmState {
Drawing, Drawing,
} }
#[remain::sorted]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum SplineOptionsUpdate { pub enum SplineOptionsUpdate {
FillColor(Option<Color>), FillColor(Option<Color>),

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

@ -40,32 +40,23 @@ impl Default for TextOptions {
} }
} }
#[remain::sorted]
#[impl_message(Message, ToolMessage, Text)] #[impl_message(Message, ToolMessage, Text)]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum TextToolMessage { pub enum TextToolMessage {
// Standard messages // Standard messages
#[remain::unsorted]
Abort, Abort,
#[remain::unsorted]
WorkingColorChanged, WorkingColorChanged,
#[remain::unsorted]
Overlays(OverlayContext), Overlays(OverlayContext),
// Tool-specific messages // Tool-specific messages
CommitText, CommitText,
EditSelected, EditSelected,
Interact, Interact,
TextChange { TextChange { new_text: String },
new_text: String, UpdateBounds { new_text: String },
},
UpdateBounds {
new_text: String,
},
UpdateOptions(TextOptionsUpdate), UpdateOptions(TextOptionsUpdate),
} }
#[remain::sorted]
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)] #[derive(PartialEq, Clone, Debug, Serialize, Deserialize, specta::Type)]
pub enum TextOptionsUpdate { pub enum TextOptionsUpdate {
FillColor(Option<Color>), FillColor(Option<Color>),

1
editor/src/messages/tool/transform_layer/transform_layer_message.rs
View File

@ -3,7 +3,6 @@ use crate::messages::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, ToolMessage, TransformLayer)] #[impl_message(Message, ToolMessage, TransformLayer)]
#[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize)]
pub enum TransformLayerMessage { pub enum TransformLayerMessage {

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

@ -42,7 +42,6 @@ impl TransformLayerMessageHandler {
type TransformData<'a> = (&'a DocumentMessageHandler, &'a InputPreprocessorMessageHandler, &'a ToolData, &'a mut ShapeState); type TransformData<'a> = (&'a DocumentMessageHandler, &'a InputPreprocessorMessageHandler, &'a ToolData, &'a mut ShapeState);
impl<'a> MessageHandler<TransformLayerMessage, TransformData<'a>> for TransformLayerMessageHandler { impl<'a> MessageHandler<TransformLayerMessage, TransformData<'a>> for TransformLayerMessageHandler {
#[remain::check]
fn process_message(&mut self, message: TransformLayerMessage, responses: &mut VecDeque<Message>, (document, input, tool_data, shape_editor): TransformData) { fn process_message(&mut self, message: TransformLayerMessage, responses: &mut VecDeque<Message>, (document, input, tool_data, shape_editor): TransformData) {
use TransformLayerMessage::*; use TransformLayerMessage::*;
@ -91,7 +90,6 @@ impl<'a> MessageHandler<TransformLayerMessage, TransformData<'a>> for TransformL
selected.original_transforms.clear(); selected.original_transforms.clear();
}; };
#[remain::sorted]
match message { match message {
ApplyTransformOperation => { ApplyTransformOperation => {
selected.original_transforms.clear(); selected.original_transforms.clear();

1
editor/src/messages/workspace/workspace_message.rs
View File

@ -2,7 +2,6 @@ use crate::messages::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[remain::sorted]
#[impl_message(Message, Workspace)] #[impl_message(Message, Workspace)]
#[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize)]
pub enum WorkspaceMessage { pub enum WorkspaceMessage {

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

@ -6,11 +6,9 @@ pub struct WorkspaceMessageHandler {
} }
impl MessageHandler<WorkspaceMessage, ()> for WorkspaceMessageHandler { impl MessageHandler<WorkspaceMessage, ()> for WorkspaceMessageHandler {
#[remain::check]
fn process_message(&mut self, message: WorkspaceMessage, _responses: &mut VecDeque<Message>, _data: ()) { fn process_message(&mut self, message: WorkspaceMessage, _responses: &mut VecDeque<Message>, _data: ()) {
use WorkspaceMessage::*; use WorkspaceMessage::*;
#[remain::sorted]
match message { match message {
// Messages // Messages
NodeGraphToggleVisibility => { NodeGraphToggleVisibility => {