Scale thin strokes to maintain a minimum selection tolerance

Author: Nuhiat-Arefin

.branding

@@ -1,2 +1,2 @@
-https://github.com/Keavon/graphite-branded-assets/archive/8cd7cf811d36228a2eb7ce741adc3c745632a6e7.tar.gz
-17a7cd32dda4afd893c65e1fb6757f1ecf760702217f647d1c680db8d92643ef
+https://github.com/Keavon/graphite-branded-assets/archive/f44aa2f362ae4fed8d634878b817a1d3948a7dcb.tar.gz
+dffe2b483e491979ef57c320d61446ada5400ef73ff26582976631d9c36efefc

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 {
@@ -78,6 +79,8 @@ impl App {
 		let mut persistent_data = PersistentData::default();
 		persistent_data.load_from_disk();
 
+		let desktop_wrapper = DesktopWrapper::new(rand::rng().random());
+
 		Self {
 			render_state: None,
 			wgpu_context,
@@ -91,7 +94,7 @@ impl App {
 			ui_scale: 1.,
 			app_event_receiver,
 			app_event_scheduler,
-			desktop_wrapper: DesktopWrapper::new(),
+			desktop_wrapper,
 			last_ui_update: Instant::now(),
 			cef_context,
 			cef_schedule: Some(Instant::now()),
@@ -478,14 +481,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,6 +66,7 @@ pub fn start() {
 		}
 	};
 
+	// Must be called before event loop initialization or native window integrations will break
 	App::init();
 
 	let wgpu_context = futures::executor::block_on(gpu_context::create_wgpu_context());
@@ -78,9 +79,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,8 +27,18 @@ pub struct DesktopWrapper {
 }
 
 impl DesktopWrapper {
-	pub fn new() -> Self {
-		Self { editor: Editor::new() }
+	pub fn new(uuid_random_seed: u64) -> Self {
+		#[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 };
+
+		Self {
+			editor: Editor::new(env, uuid_random_seed),
+		}
 	}
 
 	pub fn init(&self, wgpu_context: WgpuContext) {
@@ -51,12 +61,6 @@ impl DesktopWrapper {
 	}
 }
 
-impl Default for DesktopWrapper {
-	fn default() -> Self {
-		Self::new()
-	}
-}
-
 pub enum NodeGraphExecutionResult {
 	HasRun(Option<wgpu::Texture>),
 	NotRun,

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,24 +1,31 @@
 use crate::dispatcher::Dispatcher;
 use crate::messages::prelude::*;
 pub use graphene_std::uuid::*;
+use std::sync::OnceLock;
 
-// TODO: serialize with serde to save the current editor state
 pub struct Editor {
 	pub dispatcher: Dispatcher,
 }
 
 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 new() -> Self {
+	pub fn new(environment: Environment, uuid_random_seed: u64) -> Self {
+		ENVIRONMENT.set(environment).expect("Editor shoud only be initialized once");
+		graphene_std::uuid::set_uuid_seed(uuid_random_seed);
+
 		Self { dispatcher: Dispatcher::new() }
 	}
 
 	#[cfg(test)]
 	pub(crate) fn new_local_executor() -> (Self, crate::node_graph_executor::NodeRuntime) {
+		let _ = ENVIRONMENT.set(*Editor::environment());
+		graphene_std::uuid::set_uuid_seed(0);
+
 		let (runtime, executor) = crate::node_graph_executor::NodeGraphExecutor::new_with_local_runtime();
-		let dispatcher = Dispatcher::with_executor(executor);
-		(Self { dispatcher }, runtime)
+		let editor = Self {
+			dispatcher: Dispatcher::with_executor(executor),
+		};
+
+		(editor, runtime)
 	}
 
 	pub fn handle_message<T: Into<Message>>(&mut self, message: T) -> Vec<FrontendMessage> {
@@ -32,9 +39,53 @@ impl Editor {
 	}
 }
 
-impl Default for Editor {
-	fn default() -> Self {
-		Self::new()
+static ENVIRONMENT: OnceLock<Environment> = OnceLock::new();
+impl Editor {
+	#[cfg(not(test))]
+	pub fn environment() -> &'static Environment {
+		ENVIRONMENT.get().expect("Editor environment accessed before initialization")
+	}
+
+	#[cfg(test)]
+	pub fn environment() -> &'static Environment {
+		&Environment {
+			platform: Platform::Desktop,
+			host: Host::Linux,
+		}
+	}
+}
+
+#[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 {
+	Windows,
+	Mac,
+	Linux,
+}
+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_windows(&self) -> bool {
+		matches!(self.host, Host::Windows)
+	}
+	pub fn is_mac(&self) -> bool {
+		matches!(self.host, Host::Mac)
+	}
+	pub fn is_linux(&self) -> bool {
+		matches!(self.host, Host::Linux)
 	}
 }
 

editor/src/dispatcher.rs

@@ -23,12 +23,11 @@ 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,
 	menu_bar_message_handler: MenuBarMessageHandler,
-	pub portfolio_message_handler: PortfolioMessageHandler,
+	pub(crate) portfolio_message_handler: PortfolioMessageHandler,
 	preferences_message_handler: PreferencesMessageHandler,
 	tool_message_handler: ToolMessageHandler,
 	viewport_message_handler: ViewportMessageHandler,
@@ -192,17 +191,11 @@ 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,
 							viewport: &self.message_handlers.viewport_message_handler,
 						},
 					);

editor/src/messages/app_window/app_window_message.rs

@@ -1,11 +1,8 @@
 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 },
 	PointerLock,
 	PointerLockMove { x: f64, y: f64 },
 	Close,

editor/src/messages/app_window/app_window_message_handler.rs

@@ -1,20 +1,15 @@
-use crate::messages::app_window::AppWindowMessage;
+use crate::application::{Environment, Platform};
 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::PointerLock => {
 				responses.add(FrontendMessage::WindowPointerLock);
 			}
@@ -66,3 +61,14 @@ pub enum AppWindowPlatform {
 	Mac,
 	Linux,
 }
+
+impl From<&Environment> for AppWindowPlatform {
+	fn from(environment: &Environment) -> Self {
+		match (environment.platform, environment.host) {
+			(Platform::Web, _) => AppWindowPlatform::Web,
+			(Platform::Desktop, Host::Linux) => AppWindowPlatform::Linux,
+			(Platform::Desktop, Host::Mac) => AppWindowPlatform::Mac,
+			(Platform::Desktop, Host::Windows) => AppWindowPlatform::Windows,
+		}
+	}
+}