Merge branch 'master' into fix-min-max-macro

Author: mTvare6

editor/src/dispatcher.rs

@@ -13,6 +13,7 @@ pub struct Dispatcher {
 
 #[derive(Debug, Default)]
 pub struct DispatcherMessageHandlers {
+	animation_message_handler: AnimationMessageHandler,
 	broadcast_message_handler: BroadcastMessageHandler,
 	debug_message_handler: DebugMessageHandler,
 	dialog_message_handler: DialogMessageHandler,
@@ -50,12 +51,9 @@ const SIDE_EFFECT_FREE_MESSAGES: &[MessageDiscriminant] = &[
 	MessageDiscriminant::Frontend(FrontendMessageDiscriminant::UpdateDocumentLayerStructure),
 	MessageDiscriminant::Frontend(FrontendMessageDiscriminant::TriggerFontLoad),
 ];
-const DEBUG_MESSAGE_BLOCK_LIST: &[MessageDiscriminant] = &[
-	MessageDiscriminant::Broadcast(BroadcastMessageDiscriminant::TriggerEvent(BroadcastEventDiscriminant::AnimationFrame)),
-	MessageDiscriminant::InputPreprocessor(InputPreprocessorMessageDiscriminant::FrameTimeAdvance),
-];
+const DEBUG_MESSAGE_BLOCK_LIST: &[MessageDiscriminant] = &[MessageDiscriminant::Broadcast(BroadcastMessageDiscriminant::TriggerEvent(BroadcastEventDiscriminant::AnimationFrame))];
 // TODO: Find a way to combine these with the list above. We use strings for now since these are the standard variant names used by multiple messages. But having these also type-checked would be best.
-const DEBUG_MESSAGE_ENDING_BLOCK_LIST: &[&str] = &["PointerMove", "PointerOutsideViewport", "Overlays", "Draw"];
+const DEBUG_MESSAGE_ENDING_BLOCK_LIST: &[&str] = &["PointerMove", "PointerOutsideViewport", "Overlays", "Draw", "CurrentTime", "Time"];
 
 impl Dispatcher {
 	pub fn new() -> Self {
@@ -177,6 +175,9 @@ impl Dispatcher {
 					// Finish loading persistent data from the browser database
 					queue.add(FrontendMessage::TriggerLoadRestAutoSaveDocuments);
 				}
+				Message::Animation(message) => {
+					self.message_handlers.animation_message_handler.process_message(message, &mut queue, ());
+				}
 				Message::Batched(messages) => {
 					messages.iter().for_each(|message| self.handle_message(message.to_owned(), false));
 				}
@@ -232,6 +233,8 @@ impl Dispatcher {
 					let preferences = &self.message_handlers.preferences_message_handler;
 					let current_tool = &self.message_handlers.tool_message_handler.tool_state.tool_data.active_tool_type;
 					let message_logging_verbosity = self.message_handlers.debug_message_handler.message_logging_verbosity;
+					let timing_information = self.message_handlers.animation_message_handler.timing_information();
+					let animation = &self.message_handlers.animation_message_handler;
 
 					self.message_handlers.portfolio_message_handler.process_message(
 						message,
@@ -241,6 +244,8 @@ impl Dispatcher {
 							preferences,
 							current_tool,
 							message_logging_verbosity,
+							timing_information,
+							animation,
 						},
 					);
 				}
@@ -283,6 +288,7 @@ impl Dispatcher {
 		// TODO: Reduce the number of heap allocations
 		let mut list = Vec::new();
 		list.extend(self.message_handlers.dialog_message_handler.actions());
+		list.extend(self.message_handlers.animation_message_handler.actions());
 		list.extend(self.message_handlers.input_preprocessor_message_handler.actions());
 		list.extend(self.message_handlers.key_mapping_message_handler.actions());
 		list.extend(self.message_handlers.debug_message_handler.actions());

editor/src/messages/animation/animation_message.rs

@@ -0,0 +1,17 @@
+use crate::messages::prelude::*;
+
+use super::animation_message_handler::AnimationTimeMode;
+
+#[impl_message(Message, Animation)]
+#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub enum AnimationMessage {
+	ToggleLivePreview,
+	EnableLivePreview,
+	DisableLivePreview,
+	RestartAnimation,
+	SetFrameIndex(f64),
+	SetTime(f64),
+	UpdateTime,
+	IncrementFrameCounter,
+	SetAnimationTimeMode(AnimationTimeMode),
+}

editor/src/messages/animation/animation_message_handler.rs

@@ -0,0 +1,133 @@
+use std::time::Duration;
+
+use crate::messages::prelude::*;
+
+use super::TimingInformation;
+
+#[derive(PartialEq, Clone, Default, Debug, serde::Serialize, serde::Deserialize)]
+pub enum AnimationTimeMode {
+	#[default]
+	TimeBased,
+	FrameBased,
+}
+
+#[derive(Default, Debug, Clone, PartialEq)]
+enum AnimationState {
+	#[default]
+	Stopped,
+	Playing {
+		start: f64,
+	},
+	Paused {
+		start: f64,
+		pause_time: f64,
+	},
+}
+
+#[derive(Default, Debug, Clone, PartialEq)]
+pub struct AnimationMessageHandler {
+	/// Used to re-send the UI on the next frame after playback starts
+	live_preview_recently_zero: bool,
+	timestamp: f64,
+	frame_index: f64,
+	animation_state: AnimationState,
+	fps: f64,
+	animation_time_mode: AnimationTimeMode,
+}
+impl AnimationMessageHandler {
+	pub(crate) fn timing_information(&self) -> TimingInformation {
+		let animation_time = self.timestamp - self.animation_start();
+		let animation_time = match self.animation_time_mode {
+			AnimationTimeMode::TimeBased => Duration::from_millis(animation_time as u64),
+			AnimationTimeMode::FrameBased => Duration::from_secs((self.frame_index / self.fps) as u64),
+		};
+		TimingInformation { time: self.timestamp, animation_time }
+	}
+
+	pub(crate) fn animation_start(&self) -> f64 {
+		match self.animation_state {
+			AnimationState::Stopped => self.timestamp,
+			AnimationState::Playing { start } => start,
+			AnimationState::Paused { start, pause_time } => start + self.timestamp - pause_time,
+		}
+	}
+
+	pub fn is_playing(&self) -> bool {
+		matches!(self.animation_state, AnimationState::Playing { .. })
+	}
+}
+
+impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
+	fn process_message(&mut self, message: AnimationMessage, responses: &mut VecDeque<Message>, _data: ()) {
+		match message {
+			AnimationMessage::ToggleLivePreview => match self.animation_state {
+				AnimationState::Stopped => responses.add(AnimationMessage::EnableLivePreview),
+				AnimationState::Playing { .. } => responses.add(AnimationMessage::DisableLivePreview),
+				AnimationState::Paused { .. } => responses.add(AnimationMessage::EnableLivePreview),
+			},
+			AnimationMessage::EnableLivePreview => {
+				self.animation_state = AnimationState::Playing { start: self.animation_start() };
+
+				// Update the restart and pause/play buttons
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::DisableLivePreview => {
+				match self.animation_state {
+					AnimationState::Stopped => (),
+					AnimationState::Playing { start } => self.animation_state = AnimationState::Paused { start, pause_time: self.timestamp },
+					AnimationState::Paused { .. } => (),
+				}
+
+				// Update the restart and pause/play buttons
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::SetFrameIndex(frame) => {
+				self.frame_index = frame;
+				responses.add(PortfolioMessage::SubmitActiveGraphRender);
+				// Update the restart and pause/play buttons
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::SetTime(time) => {
+				self.timestamp = time;
+				responses.add(AnimationMessage::UpdateTime);
+			}
+			AnimationMessage::IncrementFrameCounter => {
+				if self.is_playing() {
+					self.frame_index += 1.;
+					responses.add(AnimationMessage::UpdateTime);
+				}
+			}
+			AnimationMessage::UpdateTime => {
+				if self.is_playing() {
+					responses.add(PortfolioMessage::SubmitActiveGraphRender);
+
+					if self.live_preview_recently_zero {
+						// Update the restart and pause/play buttons
+						responses.add(PortfolioMessage::UpdateDocumentWidgets);
+						self.live_preview_recently_zero = false;
+					}
+				}
+			}
+			AnimationMessage::RestartAnimation => {
+				self.frame_index = 0.;
+				self.animation_state = match self.animation_state {
+					AnimationState::Playing { .. } => AnimationState::Playing { start: self.timestamp },
+					_ => AnimationState::Stopped,
+				};
+				self.live_preview_recently_zero = true;
+				responses.add(PortfolioMessage::SubmitActiveGraphRender);
+				// Update the restart and pause/play buttons
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::SetAnimationTimeMode(animation_time_mode) => {
+				self.animation_time_mode = animation_time_mode;
+			}
+		}
+	}
+
+	advertise_actions!(AnimationMessageDiscriminant;
+		ToggleLivePreview,
+		SetFrameIndex,
+		RestartAnimation,
+	);
+}

editor/src/messages/animation/mod.rs

@@ -0,0 +1,9 @@
+mod animation_message;
+mod animation_message_handler;
+
+#[doc(inline)]
+pub use animation_message::{AnimationMessage, AnimationMessageDiscriminant};
+#[doc(inline)]
+pub use animation_message_handler::AnimationMessageHandler;
+
+pub use graphene_core::application_io::TimingInformation;

editor/src/messages/frontend/frontend_message.rs

@@ -150,6 +150,15 @@ pub enum FrontendMessage {
 	UpdateGraphViewOverlay {
 		open: bool,
 	},
+	UpdateSpreadsheetState {
+		open: bool,
+		node: Option<NodeId>,
+	},
+	UpdateSpreadsheetLayout {
+		#[serde(rename = "layoutTarget")]
+		layout_target: LayoutTarget,
+		diff: Vec<WidgetDiff>,
+	},
 	UpdateImportReorderIndex {
 		#[serde(rename = "importIndex")]
 		index: Option<usize>,

editor/src/messages/input_mapper/input_mappings.rs

@@ -430,6 +430,9 @@ pub fn input_mappings() -> Mapping {
 		entry!(KeyDown(Digit0); modifiers=[Alt], action_dispatch=DebugMessage::MessageOff),
 		entry!(KeyDown(Digit1); modifiers=[Alt], action_dispatch=DebugMessage::MessageNames),
 		entry!(KeyDown(Digit2); modifiers=[Alt], action_dispatch=DebugMessage::MessageContents),
+		// AnimationMessage
+		entry!(KeyDown(Space); modifiers=[Shift], action_dispatch=AnimationMessage::ToggleLivePreview),
+		entry!(KeyDown(Home); modifiers=[Shift], action_dispatch=AnimationMessage::RestartAnimation),
 	];
 	let (mut key_up, mut key_down, mut key_up_no_repeat, mut key_down_no_repeat, mut double_click, mut wheel_scroll, mut pointer_move) = mappings;
 

editor/src/messages/input_mapper/utility_types/input_mouse.rs

@@ -88,10 +88,9 @@ pub struct MouseState {
 
 impl MouseState {
 	pub fn finish_transaction(&self, drag_start: DVec2, responses: &mut VecDeque<Message>) {
-		match drag_start.distance(self.position) <= DRAG_THRESHOLD {
-			true => responses.add(DocumentMessage::AbortTransaction),
-			false => responses.add(DocumentMessage::EndTransaction),
-		}
+		let drag_too_small = drag_start.distance(self.position) <= DRAG_THRESHOLD;
+		let response = if drag_too_small { DocumentMessage::AbortTransaction } else { DocumentMessage::EndTransaction };
+		responses.add(response);
 	}
 }
 

editor/src/messages/input_preprocessor/input_preprocessor_message.rs

@@ -1,7 +1,6 @@
 use crate::messages::input_mapper::utility_types::input_keyboard::{Key, ModifierKeys};
 use crate::messages::input_mapper::utility_types::input_mouse::{EditorMouseState, ViewportBounds};
 use crate::messages::prelude::*;
-use core::time::Duration;
 
 #[impl_message(Message, InputPreprocessor)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -13,6 +12,6 @@ pub enum InputPreprocessorMessage {
 	PointerDown { editor_mouse_state: EditorMouseState, modifier_keys: ModifierKeys },
 	PointerMove { editor_mouse_state: EditorMouseState, modifier_keys: ModifierKeys },
 	PointerUp { editor_mouse_state: EditorMouseState, modifier_keys: ModifierKeys },
-	FrameTimeAdvance { timestamp: Duration },
+	CurrentTime { timestamp: u64 },
 	WheelScroll { editor_mouse_state: EditorMouseState, modifier_keys: ModifierKeys },
 }

editor/src/messages/input_preprocessor/input_preprocessor_message_handler.rs

@@ -12,6 +12,7 @@ pub struct InputPreprocessorMessageData {
 #[derive(Debug, Default)]
 pub struct InputPreprocessorMessageHandler {
 	pub frame_time: FrameTimeInfo,
+	pub time: u64,
 	pub keyboard: KeyStates,
 	pub mouse: MouseState,
 	pub viewport_bounds: ViewportBounds,
@@ -93,8 +94,9 @@ impl MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageData> for
 
 				self.translate_mouse_event(mouse_state, false, responses);
 			}
-			InputPreprocessorMessage::FrameTimeAdvance { timestamp } => {
-				self.frame_time.advance_timestamp(timestamp);
+			InputPreprocessorMessage::CurrentTime { timestamp } => {
+				responses.add(AnimationMessage::SetTime(timestamp as f64));
+				self.time = timestamp;
 			}
 			InputPreprocessorMessage::WheelScroll { editor_mouse_state, modifier_keys } => {
 				self.update_states_of_modifier_keys(modifier_keys, keyboard_platform, responses);

editor/src/messages/layout/layout_message_handler.rs

@@ -40,6 +40,29 @@ impl LayoutMessageHandler {
 				LayoutGroup::Section { layout, .. } => {
 					stack.extend(layout.iter().enumerate().map(|(index, val)| ([widget_path.as_slice(), &[index]].concat(), val)));
 				}
+
+				LayoutGroup::Table { rows } => {
+					for (row_index, cell) in rows.iter().enumerate() {
+						for (cell_index, entry) in cell.iter().enumerate() {
+							// Return if this is the correct ID
+							if entry.widget_id == widget_id {
+								widget_path.push(row_index);
+								widget_path.push(cell_index);
+								return Some((entry, widget_path));
+							}
+
+							if let Widget::PopoverButton(popover) = &entry.widget {
+								stack.extend(
+									popover
+										.popover_layout
+										.iter()
+										.enumerate()
+										.map(|(child, val)| ([widget_path.as_slice(), &[row_index, cell_index, child]].concat(), val)),
+								);
+							}
+						}
+					}
+				}
 			}
 		}
 		None
@@ -405,6 +428,7 @@ impl LayoutMessageHandler {
 			LayoutTarget::MenuBar => unreachable!("Menu bar is not diffed"),
 			LayoutTarget::NodeGraphControlBar => FrontendMessage::UpdateNodeGraphControlBarLayout { layout_target, diff },
 			LayoutTarget::PropertiesSections => FrontendMessage::UpdatePropertyPanelSectionsLayout { layout_target, diff },
+			LayoutTarget::Spreadsheet => FrontendMessage::UpdateSpreadsheetLayout { layout_target, diff },
 			LayoutTarget::ToolOptions => FrontendMessage::UpdateToolOptionsLayout { layout_target, diff },
 			LayoutTarget::ToolShelf => FrontendMessage::UpdateToolShelfLayout { layout_target, diff },
 			LayoutTarget::WorkingColors => FrontendMessage::UpdateWorkingColorsLayout { layout_target, diff },