Detailed changes
@@ -13,7 +13,7 @@ use call::{report_call_event_for_room, ActiveCall};
pub use collab_panel::CollabPanel;
pub use collab_titlebar_item::CollabTitlebarItem;
use gpui::{
- actions, point, AppContext, GlobalPixels, Pixels, PlatformDisplay, Size, Task, WindowContext,
+ actions, point, AppContext, DevicePixels, Pixels, PlatformDisplay, Size, Task, WindowContext,
WindowKind, WindowOptions,
};
use panel_settings::MessageEditorSettings;
@@ -97,13 +97,13 @@ fn notification_window_options(
screen: Rc<dyn PlatformDisplay>,
window_size: Size<Pixels>,
) -> WindowOptions {
- let notification_margin_width = GlobalPixels::from(16.);
- let notification_margin_height = GlobalPixels::from(-0.) - GlobalPixels::from(48.);
+ let notification_margin_width = DevicePixels::from(16);
+ let notification_margin_height = DevicePixels::from(-0) - DevicePixels::from(48);
let screen_bounds = screen.bounds();
- let size: Size<GlobalPixels> = window_size.into();
+ let size: Size<DevicePixels> = window_size.into();
- let bounds = gpui::Bounds::<GlobalPixels> {
+ let bounds = gpui::Bounds::<DevicePixels> {
origin: screen_bounds.upper_right()
- point(
size.width + notification_margin_width,
@@ -7304,8 +7304,8 @@ async fn test_following(cx: &mut gpui::TestAppContext) {
cx.open_window(
WindowOptions {
bounds: Some(Bounds::from_corners(
- gpui::Point::new(0_f64.into(), 0_f64.into()),
- gpui::Point::new(10_f64.into(), 80_f64.into()),
+ gpui::Point::new(0.into(), 0.into()),
+ gpui::Point::new(10.into(), 80.into()),
)),
..Default::default()
},
@@ -63,7 +63,7 @@ fn main() {
.with_assets(Assets {})
.run(|cx: &mut AppContext| {
let options = WindowOptions {
- bounds: Some(Bounds::centered(size(px(300.), px(300.)), cx)),
+ bounds: Some(Bounds::centered(None, size(px(300.), px(300.)), cx)),
..Default::default()
};
cx.open_window(options, |cx| {
@@ -23,7 +23,7 @@ impl Render for HelloWorld {
fn main() {
App::new().run(|cx: &mut AppContext| {
- let bounds = Bounds::centered(size(px(600.0), px(600.0)), cx);
+ let bounds = Bounds::centered(None, size(px(600.0), px(600.0)), cx);
cx.open_window(
WindowOptions {
bounds: Some(bounds),
@@ -0,0 +1,66 @@
+use gpui::*;
+
+struct WindowContent {
+ text: SharedString,
+}
+
+impl Render for WindowContent {
+ fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+ div()
+ .flex()
+ .bg(rgb(0x1e2025))
+ .size_full()
+ .justify_center()
+ .items_center()
+ .text_xl()
+ .text_color(rgb(0xffffff))
+ .child(self.text.clone())
+ }
+}
+
+fn main() {
+ App::new().run(|cx: &mut AppContext| {
+ // Create several new windows, positioned in the top right corner of each screen
+
+ for screen in cx.displays() {
+ let options = {
+ let popup_margin_width = DevicePixels::from(16);
+ let popup_margin_height = DevicePixels::from(-0) - DevicePixels::from(48);
+
+ let window_size = Size {
+ width: px(400.),
+ height: px(72.),
+ };
+
+ let screen_bounds = screen.bounds();
+ let size: Size<DevicePixels> = window_size.into();
+
+ let bounds = gpui::Bounds::<DevicePixels> {
+ origin: screen_bounds.upper_right()
+ - point(size.width + popup_margin_width, popup_margin_height),
+ size: window_size.into(),
+ };
+
+ WindowOptions {
+ // Set the bounds of the window in screen coordinates
+ bounds: Some(bounds),
+ // Specify the display_id to ensure the window is created on the correct screen
+ display_id: Some(screen.id()),
+
+ titlebar: None,
+ focus: false,
+ show: true,
+ kind: WindowKind::PopUp,
+ is_movable: false,
+ fullscreen: false,
+ }
+ };
+
+ cx.open_window(options, |cx| {
+ cx.new_view(|_| WindowContent {
+ text: format!("{:?}", screen.id()).into(),
+ })
+ });
+ }
+ });
+}
@@ -30,11 +30,11 @@ use util::{
use crate::{
current_platform, image_cache::ImageCache, init_app_menus, Action, ActionRegistry, Any,
AnyView, AnyWindowHandle, AppMetadata, AssetSource, BackgroundExecutor, ClipboardItem, Context,
- DispatchPhase, Entity, EventEmitter, ForegroundExecutor, Global, KeyBinding, Keymap, Keystroke,
- LayoutId, Menu, PathPromptOptions, Pixels, Platform, PlatformDisplay, Point, PromptBuilder,
- PromptHandle, PromptLevel, Render, RenderablePromptHandle, SharedString, SubscriberSet,
- Subscription, SvgRenderer, Task, TextSystem, View, ViewContext, Window, WindowAppearance,
- WindowContext, WindowHandle, WindowId,
+ DispatchPhase, DisplayId, Entity, EventEmitter, ForegroundExecutor, Global, KeyBinding, Keymap,
+ Keystroke, LayoutId, Menu, PathPromptOptions, Pixels, Platform, PlatformDisplay, Point,
+ PromptBuilder, PromptHandle, PromptLevel, Render, RenderablePromptHandle, SharedString,
+ SubscriberSet, Subscription, SvgRenderer, Task, TextSystem, View, ViewContext, Window,
+ WindowAppearance, WindowContext, WindowHandle, WindowId,
};
mod async_context;
@@ -525,6 +525,14 @@ impl AppContext {
self.platform.primary_display()
}
+ /// Returns the display with the given ID, if one exists.
+ pub fn find_display(&self, id: DisplayId) -> Option<Rc<dyn PlatformDisplay>> {
+ self.displays()
+ .iter()
+ .find(|display| display.id() == id)
+ .cloned()
+ }
+
/// Returns the appearance of the application's windows.
pub fn window_appearance(&self) -> WindowAppearance {
self.platform.window_appearance()
@@ -173,7 +173,7 @@ impl TestAppContext {
let mut cx = self.app.borrow_mut();
// Some tests rely on the window size matching the bounds of the test display
- let bounds = Bounds::maximized(&mut cx);
+ let bounds = Bounds::maximized(None, &mut cx);
cx.open_window(
WindowOptions {
bounds: Some(bounds),
@@ -186,7 +186,7 @@ impl TestAppContext {
/// Adds a new window with no content.
pub fn add_empty_window(&mut self) -> &mut VisualTestContext {
let mut cx = self.app.borrow_mut();
- let bounds = Bounds::maximized(&mut cx);
+ let bounds = Bounds::maximized(None, &mut cx);
let window = cx.open_window(
WindowOptions {
bounds: Some(bounds),
@@ -209,7 +209,7 @@ impl TestAppContext {
V: 'static + Render,
{
let mut cx = self.app.borrow_mut();
- let bounds = Bounds::maximized(&mut cx);
+ let bounds = Bounds::maximized(None, &mut cx);
let window = cx.open_window(
WindowOptions {
bounds: Some(bounds),
@@ -13,7 +13,7 @@ use std::{
ops::{Add, Div, Mul, MulAssign, Sub},
};
-use crate::AppContext;
+use crate::{AppContext, DisplayId};
/// An axis along which a measurement can be made.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
@@ -363,11 +363,11 @@ pub struct Size<T: Clone + Default + Debug> {
pub height: T,
}
-impl From<Size<GlobalPixels>> for Size<Pixels> {
- fn from(size: Size<GlobalPixels>) -> Self {
+impl From<Size<DevicePixels>> for Size<Pixels> {
+ fn from(size: Size<DevicePixels>) -> Self {
Size {
- width: Pixels(size.width.0),
- height: Pixels(size.height.0),
+ width: Pixels(size.width.0 as f32),
+ height: Pixels(size.height.0 as f32),
}
}
}
@@ -604,11 +604,11 @@ impl<T: Clone + Default + Debug> From<Point<T>> for Size<T> {
}
}
-impl From<Size<Pixels>> for Size<GlobalPixels> {
+impl From<Size<Pixels>> for Size<DevicePixels> {
fn from(size: Size<Pixels>) -> Self {
Size {
- width: GlobalPixels(size.width.0),
- height: GlobalPixels(size.height.0),
+ width: DevicePixels(size.width.0 as i32),
+ height: DevicePixels(size.height.0 as i32),
}
}
}
@@ -693,31 +693,43 @@ pub struct Bounds<T: Clone + Default + Debug> {
pub size: Size<T>,
}
-impl Bounds<GlobalPixels> {
- /// Generate a centered bounds for the primary display
- pub fn centered(size: impl Into<Size<GlobalPixels>>, cx: &mut AppContext) -> Self {
+impl Bounds<DevicePixels> {
+ /// Generate a centered bounds for the given display or primary display if none is provided
+ pub fn centered(
+ display_id: Option<DisplayId>,
+ size: impl Into<Size<DevicePixels>>,
+ cx: &mut AppContext,
+ ) -> Self {
+ let display = display_id
+ .and_then(|id| cx.find_display(id))
+ .or_else(|| cx.primary_display());
+
let size = size.into();
- cx.primary_display()
+ display
.map(|display| {
let center = display.bounds().center();
Bounds {
- origin: point(center.x - size.width / 2.0, center.y - size.height / 2.0),
+ origin: point(center.x - size.width / 2, center.y - size.height / 2),
size,
}
})
.unwrap_or_else(|| Bounds {
- origin: point(GlobalPixels(0.0), GlobalPixels(0.0)),
+ origin: point(DevicePixels(0), DevicePixels(0)),
size,
})
}
- /// Generate maximized bounds for the primary display
- pub fn maximized(cx: &mut AppContext) -> Self {
- cx.primary_display()
+ /// Generate maximized bounds for the given display or primary display if none is provided
+ pub fn maximized(display_id: Option<DisplayId>, cx: &mut AppContext) -> Self {
+ let display = display_id
+ .and_then(|id| cx.find_display(id))
+ .or_else(|| cx.primary_display());
+
+ display
.map(|display| display.bounds())
.unwrap_or_else(|| Bounds {
- origin: point(GlobalPixels(0.0), GlobalPixels(0.0)),
- size: size(GlobalPixels(1024.0), GlobalPixels(768.0)),
+ origin: point(DevicePixels(0), DevicePixels(0)),
+ size: size(DevicePixels(1024), DevicePixels(768)),
})
}
}
@@ -2455,34 +2467,6 @@ impl From<ScaledPixels> for f64 {
}
}
-/// Represents pixels in a global coordinate space, which can span across multiple displays.
-///
-/// `GlobalPixels` is used when dealing with a coordinate system that is not limited to a single
-/// display's boundaries. This type is particularly useful in multi-monitor setups where
-/// positioning and measurements need to be consistent and relative to a "global" origin point
-/// rather than being relative to any individual display.
-#[derive(Clone, Copy, Default, Add, AddAssign, Sub, SubAssign, Div, PartialEq, PartialOrd)]
-#[repr(transparent)]
-pub struct GlobalPixels(pub(crate) f32);
-
-impl Debug for GlobalPixels {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- write!(f, "{} px (global coordinate space)", self.0)
- }
-}
-
-impl From<GlobalPixels> for f64 {
- fn from(global_pixels: GlobalPixels) -> Self {
- global_pixels.0 as f64
- }
-}
-
-impl From<f64> for GlobalPixels {
- fn from(global_pixels: f64) -> Self {
- GlobalPixels(global_pixels as f32)
- }
-}
-
/// Represents a length in rems, a unit based on the font-size of the window, which can be assigned with [`WindowContext::set_rem_size`][set_rem_size].
///
/// Rems are used for defining lengths that are scalable and consistent across different UI elements.
@@ -2834,12 +2818,6 @@ impl Half for Rems {
}
}
-impl Half for GlobalPixels {
- fn half(&self) -> Self {
- Self(self.0 / 2.)
- }
-}
-
/// Provides a trait for types that can negate their values.
pub trait Negate {
/// Returns the negation of the given value
@@ -2882,12 +2860,6 @@ impl Negate for Rems {
}
}
-impl Negate for GlobalPixels {
- fn negate(self) -> Self {
- Self(-self.0)
- }
-}
-
/// A trait for checking if a value is zero.
///
/// This trait provides a method to determine if a value is considered to be zero.
@@ -23,9 +23,9 @@ mod windows;
use crate::{
Action, AnyWindowHandle, AsyncWindowContext, BackgroundExecutor, Bounds, DevicePixels,
- DispatchEventResult, Font, FontId, FontMetrics, FontRun, ForegroundExecutor, GlobalPixels,
- GlyphId, Keymap, LineLayout, Pixels, PlatformInput, Point, RenderGlyphParams,
- RenderImageParams, RenderSvgParams, Scene, SharedString, Size, Task, TaskLabel, WindowContext,
+ DispatchEventResult, Font, FontId, FontMetrics, FontRun, ForegroundExecutor, GlyphId, Keymap,
+ LineLayout, Pixels, PlatformInput, Point, RenderGlyphParams, RenderImageParams,
+ RenderSvgParams, Scene, SharedString, Size, Task, TaskLabel, WindowContext,
};
use anyhow::Result;
use async_task::Runnable;
@@ -152,7 +152,7 @@ pub trait PlatformDisplay: Send + Sync + Debug {
fn uuid(&self) -> Result<Uuid>;
/// Get the bounds for this display
- fn bounds(&self) -> Bounds<GlobalPixels>;
+ fn bounds(&self) -> Bounds<DevicePixels>;
}
/// An opaque identifier for a hardware display
@@ -168,7 +168,7 @@ impl Debug for DisplayId {
unsafe impl Send for DisplayId {}
pub(crate) trait PlatformWindow: HasWindowHandle + HasDisplayHandle {
- fn bounds(&self) -> Bounds<GlobalPixels>;
+ fn bounds(&self) -> Bounds<DevicePixels>;
fn is_maximized(&self) -> bool;
fn is_minimized(&self) -> bool;
fn content_size(&self) -> Size<Pixels>;
@@ -508,8 +508,9 @@ pub trait InputHandler: 'static {
/// The variables that can be configured when creating a new window
#[derive(Debug)]
pub struct WindowOptions {
+ /// The bounds of the window in screen coordinates.
/// None -> inherit, Some(bounds) -> set bounds
- pub bounds: Option<Bounds<GlobalPixels>>,
+ pub bounds: Option<Bounds<DevicePixels>>,
/// The titlebar configuration of the window
pub titlebar: Option<TitlebarOptions>,
@@ -529,7 +530,8 @@ pub struct WindowOptions {
/// Whether the window should be movable by the user
pub is_movable: bool,
- /// The display to create the window on
+ /// The display to create the window on, if this is None,
+ /// the window will be created on the main display
pub display_id: Option<DisplayId>,
}
@@ -537,7 +539,7 @@ pub struct WindowOptions {
#[derive(Debug)]
pub(crate) struct WindowParams {
///
- pub bounds: Bounds<GlobalPixels>,
+ pub bounds: Bounds<DevicePixels>,
/// The titlebar configuration of the window
pub titlebar: Option<TitlebarOptions>,
@@ -552,7 +554,6 @@ pub(crate) struct WindowParams {
pub show: bool,
- /// The display to create the window on
pub display_id: Option<DisplayId>,
}
@@ -599,10 +600,6 @@ pub enum WindowKind {
PopUp,
}
-/// Platform level interface
-/// bounds: Bounds<GlobalPixels>
-/// fullscreen: bool
-
/// The appearance of the window, as defined by the operating system.
///
/// On macOS, this corresponds to named [`NSAppearance`](https://developer.apple.com/documentation/appkit/nsappearance)
@@ -2,7 +2,7 @@ use std::fmt::Debug;
use uuid::Uuid;
-use crate::{Bounds, DisplayId, GlobalPixels, PlatformDisplay, Size};
+use crate::{Bounds, DevicePixels, DisplayId, PlatformDisplay, Size};
#[derive(Debug)]
pub(crate) struct WaylandDisplay {}
@@ -19,12 +19,12 @@ impl PlatformDisplay for WaylandDisplay {
}
// todo(linux)
- fn bounds(&self) -> Bounds<GlobalPixels> {
+ fn bounds(&self) -> Bounds<DevicePixels> {
Bounds {
origin: Default::default(),
size: Size {
- width: GlobalPixels(1000f32),
- height: GlobalPixels(500f32),
+ width: DevicePixels(1000),
+ height: DevicePixels(500),
},
} // return some fake data so it doesn't panic
}
@@ -22,7 +22,7 @@ use crate::platform::linux::wayland::display::WaylandDisplay;
use crate::platform::{PlatformAtlas, PlatformInputHandler, PlatformWindow};
use crate::scene::Scene;
use crate::{
- px, size, Bounds, GlobalPixels, Modifiers, Pixels, PlatformDisplay, PlatformInput, Point,
+ px, size, Bounds, DevicePixels, Modifiers, Pixels, PlatformDisplay, PlatformInput, Point,
PromptLevel, Size, WindowAppearance, WindowParams,
};
@@ -274,7 +274,7 @@ impl HasDisplayHandle for WaylandWindow {
impl PlatformWindow for WaylandWindow {
// todo(linux)
- fn bounds(&self) -> Bounds<GlobalPixels> {
+ fn bounds(&self) -> Bounds<DevicePixels> {
unimplemented!()
}
@@ -2,12 +2,12 @@ use anyhow::Result;
use uuid::Uuid;
use x11rb::{connection::Connection as _, xcb_ffi::XCBConnection};
-use crate::{Bounds, DisplayId, GlobalPixels, PlatformDisplay, Size};
+use crate::{Bounds, DevicePixels, DisplayId, PlatformDisplay, Size};
#[derive(Debug)]
pub(crate) struct X11Display {
x_screen_index: usize,
- bounds: Bounds<GlobalPixels>,
+ bounds: Bounds<DevicePixels>,
uuid: Uuid,
}
@@ -19,8 +19,8 @@ impl X11Display {
bounds: Bounds {
origin: Default::default(),
size: Size {
- width: GlobalPixels(screen.width_in_pixels as f32),
- height: GlobalPixels(screen.height_in_pixels as f32),
+ width: DevicePixels(screen.width_in_pixels as i32),
+ height: DevicePixels(screen.height_in_pixels as i32),
},
},
uuid: Uuid::from_bytes([0; 16]),
@@ -37,7 +37,7 @@ impl PlatformDisplay for X11Display {
Ok(self.uuid)
}
- fn bounds(&self) -> Bounds<GlobalPixels> {
+ fn bounds(&self) -> Bounds<DevicePixels> {
self.bounds
}
}
@@ -2,7 +2,7 @@
#![allow(unused)]
use crate::{
- platform::blade::BladeRenderer, size, Bounds, GlobalPixels, Modifiers, Pixels, PlatformAtlas,
+ platform::blade::BladeRenderer, size, Bounds, DevicePixels, Modifiers, Pixels, PlatformAtlas,
PlatformDisplay, PlatformInput, PlatformInputHandler, PlatformWindow, Point, PromptLevel,
Scene, Size, WindowAppearance, WindowOptions, WindowParams,
};
@@ -245,7 +245,7 @@ impl X11WindowState {
x_window,
callbacks: RefCell::new(Callbacks::default()),
inner: RefCell::new(LinuxWindowInner {
- bounds: params.bounds.map(|v| v.0 as i32),
+ bounds: params.bounds.map(|v| v.0),
scale_factor: 1.0,
renderer: BladeRenderer::new(gpu, gpu_extent),
input_handler: None,
@@ -325,12 +325,8 @@ impl X11WindowState {
}
impl PlatformWindow for X11Window {
- fn bounds(&self) -> Bounds<GlobalPixels> {
- self.0
- .inner
- .borrow_mut()
- .bounds
- .map(|v| GlobalPixels(v as f32))
+ fn bounds(&self) -> Bounds<DevicePixels> {
+ self.0.inner.borrow_mut().bounds.map(|v| v.into())
}
// todo(linux)
@@ -22,7 +22,7 @@ mod text_system;
mod window;
mod window_appearance;
-use crate::{px, size, GlobalPixels, Pixels, Size};
+use crate::{px, size, DevicePixels, Pixels, Size};
use cocoa::{
base::{id, nil},
foundation::{NSAutoreleasePool, NSNotFound, NSRect, NSSize, NSString, NSUInteger},
@@ -122,9 +122,9 @@ impl From<NSRect> for Size<Pixels> {
}
}
-impl From<NSRect> for Size<GlobalPixels> {
+impl From<NSRect> for Size<DevicePixels> {
fn from(rect: NSRect) -> Self {
let NSSize { width, height } = rect.size;
- size(width.into(), height.into())
+ size(DevicePixels(width as i32), DevicePixels(height as i32))
}
}
@@ -1,9 +1,9 @@
-use crate::{point, size, Bounds, DisplayId, GlobalPixels, PlatformDisplay};
+use crate::{point, size, Bounds, DevicePixels, DisplayId, PlatformDisplay};
use anyhow::Result;
use cocoa::{
appkit::NSScreen,
base::{id, nil},
- foundation::{NSDictionary, NSPoint, NSRect, NSSize, NSString},
+ foundation::{NSDictionary, NSString},
};
use core_foundation::uuid::{CFUUIDGetUUIDBytes, CFUUIDRef};
use core_graphics::display::{CGDirectDisplayID, CGDisplayBounds, CGGetActiveDisplayList};
@@ -69,49 +69,6 @@ extern "C" {
fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> CFUUIDRef;
}
-/// Convert the given rectangle from Cocoa's coordinate space to GPUI's coordinate space.
-///
-/// Cocoa's coordinate space has its origin at the bottom left of the primary screen,
-/// with the Y axis pointing upwards.
-///
-/// Conversely, in GPUI's coordinate system, the origin is placed at the top left of the primary
-/// screen, with the Y axis pointing downwards (matching CoreGraphics)
-pub(crate) fn global_bounds_from_ns_rect(rect: NSRect) -> Bounds<GlobalPixels> {
- let primary_screen_size = unsafe { CGDisplayBounds(MacDisplay::primary().id().0) }.size;
-
- Bounds {
- origin: point(
- GlobalPixels(rect.origin.x as f32),
- GlobalPixels(
- primary_screen_size.height as f32 - rect.origin.y as f32 - rect.size.height as f32,
- ),
- ),
- size: size(
- GlobalPixels(rect.size.width as f32),
- GlobalPixels(rect.size.height as f32),
- ),
- }
-}
-
-/// Convert the given rectangle from GPUI's coordinate system to Cocoa's native coordinate space.
-///
-/// Cocoa's coordinate space has its origin at the bottom left of the primary screen,
-/// with the Y axis pointing upwards.
-///
-/// Conversely, in GPUI's coordinate system, the origin is placed at the top left of the primary
-/// screen, with the Y axis pointing downwards (matching CoreGraphics)
-pub(crate) fn global_bounds_to_ns_rect(bounds: Bounds<GlobalPixels>) -> NSRect {
- let primary_screen_height = MacDisplay::primary().bounds().size.height;
-
- NSRect::new(
- NSPoint::new(
- bounds.origin.x.into(),
- (primary_screen_height - bounds.origin.y - bounds.size.height).into(),
- ),
- NSSize::new(bounds.size.width.into(), bounds.size.height.into()),
- )
-}
-
impl PlatformDisplay for MacDisplay {
fn id(&self) -> DisplayId {
DisplayId(self.0)
@@ -145,20 +102,17 @@ impl PlatformDisplay for MacDisplay {
]))
}
- fn bounds(&self) -> Bounds<GlobalPixels> {
+ fn bounds(&self) -> Bounds<DevicePixels> {
unsafe {
// CGDisplayBounds is in "global display" coordinates, where 0 is
// the top left of the primary display.
let bounds = CGDisplayBounds(self.0);
Bounds {
- origin: point(
- GlobalPixels(bounds.origin.x as f32),
- GlobalPixels(bounds.origin.y as f32),
- ),
+ origin: point(DevicePixels(0), DevicePixels(0)),
size: size(
- GlobalPixels(bounds.size.width as f32),
- GlobalPixels(bounds.size.height as f32),
+ DevicePixels(bounds.size.width as i32),
+ DevicePixels(bounds.size.height as i32),
),
}
}
@@ -1,10 +1,10 @@
-use super::{global_bounds_from_ns_rect, ns_string, renderer, MacDisplay, NSRange};
+use super::{ns_string, renderer, MacDisplay, NSRange};
use crate::{
- global_bounds_to_ns_rect, platform::PlatformInputHandler, point, px, size, AnyWindowHandle,
- Bounds, DisplayLink, ExternalPaths, FileDropEvent, ForegroundExecutor, GlobalPixels,
- KeyDownEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton, MouseDownEvent,
- MouseMoveEvent, MouseUpEvent, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput,
- PlatformWindow, Point, PromptLevel, Size, Timer, WindowAppearance, WindowKind, WindowParams,
+ platform::PlatformInputHandler, point, px, size, AnyWindowHandle, Bounds, DevicePixels,
+ DisplayLink, ExternalPaths, FileDropEvent, ForegroundExecutor, KeyDownEvent, Keystroke,
+ Modifiers, ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent,
+ Pixels, PlatformAtlas, PlatformDisplay, PlatformInput, PlatformWindow, Point, PromptLevel,
+ Size, Timer, WindowAppearance, WindowKind, WindowParams,
};
use block::ConcreteBlock;
use cocoa::{
@@ -441,9 +441,28 @@ impl MacWindowState {
}
}
- fn bounds(&self) -> Bounds<GlobalPixels> {
- let frame = unsafe { NSWindow::frame(self.native_window) };
- global_bounds_from_ns_rect(frame)
+ fn bounds(&self) -> Bounds<DevicePixels> {
+ let mut window_frame = unsafe { NSWindow::frame(self.native_window) };
+ let screen_frame = unsafe {
+ let screen = NSWindow::screen(self.native_window);
+ NSScreen::frame(screen)
+ };
+
+ // Flip the y coordinate to be top-left origin
+ window_frame.origin.y =
+ screen_frame.size.height - window_frame.origin.y - window_frame.size.height;
+
+ let bounds = Bounds::new(
+ point(
+ ((window_frame.origin.x - screen_frame.origin.x) as i32).into(),
+ ((window_frame.origin.y - screen_frame.origin.y) as i32).into(),
+ ),
+ size(
+ (window_frame.size.width as i32).into(),
+ (window_frame.size.height as i32).into(),
+ ),
+ );
+ bounds
}
fn content_size(&self) -> Size<Pixels> {
@@ -494,9 +513,9 @@ impl MacWindow {
titlebar,
kind,
is_movable,
- display_id,
focus,
show,
+ display_id,
}: WindowParams,
executor: ForegroundExecutor,
renderer_context: renderer::Context,
@@ -529,28 +548,37 @@ impl MacWindow {
let display = display_id
.and_then(MacDisplay::find_by_id)
- .unwrap_or_else(MacDisplay::primary);
+ .unwrap_or_else(|| MacDisplay::primary());
let mut target_screen = nil;
+ let mut screen_frame = None;
+
let screens = NSScreen::screens(nil);
let count: u64 = cocoa::foundation::NSArray::count(screens);
for i in 0..count {
let screen = cocoa::foundation::NSArray::objectAtIndex(screens, i);
+ let frame = NSScreen::visibleFrame(screen);
let display_id = display_id_for_screen(screen);
- if display_id == display.id().0 {
+ if display_id == display.0 {
+ screen_frame = Some(frame);
target_screen = screen;
- break;
}
}
- let window_rect = {
- let display_bounds = display.bounds();
- if bounds.intersects(&display_bounds) {
- global_bounds_to_ns_rect(bounds)
- } else {
- global_bounds_to_ns_rect(display_bounds)
- }
- };
+ let screen_frame = screen_frame.unwrap_or_else(|| {
+ let screen = NSScreen::mainScreen(nil);
+ target_screen = screen;
+ NSScreen::visibleFrame(screen)
+ });
+
+ let window_rect = NSRect::new(
+ NSPoint::new(
+ screen_frame.origin.x + bounds.origin.x.0 as f64,
+ screen_frame.origin.y
+ + (display.bounds().size.height - bounds.origin.y).0 as f64,
+ ),
+ NSSize::new(bounds.size.width.0 as f64, bounds.size.height.0 as f64),
+ );
let native_window = native_window.initWithContentRect_styleMask_backing_defer_screen_(
window_rect,
@@ -572,7 +600,10 @@ impl MacWindow {
let window_size = {
let scale = get_scale_factor(native_window);
- size(bounds.size.width.0 * scale, bounds.size.height.0 * scale)
+ size(
+ bounds.size.width.0 as f32 * scale,
+ bounds.size.height.0 as f32 * scale,
+ )
};
let window = Self(Arc::new(Mutex::new(MacWindowState {
@@ -692,6 +723,11 @@ impl MacWindow {
native_window.orderFront_(nil);
}
+ // Set the initial position of the window to the specified origin.
+ // Although we already specified the position using `initWithContentRect_styleMask_backing_defer_screen_`,
+ // the window position might be incorrect if the main screen (the screen that contains the window that has focus)
+ // is different from the primary screen.
+ NSWindow::setFrameTopLeftPoint_(native_window, window_rect.origin);
window.0.lock().move_traffic_light();
pool.drain();
@@ -737,7 +773,7 @@ impl Drop for MacWindow {
}
impl PlatformWindow for MacWindow {
- fn bounds(&self) -> Bounds<GlobalPixels> {
+ fn bounds(&self) -> Bounds<DevicePixels> {
self.0.as_ref().lock().bounds()
}
@@ -1,12 +1,12 @@
use anyhow::{Ok, Result};
-use crate::{Bounds, DisplayId, GlobalPixels, PlatformDisplay, Point};
+use crate::{Bounds, DevicePixels, DisplayId, PlatformDisplay, Point};
#[derive(Debug)]
pub(crate) struct TestDisplay {
id: DisplayId,
uuid: uuid::Uuid,
- bounds: Bounds<GlobalPixels>,
+ bounds: Bounds<DevicePixels>,
}
impl TestDisplay {
@@ -16,7 +16,7 @@ impl TestDisplay {
uuid: uuid::Uuid::new_v4(),
bounds: Bounds::from_corners(
Point::default(),
- Point::new(GlobalPixels(1920.), GlobalPixels(1080.)),
+ Point::new(DevicePixels(1920), DevicePixels(1080)),
),
}
}
@@ -31,7 +31,7 @@ impl PlatformDisplay for TestDisplay {
Ok(self.uuid)
}
- fn bounds(&self) -> crate::Bounds<crate::GlobalPixels> {
+ fn bounds(&self) -> crate::Bounds<crate::DevicePixels> {
self.bounds
}
}
@@ -1,7 +1,8 @@
use crate::{
- AnyWindowHandle, AtlasKey, AtlasTextureId, AtlasTile, Bounds, DispatchEventResult,
- GlobalPixels, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput, PlatformInputHandler,
- PlatformWindow, Point, Size, TestPlatform, TileId, WindowAppearance, WindowParams,
+ AnyWindowHandle, AtlasKey, AtlasTextureId, AtlasTile, Bounds, DevicePixels,
+ DispatchEventResult, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput,
+ PlatformInputHandler, PlatformWindow, Point, Size, TestPlatform, TileId, WindowAppearance,
+ WindowParams,
};
use collections::HashMap;
use parking_lot::Mutex;
@@ -12,7 +13,7 @@ use std::{
};
pub(crate) struct TestWindowState {
- pub(crate) bounds: Bounds<GlobalPixels>,
+ pub(crate) bounds: Bounds<DevicePixels>,
pub(crate) handle: AnyWindowHandle,
display: Rc<dyn PlatformDisplay>,
pub(crate) title: Option<String>,
@@ -78,7 +79,7 @@ impl TestWindow {
let Some(mut callback) = lock.resize_callback.take() else {
return;
};
- lock.bounds.size = size.map(|pixels| f64::from(pixels).into());
+ lock.bounds.size = size.map(|pixels| (pixels.0 as i32).into());
drop(lock);
callback(size, scale_factor);
self.0.lock().resize_callback = Some(callback);
@@ -107,7 +108,7 @@ impl TestWindow {
}
impl PlatformWindow for TestWindow {
- fn bounds(&self) -> Bounds<GlobalPixels> {
+ fn bounds(&self) -> Bounds<DevicePixels> {
self.0.lock().bounds
}
@@ -7,13 +7,13 @@ use windows::{
Win32::{Foundation::*, Graphics::Gdi::*},
};
-use crate::{Bounds, DisplayId, GlobalPixels, PlatformDisplay, Point, Size};
+use crate::{Bounds, DevicePixels, DisplayId, PlatformDisplay, Point, Size};
#[derive(Debug)]
pub(crate) struct WindowsDisplay {
pub handle: HMONITOR,
pub display_id: DisplayId,
- bounds: Bounds<GlobalPixels>,
+ bounds: Bounds<DevicePixels>,
uuid: Uuid,
}
@@ -33,12 +33,12 @@ impl WindowsDisplay {
display_id,
bounds: Bounds {
origin: Point {
- x: GlobalPixels(size.left as f32),
- y: GlobalPixels(size.top as f32),
+ x: DevicePixels(size.left as i32),
+ y: DevicePixels(size.top as i32),
},
size: Size {
- width: GlobalPixels((size.right - size.left) as f32),
- height: GlobalPixels((size.bottom - size.top) as f32),
+ width: DevicePixels((size.right - size.left) as i32),
+ height: DevicePixels((size.bottom - size.top) as i32),
},
},
uuid,
@@ -59,12 +59,12 @@ impl WindowsDisplay {
display_id: DisplayId(display_id as _),
bounds: Bounds {
origin: Point {
- x: GlobalPixels(size.left as f32),
- y: GlobalPixels(size.top as f32),
+ x: DevicePixels(size.left as i32),
+ y: DevicePixels(size.top as i32),
},
size: Size {
- width: GlobalPixels((size.right - size.left) as f32),
- height: GlobalPixels((size.bottom - size.top) as f32),
+ width: DevicePixels((size.right - size.left) as i32),
+ height: DevicePixels((size.bottom - size.top) as i32),
},
},
uuid,
@@ -81,12 +81,12 @@ impl WindowsDisplay {
display_id,
bounds: Bounds {
origin: Point {
- x: GlobalPixels(size.left as f32),
- y: GlobalPixels(size.top as f32),
+ x: DevicePixels(size.left as i32),
+ y: DevicePixels(size.top as i32),
},
size: Size {
- width: GlobalPixels((size.right - size.left) as f32),
- height: GlobalPixels((size.bottom - size.top) as f32),
+ width: DevicePixels((size.right - size.left) as i32),
+ height: DevicePixels((size.bottom - size.top) as i32),
},
},
uuid,
@@ -148,7 +148,7 @@ impl PlatformDisplay for WindowsDisplay {
Ok(self.uuid)
}
- fn bounds(&self) -> Bounds<GlobalPixels> {
+ fn bounds(&self) -> Bounds<DevicePixels> {
self.bounds
}
}
@@ -42,8 +42,8 @@ use crate::*;
pub(crate) struct WindowsWindowInner {
hwnd: HWND,
- origin: Cell<Point<GlobalPixels>>,
- physical_size: Cell<Size<GlobalPixels>>,
+ origin: Cell<Point<DevicePixels>>,
+ physical_size: Cell<Size<DevicePixels>>,
scale_factor: Cell<f32>,
input_handler: Cell<Option<PlatformInputHandler>>,
renderer: RefCell<BladeRenderer>,
@@ -68,12 +68,12 @@ impl WindowsWindowInner {
) -> Self {
let monitor_dpi = unsafe { GetDpiForWindow(hwnd) } as f32;
let origin = Cell::new(Point {
- x: GlobalPixels(cs.x as f32),
- y: GlobalPixels(cs.y as f32),
+ x: DevicePixels(cs.x as i32),
+ y: DevicePixels(cs.y as i32),
});
let physical_size = Cell::new(Size {
- width: GlobalPixels(cs.cx as f32),
- height: GlobalPixels(cs.cy as f32),
+ width: DevicePixels(cs.cx as i32),
+ height: DevicePixels(cs.cy as i32),
});
let scale_factor = Cell::new(monitor_dpi / USER_DEFAULT_SCREEN_DPI as f32);
let input_handler = Cell::new(None);
@@ -299,15 +299,15 @@ impl WindowsWindowInner {
}
fn handle_move_msg(&self, lparam: LPARAM) -> Option<isize> {
- let x = lparam.signed_loword() as f32;
- let y = lparam.signed_hiword() as f32;
+ let x = lparam.signed_loword() as i32;
+ let y = lparam.signed_hiword() as i32;
self.origin.set(Point {
- x: GlobalPixels(x),
- y: GlobalPixels(y),
+ x: DevicePixels(x),
+ y: DevicePixels(y),
});
let size = self.physical_size.get();
- let center_x = x + size.width.0 / 2.0;
- let center_y = y + size.height.0 / 2.0;
+ let center_x = x + size.width.0 / 2;
+ let center_y = y + size.height.0 / 2;
let monitor_bounds = self.display.borrow().bounds();
if center_x < monitor_bounds.left().0
|| center_x > monitor_bounds.right().0
@@ -329,12 +329,12 @@ impl WindowsWindowInner {
}
fn handle_size_msg(&self, lparam: LPARAM) -> Option<isize> {
- let width = lparam.loword().max(1) as f32;
- let height = lparam.hiword().max(1) as f32;
+ let width = lparam.loword().max(1) as i32;
+ let height = lparam.hiword().max(1) as i32;
let scale_factor = self.scale_factor.get();
let new_physical_size = Size {
- width: GlobalPixels(width),
- height: GlobalPixels(height),
+ width: DevicePixels(width),
+ height: DevicePixels(height),
};
self.physical_size.set(new_physical_size);
self.renderer.borrow_mut().update_drawable_size(Size {
@@ -648,7 +648,7 @@ impl WindowsWindowInner {
if let Some(callback) = callbacks.input.as_mut() {
let x = lparam.signed_loword() as f32;
let y = lparam.signed_hiword() as f32;
- let physical_point = point(GlobalPixels(x), GlobalPixels(y));
+ let physical_point = point(DevicePixels(x as i32), DevicePixels(y as i32));
let click_count = self.click_state.borrow_mut().update(button, physical_point);
let scale_factor = self.scale_factor.get();
let event = MouseDownEvent {
@@ -924,8 +924,8 @@ impl WindowsWindowInner {
let height = size_rect.bottom - size_rect.top;
self.physical_size.set(Size {
- width: GlobalPixels(width as f32),
- height: GlobalPixels(height as f32),
+ width: DevicePixels(width as i32),
+ height: DevicePixels(height as i32),
});
if self.hide_title_bar {
@@ -1077,8 +1077,8 @@ impl WindowsWindowInner {
};
unsafe { ScreenToClient(self.hwnd, &mut cursor_point) };
let physical_point = point(
- GlobalPixels(cursor_point.x as f32),
- GlobalPixels(cursor_point.y as f32),
+ DevicePixels(cursor_point.x as i32),
+ DevicePixels(cursor_point.y as i32),
);
let click_count = self.click_state.borrow_mut().update(button, physical_point);
let scale_factor = self.scale_factor.get();
@@ -1305,7 +1305,7 @@ impl Drop for WindowsWindow {
}
impl PlatformWindow for WindowsWindow {
- fn bounds(&self) -> Bounds<GlobalPixels> {
+ fn bounds(&self) -> Bounds<DevicePixels> {
Bounds {
origin: self.inner.origin.get(),
size: self.inner.physical_size.get(),
@@ -1674,7 +1674,7 @@ impl IDropTarget_Impl for WindowsDragDropHandler {
struct ClickState {
button: MouseButton,
last_click: Instant,
- last_position: Point<GlobalPixels>,
+ last_position: Point<DevicePixels>,
current_count: usize,
}
@@ -1689,7 +1689,7 @@ impl ClickState {
}
/// update self and return the needed click count
- pub fn update(&mut self, button: MouseButton, new_position: Point<GlobalPixels>) -> usize {
+ pub fn update(&mut self, button: MouseButton, new_position: Point<DevicePixels>) -> usize {
if self.button == button && self.is_double_click(new_position) {
self.current_count += 1;
} else {
@@ -1703,7 +1703,7 @@ impl ClickState {
}
#[inline]
- fn is_double_click(&self, new_position: Point<GlobalPixels>) -> bool {
+ fn is_double_click(&self, new_position: Point<DevicePixels>) -> bool {
let diff = self.last_position - new_position;
self.last_click.elapsed() < DOUBLE_CLICK_INTERVAL
@@ -1839,10 +1839,10 @@ fn oemkey_vkcode_to_string(code: u16) -> Option<String> {
}
#[inline]
-fn logical_size(physical_size: Size<GlobalPixels>, scale_factor: f32) -> Size<Pixels> {
+fn logical_size(physical_size: Size<DevicePixels>, scale_factor: f32) -> Size<Pixels> {
Size {
- width: px(physical_size.width.0 / scale_factor),
- height: px(physical_size.height.0 / scale_factor),
+ width: px(physical_size.width.0 as f32 / scale_factor),
+ height: px(physical_size.height.0 as f32 / scale_factor),
}
}
@@ -1867,51 +1867,36 @@ const DRAGDROP_GET_FILES_COUNT: u32 = 0xFFFFFFFF;
// https://learn.microsoft.com/en-us/windows/win32/controls/ttm-setdelaytime?redirectedfrom=MSDN
const DOUBLE_CLICK_INTERVAL: Duration = Duration::from_millis(500);
// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getsystemmetrics
-const DOUBLE_CLICK_SPATIAL_TOLERANCE: f32 = 4.0;
+const DOUBLE_CLICK_SPATIAL_TOLERANCE: i32 = 4;
#[cfg(test)]
mod tests {
use super::ClickState;
- use crate::{point, GlobalPixels, MouseButton};
+ use crate::{point, DevicePixels, MouseButton};
use std::time::Duration;
#[test]
fn test_double_click_interval() {
let mut state = ClickState::new();
assert_eq!(
- state.update(
- MouseButton::Left,
- point(GlobalPixels(0.0), GlobalPixels(0.0))
- ),
+ state.update(MouseButton::Left, point(DevicePixels(0), DevicePixels(0))),
1
);
assert_eq!(
- state.update(
- MouseButton::Right,
- point(GlobalPixels(0.0), GlobalPixels(0.0))
- ),
+ state.update(MouseButton::Right, point(DevicePixels(0), DevicePixels(0))),
1
);
assert_eq!(
- state.update(
- MouseButton::Left,
- point(GlobalPixels(0.0), GlobalPixels(0.0))
- ),
+ state.update(MouseButton::Left, point(DevicePixels(0), DevicePixels(0))),
1
);
assert_eq!(
- state.update(
- MouseButton::Left,
- point(GlobalPixels(0.0), GlobalPixels(0.0))
- ),
+ state.update(MouseButton::Left, point(DevicePixels(0), DevicePixels(0))),
2
);
state.last_click -= Duration::from_millis(700);
assert_eq!(
- state.update(
- MouseButton::Left,
- point(GlobalPixels(0.0), GlobalPixels(0.0))
- ),
+ state.update(MouseButton::Left, point(DevicePixels(0), DevicePixels(0))),
1
);
}
@@ -1920,31 +1905,19 @@ mod tests {
fn test_double_click_spatial_tolerance() {
let mut state = ClickState::new();
assert_eq!(
- state.update(
- MouseButton::Left,
- point(GlobalPixels(-3.0), GlobalPixels(0.0))
- ),
+ state.update(MouseButton::Left, point(DevicePixels(-3), DevicePixels(0))),
1
);
assert_eq!(
- state.update(
- MouseButton::Left,
- point(GlobalPixels(0.0), GlobalPixels(3.0))
- ),
+ state.update(MouseButton::Left, point(DevicePixels(0), DevicePixels(3))),
2
);
assert_eq!(
- state.update(
- MouseButton::Right,
- point(GlobalPixels(3.0), GlobalPixels(2.0))
- ),
+ state.update(MouseButton::Right, point(DevicePixels(3), DevicePixels(2))),
1
);
assert_eq!(
- state.update(
- MouseButton::Right,
- point(GlobalPixels(10.0), GlobalPixels(0.0))
- ),
+ state.update(MouseButton::Right, point(DevicePixels(10), DevicePixels(0))),
1
);
}
@@ -1,13 +1,13 @@
use crate::{
point, px, size, transparent_black, Action, AnyDrag, AnyView, AppContext, Arena,
- AsyncWindowContext, Bounds, Context, Corners, CursorStyle, DispatchActionListener,
- DispatchNodeId, DispatchTree, DisplayId, Edges, Effect, Entity, EntityId, EventEmitter,
- FileDropEvent, Flatten, Global, GlobalElementId, GlobalPixels, Hsla, KeyBinding, KeyDownEvent,
- KeyMatch, KeymatchResult, Keystroke, KeystrokeEvent, Model, ModelContext, Modifiers,
- ModifiersChangedEvent, MouseButton, MouseMoveEvent, MouseUpEvent, Pixels, PlatformAtlas,
- PlatformDisplay, PlatformInput, PlatformWindow, Point, PromptLevel, Render, ScaledPixels,
- SharedString, Size, SubscriberSet, Subscription, TaffyLayoutEngine, Task, TextStyle,
- TextStyleRefinement, View, VisualContext, WeakView, WindowAppearance, WindowOptions,
+ AsyncWindowContext, Bounds, Context, Corners, CursorStyle, DevicePixels,
+ DispatchActionListener, DispatchNodeId, DispatchTree, DisplayId, Edges, Effect, Entity,
+ EntityId, EventEmitter, FileDropEvent, Flatten, Global, GlobalElementId, Hsla, KeyBinding,
+ KeyDownEvent, KeyMatch, KeymatchResult, Keystroke, KeystrokeEvent, Model, ModelContext,
+ Modifiers, ModifiersChangedEvent, MouseButton, MouseMoveEvent, MouseUpEvent, Pixels,
+ PlatformAtlas, PlatformDisplay, PlatformInput, PlatformWindow, Point, PromptLevel, Render,
+ ScaledPixels, SharedString, Size, SubscriberSet, Subscription, TaffyLayoutEngine, Task,
+ TextStyle, TextStyleRefinement, View, VisualContext, WeakView, WindowAppearance, WindowOptions,
WindowParams, WindowTextSystem,
};
use anyhow::{anyhow, Context as _, Result};
@@ -358,26 +358,27 @@ pub(crate) struct ElementStateBox {
pub(crate) type_name: &'static str,
}
-fn default_bounds(cx: &mut AppContext) -> Bounds<GlobalPixels> {
- const DEFAULT_WINDOW_SIZE: Size<GlobalPixels> = size(GlobalPixels(1024.0), GlobalPixels(700.0));
- const DEFAULT_WINDOW_OFFSET: Point<GlobalPixels> = point(GlobalPixels(0.0), GlobalPixels(35.0));
+fn default_bounds(display_id: Option<DisplayId>, cx: &mut AppContext) -> Bounds<DevicePixels> {
+ const DEFAULT_WINDOW_SIZE: Size<DevicePixels> = size(DevicePixels(1024), DevicePixels(700));
+ const DEFAULT_WINDOW_OFFSET: Point<DevicePixels> = point(DevicePixels(0), DevicePixels(35));
cx.active_window()
.and_then(|w| w.update(cx, |_, cx| cx.window_bounds()).ok())
.map(|bounds| bounds.map_origin(|origin| origin + DEFAULT_WINDOW_OFFSET))
.unwrap_or_else(|| {
- cx.primary_display()
+ let display = display_id
+ .map(|id| cx.find_display(id))
+ .unwrap_or_else(|| cx.primary_display());
+
+ display
.map(|display| {
let center = display.bounds().center();
- let offset = DEFAULT_WINDOW_SIZE / 2.0;
+ let offset = DEFAULT_WINDOW_SIZE / 2;
let origin = point(center.x - offset.width, center.y - offset.height);
Bounds::new(origin, DEFAULT_WINDOW_SIZE)
})
.unwrap_or_else(|| {
- Bounds::new(
- point(GlobalPixels(0.0), GlobalPixels(0.0)),
- DEFAULT_WINDOW_SIZE,
- )
+ Bounds::new(point(DevicePixels(0), DevicePixels(0)), DEFAULT_WINDOW_SIZE)
})
})
}
@@ -399,7 +400,7 @@ impl Window {
fullscreen,
} = options;
- let bounds = bounds.unwrap_or_else(|| default_bounds(cx));
+ let bounds = bounds.unwrap_or_else(|| default_bounds(display_id, cx));
let platform_window = cx.platform.open_window(
handle,
WindowParams {
@@ -867,7 +868,7 @@ impl<'a> WindowContext<'a> {
}
/// Returns the bounds of the current window in the global coordinate space, which could span across multiple displays.
- pub fn window_bounds(&self) -> Bounds<GlobalPixels> {
+ pub fn window_bounds(&self) -> Bounds<DevicePixels> {
self.window.platform_window.bounds()
}
@@ -85,7 +85,7 @@ fn main() {
cx.set_menus(app_menus());
let size = size(px(1500.), px(780.));
- let bounds = Bounds::centered(size, cx);
+ let bounds = Bounds::centered(None, size, cx);
let _window = cx.open_window(
WindowOptions {
bounds: Some(bounds),
@@ -59,7 +59,7 @@ impl sqlez::bindable::Column for SerializedAxis {
}
#[derive(Clone, Debug, PartialEq)]
-pub(crate) struct SerializedWindowsBounds(pub(crate) Bounds<gpui::GlobalPixels>);
+pub(crate) struct SerializedWindowsBounds(pub(crate) Bounds<gpui::DevicePixels>);
impl StaticColumnCount for SerializedWindowsBounds {
fn column_count() -> usize {
@@ -73,10 +73,10 @@ impl Bind for SerializedWindowsBounds {
statement.bind(
&(
- SerializedGlobalPixels(self.0.origin.x),
- SerializedGlobalPixels(self.0.origin.y),
- SerializedGlobalPixels(self.0.size.width),
- SerializedGlobalPixels(self.0.size.height),
+ SerializedDevicePixels(self.0.origin.x),
+ SerializedDevicePixels(self.0.origin.y),
+ SerializedDevicePixels(self.0.size.width),
+ SerializedDevicePixels(self.0.size.height),
),
next_index,
)
@@ -89,10 +89,10 @@ impl Column for SerializedWindowsBounds {
let bounds = match window_state.as_str() {
"Fixed" => {
let ((x, y, width, height), _) = Column::column(statement, next_index)?;
- let x: f64 = x;
- let y: f64 = y;
- let width: f64 = width;
- let height: f64 = height;
+ let x: i32 = x;
+ let y: i32 = y;
+ let width: i32 = width;
+ let height: i32 = height;
SerializedWindowsBounds(Bounds {
origin: point(x.into(), y.into()),
size: size(width.into(), height.into()),
@@ -106,17 +106,16 @@ impl Column for SerializedWindowsBounds {
}
#[derive(Clone, Debug, PartialEq)]
-struct SerializedGlobalPixels(gpui::GlobalPixels);
-impl sqlez::bindable::StaticColumnCount for SerializedGlobalPixels {}
+struct SerializedDevicePixels(gpui::DevicePixels);
+impl sqlez::bindable::StaticColumnCount for SerializedDevicePixels {}
-impl sqlez::bindable::Bind for SerializedGlobalPixels {
+impl sqlez::bindable::Bind for SerializedDevicePixels {
fn bind(
&self,
statement: &sqlez::statement::Statement,
start_index: i32,
) -> anyhow::Result<i32> {
- let this: f64 = self.0.into();
- let this: f32 = this as _;
+ let this: i32 = self.0.into();
this.bind(statement, start_index)
}
}
@@ -6,7 +6,7 @@ use db::sqlez::{
bindable::{Bind, Column, StaticColumnCount},
statement::Statement,
};
-use gpui::{AsyncWindowContext, Bounds, GlobalPixels, Model, Task, View, WeakView};
+use gpui::{AsyncWindowContext, Bounds, DevicePixels, Model, Task, View, WeakView};
use project::Project;
use std::{
path::{Path, PathBuf},
@@ -69,7 +69,7 @@ pub(crate) struct SerializedWorkspace {
pub(crate) id: WorkspaceId,
pub(crate) location: WorkspaceLocation,
pub(crate) center_group: SerializedPaneGroup,
- pub(crate) bounds: Option<Bounds<GlobalPixels>>,
+ pub(crate) bounds: Option<Bounds<DevicePixels>>,
pub(crate) fullscreen: bool,
pub(crate) display: Option<Uuid>,
pub(crate) docks: DockStructure,
@@ -27,8 +27,8 @@ use futures::{
};
use gpui::{
actions, canvas, impl_actions, point, size, Action, AnyElement, AnyView, AnyWeakView,
- AppContext, AsyncAppContext, AsyncWindowContext, Bounds, DragMoveEvent, Entity as _, EntityId,
- EventEmitter, FocusHandle, FocusableView, Global, GlobalPixels, KeyContext, Keystroke,
+ AppContext, AsyncAppContext, AsyncWindowContext, Bounds, DevicePixels, DragMoveEvent,
+ Entity as _, EntityId, EventEmitter, FocusHandle, FocusableView, Global, KeyContext, Keystroke,
LayoutId, ManagedView, Model, ModelContext, PathPromptOptions, Point, PromptLevel, Render,
Size, Subscription, Task, View, WeakView, WindowHandle, WindowOptions,
};
@@ -89,11 +89,11 @@ use crate::persistence::{
};
lazy_static! {
- static ref ZED_WINDOW_SIZE: Option<Size<GlobalPixels>> = env::var("ZED_WINDOW_SIZE")
+ static ref ZED_WINDOW_SIZE: Option<Size<DevicePixels>> = env::var("ZED_WINDOW_SIZE")
.ok()
.as_deref()
.and_then(parse_pixel_size_env_var);
- static ref ZED_WINDOW_POSITION: Option<Point<GlobalPixels>> = env::var("ZED_WINDOW_POSITION")
+ static ref ZED_WINDOW_POSITION: Option<Point<DevicePixels>> = env::var("ZED_WINDOW_POSITION")
.ok()
.as_deref()
.and_then(parse_pixel_position_env_var);
@@ -745,11 +745,7 @@ impl Workspace {
cx.observe_window_activation(Self::on_window_activation_changed),
cx.observe_window_bounds(move |_, cx| {
if let Some(display) = cx.display() {
- // Transform fixed bounds to be stored in terms of the containing display
- let mut window_bounds = cx.window_bounds();
- let display_bounds = display.bounds();
- window_bounds.origin.x -= display_bounds.origin.x;
- window_bounds.origin.y -= display_bounds.origin.y;
+ let window_bounds = cx.window_bounds();
let fullscreen = cx.is_fullscreen();
if let Some(display_uuid) = display.uuid().log_err() {
@@ -902,7 +898,7 @@ impl Workspace {
})?;
window
} else {
- let window_bounds_override = window_bounds_env_override(&cx);
+ let window_bounds_override = window_bounds_env_override();
let (bounds, display, fullscreen) = if let Some(bounds) = window_bounds_override {
(Some(bounds), None, false)
@@ -917,24 +913,7 @@ impl Workspace {
Some((display?, bounds?.0, fullscreen.unwrap_or(false)))
});
- if let Some((serialized_display, mut bounds, fullscreen)) = restorable_bounds {
- // Stored bounds are relative to the containing display.
- // So convert back to global coordinates if that screen still exists
- let screen_bounds = cx
- .update(|cx| {
- cx.displays()
- .into_iter()
- .find(|display| display.uuid().ok() == Some(serialized_display))
- })
- .ok()
- .flatten()
- .map(|screen| screen.bounds());
-
- if let Some(screen_bounds) = screen_bounds {
- bounds.origin.x += screen_bounds.origin.x;
- bounds.origin.y += screen_bounds.origin.y;
- }
-
+ if let Some((serialized_display, bounds, fullscreen)) = restorable_bounds {
(Some(bounds), Some(serialized_display), fullscreen)
} else {
(None, None, false)
@@ -3756,14 +3735,11 @@ impl Workspace {
}
}
-fn window_bounds_env_override(cx: &AsyncAppContext) -> Option<Bounds<GlobalPixels>> {
- let display_origin = cx
- .update(|cx| Some(cx.displays().first()?.bounds().origin))
- .ok()??;
+fn window_bounds_env_override() -> Option<Bounds<DevicePixels>> {
ZED_WINDOW_POSITION
.zip(*ZED_WINDOW_SIZE)
.map(|(position, size)| Bounds {
- origin: display_origin + position,
+ origin: position,
size,
})
}
@@ -4662,7 +4638,7 @@ pub fn join_hosted_project(
)
.await?;
- let window_bounds_override = window_bounds_env_override(&cx);
+ let window_bounds_override = window_bounds_env_override();
cx.update(|cx| {
let mut options = (app_state.build_window_options)(None, cx);
options.bounds = window_bounds_override;
@@ -4723,7 +4699,7 @@ pub fn join_in_room_project(
})?
.await?;
- let window_bounds_override = window_bounds_env_override(&cx);
+ let window_bounds_override = window_bounds_env_override();
cx.update(|cx| {
let mut options = (app_state.build_window_options)(None, cx);
options.bounds = window_bounds_override;
@@ -4817,18 +4793,18 @@ pub fn restart(_: &Restart, cx: &mut AppContext) {
.detach_and_log_err(cx);
}
-fn parse_pixel_position_env_var(value: &str) -> Option<Point<GlobalPixels>> {
+fn parse_pixel_position_env_var(value: &str) -> Option<Point<DevicePixels>> {
let mut parts = value.split(',');
let x: usize = parts.next()?.parse().ok()?;
let y: usize = parts.next()?.parse().ok()?;
- Some(point((x as f64).into(), (y as f64).into()))
+ Some(point((x as i32).into(), (y as i32).into()))
}
-fn parse_pixel_size_env_var(value: &str) -> Option<Size<GlobalPixels>> {
+fn parse_pixel_size_env_var(value: &str) -> Option<Size<DevicePixels>> {
let mut parts = value.split(',');
let width: usize = parts.next()?.parse().ok()?;
let height: usize = parts.next()?.parse().ok()?;
- Some(size((width as f64).into(), (height as f64).into()))
+ Some(size((width as i32).into(), (height as i32).into()))
}
struct DisconnectedOverlay;