Replace globals with editor enviroment

Author: timon-schelling

desktop/src/app.rs

@@ -1,3 +1,4 @@
+use rand::Rng;
 use rfd::AsyncFileDialog;
 use std::fs;
 use std::path::PathBuf;
@@ -16,7 +17,7 @@ use crate::event::{AppEvent, AppEventScheduler};
 use crate::persist::PersistentData;
 use crate::render::{RenderError, RenderState};
 use crate::window::Window;
-use crate::wrapper::messages::{DesktopFrontendMessage, DesktopWrapperMessage, InputMessage, MouseKeys, MouseState, Platform};
+use crate::wrapper::messages::{DesktopFrontendMessage, DesktopWrapperMessage, InputMessage, MouseKeys, MouseState};
 use crate::wrapper::{DesktopWrapper, NodeGraphExecutionResult, WgpuContext, serialize_frontend_messages};
 
 pub(crate) struct App {
@@ -46,7 +47,8 @@ pub(crate) struct App {
 }
 
 impl App {
-	pub(crate) fn init() {
+	pub(crate) fn init(wgpu_context: &WgpuContext) {
+		DesktopWrapper::init(wgpu_context, rand::rng().random());
 		Window::init();
 	}
 
@@ -476,16 +478,6 @@ impl ApplicationHandler for App {
 		}
 
 		self.resize();
-
-		self.desktop_wrapper.init(self.wgpu_context.clone());
-
-		#[cfg(target_os = "windows")]
-		let platform = Platform::Windows;
-		#[cfg(target_os = "macos")]
-		let platform = Platform::Mac;
-		#[cfg(target_os = "linux")]
-		let platform = Platform::Linux;
-		self.dispatch_desktop_wrapper_message(DesktopWrapperMessage::UpdatePlatform(platform));
 	}
 
 	fn proxy_wake_up(&mut self, event_loop: &dyn ActiveEventLoop) {

desktop/src/lib.rs

@@ -66,10 +66,10 @@ pub fn start() {
 		}
 	};
 
-	App::init();
-
 	let wgpu_context = futures::executor::block_on(gpu_context::create_wgpu_context());
 
+	App::init(&wgpu_context);
+
 	let event_loop = EventLoop::new().unwrap();
 	let (app_event_sender, app_event_receiver) = std::sync::mpsc::channel();
 	let app_event_scheduler = event_loop.create_app_event_scheduler(app_event_sender);
@@ -78,9 +78,9 @@ pub fn start() {
 
 	let cef_handler = cef::CefHandler::new(wgpu_context.clone(), app_event_scheduler.clone(), cef_view_info_receiver);
 	let cef_context = match cef_context_builder.initialize(cef_handler, cli.disable_ui_acceleration) {
-		Ok(c) => {
+		Ok(context) => {
 			tracing::info!("CEF initialized successfully");
-			c
+			context
 		}
 		Err(cef::InitError::AlreadyRunning) => {
 			tracing::error!("Another instance is already running, Exiting.");

desktop/wrapper/src/handle_desktop_wrapper_message.rs

@@ -1,11 +1,10 @@
 use graphene_std::Color;
 use graphene_std::raster::Image;
-use graphite_editor::messages::app_window::app_window_message_handler::AppWindowPlatform;
 use graphite_editor::messages::clipboard::utility_types::ClipboardContentRaw;
 use graphite_editor::messages::prelude::*;
 
 use super::DesktopWrapperMessageDispatcher;
-use super::messages::{DesktopFrontendMessage, DesktopWrapperMessage, EditorMessage, OpenFileDialogContext, Platform, SaveFileDialogContext};
+use super::messages::{DesktopFrontendMessage, DesktopWrapperMessage, EditorMessage, OpenFileDialogContext, SaveFileDialogContext};
 
 pub(super) fn handle_desktop_wrapper_message(dispatcher: &mut DesktopWrapperMessageDispatcher, message: DesktopWrapperMessage) {
 	match message {
@@ -111,15 +110,6 @@ pub(super) fn handle_desktop_wrapper_message(dispatcher: &mut DesktopWrapperMess
 			dispatcher.queue_editor_message(message);
 		}
 		DesktopWrapperMessage::PollNodeGraphEvaluation => dispatcher.poll_node_graph_evaluation(),
-		DesktopWrapperMessage::UpdatePlatform(platform) => {
-			let platform = match platform {
-				Platform::Windows => AppWindowPlatform::Windows,
-				Platform::Mac => AppWindowPlatform::Mac,
-				Platform::Linux => AppWindowPlatform::Linux,
-			};
-			let message = AppWindowMessage::UpdatePlatform { platform };
-			dispatcher.queue_editor_message(message);
-		}
 		DesktopWrapperMessage::UpdateMaximized { maximized } => {
 			let message = FrontendMessage::UpdateMaximized { maximized };
 			dispatcher.queue_editor_message(message);

desktop/wrapper/src/lib.rs

@@ -1,5 +1,5 @@
 use graph_craft::wasm_application_io::WasmApplicationIo;
-use graphite_editor::application::Editor;
+use graphite_editor::application::{Editor, Environment, Host, Platform};
 use graphite_editor::messages::prelude::{FrontendMessage, Message};
 
 // TODO: Remove usage of this reexport in desktop create and remove this line
@@ -27,15 +27,24 @@ pub struct DesktopWrapper {
 }
 
 impl DesktopWrapper {
-	pub fn new() -> Self {
-		Self { editor: Editor::new() }
-	}
+	pub fn init(wgpu_context: &WgpuContext, uuid_random_seed: u64) {
+		#[cfg(target_os = "windows")]
+		let host = Host::Windows;
+		#[cfg(target_os = "macos")]
+		let host = Host::Mac;
+		#[cfg(target_os = "linux")]
+		let host = Host::Linux;
+		let env = Environment { platform: Platform::Desktop, host };
+		Editor::init(env, uuid_random_seed);
 
-	pub fn init(&self, wgpu_context: WgpuContext) {
-		let application_io = WasmApplicationIo::new_with_context(wgpu_context);
+		let application_io = WasmApplicationIo::new_with_context(wgpu_context.clone());
 		futures::executor::block_on(graphite_editor::node_graph_executor::replace_application_io(application_io));
 	}
 
+	pub fn new() -> Self {
+		Self { editor: Editor::new() }
+	}
+
 	pub fn dispatch(&mut self, message: DesktopWrapperMessage) -> Vec<DesktopFrontendMessage> {
 		let mut executor = DesktopWrapperMessageDispatcher::new(&mut self.editor);
 		executor.queue_desktop_wrapper_message(message);

desktop/wrapper/src/messages.rs

@@ -109,7 +109,6 @@ pub enum DesktopWrapperMessage {
 		content: Vec<u8>,
 	},
 	PollNodeGraphEvaluation,
-	UpdatePlatform(Platform),
 	UpdateMaximized {
 		maximized: bool,
 	},
@@ -163,12 +162,6 @@ pub enum SaveFileDialogContext {
 	File { content: Vec<u8> },
 }
 
-pub enum Platform {
-	Windows,
-	Mac,
-	Linux,
-}
-
 pub enum MenuItem {
 	Action {
 		id: String,

editor/src/application.rs

@@ -1,3 +1,5 @@
+use std::sync::OnceLock;
+
 use crate::dispatcher::Dispatcher;
 use crate::messages::prelude::*;
 pub use graphene_std::uuid::*;
@@ -8,8 +10,12 @@ pub struct Editor {
 }
 
 impl Editor {
-	/// Construct the editor.
-	/// Remember to provide a random seed with `editor::set_uuid_seed(seed)` before any editors can be used.
+	pub fn init(enviroment: Environment, uuid_random_seed: u64) {
+		ENVIROMENT.set(enviroment).expect("Editor shoud only be initialized once");
+		graphene_std::uuid::init_rng(uuid_random_seed);
+	}
+
+	/// `Editor::init` must be called before this function
 	pub fn new() -> Self {
 		Self { dispatcher: Dispatcher::new() }
 	}
@@ -31,13 +37,57 @@ impl Editor {
 		self.dispatcher.poll_node_graph_evaluation(responses)
 	}
 }
-
 impl Default for Editor {
 	fn default() -> Self {
 		Self::new()
 	}
 }
 
+static ENVIROMENT: OnceLock<Environment> = OnceLock::new();
+impl Editor {
+	pub fn environment() -> &'static Environment {
+		ENVIROMENT.get().expect("Editor environment accessed before initialization")
+	}
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct Environment {
+	pub platform: Platform,
+	pub host: Host,
+}
+#[derive(Clone, Copy, Debug)]
+pub enum Platform {
+	Desktop,
+	Web,
+}
+#[derive(Clone, Copy, Debug)]
+pub enum Host {
+	Linux,
+	Mac,
+	Windows,
+	Unknown,
+}
+impl Environment {
+	pub fn is_desktop(&self) -> bool {
+		matches!(self.platform, Platform::Desktop)
+	}
+	pub fn is_web(&self) -> bool {
+		matches!(self.platform, Platform::Web)
+	}
+	pub fn is_linux(&self) -> bool {
+		matches!(self.host, Host::Linux)
+	}
+	pub fn is_mac(&self) -> bool {
+		matches!(self.host, Host::Mac)
+	}
+	pub fn is_windows(&self) -> bool {
+		matches!(self.host, Host::Windows)
+	}
+	pub fn is_unknown_host(&self) -> bool {
+		matches!(self.host, Host::Unknown)
+	}
+}
+
 pub const GRAPHITE_RELEASE_SERIES: &str = env!("GRAPHITE_RELEASE_SERIES");
 pub const GRAPHITE_GIT_COMMIT_BRANCH: Option<&str> = option_env!("GRAPHITE_GIT_COMMIT_BRANCH");
 pub const GRAPHITE_GIT_COMMIT_HASH: &str = env!("GRAPHITE_GIT_COMMIT_HASH");

editor/src/dispatcher.rs

@@ -1,3 +1,4 @@
+use crate::application::Editor;
 use crate::messages::debug::utility_types::MessageLoggingVerbosity;
 use crate::messages::defer::DeferMessageContext;
 use crate::messages::dialog::DialogMessageContext;
@@ -23,7 +24,6 @@ pub struct DispatcherMessageHandlers {
 	debug_message_handler: DebugMessageHandler,
 	defer_message_handler: DeferMessageHandler,
 	dialog_message_handler: DialogMessageHandler,
-	globals_message_handler: GlobalsMessageHandler,
 	input_preprocessor_message_handler: InputPreprocessorMessageHandler,
 	key_mapping_message_handler: KeyMappingMessageHandler,
 	layout_message_handler: LayoutMessageHandler,
@@ -192,17 +192,12 @@ impl Dispatcher {
 						self.responses.push(message);
 					}
 				}
-				Message::Globals(message) => {
-					self.message_handlers.globals_message_handler.process_message(message, &mut queue, ());
-				}
 				Message::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,
 						&mut queue,
 						InputPreprocessorMessageContext {
-							keyboard_platform,
+							keyboard_platform: Editor::environment().host.into(),
 							viewport: &self.message_handlers.viewport_message_handler,
 						},
 					);
@@ -309,6 +304,10 @@ impl Dispatcher {
 				Message::Viewport(message) => {
 					self.message_handlers.viewport_message_handler.process_message(message, &mut queue, ());
 				}
+				Message::Init => {
+					self.handle_message(AppWindowMessage::Init, false);
+					self.handle_message(PortfolioMessage::Init, false);
+				}
 				Message::NoOp => {}
 				Message::Batched { messages } => {
 					messages.into_iter().for_each(|message| self.handle_message(message, false));

editor/src/messages/app_window/app_window_message.rs

@@ -1,11 +1,9 @@
 use crate::messages::prelude::*;
 
-use super::app_window_message_handler::AppWindowPlatform;
-
 #[impl_message(Message, AppWindow)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum AppWindowMessage {
-	UpdatePlatform { platform: AppWindowPlatform },
+	Init,
 	PointerLock,
 	PointerLockMove { x: f64, y: f64 },
 	Close,

editor/src/messages/app_window/app_window_message_handler.rs

@@ -1,19 +1,19 @@
-use crate::messages::app_window::AppWindowMessage;
+use crate::application::{Editor, Environment};
 use crate::messages::prelude::*;
+use crate::{application::Host, messages::app_window::AppWindowMessage};
 use graphite_proc_macros::{ExtractField, message_handler_data};
 
 #[derive(Debug, Clone, Default, ExtractField)]
-pub struct AppWindowMessageHandler {
-	platform: AppWindowPlatform,
-}
+pub struct AppWindowMessageHandler {}
 
 #[message_handler_data]
 impl MessageHandler<AppWindowMessage, ()> for AppWindowMessageHandler {
 	fn process_message(&mut self, message: AppWindowMessage, responses: &mut std::collections::VecDeque<Message>, _: ()) {
 		match message {
-			AppWindowMessage::UpdatePlatform { platform } => {
-				self.platform = platform;
-				responses.add(FrontendMessage::UpdatePlatform { platform: self.platform });
+			AppWindowMessage::Init => {
+				responses.add(FrontendMessage::UpdatePlatform {
+					platform: Editor::environment().into(),
+				});
 			}
 			AppWindowMessage::PointerLock => {
 				responses.add(FrontendMessage::WindowPointerLock);
@@ -66,3 +66,16 @@ pub enum AppWindowPlatform {
 	Mac,
 	Linux,
 }
+
+impl From<&Environment> for AppWindowPlatform {
+	fn from(environment: &Environment) -> Self {
+		if environment.is_web() {
+			return AppWindowPlatform::Web;
+		}
+		match environment.host {
+			Host::Linux => AppWindowPlatform::Linux,
+			Host::Mac => AppWindowPlatform::Mac,
+			Host::Windows | Host::Unknown => AppWindowPlatform::Windows,
+		}
+	}
+}