Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
gpui: Smooth frame pacing in macOS Low Power Mode (#63477)
Lukas Wirthfdcb19811034
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rsindex 8167c2e6b9b..7eca7f2f206 100644--- a/crates/gpui/src/app.rs+++ b/crates/gpui/src/app.rs@@ -51,9 +51,9 @@ use crate::{DisplayChanges, DisplayEvent, DisplayId, EventEmitter, ExternalDragPayload, FocusHandle,FocusMap, ForegroundExecutor, Global, KeyBinding, KeyContext, Keymap, Keystroke, LayoutId,Menu, MenuItem, MissingGlyph, OwnedMenu, PathPromptOptions, Pixels, Platform, PlatformDisplay,- PlatformKeyboardLayout, PlatformKeyboardMapper, Point, Priority, PromptBuilder, PromptButton,- PromptHandle, PromptLevel, Render, RenderImage, RenderablePromptHandle, Reservation,- ScreenCaptureSource, SharedString, SubscriberSet, Subscription, SvgRenderer,+ PlatformKeyboardLayout, PlatformKeyboardMapper, Point, PowerMode, Priority, PromptBuilder,+ PromptButton, PromptHandle, PromptLevel, Render, RenderImage, RenderablePromptHandle,+ Reservation, ScreenCaptureSource, SharedString, SubscriberSet, Subscription, SvgRenderer,SystemNotification, SystemNotificationResponse, Task, TextRenderingMode, TextSystem,ThermalState, Window, WindowAppearance, WindowButtonLayout, WindowHandle, WindowId,WindowInvalidator, WindowingRequest,@@ -939,6 +939,7 @@ pub struct App {pub(crate) reduce_motion: bool,/// Origin of the shared clock that phase-locks synced repeating animations.pub(crate) synced_animation_epoch: Instant,+ power_mode: PowerMode,/// Whether the app was created by [`Application::new_inaccessible`]. No/// accesskit APIs will be called when this flag is set.pub(crate) accessibility_force_disabled: bool,@@ -973,6 +974,7 @@ impl App {let entities = EntityMap::new();let keyboard_layout = platform.keyboard_layout();let keyboard_mapper = platform.keyboard_mapper();+ let power_mode = platform.power_mode();#[cfg(any(test, gpui_leak_detection))]let _ref_counts = entities.ref_counts_drop_handle();@@ -1048,6 +1050,7 @@ impl App {cursor_hide_mode: CursorHideMode::default(),reduce_motion: false,synced_animation_epoch,+ power_mode,accessibility_force_disabled: false,#[cfg(any(test, feature = "test-support", debug_assertions))]@@ -1150,6 +1153,16 @@ impl App {}}));+ platform.on_power_mode_change(Box::new({+ let app = Rc::downgrade(&app);+ move || {+ if let Some(app) = app.upgrade() {+ let power_mode = app.borrow().platform.power_mode();+ app.borrow_mut().power_mode = power_mode;+ }+ }+ }));+platform.on_quit(Box::new({let cx = Rc::downgrade(&app);move || {@@ -1814,6 +1827,12 @@ impl App {self.text_rendering_mode.get()}+ /// Returns the operating system's power mode, or [`PowerMode::Unknown`]+ /// when the platform cannot determine it.+ pub fn power_mode(&self) -> PowerMode {+ self.power_mode+ }+/// Writes data to the platform clipboard.pub fn write_to_clipboard(&self, item: ClipboardItem) {self.platform.write_to_clipboard(item)diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rsindex 90b3bc39e3a..a99c4ba3e46 100644--- a/crates/gpui/src/platform.rs+++ b/crates/gpui/src/platform.rs@@ -514,6 +514,14 @@ pub trait Platform: 'static {fn on_thermal_state_change(&self, callback: Box<dyn FnMut()>);fn prevent_idle_sleep(&self, reason: &str) -> Task<Result<ActivityGuard>>;+ /// Returns the operating system's power mode, or [`PowerMode::Unknown`]+ /// when the platform cannot determine it.+ fn power_mode(&self) -> PowerMode {+ PowerMode::Unknown+ }+ /// Registers a callback invoked when the reported power mode changes.+ fn on_power_mode_change(&self, _callback: Box<dyn FnMut()>) {}+/// Sets the application's process-wide identity and user-visible name.////// The identifier is used for platform identity mechanisms such as the@@ -701,6 +709,20 @@ pub struct SystemNotificationResponse {pub action_id: Option<SharedString>,}+/// The operating system's preference for energy use versus performance.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum PowerMode {+ /// The platform cannot determine the mode, or cannot distinguish the+ /// active mode from other non-low-power modes.+ Unknown,+ /// The system prioritizes reducing energy use.+ LowPower,+ /// The system balances energy use and performance.+ Balanced,+ /// The system prioritizes performance over energy use.+ HighPower,+}+/// Thermal state of the system#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum ThermalState {diff --git a/crates/gpui/src/profiler/journal.rs b/crates/gpui/src/profiler/journal.rsindex 39df15d5173..28c66b6e809 100644--- a/crates/gpui/src/profiler/journal.rs+++ b/crates/gpui/src/profiler/journal.rs@@ -165,6 +165,8 @@ pub enum FrameSkipReason {InactiveFrameRateLimit,/// Thermal throttling deferred drawing.ThermalFrameRateLimit,+ /// Low power mode deferred drawing.+ LowPowerFrameRateLimit,}/// A completed frame request that returned without drawing a new frame.diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rsindex 006692dcc92..0d83066db80 100644--- a/crates/gpui/src/window.rs+++ b/crates/gpui/src/window.rs@@ -146,15 +146,6 @@ struct FrameDirtyAccumulator {invalidations: u64,}-/// Why GPUI capped a window's frame rate.-#[derive(Clone, Copy)]-enum FrameRateLimit {- /// The window isn't focused.- Inactive,- /// The system is under thermal pressure.- Thermal,-}-#[derive(Clone)]pub(crate) struct WindowInvalidator {inner: Rc<RefCell<WindowInvalidatorInner>>,@@ -1332,6 +1323,47 @@ pub(crate) struct InputRateTracker {sustain_duration: Duration,}+const THIRTY_FPS_INTERVAL: Duration = Duration::from_micros(33333);+const SIXTY_FPS_INTERVAL: Duration = Duration::from_micros(16667);+const FRAME_INTERVAL_TOLERANCE: Duration = Duration::from_millis(1);++/// Display-link timestamps can straddle a target interval by fractions of a+/// millisecond. Accepting that callback preserves an even display-frame divisor+/// instead of occasionally waiting for an additional refresh.+fn frame_request_arrived_too_early(elapsed: Duration, minimum_interval: Duration) -> bool {+ elapsed < minimum_interval.saturating_sub(FRAME_INTERVAL_TOLERANCE)+}++fn minimum_frame_interval(+ should_throttle: bool,+ inactive_without_high_rate_input: bool,+ inactive_frame_interval: Option<Duration>,+ thermal_state: ThermalState,+ power_mode: crate::PowerMode,+) -> Option<Duration> {+ let low_power_mode_enabled = power_mode == crate::PowerMode::LowPower;+ if !should_throttle {+ None+ } else if inactive_without_high_rate_input {+ match (inactive_frame_interval, low_power_mode_enabled) {+ (Some(inactive_frame_interval), true) => {+ Some(inactive_frame_interval.max(THIRTY_FPS_INTERVAL))+ }+ (inactive_frame_interval, false) => inactive_frame_interval,+ (None, true) => Some(THIRTY_FPS_INTERVAL),+ }+ } else if low_power_mode_enabled {+ Some(THIRTY_FPS_INTERVAL)+ } else if matches!(+ thermal_state,+ ThermalState::Critical | ThermalState::Serious+ ) {+ Some(SIXTY_FPS_INTERVAL)+ } else {+ None+ }+}+impl Default for InputRateTracker {fn default() -> Self {Self {@@ -1830,31 +1862,37 @@ impl Window {let force_render =mem::take(&mut deferred_force_render) || request_frame_options.force_render;- let thermal_state = handle- .update(&mut cx, |_, _, cx| cx.thermal_state())+ let power_state = handle+ .update(&mut cx, |_, _, cx| (cx.thermal_state(), cx.power_mode())).log_err();// Throttle frame rate based on conditions:// - Thermal pressure (Serious/Critical): cap to ~60fps- // - Inactive window (not focused): cap to ~30fps to save energy- let min_frame_interval = if request_frame_options.require_presentation- || (!request_frame_options.force_render- && next_frame_callbacks.borrow().is_empty())- {- None- } else if !active.get() && !input_rate_tracker.borrow_mut().is_high_rate() {- inactive_frame_interval.map(|interval| (interval, FrameRateLimit::Inactive))- } else if let Some(ThermalState::Critical | ThermalState::Serious) = thermal_state {- Some((Duration::from_micros(16667), FrameRateLimit::Thermal))- } else {- None- };+ // - Low power mode: cap to ~30fps+ // - Inactive window (not focused): use its configured frame interval+ let should_throttle = !request_frame_options.require_presentation+ && (request_frame_options.force_render+ || !next_frame_callbacks.borrow().is_empty());+ let inactive_without_high_rate_input = should_throttle+ && !active.get()+ && !input_rate_tracker.borrow_mut().is_high_rate();+ let (thermal_state, power_mode) =+ power_state.unwrap_or((ThermalState::Nominal, crate::PowerMode::Unknown));+ let min_frame_interval = minimum_frame_interval(+ should_throttle,+ inactive_without_high_rate_input,+ inactive_frame_interval,+ thermal_state,+ power_mode,+ );let now = Instant::now();- #[cfg_attr(not(feature = "profiler"), expect(unused_variables))]- if let Some((min_interval, limit)) = min_frame_interval {+ if let Some(min_interval) = min_frame_interval {if let Some(last_frame) = last_frame_time.get()- && now.duration_since(last_frame) < min_interval+ && frame_request_arrived_too_early(+ now.duration_since(last_frame),+ min_interval,+ ){// Don't lose a pending forced render to throttling.deferred_force_render |= force_render;@@ -1873,13 +1911,12 @@ impl Window {profiler::journal::record_frame_skipped(window_id,Instant::now(),- match limit {- FrameRateLimit::Inactive => {- profiler::journal::FrameSkipReason::InactiveFrameRateLimit- }- FrameRateLimit::Thermal => {- profiler::journal::FrameSkipReason::ThermalFrameRateLimit- }+ if inactive_without_high_rate_input {+ profiler::journal::FrameSkipReason::InactiveFrameRateLimit+ } else if power_mode == crate::PowerMode::LowPower {+ profiler::journal::FrameSkipReason::LowPowerFrameRateLimit+ } else {+ profiler::journal::FrameSkipReason::ThermalFrameRateLimit},);return;@@ -7919,9 +7956,9 @@ mod tests {FileDragPaths, FileDropEvent, FocusHandle, InputEvent as _, InteractiveElement as _,IntoElement, KeyDownEvent, Keystroke, LongPressEvent, MouseButton, MouseDownEvent,MouseMoveEvent, ParentElement, Pixels, PlatformInput, Point, Render, RequestFrameOptions,- ScaledPixels, StatefulInteractiveElement as _, Styled, TestAppContext, TouchDragEvent,- TouchEvent, TouchId, TouchPhase, Underline, UnderlineStyle, Window, WindowAppearance,- WindowOptions, canvas, div, hsla, point, px, size,+ ScaledPixels, StatefulInteractiveElement as _, Styled, TestAppContext, ThermalState,+ TouchDragEvent, TouchEvent, TouchId, TouchPhase, Underline, UnderlineStyle, Window,+ WindowAppearance, WindowOptions, canvas, div, hsla, point, px, size,};#[gpui::test]@@ -8429,6 +8466,64 @@ mod tests {.unwrap();}+ #[test]+ fn frame_throttle_accepts_display_link_rounding() {+ assert!(!super::frame_request_arrived_too_early(+ Duration::from_micros(16_666),+ super::SIXTY_FPS_INTERVAL,+ ));+ assert!(!super::frame_request_arrived_too_early(+ Duration::from_micros(33_332),+ super::THIRTY_FPS_INTERVAL,+ ));+ }++ #[test]+ fn frame_throttle_rejects_an_extra_display_refresh() {+ assert!(super::frame_request_arrived_too_early(+ Duration::from_micros(8_333),+ super::SIXTY_FPS_INTERVAL,+ ));+ assert!(super::frame_request_arrived_too_early(+ Duration::from_micros(16_666),+ super::THIRTY_FPS_INTERVAL,+ ));+ }++ #[test]+ fn power_modes_preserve_frame_limits() {+ for (power_mode, active_interval, thermal_interval) in [+ (+ crate::PowerMode::LowPower,+ Some(super::THIRTY_FPS_INTERVAL),+ super::THIRTY_FPS_INTERVAL,+ ),+ (crate::PowerMode::Unknown, None, super::SIXTY_FPS_INTERVAL),+ (crate::PowerMode::Balanced, None, super::SIXTY_FPS_INTERVAL),+ (crate::PowerMode::HighPower, None, super::SIXTY_FPS_INTERVAL),+ ] {+ assert_eq!(+ super::minimum_frame_interval(true, false, None, ThermalState::Nominal, power_mode),+ active_interval,+ );+ assert_eq!(+ super::minimum_frame_interval(true, false, None, ThermalState::Serious, power_mode),+ Some(thermal_interval),+ );+ let inactive_interval = Duration::from_millis(100);+ assert_eq!(+ super::minimum_frame_interval(+ true,+ true,+ Some(inactive_interval),+ ThermalState::Nominal,+ power_mode,+ ),+ Some(inactive_interval),+ );+ }+ }+struct EmptyView;impl Render for EmptyView {diff --git a/crates/gpui_apple/src/gpui_apple.rs b/crates/gpui_apple/src/gpui_apple.rsindex f3ce55a202c..1e3d0e58515 100644--- a/crates/gpui_apple/src/gpui_apple.rs+++ b/crates/gpui_apple/src/gpui_apple.rs@@ -9,7 +9,7 @@ mod dispatcher;pub mod keychain;mod metal_atlas;pub mod metal_renderer;-pub mod thermal;+pub mod process_info;#[cfg(feature = "font-kit")]mod open_type;diff --git a/crates/gpui_apple/src/process_info.rs b/crates/gpui_apple/src/process_info.rsnew file mode 100644index 00000000000..a988581141d--- /dev/null+++ b/crates/gpui_apple/src/process_info.rs@@ -0,0 +1,182 @@+use block2::RcBlock;+use futures::{StreamExt, channel::mpsc};+use gpui::{ForegroundExecutor, PowerMode, Task, ThermalState};+use objc2::{rc::Retained, runtime::ProtocolObject};+use objc2_foundation::{+ NSNotification, NSNotificationCenter, NSNotificationName, NSObjectProtocol, NSProcessInfo,+ NSProcessInfoPowerStateDidChangeNotification, NSProcessInfoThermalState,+ NSProcessInfoThermalStateDidChangeNotification,+};++pub fn thermal_state() -> ThermalState {+ match NSProcessInfo::processInfo().thermalState() {+ NSProcessInfoThermalState::Fair => ThermalState::Fair,+ NSProcessInfoThermalState::Serious => ThermalState::Serious,+ NSProcessInfoThermalState::Critical => ThermalState::Critical,+ _ => ThermalState::Nominal,+ }+}++pub fn power_mode() -> PowerMode {+ if NSProcessInfo::processInfo().isLowPowerModeEnabled() {+ PowerMode::LowPower+ } else {+ // This API does not distinguish Automatic from High Power Mode on macOS.+ PowerMode::Unknown+ }+}++pub fn observe_thermal_state(+ executor: &ForegroundExecutor,+ callback: Box<dyn FnMut()>,+) -> ProcessInfoObserver {+ // Foundation requires reading thermalState before registering for changes.+ // https://developer.apple.com/documentation/foundation/processinfo/thermalstatedidchangenotification+ thermal_state();+ ProcessInfoObserver::new(+ unsafe { NSProcessInfoThermalStateDidChangeNotification },+ executor,+ callback,+ )+}++pub fn observe_power_mode(+ executor: &ForegroundExecutor,+ callback: Box<dyn FnMut()>,+) -> ProcessInfoObserver {+ ProcessInfoObserver::new(+ unsafe { NSProcessInfoPowerStateDidChangeNotification },+ executor,+ callback,+ )+}++pub struct ProcessInfoObserver {+ center: Retained<NSNotificationCenter>,+ observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,+ _task: Task<()>,+}++impl ProcessInfoObserver {+ fn new(+ name: &NSNotificationName,+ executor: &ForegroundExecutor,+ callback: Box<dyn FnMut()>,+ ) -> Self {+ Self::with_center(+ NSNotificationCenter::defaultCenter(),+ name,+ executor,+ callback,+ )+ }++ fn with_center(+ center: Retained<NSNotificationCenter>,+ name: &NSNotificationName,+ executor: &ForegroundExecutor,+ mut callback: Box<dyn FnMut()>,+ ) -> Self {+ let (sender, mut receiver) = mpsc::unbounded();+ let block = RcBlock::new(move |_: std::ptr::NonNull<NSNotification>| {+ // Notifications can arrive synchronously or off-thread. Defer application+ // callbacks so they cannot reenter GPUI while it is already borrowed.+ if sender.unbounded_send(()).is_err() {+ log::debug!("process info observer stopped before notification delivery");+ }+ });+ let observer = unsafe {+ center.addObserverForName_object_queue_usingBlock(+ Some(name),+ Some(&NSProcessInfo::processInfo()),+ None,+ &block,+ )+ };+ let task = executor.spawn(async move {+ while receiver.next().await.is_some() {+ callback();+ }+ });+ Self {+ center,+ observer,+ _task: task,+ }+ }+}++impl Drop for ProcessInfoObserver {+ fn drop(&mut self) {+ unsafe {+ self.center.removeObserver(self.observer.as_ref());+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::{cell::Cell, rc::Rc};++ fn post_notification(center: &NSNotificationCenter, name: &NSNotificationName) {+ unsafe {+ center.postNotificationName_object(name, Some(&NSProcessInfo::processInfo()));+ }+ }++ #[gpui::test]+ fn notifications_are_deferred_and_cancelled_on_drop(cx: &mut gpui::TestAppContext) {+ for name in unsafe {+ [+ NSProcessInfoPowerStateDidChangeNotification,+ NSProcessInfoThermalStateDidChangeNotification,+ ]+ } {+ check_notification_lifecycle(cx, name);+ }+ }++ fn check_notification_lifecycle(+ cx: &mut gpui::TestAppContext,+ name: &'static NSNotificationName,+ ) {+ // Tests cannot share the default center because they run concurrently.+ let center = NSNotificationCenter::new();+ let calls = Rc::new(Cell::new(0));+ let observer = ProcessInfoObserver::with_center(+ center.clone(),+ name,+ &cx.foreground_executor,+ Box::new({+ let calls = calls.clone();+ move || calls.set(calls.get() + 1)+ }),+ );+ post_notification(¢er, name);+ assert_eq!(calls.get(), 0);+ cx.run_until_parked();+ assert_eq!(calls.get(), 1);++ cx.background_executor+ .spawn({+ let center = center.clone();+ let name = name.to_string();+ async move {+ post_notification(¢er, &objc2_foundation::NSString::from_str(&name))+ }+ })+ .detach();+ assert_eq!(calls.get(), 1);+ cx.run_until_parked();+ assert_eq!(calls.get(), 2);++ post_notification(¢er, name);+ drop(observer);+ cx.run_until_parked();+ assert_eq!(calls.get(), 2);+ post_notification(¢er, name);+ cx.run_until_parked();+ assert_eq!(calls.get(), 2);+ }+}diff --git a/crates/gpui_apple/src/thermal.rs b/crates/gpui_apple/src/thermal.rsdeleted file mode 100644index 24cc84e6baa..00000000000--- a/crates/gpui_apple/src/thermal.rs+++ /dev/null@@ -1,113 +0,0 @@-use block2::RcBlock;-use futures::{StreamExt, channel::mpsc};-use gpui::{ForegroundExecutor, Task, ThermalState};-use objc2::{rc::Retained, runtime::ProtocolObject};-use objc2_foundation::{- NSNotification, NSNotificationCenter, NSObjectProtocol, NSProcessInfo,- NSProcessInfoThermalState, NSProcessInfoThermalStateDidChangeNotification,-};--pub fn thermal_state() -> ThermalState {- match NSProcessInfo::processInfo().thermalState() {- NSProcessInfoThermalState::Fair => ThermalState::Fair,- NSProcessInfoThermalState::Serious => ThermalState::Serious,- NSProcessInfoThermalState::Critical => ThermalState::Critical,- _ => ThermalState::Nominal,- }-}--pub struct ThermalObserver {- center: Retained<NSNotificationCenter>,- observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,- _task: Task<()>,-}--impl ThermalObserver {- pub fn new(executor: &ForegroundExecutor, callback: Box<dyn FnMut()>) -> Self {- Self::with_center(NSNotificationCenter::defaultCenter(), executor, callback)- }-- fn with_center(- center: Retained<NSNotificationCenter>,- executor: &ForegroundExecutor,- mut callback: Box<dyn FnMut()>,- ) -> Self {- let (sender, mut receiver) = mpsc::unbounded();- let block = RcBlock::new(move |_: std::ptr::NonNull<NSNotification>| {- // NotificationCenter can call synchronously or off-thread. Never enter- // application code here: GPUI may already be borrowed on the main thread.- if sender.unbounded_send(()).is_err() {- log::debug!("thermal observer stopped before notification delivery");- }- });- let observer = unsafe {- center.addObserverForName_object_queue_usingBlock(- Some(NSProcessInfoThermalStateDidChangeNotification),- Some(&NSProcessInfo::processInfo()),- None,- &block,- )- };- let task = executor.spawn(async move {- while receiver.next().await.is_some() {- callback();- }- });- Self {- center,- observer,- _task: task,- }- }-}--impl Drop for ThermalObserver {- fn drop(&mut self) {- unsafe {- self.center.removeObserver(self.observer.as_ref());- }- }-}--#[cfg(test)]-mod tests {- use super::*;- use std::{cell::Cell, rc::Rc};-- // Tests run concurrently in one process, so they cannot share the default center.- fn post_thermal_notification(center: &NSNotificationCenter) {- unsafe {- center.postNotificationName_object(- NSProcessInfoThermalStateDidChangeNotification,- Some(&NSProcessInfo::processInfo()),- );- }- }-- #[gpui::test]- fn notifications_are_deferred_and_cancelled_on_drop(cx: &mut gpui::TestAppContext) {- let center = NSNotificationCenter::new();- let calls = Rc::new(Cell::new(0));- let observer = ThermalObserver::with_center(- center.clone(),- &cx.foreground_executor,- Box::new({- let calls = calls.clone();- move || calls.set(calls.get() + 1)- }),- );- let post_notification = || post_thermal_notification(¢er);- post_notification();- assert_eq!(calls.get(), 0);- cx.run_until_parked();- assert_eq!(calls.get(), 1);-- post_notification();- drop(observer);- cx.run_until_parked();- assert_eq!(calls.get(), 1);- post_notification();- cx.run_until_parked();- assert_eq!(calls.get(), 1);- }-}diff --git a/crates/gpui_ios/src/ios/platform.rs b/crates/gpui_ios/src/ios/platform.rsindex 13538a3d3e2..f1c5be758de 100644--- a/crates/gpui_ios/src/ios/platform.rs+++ b/crates/gpui_ios/src/ios/platform.rs@@ -20,11 +20,11 @@ use gpui::{Action, AnyWindowHandle, AppLifecyclePhase, BackgroundExecutor, ClipboardItem, CursorStyle,DummyKeyboardMapper, ForegroundExecutor, Keymap, Menu, MenuItem, PathPromptOptions, Platform,PlatformDisplay, PlatformKeyboardLayout, PlatformKeyboardMapper, PlatformTextSystem,- PlatformWindow, Result, Task, ThermalState, WindowAppearance, WindowParams,+ PlatformWindow, PowerMode, Result, Task, ThermalState, WindowAppearance, WindowParams,};use gpui_apple::{AppleDispatcher, keychain, main_thread_marker,- thermal::{self, ThermalObserver},+ process_info::{self, ProcessInfoObserver},};use objc2::{MainThreadOnly, rc::Retained, runtime::ProtocolObject};use objc2_foundation::{@@ -51,7 +51,8 @@ pub(crate) struct IosPlatformState {background_executor: BackgroundExecutor,foreground_executor: ForegroundExecutor,text_system: Arc<dyn PlatformTextSystem>,- thermal_observer: RefCell<Option<ThermalObserver>>,+ thermal_observer: RefCell<Option<ProcessInfoObserver>>,+ power_mode_observer: RefCell<Option<ProcessInfoObserver>>,display_observers: RefCell<Vec<Retained<ProtocolObject<dyn NSObjectProtocol>>>>,display_task: RefCell<Option<Task<()>>>,displays_changed_callback: CallbackSlot<Box<dyn FnMut()>>,@@ -75,6 +76,7 @@ impl IosPlatform {foreground_executor: ForegroundExecutor::new(dispatcher),text_system,thermal_observer: RefCell::new(None),+ power_mode_observer: RefCell::new(None),display_observers: RefCell::new(Vec::new()),display_task: RefCell::new(None),displays_changed_callback: CallbackSlot::default(),@@ -459,14 +461,23 @@ impl Platform for IosPlatform {}fn thermal_state(&self) -> ThermalState {- thermal::thermal_state()+ process_info::thermal_state()}fn on_thermal_state_change(&self, callback: Box<dyn FnMut()>) {- let observer = ThermalObserver::new(&self.0.foreground_executor, callback);+ let observer = process_info::observe_thermal_state(&self.0.foreground_executor, callback);self.0.thermal_observer.replace(Some(observer));}+ fn power_mode(&self) -> PowerMode {+ process_info::power_mode()+ }++ fn on_power_mode_change(&self, callback: Box<dyn FnMut()>) {+ let observer = process_info::observe_power_mode(&self.0.foreground_executor, callback);+ self.0.power_mode_observer.replace(Some(observer));+ }+fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {Box::new(IosKeyboardLayout)}diff --git a/crates/gpui_linux/src/linux.rs b/crates/gpui_linux/src/linux.rsindex e4da54b52b4..c5afc4a0f5d 100644--- a/crates/gpui_linux/src/linux.rs+++ b/crates/gpui_linux/src/linux.rs@@ -3,6 +3,8 @@ mod display_connection;mod headless;mod keyboard;mod platform;+#[cfg(any(feature = "wayland", feature = "x11"))]+mod power;mod system_notifications;#[cfg(any(feature = "wayland", feature = "x11"))]mod text_system;diff --git a/crates/gpui_linux/src/linux/platform.rs b/crates/gpui_linux/src/linux/platform.rsindex 0c5370db6ca..b24300bbc25 100644--- a/crates/gpui_linux/src/linux/platform.rs+++ b/crates/gpui_linux/src/linux/platform.rs@@ -39,7 +39,7 @@ use gpui::{Action, ActivityGuard, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle,ForegroundExecutor, GraphicalEnvironment, Keymap, Menu, MenuItem, OwnedMenu, PathPromptOptions,Platform, PlatformDisplay, PlatformKeyboardLayout, PlatformKeyboardMapper, PlatformTextSystem,- PlatformWindow, Result, RunnableVariant, Task, ThermalState, WindowAppearance,+ PlatformWindow, PowerMode, Result, RunnableVariant, Task, ThermalState, WindowAppearance,WindowButtonLayout, WindowParams, WindowingModes, WindowingRequest,};#[cfg(any(feature = "wayland", feature = "x11"))]@@ -71,11 +71,11 @@ pub(crate) struct PlatformHandlers {pub(crate) keyboard_layout_change: Option<Box<dyn FnMut()>>,pub(crate) system_sleep: Option<Box<dyn FnMut()>>,pub(crate) system_wake: Option<Box<dyn FnMut()>>,+ pub(crate) power_mode_change: Option<Box<dyn FnMut()>>,pub(crate) displays_changed: Option<Box<dyn FnMut()>>,}-/// A logind `PrepareForSleep` signal, forwarded from the D-Bus listener to-/// the client's event loop.+/// A system power change, forwarded from D-Bus to the client's event loop.#[derive(Debug, Clone, Copy, PartialEq, Eq)]#[cfg_attr(not(all(target_os = "linux", any(feature = "wayland", feature = "x11"))),@@ -84,6 +84,7 @@ pub(crate) struct PlatformHandlers {pub(crate) enum SystemPowerEvent {Sleep,Wake,+ ModeChanged(PowerMode),}pub(crate) struct LinuxCommon {@@ -104,6 +105,9 @@ pub(crate) struct LinuxCommon {)]power_sender: Sender<SystemPowerEvent>,power_listener_started: bool,+ power_mode: PowerMode,+ #[cfg(any(feature = "wayland", feature = "x11"))]+ power_mode_listener: Option<Task<()>>,/// Runs after each foreground runnable registered by [`LinuxCommon::register_sources`].////// X11 uses this to handle events that a runnable's requests read into xcb's queue, where@@ -148,6 +152,9 @@ impl LinuxCommon {),power_sender,power_listener_started: false,+ power_mode: PowerMode::Unknown,+ #[cfg(any(feature = "wayland", feature = "x11"))]+ power_mode_listener: None,after_runnable: None,};@@ -216,9 +223,16 @@ impl LinuxCommon {Ok(())}- /// Runs the app's sleep or wake callback, without `common` borrowed, since the callback+ /// Runs the app's power callback, without `common` borrowed, since the callback/// can call back into the platform.fn handle_system_power_event(common: &RefCell<Self>, event: SystemPowerEvent) {+ if let SystemPowerEvent::ModeChanged(mode) = event {+ let mut common = common.borrow_mut();+ if common.power_mode == mode {+ return;+ }+ common.power_mode = mode;+ }fn slot(callbacks: &mut PlatformHandlers,event: SystemPowerEvent,@@ -226,6 +240,7 @@ impl LinuxCommon {match event {SystemPowerEvent::Sleep => &mut callbacks.system_sleep,SystemPowerEvent::Wake => &mut callbacks.system_wake,+ SystemPowerEvent::ModeChanged(_) => &mut callbacks.power_mode_change,}}let callback = slot(&mut common.borrow_mut().callbacks, event).take();@@ -589,6 +604,34 @@ impl Platform for LinuxPlatform {ThermalState::Nominal}+ fn power_mode(&self) -> PowerMode {+ self.with_common(|common| common.power_mode)+ }++ fn on_power_mode_change(&self, callback: Box<dyn FnMut()>) {+ self.with_common(|common| {+ common.callbacks.power_mode_change = Some(callback);+ #[cfg(any(feature = "wayland", feature = "x11"))]+ if common.power_mode_listener.is_none() {+ let sender = common.power_sender.clone();+ common.power_mode_listener = Some(common.background_executor.spawn(async move {+ let result = async {+ let connection = ashpd::zbus::Connection::system().await?;+ crate::linux::power::monitor_power_mode(&connection, |mode| {+ sender.send(SystemPowerEvent::ModeChanged(mode))?;+ Ok(())+ })+ .await+ }+ .await;+ if let Err(error) = result {+ log::debug!("failed to monitor system power mode: {error:?}");+ }+ }));+ }+ });+ }+#[cfg(not(any(feature = "wayland", feature = "x11")))]fn prevent_idle_sleep(&self, reason: &str) -> Task<Result<ActivityGuard>> {Task::ready(Err(anyhow!(@@ -1714,6 +1757,43 @@ mod tests {use super::*;use gpui::{Point, px};+ #[test]+ fn power_mode_callbacks_can_reenter_and_replace_themselves() -> anyhow::Result<()> {+ let event_loop = EventLoop::<()>::try_new()?;+ let (common, _, _) = LinuxCommon::new(event_loop.get_signal());+ let common = Rc::new(RefCell::new(common));+ let calls = Rc::new(RefCell::new(Vec::new()));+ common.borrow_mut().callbacks.power_mode_change = Some(Box::new({+ let common = Rc::downgrade(&common);+ let calls = calls.clone();+ move || {+ let common = common.upgrade().expect("common is alive");+ calls.borrow_mut().push((common.borrow().power_mode, false));+ common.borrow_mut().callbacks.power_mode_change = Some(Box::new({+ let common = Rc::downgrade(&common);+ let calls = calls.clone();+ move || {+ let common = common.upgrade().expect("common is alive");+ calls.borrow_mut().push((common.borrow().power_mode, true));+ }+ }));+ }+ }));+ // Repeated reports of the same mode must not invoke the callback again.+ for mode in [+ PowerMode::LowPower,+ PowerMode::LowPower,+ PowerMode::Balanced,+ ] {+ LinuxCommon::handle_system_power_event(&common, SystemPowerEvent::ModeChanged(mode));+ }+ assert_eq!(+ *calls.borrow(),+ [(PowerMode::LowPower, false), (PowerMode::Balanced, true)]+ );+ Ok(())+ }+#[cfg(any(feature = "wayland", feature = "x11"))]#[test]fn rejects_null_xkb_context() {diff --git a/crates/gpui_linux/src/linux/power.rs b/crates/gpui_linux/src/linux/power.rsnew file mode 100644index 00000000000..83a75921ee8--- /dev/null+++ b/crates/gpui_linux/src/linux/power.rs@@ -0,0 +1,265 @@+use ashpd::zbus::{+ Connection, Proxy,+ fdo::PropertiesProxy,+ proxy::{Builder, CacheProperties},+};+use futures::{StreamExt as _, stream};+use gpui::PowerMode;++// The UPower namespace replaced net.hadess in v0.20; prefer it while retaining+// compatibility with older daemons.+// https://upower.pages.freedesktop.org/power-profiles-daemon/gdbus-org.freedesktop.UPower.PowerProfiles.html+// https://gitlab.freedesktop.org/upower/power-profiles-daemon/-/releases/0.20+const POWER_PROFILES_SERVICES: [(&str, &str); 2] = [+ (+ "org.freedesktop.UPower.PowerProfiles",+ "/org/freedesktop/UPower/PowerProfiles",+ ),+ ("net.hadess.PowerProfiles", "/net/hadess/PowerProfiles"),+];++fn power_mode(profile: &str) -> PowerMode {+ match profile {+ "power-saver" => PowerMode::LowPower,+ "balanced" => PowerMode::Balanced,+ "performance" => PowerMode::HighPower,+ _ => PowerMode::Unknown,+ }+}++pub(super) async fn monitor_power_mode(+ connection: &Connection,+ mut on_change: impl FnMut(PowerMode) -> anyhow::Result<()>,+) -> anyhow::Result<()> {+ let mut proxies = Vec::new();+ let mut changes = Vec::new();+ for (service, path) in POWER_PROFILES_SERVICES {+ let proxy = Builder::<Proxy<'_>>::new(connection)+ .destination(service)?+ .path(path)?+ .interface(service)?+ .cache_properties(CacheProperties::No)+ .build()+ .await?;+ let properties = PropertiesProxy::builder(connection)+ .destination(service)?+ .path(path)?+ .build()+ .await?;+ changes.push(+ properties+ .receive_properties_changed()+ .await?+ .map(|_| ())+ .boxed(),+ );+ changes.push(proxy.receive_owner_changed().await?.map(|_| ()).boxed());+ proxies.push(proxy);+ }+ let mut changes = stream::select_all(changes);+ let mut previous_mode = None;+ loop {+ // Subscribe before reading, and bypass property caches so service loss+ // cannot leave us reporting the previous owner's profile.+ let mut mode = PowerMode::Unknown;+ for proxy in &proxies {+ match proxy.get_property::<String>("ActiveProfile").await {+ Ok(profile) => {+ mode = power_mode(&profile);+ break;+ }+ Err(error) => log::debug!(+ "could not query power profile from {}: {error}",+ proxy.destination()+ ),+ }+ }+ if previous_mode != Some(mode) {+ on_change(mode)?;+ previous_mode = Some(mode);+ }+ if changes.next().await.is_none() {+ on_change(PowerMode::Unknown)?;+ anyhow::bail!("power profile notification streams closed");+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use anyhow::Context as _;+ use futures::channel::mpsc;+ use std::{+ collections::HashMap,+ io::{BufRead as _, BufReader},+ process::{Child, Stdio},+ sync::Arc,+ time::Duration,+ };++ struct TestBus(Child);++ impl TestBus {+ #[expect(+ clippy::disallowed_methods,+ reason = "this integration test owns and reaps a real D-Bus daemon"+ )]+ fn start() -> anyhow::Result<(Self, String)> {+ let child = gpui_util::new_std_command("dbus-daemon")+ .args(["--session", "--nofork", "--print-address=1"])+ .stdout(Stdio::piped())+ .spawn()?;+ let mut bus = Self(child);+ let stdout = bus+ .0+ .stdout+ .take()+ .context("missing D-Bus address output")?;+ let mut address = String::new();+ BufReader::new(stdout).read_line(&mut address)?;+ Ok((bus, address.trim().to_owned()))+ }+ }++ impl Drop for TestBus {+ fn drop(&mut self) {+ if let Err(error) = self.0.kill() {+ log::warn!("failed to stop test D-Bus daemon: {error}");+ }+ if let Err(error) = self.0.wait() {+ log::warn!("failed to reap test D-Bus daemon: {error}");+ }+ }+ }++ macro_rules! mock_profiles {+ ($name:ident, $interface:literal) => {+ struct $name(Arc<parking_lot::Mutex<String>>);++ #[ashpd::zbus::interface(name = $interface, crate = "ashpd::zbus")]+ impl $name {+ #[zbus(property)]+ fn active_profile(&self) -> String {+ self.0.lock().clone()+ }+ }+ };+ }++ mock_profiles!(ModernProfiles, "org.freedesktop.UPower.PowerProfiles");+ mock_profiles!(LegacyProfiles, "net.hadess.PowerProfiles");++ #[test]+ fn maps_profiles_without_guessing_unknown_values() {+ for (profile, expected) in [+ ("power-saver", PowerMode::LowPower),+ ("balanced", PowerMode::Balanced),+ ("performance", PowerMode::HighPower),+ ("custom", PowerMode::Unknown),+ ("", PowerMode::Unknown),+ ] {+ assert_eq!(power_mode(profile), expected);+ }+ }++ #[test]+ #[expect(+ clippy::disallowed_methods,+ reason = "real D-Bus I/O requires a wall-clock timeout, not a GPUI scheduler timer"+ )]+ fn monitors_profiles_and_service_restarts() -> anyhow::Result<()> {+ smol::block_on(futures::future::select(+ Box::pin(check_service_lifecycle()),+ Box::pin(async {+ smol::Timer::after(Duration::from_secs(15)).await;+ anyhow::bail!("timed out monitoring mock power profiles")+ }),+ ))+ .factor_first()+ .0+ }++ async fn check_service_lifecycle() -> anyhow::Result<()> {+ let (_bus, address) = TestBus::start()?;+ let modern_profile = Arc::new(parking_lot::Mutex::new("balanced".to_owned()));+ let legacy_profile = Arc::new(parking_lot::Mutex::new("balanced".to_owned()));+ let server = ashpd::zbus::connection::Builder::address(address.as_str())?+ .serve_at(+ POWER_PROFILES_SERVICES[0].1,+ ModernProfiles(modern_profile.clone()),+ )?+ .serve_at(+ POWER_PROFILES_SERVICES[1].1,+ LegacyProfiles(legacy_profile.clone()),+ )?+ .build()+ .await?;+ let connection = ashpd::zbus::connection::Builder::address(address.as_str())?+ .build()+ .await?;+ let (sender, mut receiver) = mpsc::unbounded();+ let monitor = smol::spawn({+ let connection = connection.clone();+ async move {+ monitor_power_mode(&connection, |mode| {+ sender.unbounded_send(mode)?;+ Ok(())+ })+ .await+ }+ });+ assert_eq!(receiver.next().await, Some(PowerMode::Unknown));++ for ((service, path), active_profile) in POWER_PROFILES_SERVICES+ .into_iter()+ .zip([&modern_profile, &legacy_profile])+ {+ server.request_name(service).await?;+ assert_eq!(receiver.next().await, Some(PowerMode::Balanced));+ for (profile, expected) in [+ ("power-saver", PowerMode::LowPower),+ ("performance", PowerMode::HighPower),+ ("custom", PowerMode::Unknown),+ ("balanced", PowerMode::Balanced),+ ] {+ *active_profile.lock() = profile.to_owned();+ server+ .emit_signal(+ None::<&str>,+ path,+ "org.freedesktop.DBus.Properties",+ "PropertiesChanged",+ &(+ service,+ HashMap::from([(+ "ActiveProfile",+ ashpd::zbus::zvariant::Value::from(profile),+ )]),+ Vec::<&str>::new(),+ ),+ )+ .await?;+ assert_eq!(receiver.next().await, Some(expected));+ }+ server.release_name(service).await?;+ assert_eq!(receiver.next().await, Some(PowerMode::Unknown));+ server.request_name(service).await?;+ assert_eq!(receiver.next().await, Some(PowerMode::Balanced));+ server.release_name(service).await?;+ assert_eq!(receiver.next().await, Some(PowerMode::Unknown));+ }+ *legacy_profile.lock() = "power-saver".to_owned();+ *modern_profile.lock() = "performance".to_owned();+ server.request_name(POWER_PROFILES_SERVICES[1].0).await?;+ assert_eq!(receiver.next().await, Some(PowerMode::LowPower));+ server.request_name(POWER_PROFILES_SERVICES[0].0).await?;+ assert_eq!(receiver.next().await, Some(PowerMode::HighPower));+ server.release_name(POWER_PROFILES_SERVICES[0].0).await?;+ assert_eq!(receiver.next().await, Some(PowerMode::LowPower));+ server.release_name(POWER_PROFILES_SERVICES[1].0).await?;+ assert_eq!(receiver.next().await, Some(PowerMode::Unknown));+ drop(monitor);+ Ok(())+ }+}diff --git a/crates/gpui_macos/src/platform.rs b/crates/gpui_macos/src/platform.rsindex 798262d47e3..aa0bc2d9ac2 100644--- a/crates/gpui_macos/src/platform.rs+++ b/crates/gpui_macos/src/platform.rs@@ -13,13 +13,13 @@ use gpui::{Action, ActivationPolicy, ActivityGuard, AnyWindowHandle, BackgroundExecutor, ClipboardItem,CursorStyle, ForegroundExecutor, GraphicalEnvironment, KeyContext, Keymap, Menu, MenuItem,OsMenu, OwnedMenu, PathPromptOptions, Platform, PlatformDisplay, PlatformKeyboardLayout,- PlatformKeyboardMapper, PlatformTextSystem, PlatformWindow, Result, SystemMenuType, Task,- ThermalState, WindowAppearance, WindowKind, WindowParams, WindowingRequest,+ PlatformKeyboardMapper, PlatformTextSystem, PlatformWindow, PowerMode, Result, SystemMenuType,+ Task, ThermalState, WindowAppearance, WindowKind, WindowParams, WindowingRequest,popup::PopupNotSupportedError,};use gpui_apple::{keychain,- thermal::{self, ThermalObserver},+ process_info::{self, ProcessInfoObserver},};use gpui_util::{ResultExt, new_std_command};use itertools::Itertools;@@ -151,7 +151,6 @@ unsafe fn build_classes() {sel!(onSystemSleep:),on_system_sleep as extern "C-unwind" fn(_, Sel, *mut AnyObject),);-decl.add_method(sel!(onSystemWake:),on_system_wake as extern "C-unwind" fn(_, Sel, *mut AnyObject),@@ -176,7 +175,8 @@ pub(crate) struct MacPlatformState {find_pasteboard: Pasteboard,reopen: Option<Box<dyn FnMut()>>,on_keyboard_layout_change: Option<Box<dyn FnMut()>>,- thermal_observer: Option<ThermalObserver>,+ thermal_observer: Option<ProcessInfoObserver>,+ power_mode_observer: Option<ProcessInfoObserver>,on_displays_changed: Option<Box<dyn FnMut()>>,on_system_sleep: Option<Box<dyn FnMut()>>,on_system_wake: Option<Box<dyn FnMut()>>,@@ -254,6 +254,7 @@ impl MacPlatform {dock_menu: None,on_keyboard_layout_change: None,thermal_observer: None,+ power_mode_observer: None,on_displays_changed: None,on_system_sleep: None,on_system_wake: None,@@ -1059,7 +1060,7 @@ impl Platform for MacPlatform {}fn on_thermal_state_change(&self, callback: Box<dyn FnMut()>) {- let observer = ThermalObserver::new(&self.foreground_executor(), callback);+ let observer = process_info::observe_thermal_state(&self.foreground_executor(), callback);self.0.lock().thermal_observer = Some(observer);}@@ -1068,13 +1069,18 @@ impl Platform for MacPlatform {self.ensure_system_power_observers();}+ fn on_power_mode_change(&self, callback: Box<dyn FnMut()>) {+ let observer = process_info::observe_power_mode(&self.foreground_executor(), callback);+ self.0.lock().power_mode_observer = Some(observer);+ }+fn on_system_wake(&self, callback: Box<dyn FnMut()>) {self.0.lock().on_system_wake = Some(callback);self.ensure_system_power_observers();}fn thermal_state(&self) -> ThermalState {- thermal::thermal_state()+ process_info::thermal_state()}fn prevent_idle_sleep(&self, reason: &str) -> Task<Result<ActivityGuard>> {@@ -1084,6 +1090,10 @@ impl Platform for MacPlatform {)))}+ fn power_mode(&self) -> PowerMode {+ process_info::power_mode()+ }+fn show_system_notification(&self, notification: gpui::SystemNotification) {let mut state = self.0.lock();let executor = state.foreground_executor.clone();@@ -1319,7 +1329,6 @@ extern "C-unwind" fn did_finish_launching(this: &AnyObject, _: Sel, _: *mut AnyOname: ns_string("NSApplicationDidChangeScreenParametersNotification"),object: ptr::null_mut::<AnyObject>()];-let platform = get_mac_platform(this);let callback = {let mut state = platform.0.lock();diff --git a/crates/gpui_windows/src/directx_renderer.rs b/crates/gpui_windows/src/directx_renderer.rsindex 98a13f304c8..da719662473 100644--- a/crates/gpui_windows/src/directx_renderer.rs+++ b/crates/gpui_windows/src/directx_renderer.rs@@ -409,7 +409,7 @@ impl DirectXRenderer {/// goes through MetalRenderer; this is the Windows analogue). Draws into/// the existing render target, copies it into a `D3D11_USAGE_STAGING`/// texture, maps it, and converts BGRA to RGBA.- #[cfg(any(test, feature = "test-support"))]+ #[cfg(feature = "test-support")]pub(crate) fn render_to_image(&mut self,scene: &Scene,diff --git a/crates/gpui_windows/src/platform.rs b/crates/gpui_windows/src/platform.rsindex 095e009e23e..72731ecb036 100644--- a/crates/gpui_windows/src/platform.rs+++ b/crates/gpui_windows/src/platform.rs@@ -28,7 +28,7 @@ use windows::{Ole::*,Power::*,SystemInformation::*,- SystemServices::POWER_REQUEST_CONTEXT_VERSION,+ SystemServices::{GUID_POWER_SAVING_STATUS, POWER_REQUEST_CONTEXT_VERSION},Threading::{POWER_REQUEST_CONTEXT_SIMPLE_STRING, REASON_CONTEXT, REASON_CONTEXT_0},},UI::{Input::KeyboardAndMouse::*, Shell::*, WindowsAndMessaging::*},@@ -71,6 +71,7 @@ pub struct WindowsPlatform {invalidate_devices: Arc<AtomicBool>,handle: HWND,suspend_resume_notification: RefCell<Option<HPOWERNOTIFY>>,+ power_saving_notification: RefCell<Option<HPOWERNOTIFY>>,disable_direct_composition: bool,has_package_identity: bool,app_identity: RefCell<Option<(String, String)>>,@@ -98,6 +99,7 @@ pub(crate) struct WindowsPlatformState {/// thread; see [`DrawCoordinator`].pub(crate) draw_coordinator: Rc<DrawCoordinator>,directx_devices: RefCell<Option<DirectXDevices>>,+ low_power_mode_enabled: Cell<bool>,}#[derive(Default)]@@ -111,6 +113,7 @@ struct PlatformCallbacks {keyboard_layout_change: Cell<Option<Box<dyn FnMut()>>>,system_sleep: Cell<Option<Box<dyn FnMut()>>>,system_wake: Cell<Option<Box<dyn FnMut()>>>,+ low_power_mode_change: Cell<Option<Box<dyn FnMut()>>>,displays_changed: Cell<Option<Box<dyn FnMut()>>>,}@@ -127,6 +130,7 @@ impl WindowsPlatformState {cursor_visible: Arc::new(AtomicBool::new(true)),draw_coordinator: Rc::new(DrawCoordinator::new()),directx_devices: RefCell::new(directx_devices),+ low_power_mode_enabled: Cell::new(false),menus: RefCell::new(Vec::new()),}}@@ -240,6 +244,14 @@ impl WindowsPlatform {.inner.take().context("CreateWindowExW did not run correctly")??;+ let mut power_status = SYSTEM_POWER_STATUS::default();+ match unsafe { GetSystemPowerStatus(&mut power_status) } {+ Ok(()) => inner+ .state+ .low_power_mode_enabled+ .set(power_status.SystemStatusFlag == 1),+ Err(error) => log::warn!("Failed to query Windows battery saver status: {error}"),+ }let dispatcher = context.dispatcher.take()@@ -278,6 +290,7 @@ impl WindowsPlatform {text_system,direct_write_text_system,suspend_resume_notification: RefCell::new(None),+ power_saving_notification: RefCell::new(None),disable_direct_composition,has_package_identity: has_package_identity(),drop_target_helper,@@ -877,6 +890,33 @@ impl Platform for WindowsPlatform {}}+ fn power_mode(&self) -> PowerMode {+ if self.inner.state.low_power_mode_enabled.get() {+ PowerMode::LowPower+ } else {+ PowerMode::HighPower+ }+ }++ fn on_power_mode_change(&self, callback: Box<dyn FnMut()>) {+ self.inner+ .state+ .callbacks+ .low_power_mode_change+ .set(Some(callback));+ let mut notification = self.power_saving_notification.borrow_mut();+ if notification.is_none() {+ *notification = unsafe {+ RegisterPowerSettingNotification(+ HANDLE(self.handle.0),+ &GUID_POWER_SAVING_STATUS,+ DEVICE_NOTIFY_WINDOW_HANDLE,+ )+ .log_err()+ };+ }+ }+fn set_app_identity(&self, identifier: &str, name: &str) {// If the process has package identity, it's automatally granted an AUMID by the system.if self.has_package_identity {@@ -1198,7 +1238,7 @@ impl WindowsPlatformInner {| WM_GPUI_KEYBOARD_LAYOUT_CHANGED| WM_GPUI_DISPLAYS_CHANGED| WM_GPUI_GPU_DEVICE_LOST => self.handle_gpui_events(msg, wparam, lparam),- WM_POWERBROADCAST => self.handle_power_broadcast(wparam),+ WM_POWERBROADCAST => self.handle_power_broadcast(wparam, lparam),WM_DISPLAYCHANGE => self.handle_display_change(handle),WM_QUERYENDSESSION => Some(1),WM_ENDSESSION if wparam.0 != 0 => self.handle_end_session(),@@ -1380,7 +1420,7 @@ impl WindowsPlatformInner {Some(0)}- fn handle_power_broadcast(&self, wparam: WPARAM) -> Option<isize> {+ fn handle_power_broadcast(&self, wparam: WPARAM, lparam: LPARAM) -> Option<isize> {match wparam.0 as u32 {PBT_APMSUSPEND => {self.with_callback(|callbacks| &callbacks.system_sleep, |callback| callback());@@ -1388,6 +1428,16 @@ impl WindowsPlatformInner {PBT_APMRESUMEAUTOMATIC => {self.with_callback(|callbacks| &callbacks.system_wake, |callback| callback());}+ PBT_POWERSETTINGCHANGE => {+ if let Some(enabled) = unsafe { power_saving_status(lparam) } {+ if self.state.low_power_mode_enabled.replace(enabled) != enabled {+ self.with_callback(+ |callbacks| &callbacks.low_power_mode_change,+ |callback| callback(),+ );+ }+ }+ }_ => {}}Some(1)@@ -1406,6 +1456,23 @@ impl WindowsPlatformInner {}}+unsafe fn power_saving_status(lparam: LPARAM) -> Option<bool> {+ let setting = unsafe { (lparam.0 as *const POWERBROADCAST_SETTING).as_ref()? };+ if setting.PowerSetting != GUID_POWER_SAVING_STATUS || setting.DataLength != 4 {+ return None;+ }+ let data = unsafe {+ std::ptr::addr_of!(setting.Data)+ .cast::<u32>()+ .read_unaligned()+ };+ match data {+ 0 => Some(false),+ 1 => Some(true),+ _ => None,+ }+}+impl Drop for WindowsPlatform {fn drop(&mut self) {if let Some(stop) = self.vsync_stop.borrow_mut().take() {@@ -1416,6 +1483,9 @@ impl Drop for WindowsPlatform {// SAFETY: notification was returned by RegisterSuspendResumeNotification.UnregisterSuspendResumeNotification(notification).log_err();}+ if let Some(notification) = self.power_saving_notification.borrow_mut().take() {+ UnregisterPowerSettingNotification(notification).log_err();+ }DestroyWindow(self.handle).context("Destroying platform window").log_err();diff --git a/crates/gpui_windows/src/window.rs b/crates/gpui_windows/src/window.rsindex c467101fc8a..d6d1d264000 100644--- a/crates/gpui_windows/src/window.rs+++ b/crates/gpui_windows/src/window.rs@@ -1041,7 +1041,7 @@ impl PlatformWindow for WindowsWindow {.log_err();}- #[cfg(any(test, feature = "test-support"))]+ #[cfg(feature = "test-support")]fn render_to_image(&self, scene: &Scene) -> anyhow::Result<image::RgbaImage> {self.state.renderer