Add Global Eyedropper for Windows

desktop/Cargo.toml

@@ -23,6 +23,7 @@ accelerated_paint = ["cef/accelerated_osr"]
 # Local dependencies
 graphite-desktop-wrapper = { path = "wrapper" }
 graphite-desktop-embedded-resources = { path = "embedded-resources", optional = true }
+graphene-std = { workspace = true }
 
 wgpu = { workspace = true }
 winit = { workspace = true, features = [

desktop/src/app.rs

@@ -45,6 +45,7 @@ pub(crate) struct App {
 	start_render_sender: SyncSender<()>,
 	web_communication_initialized: bool,
 	web_communication_startup_buffer: Vec<Vec<u8>>,
+	global_eyedropper: crate::global_eyedropper::GlobalEyedropper,
 	persistent_data: PersistentData,
 	cli: Cli,
 	startup_time: Option<Instant>,
@@ -115,6 +116,7 @@ impl App {
 			start_render_sender,
 			web_communication_initialized: false,
 			web_communication_startup_buffer: Vec::new(),
+			global_eyedropper: crate::global_eyedropper::GlobalEyedropper::new(),
 			persistent_data,
 			cli,
 			startup_time: None,
@@ -429,6 +431,15 @@ impl App {
 				let message = DesktopWrapperMessage::LoadThirdPartyLicenses { text };
 				responses.push(message);
 			}
+			DesktopFrontendMessage::GlobalEyedropper { open, primary } => {
+				if open {
+					if !self.global_eyedropper.is_active() {
+						self.app_event_scheduler.schedule(AppEvent::StartGlobalEyedropper { primary });
+					}
+				} else {
+					self.global_eyedropper.stop();
+				}
+			}
 		}
 	}
 
@@ -504,6 +515,9 @@ impl App {
 				tracing::info!("Exiting main event loop");
 				event_loop.exit();
 			}
+			AppEvent::StartGlobalEyedropper { primary } => {
+				self.global_eyedropper.start(event_loop, primary);
+			}
 			#[cfg(target_os = "macos")]
 			AppEvent::MenuEvent { id } => {
 				self.dispatch_desktop_wrapper_message(DesktopWrapperMessage::MenuEvent { id });
@@ -536,7 +550,33 @@ impl ApplicationHandler for App {
 		}
 	}
 
-	fn window_event(&mut self, _event_loop: &dyn ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {
+	fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, window_id: WindowId, event: WindowEvent) {
+		if Some(window_id) == self.global_eyedropper.window_id() {
+			match event {
+				WindowEvent::PointerMoved { position, .. } => {
+					self.global_eyedropper.update(position);
+				}
+				WindowEvent::PointerButton {
+					state: ElementState::Pressed,
+					button: ButtonSource::Mouse(MouseButton::Left),
+					..
+				} => {
+					if let Some(color) = self.global_eyedropper.sample_color() {
+						let primary = self.global_eyedropper.is_primary();
+						let message = DesktopWrapperMessage::PickGlobalColor { color, primary };
+						self.dispatch_desktop_wrapper_message(message);
+					}
+					self.global_eyedropper.stop();
+				}
+				WindowEvent::KeyboardInput { .. } => {
+					// TODO: Support Esc to abort
+					self.global_eyedropper.stop();
+				}
+				_ => {}
+			}
+			return;
+		}
+
 		// Handle pointer lock release
 		if let Some(pointer_lock_position) = self.pointer_lock_position
 			&& let WindowEvent::PointerButton {
@@ -567,6 +607,11 @@ impl ApplicationHandler for App {
 				self.resize();
 			}
 			WindowEvent::RedrawRequested => {
+				if Some(window_id) == self.global_eyedropper.window_id() {
+					self.global_eyedropper.render();
+					return;
+				}
+
 				#[cfg(target_os = "macos")]
 				self.resize();
 

desktop/src/event.rs

@@ -9,6 +9,9 @@ pub(crate) enum AppEvent {
 	DesktopWrapperMessage(DesktopWrapperMessage),
 	NodeGraphExecutionResult(NodeGraphExecutionResult),
 	Exit,
+	StartGlobalEyedropper {
+		primary: bool,
+	},
 	#[cfg(target_os = "macos")]
 	MenuEvent {
 		id: String,

desktop/src/global_eyedropper/linux.rs

@@ -0,0 +1,40 @@
+use graphene_std::raster::color::Color;
+use winit::dpi::PhysicalPosition;
+use winit::event_loop::ActiveEventLoop;
+use winit::window::WindowId;
+
+pub(crate) struct GlobalEyedropperImpl {
+	primary: bool,
+}
+
+impl super::NativeEyedropper for GlobalEyedropperImpl {
+	fn new() -> Self {
+		Self { primary: true }
+	}
+
+	fn start(&mut self, _event_loop: &dyn ActiveEventLoop, _primary: bool) {
+		tracing::warn!("Global eyedropper is not yet supported on this platform");
+	}
+
+	fn stop(&mut self) {}
+
+	fn is_active(&self) -> bool {
+		false
+	}
+
+	fn window_id(&self) -> Option<WindowId> {
+		None
+	}
+
+	fn update(&mut self, _position: PhysicalPosition<f64>) {}
+
+	fn render(&self) {}
+
+	fn sample_color(&self) -> Option<Color> {
+		None
+	}
+
+	fn is_primary(&self) -> bool {
+		self.primary
+	}
+}

desktop/src/global_eyedropper/mac.rs

@@ -0,0 +1,40 @@
+use graphene_std::raster::color::Color;
+use winit::dpi::PhysicalPosition;
+use winit::event_loop::ActiveEventLoop;
+use winit::window::WindowId;
+
+pub(crate) struct GlobalEyedropperImpl {
+	primary: bool,
+}
+
+impl super::NativeEyedropper for GlobalEyedropperImpl {
+	fn new() -> Self {
+		Self { primary: true }
+	}
+
+	fn start(&mut self, _event_loop: &dyn ActiveEventLoop, _primary: bool) {
+		tracing::warn!("Global eyedropper is not yet supported on this platform");
+	}
+
+	fn stop(&mut self) {}
+
+	fn is_active(&self) -> bool {
+		false
+	}
+
+	fn window_id(&self) -> Option<WindowId> {
+		None
+	}
+
+	fn update(&mut self, _position: PhysicalPosition<f64>) {}
+
+	fn render(&self) {}
+
+	fn sample_color(&self) -> Option<Color> {
+		None
+	}
+
+	fn is_primary(&self) -> bool {
+		self.primary
+	}
+}

desktop/src/global_eyedropper/mod.rs

@@ -0,0 +1,33 @@
+use graphene_std::raster::color::Color;
+use winit::dpi::PhysicalPosition;
+use winit::event_loop::ActiveEventLoop;
+use winit::window::WindowId;
+
+pub(crate) trait NativeEyedropper {
+	fn new() -> Self;
+	fn start(&mut self, event_loop: &dyn ActiveEventLoop, primary: bool);
+	fn stop(&mut self);
+	fn is_active(&self) -> bool;
+	fn window_id(&self) -> Option<WindowId>;
+	fn update(&mut self, position: PhysicalPosition<f64>);
+	fn render(&self);
+	fn sample_color(&self) -> Option<Color>;
+	fn is_primary(&self) -> bool;
+}
+
+#[cfg(target_os = "windows")]
+mod win;
+#[cfg(target_os = "windows")]
+use win as native;
+
+#[cfg(target_os = "linux")]
+mod linux;
+#[cfg(target_os = "linux")]
+use linux as native;
+
+#[cfg(target_os = "macos")]
+mod mac;
+#[cfg(target_os = "macos")]
+use mac as native;
+
+pub(crate) type GlobalEyedropper = native::GlobalEyedropperImpl;

desktop/src/global_eyedropper/win.rs

@@ -0,0 +1,176 @@
+use graphene_std::raster::color::Color;
+use winit::dpi::{PhysicalPosition, PhysicalSize};
+use winit::event_loop::ActiveEventLoop;
+use winit::raw_window_handle::HasWindowHandle;
+use winit::window::{Window, WindowAttributes, WindowId};
+use windows::Win32::Foundation::{HWND, RECT};
+use windows::Win32::Graphics::Gdi::{
+	CreateCompatibleBitmap, CreateCompatibleDC, DeleteDC, DeleteObject, FrameRect, GetDC, GetStockObject, ReleaseDC, SelectObject, StretchBlt, BLACK_BRUSH, SRCCOPY,
+};
+use windows::Win32::UI::WindowsAndMessaging::GetCursorPos;
+
+const MAGNIFIER_RES: u32 = 11;
+const MAGNIFIER_SIZE: u32 = 110;
+
+pub(crate) struct GlobalEyedropperImpl {
+	window: Option<Window>,
+	primary: bool,
+}
+
+impl super::NativeEyedropper for GlobalEyedropperImpl {
+	fn new() -> Self {
+		Self {
+			window: None,
+			primary: true,
+		}
+	}
+
+	fn start(&mut self, event_loop: &dyn ActiveEventLoop, primary: bool) {
+		if self.is_active() {
+			return;
+		}
+
+		self.primary = primary;
+		let attributes = WindowAttributes::default()
+			.with_title("Graphite Eyedropper")
+			.with_decorations(false)
+			.with_transparent(true)
+			.with_always_on_top(true)
+			.with_visible(false);
+
+		match event_loop.create_window(attributes) {
+			Ok(window) => {
+				self.window = Some(window);
+			}
+			Err(e) => {
+				tracing::error!("Failed to create global eyedropper window: {:?}", e);
+			}
+		}
+	}
+
+	fn stop(&mut self) {
+		self.window = None;
+	}
+
+	fn is_active(&self) -> bool {
+		self.window.is_some()
+	}
+
+	fn window_id(&self) -> Option<WindowId> {
+		self.window.as_ref().map(|w| w.id())
+	}
+
+	fn update(&mut self, position: PhysicalPosition<f64>) {
+		let Some(window) = &self.window else { return };
+
+		let size = PhysicalSize::new(MAGNIFIER_SIZE, MAGNIFIER_SIZE);
+		window.set_outer_position(PhysicalPosition::new(position.x - size.width as f64 / 2., position.y - size.height as f64 / 2.));
+		window.set_min_surface_size(Some(size.into()));
+		window.set_visible(true);
+		window.request_redraw();
+	}
+
+	fn render(&self) {
+		let Some(_window) = &self.window else { return };
+
+		unsafe {
+			let mut pt = Default::default();
+			if GetCursorPos(&mut pt).is_err() {
+				return;
+			}
+
+			let pixel_size = MAGNIFIER_SIZE / MAGNIFIER_RES;
+			let half = MAGNIFIER_RES as i32 / 2;
+
+			let desktop_dc = GetDC(HWND::default());
+			let window_hwnd = self.window_hwnd();
+			let window_dc = GetDC(window_hwnd);
+
+			let mem_dc = CreateCompatibleDC(desktop_dc);
+			let bitmap = CreateCompatibleBitmap(desktop_dc, MAGNIFIER_RES as i32, MAGNIFIER_RES as i32);
+			let old_bitmap = SelectObject(mem_dc, bitmap);
+
+			StretchBlt(
+				mem_dc,
+				0,
+				0,
+				MAGNIFIER_RES as i32,
+				MAGNIFIER_RES as i32,
+				desktop_dc,
+				pt.x - half,
+				pt.y - half,
+				MAGNIFIER_RES as i32,
+				MAGNIFIER_RES as i32,
+				SRCCOPY,
+			)
+			.ok();
+
+			StretchBlt(
+				window_dc,
+				0,
+				0,
+				MAGNIFIER_SIZE as i32,
+				MAGNIFIER_SIZE as i32,
+				mem_dc,
+				0,
+				0,
+				MAGNIFIER_RES as i32,
+				MAGNIFIER_RES as i32,
+				SRCCOPY,
+			)
+			.ok();
+
+			SelectObject(mem_dc, old_bitmap);
+			let _ = DeleteObject(bitmap);
+			let _ = DeleteDC(mem_dc);
+
+			let mid = MAGNIFIER_RES / 2;
+			let rect = RECT {
+				left: (mid * pixel_size) as i32,
+				top: (mid * pixel_size) as i32,
+				right: ((mid + 1) * pixel_size) as i32,
+				bottom: ((mid + 1) * pixel_size) as i32,
+			};
+			let black_brush = GetStockObject(BLACK_BRUSH);
+			FrameRect(window_dc, &rect, black_brush.into());
+
+			ReleaseDC(HWND::default(), desktop_dc);
+			ReleaseDC(window_hwnd, window_dc);
+		}
+	}
+
+	fn sample_color(&self) -> Option<Color> {
+		unsafe {
+			let mut pt = Default::default();
+			if GetCursorPos(&mut pt).is_err() {
+				return None;
+			}
+
+			let hdc = GetDC(HWND::default());
+			let pixel = windows::Win32::Graphics::Gdi::GetPixel(hdc, pt.x, pt.y);
+			ReleaseDC(HWND::default(), hdc);
+
+			let r = (pixel.0 & 0xFF) as f32 / 255.0;
+			let g = ((pixel.0 >> 8) & 0xFF) as f32 / 255.0;
+			let b = ((pixel.0 >> 16) & 0xFF) as f32 / 255.0;
+
+			Some(Color::from_rgbaf32_unchecked(r, g, b, 1.0))
+		}
+	}
+
+	fn is_primary(&self) -> bool {
+		self.primary
+	}
+}
+
+impl GlobalEyedropperImpl {
+	fn window_hwnd(&self) -> HWND {
+		let Some(window) = &self.window else {
+			return HWND::default();
+		};
+		HWND(match window.window_handle().unwrap().as_raw() {
+			winit::raw_window_handle::RawWindowHandle::Win32(handle) => handle.hwnd.get() as isize,
+			_ => 0,
+		})
+	}
+}