mirror of
https://github.com/zed-industries/zed.git
synced 2024-09-18 18:08:07 +03:00
Fix issues where screen and window sizes contained Pixels, but were declared as DevicePixels (#12991)
On most platforms, things were working correctly, but had the wrong type. On X11, there were some problems with window and display size calculations. Release Notes: - Fixed issues with window positioning on X11 --------- Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com> Co-authored-by: Mikayla <mikayla@zed.dev>
This commit is contained in:
parent
22dc88ed3d
commit
da281d6d8f
@ -14,8 +14,8 @@ use futures::{
|
||||
use fuzzy::StringMatchCandidate;
|
||||
use gpui::{
|
||||
actions, percentage, point, size, Animation, AnimationExt, AppContext, BackgroundExecutor,
|
||||
Bounds, DevicePixels, EventEmitter, Global, PromptLevel, ReadGlobal, Subscription, Task,
|
||||
TitlebarOptions, Transformation, UpdateGlobal, View, WindowBounds, WindowHandle, WindowOptions,
|
||||
Bounds, EventEmitter, Global, PromptLevel, ReadGlobal, Subscription, Task, TitlebarOptions,
|
||||
Transformation, UpdateGlobal, View, WindowBounds, WindowHandle, WindowOptions,
|
||||
};
|
||||
use heed::{types::SerdeBincode, Database, RoTxn};
|
||||
use language::{language_settings::SoftWrap, Buffer, LanguageRegistry};
|
||||
@ -80,11 +80,7 @@ pub fn open_prompt_library(
|
||||
cx.spawn(|cx| async move {
|
||||
let store = store.await?;
|
||||
cx.update(|cx| {
|
||||
let bounds = Bounds::centered(
|
||||
None,
|
||||
size(DevicePixels::from(1024), DevicePixels::from(768)),
|
||||
cx,
|
||||
);
|
||||
let bounds = Bounds::centered(None, size(px(1024.0), px(768.0)), cx);
|
||||
cx.open_window(
|
||||
WindowOptions {
|
||||
titlebar: Some(TitlebarOptions {
|
||||
|
@ -13,8 +13,8 @@ use call::{report_call_event_for_room, ActiveCall};
|
||||
pub use collab_panel::CollabPanel;
|
||||
pub use collab_titlebar_item::CollabTitlebarItem;
|
||||
use gpui::{
|
||||
actions, point, AppContext, DevicePixels, Pixels, PlatformDisplay, Size, Task,
|
||||
WindowBackgroundAppearance, WindowBounds, WindowContext, WindowKind, WindowOptions,
|
||||
actions, point, AppContext, Pixels, PlatformDisplay, Size, Task, WindowBackgroundAppearance,
|
||||
WindowBounds, WindowContext, WindowKind, WindowOptions,
|
||||
};
|
||||
use panel_settings::MessageEditorSettings;
|
||||
pub use panel_settings::{
|
||||
@ -22,6 +22,7 @@ pub use panel_settings::{
|
||||
};
|
||||
use release_channel::ReleaseChannel;
|
||||
use settings::Settings;
|
||||
use ui::px;
|
||||
use workspace::{notifications::DetachAndPromptErr, AppState};
|
||||
|
||||
actions!(
|
||||
@ -96,22 +97,19 @@ pub fn toggle_deafen(_: &ToggleDeafen, cx: &mut AppContext) {
|
||||
|
||||
fn notification_window_options(
|
||||
screen: Rc<dyn PlatformDisplay>,
|
||||
window_size: Size<Pixels>,
|
||||
size: Size<Pixels>,
|
||||
cx: &AppContext,
|
||||
) -> WindowOptions {
|
||||
let notification_margin_width = DevicePixels::from(16);
|
||||
let notification_margin_height = DevicePixels::from(-0) - DevicePixels::from(48);
|
||||
let notification_margin_width = px(16.);
|
||||
let notification_margin_height = px(-48.);
|
||||
|
||||
let screen_bounds = screen.bounds();
|
||||
let size: Size<DevicePixels> = window_size.into();
|
||||
|
||||
let bounds = gpui::Bounds::<DevicePixels> {
|
||||
origin: screen_bounds.upper_right()
|
||||
let bounds = gpui::Bounds::<Pixels> {
|
||||
origin: screen.bounds().upper_right()
|
||||
- point(
|
||||
size.width + notification_margin_width,
|
||||
notification_margin_height,
|
||||
),
|
||||
size: window_size.into(),
|
||||
size,
|
||||
};
|
||||
|
||||
let app_id = ReleaseChannel::global(cx).app_id();
|
||||
|
@ -7659,8 +7659,8 @@ async fn test_following(cx: &mut gpui::TestAppContext) {
|
||||
cx.open_window(
|
||||
WindowOptions {
|
||||
window_bounds: Some(WindowBounds::Windowed(Bounds::from_corners(
|
||||
gpui::Point::new(0.into(), 0.into()),
|
||||
gpui::Point::new(10.into(), 80.into()),
|
||||
gpui::Point::new(px(0.), px(0.)),
|
||||
gpui::Point::new(px(10.), px(80.)),
|
||||
))),
|
||||
..Default::default()
|
||||
},
|
||||
|
@ -80,8 +80,8 @@ fn main() {
|
||||
}),
|
||||
|
||||
window_bounds: Some(WindowBounds::Windowed(Bounds {
|
||||
size: size(px(1100.), px(600.)).into(),
|
||||
origin: Point::new(DevicePixels::from(200), DevicePixels::from(200)),
|
||||
size: size(px(1100.), px(600.)),
|
||||
origin: Point::new(px(200.), px(200.)),
|
||||
})),
|
||||
|
||||
..Default::default()
|
||||
|
@ -24,21 +24,18 @@ fn main() {
|
||||
|
||||
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 margin_right = px(16.);
|
||||
let margin_height = px(-48.);
|
||||
|
||||
let window_size = Size {
|
||||
let 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(),
|
||||
let bounds = gpui::Bounds::<Pixels> {
|
||||
origin: screen.bounds().upper_right()
|
||||
- point(size.width + margin_right, margin_height),
|
||||
size,
|
||||
};
|
||||
|
||||
WindowOptions {
|
||||
|
@ -363,15 +363,6 @@ pub struct Size<T: Clone + Default + Debug> {
|
||||
pub height: T,
|
||||
}
|
||||
|
||||
impl From<Size<DevicePixels>> for Size<Pixels> {
|
||||
fn from(size: Size<DevicePixels>) -> Self {
|
||||
Size {
|
||||
width: Pixels(size.width.0 as f32),
|
||||
height: Pixels(size.height.0 as f32),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Constructs a new `Size<T>` with the provided width and height.
|
||||
///
|
||||
/// # Arguments
|
||||
@ -633,15 +624,6 @@ impl<T: Clone + Default + Debug> From<Point<T>> for Size<T> {
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Size<Pixels>> for Size<DevicePixels> {
|
||||
fn from(size: Size<Pixels>) -> Self {
|
||||
Size {
|
||||
width: DevicePixels(size.width.0 as i32),
|
||||
height: DevicePixels(size.height.0 as i32),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Size<Pixels>> for Size<DefiniteLength> {
|
||||
fn from(size: Size<Pixels>) -> Self {
|
||||
Size {
|
||||
@ -722,28 +704,27 @@ pub struct Bounds<T: Clone + Default + Debug> {
|
||||
pub size: Size<T>,
|
||||
}
|
||||
|
||||
impl Bounds<DevicePixels> {
|
||||
impl Bounds<Pixels> {
|
||||
/// 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>>,
|
||||
size: Size<Pixels>,
|
||||
cx: &mut AppContext,
|
||||
) -> Self {
|
||||
let display = display_id
|
||||
.and_then(|id| cx.find_display(id))
|
||||
.or_else(|| cx.primary_display());
|
||||
|
||||
let size = size.into();
|
||||
display
|
||||
.map(|display| {
|
||||
let center = display.bounds().center();
|
||||
Bounds {
|
||||
origin: point(center.x - size.width / 2, center.y - size.height / 2),
|
||||
origin: point(center.x - size.width / 2., center.y - size.height / 2.),
|
||||
size,
|
||||
}
|
||||
})
|
||||
.unwrap_or_else(|| Bounds {
|
||||
origin: point(DevicePixels(0), DevicePixels(0)),
|
||||
origin: point(px(0.), px(0.)),
|
||||
size,
|
||||
})
|
||||
}
|
||||
@ -757,8 +738,8 @@ impl Bounds<DevicePixels> {
|
||||
display
|
||||
.map(|display| display.bounds())
|
||||
.unwrap_or_else(|| Bounds {
|
||||
origin: point(DevicePixels(0), DevicePixels(0)),
|
||||
size: size(DevicePixels(1024), DevicePixels(768)),
|
||||
origin: point(px(0.), px(0.)),
|
||||
size: size(px(1024.), px(768.)),
|
||||
})
|
||||
}
|
||||
}
|
||||
@ -1309,6 +1290,26 @@ impl<T: PartialOrd + Default + Debug + Clone> Bounds<T> {
|
||||
}
|
||||
}
|
||||
|
||||
impl Size<DevicePixels> {
|
||||
/// Converts the size from physical to logical pixels.
|
||||
pub(crate) fn to_pixels(self, scale_factor: f32) -> Size<Pixels> {
|
||||
size(
|
||||
px(self.width.0 as f32 / scale_factor),
|
||||
px(self.height.0 as f32 / scale_factor),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl Size<Pixels> {
|
||||
/// Converts the size from physical to logical pixels.
|
||||
pub(crate) fn to_device_pixels(self, scale_factor: f32) -> Size<DevicePixels> {
|
||||
size(
|
||||
DevicePixels((self.width.0 * scale_factor) as i32),
|
||||
DevicePixels((self.height.0 * scale_factor) as i32),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl Bounds<Pixels> {
|
||||
/// Scales the bounds by a given factor, typically used to adjust for display scaling.
|
||||
///
|
||||
@ -1346,6 +1347,30 @@ impl Bounds<Pixels> {
|
||||
size: self.size.scale(factor),
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert the bounds from logical pixels to physical pixels
|
||||
pub fn to_device_pixels(&self, factor: f32) -> Bounds<DevicePixels> {
|
||||
Bounds {
|
||||
origin: point(
|
||||
DevicePixels((self.origin.x.0 * factor) as i32),
|
||||
DevicePixels((self.origin.y.0 * factor) as i32),
|
||||
),
|
||||
size: self.size.to_device_pixels(factor),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Bounds<DevicePixels> {
|
||||
/// Convert the bounds from physical pixels to logical pixels
|
||||
pub fn to_pixels(self, scale_factor: f32) -> Bounds<Pixels> {
|
||||
Bounds {
|
||||
origin: point(
|
||||
px(self.origin.x.0 as f32 / scale_factor),
|
||||
px(self.origin.y.0 as f32 / scale_factor),
|
||||
),
|
||||
size: self.size.to_pixels(scale_factor),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Clone + Debug + Copy + Default> Copy for Bounds<T> {}
|
||||
|
@ -187,12 +187,12 @@ pub trait PlatformDisplay: Send + Sync + Debug {
|
||||
fn uuid(&self) -> Result<Uuid>;
|
||||
|
||||
/// Get the bounds for this display
|
||||
fn bounds(&self) -> Bounds<DevicePixels>;
|
||||
fn bounds(&self) -> Bounds<Pixels>;
|
||||
|
||||
/// Get the default bounds for this display to place a window
|
||||
fn default_bounds(&self) -> Bounds<DevicePixels> {
|
||||
fn default_bounds(&self) -> Bounds<Pixels> {
|
||||
let center = self.bounds().center();
|
||||
let offset = DEFAULT_WINDOW_SIZE / 2;
|
||||
let offset = DEFAULT_WINDOW_SIZE / 2.0;
|
||||
let origin = point(center.x - offset.width, center.y - offset.height);
|
||||
Bounds::new(origin, DEFAULT_WINDOW_SIZE)
|
||||
}
|
||||
@ -211,7 +211,7 @@ impl Debug for DisplayId {
|
||||
unsafe impl Send for DisplayId {}
|
||||
|
||||
pub(crate) trait PlatformWindow: HasWindowHandle + HasDisplayHandle {
|
||||
fn bounds(&self) -> Bounds<DevicePixels>;
|
||||
fn bounds(&self) -> Bounds<Pixels>;
|
||||
fn is_maximized(&self) -> bool;
|
||||
fn window_bounds(&self) -> WindowBounds;
|
||||
fn content_size(&self) -> Size<Pixels>;
|
||||
@ -569,7 +569,7 @@ pub struct WindowOptions {
|
||||
/// The variables that can be configured when creating a new window
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct WindowParams {
|
||||
pub bounds: Bounds<DevicePixels>,
|
||||
pub bounds: Bounds<Pixels>,
|
||||
|
||||
/// The titlebar configuration of the window
|
||||
pub titlebar: Option<TitlebarOptions>,
|
||||
@ -597,13 +597,13 @@ pub(crate) struct WindowParams {
|
||||
#[derive(Debug, Copy, Clone, PartialEq)]
|
||||
pub enum WindowBounds {
|
||||
/// Indicates that the window should open in a windowed state with the given bounds.
|
||||
Windowed(Bounds<DevicePixels>),
|
||||
Windowed(Bounds<Pixels>),
|
||||
/// Indicates that the window should open in a maximized state.
|
||||
/// The bounds provided here represent the restore size of the window.
|
||||
Maximized(Bounds<DevicePixels>),
|
||||
Maximized(Bounds<Pixels>),
|
||||
/// Indicates that the window should open in fullscreen mode.
|
||||
/// The bounds provided here represent the restore size of the window.
|
||||
Fullscreen(Bounds<DevicePixels>),
|
||||
Fullscreen(Bounds<Pixels>),
|
||||
}
|
||||
|
||||
impl Default for WindowBounds {
|
||||
@ -614,7 +614,7 @@ impl Default for WindowBounds {
|
||||
|
||||
impl WindowBounds {
|
||||
/// Retrieve the inner bounds
|
||||
pub fn get_bounds(&self) -> Bounds<DevicePixels> {
|
||||
pub fn get_bounds(&self) -> Bounds<Pixels> {
|
||||
match self {
|
||||
WindowBounds::Windowed(bounds) => *bounds,
|
||||
WindowBounds::Maximized(bounds) => *bounds,
|
||||
|
@ -3,8 +3,8 @@
|
||||
|
||||
use super::{BladeAtlas, PATH_TEXTURE_FORMAT};
|
||||
use crate::{
|
||||
AtlasTextureKind, AtlasTile, Bounds, ContentMask, Hsla, MonochromeSprite, Path, PathId,
|
||||
PathVertex, PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size,
|
||||
AtlasTextureKind, AtlasTile, Bounds, ContentMask, DevicePixels, Hsla, MonochromeSprite, Path,
|
||||
PathId, PathVertex, PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size,
|
||||
Underline,
|
||||
};
|
||||
use bytemuck::{Pod, Zeroable};
|
||||
@ -417,10 +417,10 @@ impl BladeRenderer {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update_drawable_size(&mut self, size: Size<f64>) {
|
||||
pub fn update_drawable_size(&mut self, size: Size<DevicePixels>) {
|
||||
let gpu_size = gpu::Extent {
|
||||
width: size.width as u32,
|
||||
height: size.height as u32,
|
||||
width: size.width.0 as u32,
|
||||
height: size.height.0 as u32,
|
||||
depth: 1,
|
||||
};
|
||||
|
||||
|
@ -557,7 +557,7 @@ impl LinuxClient for WaylandClient {
|
||||
Rc::new(WaylandDisplay {
|
||||
id: id.clone(),
|
||||
name: output.name.clone(),
|
||||
bounds: output.bounds,
|
||||
bounds: output.bounds.to_pixels(output.scale as f32),
|
||||
}) as Rc<dyn PlatformDisplay>
|
||||
})
|
||||
.collect()
|
||||
@ -573,7 +573,7 @@ impl LinuxClient for WaylandClient {
|
||||
Rc::new(WaylandDisplay {
|
||||
id: object_id.clone(),
|
||||
name: output.name.clone(),
|
||||
bounds: output.bounds,
|
||||
bounds: output.bounds.to_pixels(output.scale as f32),
|
||||
}) as Rc<dyn PlatformDisplay>
|
||||
})
|
||||
})
|
||||
|
@ -6,14 +6,14 @@ use std::{
|
||||
use uuid::Uuid;
|
||||
use wayland_backend::client::ObjectId;
|
||||
|
||||
use crate::{Bounds, DevicePixels, DisplayId, PlatformDisplay};
|
||||
use crate::{Bounds, DisplayId, Pixels, PlatformDisplay};
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub(crate) struct WaylandDisplay {
|
||||
/// The ID of the wl_output object
|
||||
pub id: ObjectId,
|
||||
pub name: Option<String>,
|
||||
pub bounds: Bounds<DevicePixels>,
|
||||
pub bounds: Bounds<Pixels>,
|
||||
}
|
||||
|
||||
impl Hash for WaylandDisplay {
|
||||
@ -35,7 +35,7 @@ impl PlatformDisplay for WaylandDisplay {
|
||||
}
|
||||
}
|
||||
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
self.bounds
|
||||
}
|
||||
}
|
||||
|
@ -1,6 +1,5 @@
|
||||
use std::cell::{Ref, RefCell, RefMut};
|
||||
use std::ffi::c_void;
|
||||
use std::num::NonZeroU32;
|
||||
use std::ptr::NonNull;
|
||||
use std::rc::Rc;
|
||||
use std::sync::Arc;
|
||||
@ -26,9 +25,9 @@ use crate::platform::linux::wayland::serial::SerialKind;
|
||||
use crate::platform::{PlatformAtlas, PlatformInputHandler, PlatformWindow};
|
||||
use crate::scene::Scene;
|
||||
use crate::{
|
||||
px, size, AnyWindowHandle, Bounds, DevicePixels, Globals, Modifiers, Output, Pixels,
|
||||
PlatformDisplay, PlatformInput, Point, PromptLevel, Size, WaylandClientStatePtr,
|
||||
WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowParams,
|
||||
px, size, AnyWindowHandle, Bounds, Globals, Modifiers, Output, Pixels, PlatformDisplay,
|
||||
PlatformInput, Point, PromptLevel, Size, WaylandClientStatePtr, WindowAppearance,
|
||||
WindowBackgroundAppearance, WindowBounds, WindowParams,
|
||||
};
|
||||
|
||||
#[derive(Default)]
|
||||
@ -76,13 +75,13 @@ pub struct WaylandWindowState {
|
||||
display: Option<(ObjectId, Output)>,
|
||||
globals: Globals,
|
||||
renderer: BladeRenderer,
|
||||
bounds: Bounds<u32>,
|
||||
bounds: Bounds<Pixels>,
|
||||
scale: f32,
|
||||
input_handler: Option<PlatformInputHandler>,
|
||||
decoration_state: WaylandDecorationState,
|
||||
fullscreen: bool,
|
||||
maximized: bool,
|
||||
windowed_bounds: Bounds<DevicePixels>,
|
||||
windowed_bounds: Bounds<Pixels>,
|
||||
client: WaylandClientStatePtr,
|
||||
handle: AnyWindowHandle,
|
||||
active: bool,
|
||||
@ -108,8 +107,6 @@ impl WaylandWindowState {
|
||||
globals: Globals,
|
||||
options: WindowParams,
|
||||
) -> anyhow::Result<Self> {
|
||||
let bounds = options.bounds.map(|p| p.0 as u32);
|
||||
|
||||
let raw = RawWindow {
|
||||
window: surface.id().as_ptr().cast::<c_void>(),
|
||||
display: surface
|
||||
@ -134,8 +131,8 @@ impl WaylandWindowState {
|
||||
);
|
||||
let config = BladeSurfaceConfig {
|
||||
size: gpu::Extent {
|
||||
width: bounds.size.width,
|
||||
height: bounds.size.height,
|
||||
width: options.bounds.size.width.0 as u32,
|
||||
height: options.bounds.size.height.0 as u32,
|
||||
depth: 1,
|
||||
},
|
||||
transparent: options.window_background != WindowBackgroundAppearance::Opaque,
|
||||
@ -153,7 +150,7 @@ impl WaylandWindowState {
|
||||
outputs: HashMap::default(),
|
||||
display: None,
|
||||
renderer: BladeRenderer::new(gpu, config),
|
||||
bounds,
|
||||
bounds: options.bounds,
|
||||
scale: 1.0,
|
||||
input_handler: None,
|
||||
decoration_state: WaylandDecorationState::Client,
|
||||
@ -349,10 +346,16 @@ impl WaylandWindowStatePtr {
|
||||
pub fn handle_toplevel_event(&self, event: xdg_toplevel::Event) -> bool {
|
||||
match event {
|
||||
xdg_toplevel::Event::Configure {
|
||||
mut width,
|
||||
mut height,
|
||||
width,
|
||||
height,
|
||||
states,
|
||||
} => {
|
||||
let mut size = if width == 0 || height == 0 {
|
||||
None
|
||||
} else {
|
||||
Some(size(px(width as f32), px(height as f32)))
|
||||
};
|
||||
|
||||
let fullscreen = states.contains(&(xdg_toplevel::State::Fullscreen as u8));
|
||||
let maximized = states.contains(&(xdg_toplevel::State::Maximized as u8));
|
||||
|
||||
@ -362,19 +365,20 @@ impl WaylandWindowStatePtr {
|
||||
state.maximized = maximized;
|
||||
|
||||
if got_unmaximized {
|
||||
width = state.windowed_bounds.size.width.0;
|
||||
height = state.windowed_bounds.size.height.0;
|
||||
} else if width != 0 && height != 0 && !fullscreen && !maximized {
|
||||
state.windowed_bounds = Bounds {
|
||||
origin: Point::default(),
|
||||
size: size(width.into(), height.into()),
|
||||
};
|
||||
size = Some(state.windowed_bounds.size);
|
||||
} else if !fullscreen && !maximized {
|
||||
if let Some(size) = size {
|
||||
state.windowed_bounds = Bounds {
|
||||
origin: Point::default(),
|
||||
size,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
let width = NonZeroU32::new(width as u32);
|
||||
let height = NonZeroU32::new(height as u32);
|
||||
drop(state);
|
||||
self.resize(width, height);
|
||||
if let Some(size) = size {
|
||||
self.resize(size);
|
||||
}
|
||||
|
||||
false
|
||||
}
|
||||
@ -483,63 +487,43 @@ impl WaylandWindowStatePtr {
|
||||
bounds
|
||||
}
|
||||
|
||||
pub fn set_size_and_scale(
|
||||
&self,
|
||||
width: Option<NonZeroU32>,
|
||||
height: Option<NonZeroU32>,
|
||||
scale: Option<f32>,
|
||||
) {
|
||||
let (width, height, scale) = {
|
||||
pub fn set_size_and_scale(&self, size: Option<Size<Pixels>>, scale: Option<f32>) {
|
||||
let (size, scale) = {
|
||||
let mut state = self.state.borrow_mut();
|
||||
if width.map_or(true, |width| width.get() == state.bounds.size.width)
|
||||
&& height.map_or(true, |height| height.get() == state.bounds.size.height)
|
||||
if size.map_or(true, |size| size == state.bounds.size)
|
||||
&& scale.map_or(true, |scale| scale == state.scale)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if let Some(width) = width {
|
||||
state.bounds.size.width = width.get();
|
||||
}
|
||||
if let Some(height) = height {
|
||||
state.bounds.size.height = height.get();
|
||||
if let Some(size) = size {
|
||||
state.bounds.size = size;
|
||||
}
|
||||
if let Some(scale) = scale {
|
||||
state.scale = scale;
|
||||
}
|
||||
let width = state.bounds.size.width;
|
||||
let height = state.bounds.size.height;
|
||||
let scale = state.scale;
|
||||
state.renderer.update_drawable_size(size(
|
||||
width as f64 * scale as f64,
|
||||
height as f64 * scale as f64,
|
||||
));
|
||||
(width, height, scale)
|
||||
let device_bounds = state.bounds.to_device_pixels(state.scale);
|
||||
state.renderer.update_drawable_size(device_bounds.size);
|
||||
(state.bounds.size, state.scale)
|
||||
};
|
||||
|
||||
if let Some(ref mut fun) = self.callbacks.borrow_mut().resize {
|
||||
fun(
|
||||
Size {
|
||||
width: px(width as f32),
|
||||
height: px(height as f32),
|
||||
},
|
||||
scale,
|
||||
);
|
||||
fun(size, scale);
|
||||
}
|
||||
|
||||
{
|
||||
let state = self.state.borrow();
|
||||
if let Some(viewport) = &state.viewport {
|
||||
viewport.set_destination(width as i32, height as i32);
|
||||
viewport.set_destination(size.width.0 as i32, size.height.0 as i32);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn resize(&self, width: Option<NonZeroU32>, height: Option<NonZeroU32>) {
|
||||
self.set_size_and_scale(width, height, None);
|
||||
pub fn resize(&self, size: Size<Pixels>) {
|
||||
self.set_size_and_scale(Some(size), None);
|
||||
}
|
||||
|
||||
pub fn rescale(&self, scale: f32) {
|
||||
self.set_size_and_scale(None, None, Some(scale));
|
||||
self.set_size_and_scale(None, Some(scale));
|
||||
}
|
||||
|
||||
/// Notifies the window of the state of the decorations.
|
||||
@ -625,8 +609,8 @@ impl rwh::HasDisplayHandle for WaylandWindow {
|
||||
}
|
||||
|
||||
impl PlatformWindow for WaylandWindow {
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
self.borrow().bounds.map(|p| DevicePixels(p as i32))
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
self.borrow().bounds
|
||||
}
|
||||
|
||||
fn is_maximized(&self) -> bool {
|
||||
@ -640,16 +624,13 @@ impl PlatformWindow for WaylandWindow {
|
||||
} else if state.maximized {
|
||||
WindowBounds::Maximized(state.windowed_bounds)
|
||||
} else {
|
||||
WindowBounds::Windowed(state.bounds.map(|p| DevicePixels(p as i32)))
|
||||
drop(state);
|
||||
WindowBounds::Windowed(self.bounds())
|
||||
}
|
||||
}
|
||||
|
||||
fn content_size(&self) -> Size<Pixels> {
|
||||
let state = self.borrow();
|
||||
Size {
|
||||
width: Pixels(state.bounds.size.width as f32),
|
||||
height: Pixels(state.bounds.size.height as f32),
|
||||
}
|
||||
self.borrow().bounds.size
|
||||
}
|
||||
|
||||
fn scale_factor(&self) -> f32 {
|
||||
@ -661,11 +642,12 @@ impl PlatformWindow for WaylandWindow {
|
||||
}
|
||||
|
||||
fn display(&self) -> Option<Rc<dyn PlatformDisplay>> {
|
||||
self.borrow().display.as_ref().map(|(id, display)| {
|
||||
let state = self.borrow();
|
||||
state.display.as_ref().map(|(id, display)| {
|
||||
Rc::new(WaylandDisplay {
|
||||
id: id.clone(),
|
||||
name: display.name.clone(),
|
||||
bounds: display.bounds,
|
||||
bounds: display.bounds.to_pixels(state.scale),
|
||||
}) as Rc<dyn PlatformDisplay>
|
||||
})
|
||||
}
|
||||
|
@ -908,8 +908,11 @@ impl LinuxClient for X11Client {
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(root_id, _)| {
|
||||
Some(Rc::new(X11Display::new(&state.xcb_connection, root_id)?)
|
||||
as Rc<dyn PlatformDisplay>)
|
||||
Some(Rc::new(X11Display::new(
|
||||
&state.xcb_connection,
|
||||
state.scale_factor,
|
||||
root_id,
|
||||
)?) as Rc<dyn PlatformDisplay>)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
@ -918,8 +921,12 @@ impl LinuxClient for X11Client {
|
||||
let state = self.0.borrow();
|
||||
|
||||
Some(Rc::new(
|
||||
X11Display::new(&state.xcb_connection, state.x_root_index)
|
||||
.expect("There should always be a root index"),
|
||||
X11Display::new(
|
||||
&state.xcb_connection,
|
||||
state.scale_factor,
|
||||
state.x_root_index,
|
||||
)
|
||||
.expect("There should always be a root index"),
|
||||
))
|
||||
}
|
||||
|
||||
@ -928,6 +935,7 @@ impl LinuxClient for X11Client {
|
||||
|
||||
Some(Rc::new(X11Display::new(
|
||||
&state.xcb_connection,
|
||||
state.scale_factor,
|
||||
id.0 as usize,
|
||||
)?))
|
||||
}
|
||||
|
@ -2,25 +2,29 @@ use anyhow::Result;
|
||||
use uuid::Uuid;
|
||||
use x11rb::{connection::Connection as _, xcb_ffi::XCBConnection};
|
||||
|
||||
use crate::{Bounds, DevicePixels, DisplayId, PlatformDisplay, Size};
|
||||
use crate::{px, Bounds, DisplayId, Pixels, PlatformDisplay, Size};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct X11Display {
|
||||
x_screen_index: usize,
|
||||
bounds: Bounds<DevicePixels>,
|
||||
bounds: Bounds<Pixels>,
|
||||
uuid: Uuid,
|
||||
}
|
||||
|
||||
impl X11Display {
|
||||
pub(crate) fn new(xc: &XCBConnection, x_screen_index: usize) -> Option<Self> {
|
||||
pub(crate) fn new(
|
||||
xc: &XCBConnection,
|
||||
scale_factor: f32,
|
||||
x_screen_index: usize,
|
||||
) -> Option<Self> {
|
||||
let screen = xc.setup().roots.get(x_screen_index).unwrap();
|
||||
Some(Self {
|
||||
x_screen_index: x_screen_index,
|
||||
x_screen_index,
|
||||
bounds: Bounds {
|
||||
origin: Default::default(),
|
||||
size: Size {
|
||||
width: DevicePixels(screen.width_in_pixels as i32),
|
||||
height: DevicePixels(screen.height_in_pixels as i32),
|
||||
width: px(screen.width_in_pixels as f32 / scale_factor),
|
||||
height: px(screen.height_in_pixels as f32 / scale_factor),
|
||||
},
|
||||
},
|
||||
uuid: Uuid::from_bytes([0; 16]),
|
||||
@ -37,7 +41,7 @@ impl PlatformDisplay for X11Display {
|
||||
Ok(self.uuid)
|
||||
}
|
||||
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
self.bounds
|
||||
}
|
||||
}
|
||||
|
@ -1,6 +1,6 @@
|
||||
use crate::{
|
||||
platform::blade::{BladeRenderer, BladeSurfaceConfig},
|
||||
size, AnyWindowHandle, Bounds, DevicePixels, ForegroundExecutor, Modifiers, Pixels,
|
||||
px, size, AnyWindowHandle, Bounds, DevicePixels, ForegroundExecutor, Modifiers, Pixels,
|
||||
PlatformAtlas, PlatformDisplay, PlatformInput, PlatformInputHandler, PlatformWindow, Point,
|
||||
PromptLevel, Scene, Size, WindowAppearance, WindowBackgroundAppearance, WindowBounds,
|
||||
WindowKind, WindowParams, X11ClientStatePtr,
|
||||
@ -162,7 +162,7 @@ pub struct X11WindowState {
|
||||
atoms: XcbAtoms,
|
||||
x_root_window: xproto::Window,
|
||||
_raw: RawWindow,
|
||||
bounds: Bounds<i32>,
|
||||
bounds: Bounds<Pixels>,
|
||||
scale_factor: f32,
|
||||
renderer: BladeRenderer,
|
||||
display: Rc<dyn PlatformDisplay>,
|
||||
@ -273,10 +273,10 @@ impl X11WindowState {
|
||||
visual.depth,
|
||||
x_window,
|
||||
visual_set.root,
|
||||
params.bounds.origin.x.0 as i16,
|
||||
params.bounds.origin.y.0 as i16,
|
||||
params.bounds.size.width.0 as u16,
|
||||
params.bounds.size.height.0 as u16,
|
||||
(params.bounds.origin.x.0 * scale_factor) as i16,
|
||||
(params.bounds.origin.y.0 * scale_factor) as i16,
|
||||
(params.bounds.size.width.0 * scale_factor) as u16,
|
||||
(params.bounds.size.height.0 * scale_factor) as u16,
|
||||
0,
|
||||
xproto::WindowClass::INPUT_OUTPUT,
|
||||
visual.id,
|
||||
@ -370,10 +370,12 @@ impl X11WindowState {
|
||||
Ok(Self {
|
||||
client,
|
||||
executor,
|
||||
display: Rc::new(X11Display::new(xcb_connection, x_screen_index).unwrap()),
|
||||
display: Rc::new(
|
||||
X11Display::new(xcb_connection, scale_factor, x_screen_index).unwrap(),
|
||||
),
|
||||
_raw: raw,
|
||||
x_root_window: visual_set.root,
|
||||
bounds: params.bounds.map(|v| v.0),
|
||||
bounds: params.bounds,
|
||||
scale_factor,
|
||||
renderer: BladeRenderer::new(gpu, config),
|
||||
atoms: *atoms,
|
||||
@ -627,6 +629,7 @@ impl X11WindowStatePtr {
|
||||
let is_resize;
|
||||
{
|
||||
let mut state = self.state.borrow_mut();
|
||||
let bounds = bounds.map(|f| px(f as f32 / state.scale_factor));
|
||||
|
||||
is_resize = bounds.size.width != state.bounds.size.width
|
||||
|| bounds.size.height != state.bounds.size.height;
|
||||
@ -641,9 +644,10 @@ impl X11WindowStatePtr {
|
||||
|
||||
let gpu_size = query_render_extent(&self.xcb_connection, self.x_window);
|
||||
if state.renderer.viewport_size() != gpu_size {
|
||||
state
|
||||
.renderer
|
||||
.update_drawable_size(size(gpu_size.width as f64, gpu_size.height as f64));
|
||||
state.renderer.update_drawable_size(size(
|
||||
DevicePixels(gpu_size.width as i32),
|
||||
DevicePixels(gpu_size.height as i32),
|
||||
));
|
||||
resize_args = Some((state.content_size(), state.scale_factor));
|
||||
}
|
||||
}
|
||||
@ -678,8 +682,8 @@ impl X11WindowStatePtr {
|
||||
}
|
||||
|
||||
impl PlatformWindow for X11Window {
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
self.0.state.borrow().bounds.map(|v| v.into())
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
self.0.state.borrow().bounds
|
||||
}
|
||||
|
||||
fn is_maximized(&self) -> bool {
|
||||
@ -693,7 +697,11 @@ impl PlatformWindow for X11Window {
|
||||
|
||||
fn window_bounds(&self) -> WindowBounds {
|
||||
let state = self.0.state.borrow();
|
||||
WindowBounds::Windowed(state.bounds.map(|p| DevicePixels(p)))
|
||||
if self.is_maximized() {
|
||||
WindowBounds::Maximized(state.bounds)
|
||||
} else {
|
||||
WindowBounds::Windowed(state.bounds)
|
||||
}
|
||||
}
|
||||
|
||||
fn content_size(&self) -> Size<Pixels> {
|
||||
|
@ -1,4 +1,4 @@
|
||||
use crate::{point, size, Bounds, DevicePixels, DisplayId, PlatformDisplay};
|
||||
use crate::{px, size, Bounds, DisplayId, Pixels, PlatformDisplay};
|
||||
use anyhow::Result;
|
||||
use cocoa::{
|
||||
appkit::NSScreen,
|
||||
@ -102,18 +102,15 @@ impl PlatformDisplay for MacDisplay {
|
||||
]))
|
||||
}
|
||||
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
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(DevicePixels(0), DevicePixels(0)),
|
||||
size: size(
|
||||
DevicePixels(bounds.size.width as i32),
|
||||
DevicePixels(bounds.size.height as i32),
|
||||
),
|
||||
origin: Default::default(),
|
||||
size: size(px(bounds.size.width as f32), px(bounds.size.height as f32)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -8,7 +8,7 @@ use anyhow::{anyhow, Result};
|
||||
use block::ConcreteBlock;
|
||||
use cocoa::{
|
||||
base::{NO, YES},
|
||||
foundation::NSUInteger,
|
||||
foundation::{NSSize, NSUInteger},
|
||||
quartzcore::AutoresizingMask,
|
||||
};
|
||||
use collections::HashMap;
|
||||
@ -268,7 +268,11 @@ impl MetalRenderer {
|
||||
.set_presents_with_transaction(presents_with_transaction);
|
||||
}
|
||||
|
||||
pub fn update_drawable_size(&mut self, size: Size<f64>) {
|
||||
pub fn update_drawable_size(&mut self, size: Size<DevicePixels>) {
|
||||
let size = NSSize {
|
||||
width: size.width.0 as f64,
|
||||
height: size.height.0 as f64,
|
||||
};
|
||||
unsafe {
|
||||
let _: () = msg_send![
|
||||
self.layer(),
|
||||
|
@ -1,11 +1,10 @@
|
||||
use super::{ns_string, renderer, MacDisplay, NSRange, NSStringExt};
|
||||
use crate::{
|
||||
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, WindowBackgroundAppearance, WindowBounds, WindowKind,
|
||||
WindowParams,
|
||||
platform::PlatformInputHandler, point, px, size, AnyWindowHandle, Bounds, DisplayLink,
|
||||
ExternalPaths, FileDropEvent, ForegroundExecutor, KeyDownEvent, Keystroke, Modifiers,
|
||||
ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels,
|
||||
PlatformAtlas, PlatformDisplay, PlatformInput, PlatformWindow, Point, PromptLevel, Size, Timer,
|
||||
WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowKind, WindowParams,
|
||||
};
|
||||
use block::ConcreteBlock;
|
||||
use cocoa::{
|
||||
@ -345,7 +344,7 @@ struct MacWindowState {
|
||||
external_files_dragged: bool,
|
||||
// Whether the next left-mouse click is also the focusing click.
|
||||
first_mouse: bool,
|
||||
fullscreen_restore_bounds: Bounds<DevicePixels>,
|
||||
fullscreen_restore_bounds: Bounds<Pixels>,
|
||||
}
|
||||
|
||||
impl MacWindowState {
|
||||
@ -439,7 +438,7 @@ impl MacWindowState {
|
||||
}
|
||||
}
|
||||
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
let mut window_frame = unsafe { NSWindow::frame(self.native_window) };
|
||||
let screen_frame = unsafe {
|
||||
let screen = NSWindow::screen(self.native_window);
|
||||
@ -452,12 +451,12 @@ impl MacWindowState {
|
||||
|
||||
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(),
|
||||
px((window_frame.origin.x - screen_frame.origin.x) as f32),
|
||||
px((window_frame.origin.y - screen_frame.origin.y) as f32),
|
||||
),
|
||||
size(
|
||||
(window_frame.size.width as i32).into(),
|
||||
(window_frame.size.height as i32).into(),
|
||||
px(window_frame.size.width as f32),
|
||||
px(window_frame.size.height as f32),
|
||||
),
|
||||
);
|
||||
bounds
|
||||
@ -473,13 +472,6 @@ impl MacWindowState {
|
||||
get_scale_factor(self.native_window)
|
||||
}
|
||||
|
||||
fn update_drawable_size(&mut self, drawable_size: NSSize) {
|
||||
self.renderer.update_drawable_size(Size {
|
||||
width: drawable_size.width,
|
||||
height: drawable_size.height,
|
||||
})
|
||||
}
|
||||
|
||||
fn titlebar_height(&self) -> Pixels {
|
||||
unsafe {
|
||||
let frame = NSWindow::frame(self.native_window);
|
||||
@ -599,14 +591,6 @@ impl MacWindow {
|
||||
let native_view = NSView::init(native_view);
|
||||
assert!(!native_view.is_null());
|
||||
|
||||
let window_size = {
|
||||
let scale = get_scale_factor(native_window);
|
||||
size(
|
||||
bounds.size.width.0 as f32 * scale,
|
||||
bounds.size.height.0 as f32 * scale,
|
||||
)
|
||||
};
|
||||
|
||||
let mut window = Self(Arc::new(Mutex::new(MacWindowState {
|
||||
handle,
|
||||
executor,
|
||||
@ -617,7 +601,7 @@ impl MacWindow {
|
||||
renderer_context,
|
||||
native_window as *mut _,
|
||||
native_view as *mut _,
|
||||
window_size,
|
||||
bounds.size.map(|pixels| pixels.0),
|
||||
window_background != WindowBackgroundAppearance::Opaque,
|
||||
),
|
||||
request_frame_callback: None,
|
||||
@ -772,7 +756,7 @@ impl Drop for MacWindow {
|
||||
}
|
||||
|
||||
impl PlatformWindow for MacWindow {
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
self.0.as_ref().lock().bounds()
|
||||
}
|
||||
|
||||
@ -1580,20 +1564,17 @@ extern "C" fn view_did_change_backing_properties(this: &Object, _: Sel) {
|
||||
let window_state = unsafe { get_window_state(this) };
|
||||
let mut lock = window_state.as_ref().lock();
|
||||
|
||||
let scale_factor = lock.scale_factor() as f64;
|
||||
let scale_factor = lock.scale_factor();
|
||||
let size = lock.content_size();
|
||||
let drawable_size: NSSize = NSSize {
|
||||
width: f64::from(size.width) * scale_factor,
|
||||
height: f64::from(size.height) * scale_factor,
|
||||
};
|
||||
let drawable_size = size.to_device_pixels(scale_factor);
|
||||
unsafe {
|
||||
let _: () = msg_send![
|
||||
lock.renderer.layer(),
|
||||
setContentsScale: scale_factor
|
||||
setContentsScale: scale_factor as f64
|
||||
];
|
||||
}
|
||||
|
||||
lock.update_drawable_size(drawable_size);
|
||||
lock.renderer.update_drawable_size(drawable_size);
|
||||
|
||||
if let Some(mut callback) = lock.resize_callback.take() {
|
||||
let content_size = lock.content_size();
|
||||
@ -1608,7 +1589,8 @@ extern "C" fn set_frame_size(this: &Object, _: Sel, size: NSSize) {
|
||||
let window_state = unsafe { get_window_state(this) };
|
||||
let mut lock = window_state.as_ref().lock();
|
||||
|
||||
if lock.content_size() == size.into() {
|
||||
let new_size = Size::<Pixels>::from(size);
|
||||
if lock.content_size() == new_size {
|
||||
return;
|
||||
}
|
||||
|
||||
@ -1616,16 +1598,10 @@ extern "C" fn set_frame_size(this: &Object, _: Sel, size: NSSize) {
|
||||
let _: () = msg_send![super(this, class!(NSView)), setFrameSize: size];
|
||||
}
|
||||
|
||||
let scale_factor = lock.scale_factor() as f64;
|
||||
let drawable_size: NSSize = NSSize {
|
||||
width: size.width * scale_factor,
|
||||
height: size.height * scale_factor,
|
||||
};
|
||||
let scale_factor = lock.scale_factor();
|
||||
let drawable_size = new_size.to_device_pixels(scale_factor);
|
||||
lock.renderer.update_drawable_size(drawable_size);
|
||||
|
||||
lock.update_drawable_size(drawable_size);
|
||||
|
||||
drop(lock);
|
||||
let mut lock = window_state.lock();
|
||||
if let Some(mut callback) = lock.resize_callback.take() {
|
||||
let content_size = lock.content_size();
|
||||
let scale_factor = lock.scale_factor();
|
||||
|
@ -1,12 +1,11 @@
|
||||
use crate::{px, Bounds, DisplayId, Pixels, PlatformDisplay, Point};
|
||||
use anyhow::{Ok, Result};
|
||||
|
||||
use crate::{Bounds, DevicePixels, DisplayId, PlatformDisplay, Point};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct TestDisplay {
|
||||
id: DisplayId,
|
||||
uuid: uuid::Uuid,
|
||||
bounds: Bounds<DevicePixels>,
|
||||
bounds: Bounds<Pixels>,
|
||||
}
|
||||
|
||||
impl TestDisplay {
|
||||
@ -14,10 +13,7 @@ impl TestDisplay {
|
||||
TestDisplay {
|
||||
id: DisplayId(1),
|
||||
uuid: uuid::Uuid::new_v4(),
|
||||
bounds: Bounds::from_corners(
|
||||
Point::default(),
|
||||
Point::new(DevicePixels(1920), DevicePixels(1080)),
|
||||
),
|
||||
bounds: Bounds::from_corners(Point::default(), Point::new(px(1920.), px(1080.))),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -31,7 +27,7 @@ impl PlatformDisplay for TestDisplay {
|
||||
Ok(self.uuid)
|
||||
}
|
||||
|
||||
fn bounds(&self) -> crate::Bounds<crate::DevicePixels> {
|
||||
fn bounds(&self) -> crate::Bounds<crate::Pixels> {
|
||||
self.bounds
|
||||
}
|
||||
}
|
||||
|
@ -1,8 +1,8 @@
|
||||
use crate::{
|
||||
AnyWindowHandle, AtlasKey, AtlasTextureId, AtlasTile, Bounds, DevicePixels,
|
||||
DispatchEventResult, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput,
|
||||
PlatformInputHandler, PlatformWindow, Point, Size, TestPlatform, TileId, WindowAppearance,
|
||||
WindowBackgroundAppearance, WindowBounds, WindowParams,
|
||||
AnyWindowHandle, AtlasKey, AtlasTextureId, AtlasTile, Bounds, DispatchEventResult, Pixels,
|
||||
PlatformAtlas, PlatformDisplay, PlatformInput, PlatformInputHandler, PlatformWindow, Point,
|
||||
Size, TestPlatform, TileId, WindowAppearance, WindowBackgroundAppearance, WindowBounds,
|
||||
WindowParams,
|
||||
};
|
||||
use collections::HashMap;
|
||||
use parking_lot::Mutex;
|
||||
@ -13,7 +13,7 @@ use std::{
|
||||
};
|
||||
|
||||
pub(crate) struct TestWindowState {
|
||||
pub(crate) bounds: Bounds<DevicePixels>,
|
||||
pub(crate) bounds: Bounds<Pixels>,
|
||||
pub(crate) handle: AnyWindowHandle,
|
||||
display: Rc<dyn PlatformDisplay>,
|
||||
pub(crate) title: Option<String>,
|
||||
@ -79,7 +79,7 @@ impl TestWindow {
|
||||
let Some(mut callback) = lock.resize_callback.take() else {
|
||||
return;
|
||||
};
|
||||
lock.bounds.size = size.map(|pixels| (pixels.0 as i32).into());
|
||||
lock.bounds.size = size;
|
||||
drop(lock);
|
||||
callback(size, scale_factor);
|
||||
self.0.lock().resize_callback = Some(callback);
|
||||
@ -108,7 +108,7 @@ impl TestWindow {
|
||||
}
|
||||
|
||||
impl PlatformWindow for TestWindow {
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
self.0.lock().bounds
|
||||
}
|
||||
|
||||
@ -121,7 +121,7 @@ impl PlatformWindow for TestWindow {
|
||||
}
|
||||
|
||||
fn content_size(&self) -> Size<Pixels> {
|
||||
self.bounds().size.into()
|
||||
self.bounds().size
|
||||
}
|
||||
|
||||
fn scale_factor(&self) -> f32 {
|
||||
|
@ -8,13 +8,13 @@ use windows::{
|
||||
Win32::{Foundation::*, Graphics::Gdi::*},
|
||||
};
|
||||
|
||||
use crate::{Bounds, DevicePixels, DisplayId, PlatformDisplay, Point, Size};
|
||||
use crate::{px, Bounds, DisplayId, Pixels, PlatformDisplay, Point, Size};
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub(crate) struct WindowsDisplay {
|
||||
pub handle: HMONITOR,
|
||||
pub display_id: DisplayId,
|
||||
bounds: Bounds<DevicePixels>,
|
||||
bounds: Bounds<Pixels>,
|
||||
uuid: Uuid,
|
||||
}
|
||||
|
||||
@ -34,12 +34,12 @@ impl WindowsDisplay {
|
||||
display_id,
|
||||
bounds: Bounds {
|
||||
origin: Point {
|
||||
x: DevicePixels(size.left),
|
||||
y: DevicePixels(size.top),
|
||||
x: px(size.left as f32),
|
||||
y: px(size.top as f32),
|
||||
},
|
||||
size: Size {
|
||||
width: DevicePixels(size.right - size.left),
|
||||
height: DevicePixels(size.bottom - size.top),
|
||||
width: px((size.right - size.left) as f32),
|
||||
height: px((size.bottom - size.top) as f32),
|
||||
},
|
||||
},
|
||||
uuid,
|
||||
@ -60,12 +60,12 @@ impl WindowsDisplay {
|
||||
display_id: DisplayId(display_id as _),
|
||||
bounds: Bounds {
|
||||
origin: Point {
|
||||
x: DevicePixels(size.left as i32),
|
||||
y: DevicePixels(size.top as i32),
|
||||
x: px(size.left as f32),
|
||||
y: px(size.top as f32),
|
||||
},
|
||||
size: Size {
|
||||
width: DevicePixels((size.right - size.left) as i32),
|
||||
height: DevicePixels((size.bottom - size.top) as i32),
|
||||
width: px((size.right - size.left) as f32),
|
||||
height: px((size.bottom - size.top) as f32),
|
||||
},
|
||||
},
|
||||
uuid,
|
||||
@ -82,12 +82,12 @@ impl WindowsDisplay {
|
||||
display_id,
|
||||
bounds: Bounds {
|
||||
origin: Point {
|
||||
x: DevicePixels(size.left as i32),
|
||||
y: DevicePixels(size.top as i32),
|
||||
x: px(size.left as f32),
|
||||
y: px(size.top as f32),
|
||||
},
|
||||
size: Size {
|
||||
width: DevicePixels((size.right - size.left) as i32),
|
||||
height: DevicePixels((size.bottom - size.top) as i32),
|
||||
width: px((size.right - size.left) as f32),
|
||||
height: px((size.bottom - size.top) as f32),
|
||||
},
|
||||
},
|
||||
uuid,
|
||||
@ -109,11 +109,11 @@ impl WindowsDisplay {
|
||||
}
|
||||
|
||||
/// Check if the center point of given bounds is inside this monitor
|
||||
pub fn check_given_bounds(&self, bounds: Bounds<DevicePixels>) -> bool {
|
||||
pub fn check_given_bounds(&self, bounds: Bounds<Pixels>) -> bool {
|
||||
let center = bounds.center();
|
||||
let center = POINT {
|
||||
x: center.x.0,
|
||||
y: center.y.0,
|
||||
x: center.x.0 as i32,
|
||||
y: center.y.0 as i32,
|
||||
};
|
||||
let monitor = unsafe { MonitorFromPoint(center, MONITOR_DEFAULTTONULL) };
|
||||
if monitor.is_invalid() {
|
||||
@ -167,7 +167,7 @@ impl PlatformDisplay for WindowsDisplay {
|
||||
Ok(self.uuid)
|
||||
}
|
||||
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
self.bounds
|
||||
}
|
||||
}
|
||||
|
@ -98,13 +98,13 @@ fn handle_move_msg(
|
||||
lparam: LPARAM,
|
||||
state_ptr: Rc<WindowsWindowStatePtr>,
|
||||
) -> Option<isize> {
|
||||
let x = lparam.signed_loword() as i32;
|
||||
let y = lparam.signed_hiword() as i32;
|
||||
let x = lparam.signed_loword() as f32;
|
||||
let y = lparam.signed_hiword() as f32;
|
||||
let mut lock = state_ptr.state.borrow_mut();
|
||||
lock.origin = point(x.into(), y.into());
|
||||
lock.origin = point(px(x), px(y));
|
||||
let size = lock.physical_size;
|
||||
let center_x = x + size.width.0 / 2;
|
||||
let center_y = y + size.height.0 / 2;
|
||||
let center_x = x + size.width.0 / 2.;
|
||||
let center_y = y + size.height.0 / 2.;
|
||||
let monitor_bounds = lock.display.bounds();
|
||||
if center_x < monitor_bounds.left().0
|
||||
|| center_x > monitor_bounds.right().0
|
||||
@ -131,18 +131,15 @@ fn handle_move_msg(
|
||||
fn handle_size_msg(lparam: LPARAM, state_ptr: Rc<WindowsWindowStatePtr>) -> Option<isize> {
|
||||
let width = lparam.loword().max(1) as i32;
|
||||
let height = lparam.hiword().max(1) as i32;
|
||||
let new_physical_size = size(width.into(), height.into());
|
||||
let mut lock = state_ptr.state.borrow_mut();
|
||||
let new_size = size(DevicePixels(width), DevicePixels(height));
|
||||
let scale_factor = lock.scale_factor;
|
||||
lock.physical_size = new_physical_size;
|
||||
lock.renderer.update_drawable_size(Size {
|
||||
width: width as f64,
|
||||
height: height as f64,
|
||||
});
|
||||
lock.renderer.update_drawable_size(new_size);
|
||||
let new_size = new_size.to_pixels(lock.scale_factor);
|
||||
lock.physical_size = new_size;
|
||||
if let Some(mut callback) = lock.callbacks.resize.take() {
|
||||
drop(lock);
|
||||
let logical_size = logical_size(new_physical_size, scale_factor);
|
||||
callback(logical_size, scale_factor);
|
||||
callback(new_size, scale_factor);
|
||||
state_ptr.state.borrow_mut().callbacks.resize = Some(callback);
|
||||
}
|
||||
Some(0)
|
||||
|
@ -27,14 +27,14 @@ use windows::{
|
||||
};
|
||||
|
||||
use crate::platform::blade::BladeRenderer;
|
||||
use crate::*;
|
||||
use crate::{Pixels, *};
|
||||
|
||||
pub(crate) struct WindowsWindow(pub Rc<WindowsWindowStatePtr>);
|
||||
|
||||
pub struct WindowsWindowState {
|
||||
pub origin: Point<DevicePixels>,
|
||||
pub physical_size: Size<DevicePixels>,
|
||||
pub fullscreen_restore_bounds: Bounds<DevicePixels>,
|
||||
pub origin: Point<Pixels>,
|
||||
pub physical_size: Size<Pixels>,
|
||||
pub fullscreen_restore_bounds: Bounds<Pixels>,
|
||||
pub scale_factor: f32,
|
||||
|
||||
pub callbacks: Callbacks,
|
||||
@ -68,8 +68,8 @@ impl WindowsWindowState {
|
||||
current_cursor: HCURSOR,
|
||||
display: WindowsDisplay,
|
||||
) -> Self {
|
||||
let origin = point(cs.x.into(), cs.y.into());
|
||||
let physical_size = size(cs.cx.into(), cs.cy.into());
|
||||
let origin = point(px(cs.x as f32), px(cs.y as f32));
|
||||
let physical_size = size(px(cs.cx as f32), px(cs.cy as f32));
|
||||
let fullscreen_restore_bounds = Bounds {
|
||||
origin,
|
||||
size: physical_size,
|
||||
@ -113,7 +113,7 @@ impl WindowsWindowState {
|
||||
!self.is_fullscreen() && unsafe { IsZoomed(self.hwnd) }.as_bool()
|
||||
}
|
||||
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
Bounds {
|
||||
origin: self.origin,
|
||||
size: self.physical_size,
|
||||
@ -131,12 +131,12 @@ impl WindowsWindowState {
|
||||
};
|
||||
let bounds = Bounds {
|
||||
origin: point(
|
||||
DevicePixels(placement.rcNormalPosition.left),
|
||||
DevicePixels(placement.rcNormalPosition.top),
|
||||
px(placement.rcNormalPosition.left as f32),
|
||||
px(placement.rcNormalPosition.top as f32),
|
||||
),
|
||||
size: size(
|
||||
DevicePixels(placement.rcNormalPosition.right - placement.rcNormalPosition.left),
|
||||
DevicePixels(placement.rcNormalPosition.bottom - placement.rcNormalPosition.top),
|
||||
px((placement.rcNormalPosition.right - placement.rcNormalPosition.left) as f32),
|
||||
px((placement.rcNormalPosition.bottom - placement.rcNormalPosition.top) as f32),
|
||||
),
|
||||
};
|
||||
|
||||
@ -154,7 +154,7 @@ impl WindowsWindowState {
|
||||
/// Currently, GPUI uses logical size of the app to handle mouse interactions (such as
|
||||
/// whether the mouse collides with other elements of GPUI).
|
||||
fn content_size(&self) -> Size<Pixels> {
|
||||
logical_size(self.physical_size, self.scale_factor)
|
||||
self.physical_size
|
||||
}
|
||||
|
||||
fn title_bar_padding(&self) -> Pixels {
|
||||
@ -306,6 +306,7 @@ impl WindowsWindow {
|
||||
} else {
|
||||
display.default_bounds()
|
||||
};
|
||||
let bounds = bounds.to_device_pixels(wnd.0.state.borrow().scale_factor);
|
||||
placement.rcNormalPosition.left = bounds.left().0;
|
||||
placement.rcNormalPosition.right = bounds.right().0;
|
||||
placement.rcNormalPosition.top = bounds.top().0;
|
||||
@ -353,7 +354,7 @@ impl Drop for WindowsWindow {
|
||||
}
|
||||
|
||||
impl PlatformWindow for WindowsWindow {
|
||||
fn bounds(&self) -> Bounds<DevicePixels> {
|
||||
fn bounds(&self) -> Bounds<Pixels> {
|
||||
self.0.state.borrow().bounds()
|
||||
}
|
||||
|
||||
@ -554,10 +555,10 @@ impl PlatformWindow for WindowsWindow {
|
||||
unsafe { GetWindowRect(state_ptr.hwnd, &mut rc) }.log_err();
|
||||
let _ = lock.fullscreen.insert(StyleAndBounds {
|
||||
style,
|
||||
x: rc.left,
|
||||
y: rc.top,
|
||||
cx: rc.right - rc.left,
|
||||
cy: rc.bottom - rc.top,
|
||||
x: px(rc.left as f32),
|
||||
y: px(rc.top as f32),
|
||||
cx: px((rc.right - rc.left) as f32),
|
||||
cy: px((rc.bottom - rc.top) as f32),
|
||||
});
|
||||
let style = style
|
||||
& !(WS_THICKFRAME
|
||||
@ -568,10 +569,10 @@ impl PlatformWindow for WindowsWindow {
|
||||
let bounds = lock.display.bounds();
|
||||
StyleAndBounds {
|
||||
style,
|
||||
x: bounds.left().0,
|
||||
y: bounds.top().0,
|
||||
cx: bounds.size.width.0,
|
||||
cy: bounds.size.height.0,
|
||||
x: bounds.left(),
|
||||
y: bounds.top(),
|
||||
cx: bounds.size.width,
|
||||
cy: bounds.size.height,
|
||||
}
|
||||
};
|
||||
drop(lock);
|
||||
@ -580,10 +581,10 @@ impl PlatformWindow for WindowsWindow {
|
||||
SetWindowPos(
|
||||
state_ptr.hwnd,
|
||||
HWND::default(),
|
||||
x,
|
||||
y,
|
||||
cx,
|
||||
cy,
|
||||
x.0 as i32,
|
||||
y.0 as i32,
|
||||
cx.0 as i32,
|
||||
cy.0 as i32,
|
||||
SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOZORDER,
|
||||
)
|
||||
}
|
||||
@ -836,10 +837,10 @@ impl ClickState {
|
||||
|
||||
struct StyleAndBounds {
|
||||
style: WINDOW_STYLE,
|
||||
x: i32,
|
||||
y: i32,
|
||||
cx: i32,
|
||||
cy: i32,
|
||||
x: Pixels,
|
||||
y: Pixels,
|
||||
cx: Pixels,
|
||||
cy: Pixels,
|
||||
}
|
||||
|
||||
fn register_wnd_class(icon_handle: HICON) -> PCWSTR {
|
||||
|
@ -52,8 +52,7 @@ mod prompts;
|
||||
|
||||
pub use prompts::*;
|
||||
|
||||
pub(crate) const DEFAULT_WINDOW_SIZE: Size<DevicePixels> =
|
||||
size(DevicePixels(1024), DevicePixels(700));
|
||||
pub(crate) const DEFAULT_WINDOW_SIZE: Size<Pixels> = size(px(1024.), px(700.));
|
||||
|
||||
/// Represents the two different phases when dispatching events.
|
||||
#[derive(Default, Copy, Clone, Debug, Eq, PartialEq)]
|
||||
@ -581,8 +580,8 @@ pub(crate) struct ElementStateBox {
|
||||
pub(crate) type_name: &'static str,
|
||||
}
|
||||
|
||||
fn default_bounds(display_id: Option<DisplayId>, cx: &mut AppContext) -> Bounds<DevicePixels> {
|
||||
const DEFAULT_WINDOW_OFFSET: Point<DevicePixels> = point(DevicePixels(0), DevicePixels(35));
|
||||
fn default_bounds(display_id: Option<DisplayId>, cx: &mut AppContext) -> Bounds<Pixels> {
|
||||
const DEFAULT_WINDOW_OFFSET: Point<Pixels> = point(px(0.), px(35.));
|
||||
|
||||
cx.active_window()
|
||||
.and_then(|w| w.update(cx, |_, cx| cx.bounds()).ok())
|
||||
@ -594,9 +593,7 @@ fn default_bounds(display_id: Option<DisplayId>, cx: &mut AppContext) -> Bounds<
|
||||
|
||||
display
|
||||
.map(|display| display.default_bounds())
|
||||
.unwrap_or_else(|| {
|
||||
Bounds::new(point(DevicePixels(0), DevicePixels(0)), DEFAULT_WINDOW_SIZE)
|
||||
})
|
||||
.unwrap_or_else(|| Bounds::new(point(px(0.), px(0.)), DEFAULT_WINDOW_SIZE))
|
||||
})
|
||||
}
|
||||
|
||||
@ -1145,7 +1142,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 bounds(&self) -> Bounds<DevicePixels> {
|
||||
pub fn bounds(&self) -> Bounds<Pixels> {
|
||||
self.window.platform_window.bounds()
|
||||
}
|
||||
|
||||
|
@ -12,6 +12,7 @@ use sqlez::{
|
||||
statement::Statement,
|
||||
};
|
||||
|
||||
use ui::px;
|
||||
use util::ResultExt;
|
||||
use uuid::Uuid;
|
||||
|
||||
@ -77,10 +78,10 @@ impl Bind for SerializedWindowBounds {
|
||||
let next_index = statement.bind(&"Windowed", start_index)?;
|
||||
statement.bind(
|
||||
&(
|
||||
SerializedDevicePixels(bounds.origin.x),
|
||||
SerializedDevicePixels(bounds.origin.y),
|
||||
SerializedDevicePixels(bounds.size.width),
|
||||
SerializedDevicePixels(bounds.size.height),
|
||||
SerializedPixels(bounds.origin.x),
|
||||
SerializedPixels(bounds.origin.y),
|
||||
SerializedPixels(bounds.size.width),
|
||||
SerializedPixels(bounds.size.height),
|
||||
),
|
||||
next_index,
|
||||
)
|
||||
@ -89,10 +90,10 @@ impl Bind for SerializedWindowBounds {
|
||||
let next_index = statement.bind(&"Maximized", start_index)?;
|
||||
statement.bind(
|
||||
&(
|
||||
SerializedDevicePixels(bounds.origin.x),
|
||||
SerializedDevicePixels(bounds.origin.y),
|
||||
SerializedDevicePixels(bounds.size.width),
|
||||
SerializedDevicePixels(bounds.size.height),
|
||||
SerializedPixels(bounds.origin.x),
|
||||
SerializedPixels(bounds.origin.y),
|
||||
SerializedPixels(bounds.size.width),
|
||||
SerializedPixels(bounds.size.height),
|
||||
),
|
||||
next_index,
|
||||
)
|
||||
@ -101,10 +102,10 @@ impl Bind for SerializedWindowBounds {
|
||||
let next_index = statement.bind(&"FullScreen", start_index)?;
|
||||
statement.bind(
|
||||
&(
|
||||
SerializedDevicePixels(bounds.origin.x),
|
||||
SerializedDevicePixels(bounds.origin.y),
|
||||
SerializedDevicePixels(bounds.size.width),
|
||||
SerializedDevicePixels(bounds.size.height),
|
||||
SerializedPixels(bounds.origin.x),
|
||||
SerializedPixels(bounds.origin.y),
|
||||
SerializedPixels(bounds.size.width),
|
||||
SerializedPixels(bounds.size.height),
|
||||
),
|
||||
next_index,
|
||||
)
|
||||
@ -116,40 +117,17 @@ impl Bind for SerializedWindowBounds {
|
||||
impl Column for SerializedWindowBounds {
|
||||
fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
|
||||
let (window_state, next_index) = String::column(statement, start_index)?;
|
||||
let ((x, y, width, height), _): ((i32, i32, i32, i32), _) =
|
||||
Column::column(statement, next_index)?;
|
||||
let bounds = Bounds {
|
||||
origin: point(px(x as f32), px(y as f32)),
|
||||
size: size(px(width as f32), px(height as f32)),
|
||||
};
|
||||
|
||||
let status = match window_state.as_str() {
|
||||
"Windowed" | "Fixed" => {
|
||||
let ((x, y, width, height), _) = Column::column(statement, next_index)?;
|
||||
let x: i32 = x;
|
||||
let y: i32 = y;
|
||||
let width: i32 = width;
|
||||
let height: i32 = height;
|
||||
SerializedWindowBounds(WindowBounds::Windowed(Bounds {
|
||||
origin: point(x.into(), y.into()),
|
||||
size: size(width.into(), height.into()),
|
||||
}))
|
||||
}
|
||||
"Maximized" => {
|
||||
let ((x, y, width, height), _) = Column::column(statement, next_index)?;
|
||||
let x: i32 = x;
|
||||
let y: i32 = y;
|
||||
let width: i32 = width;
|
||||
let height: i32 = height;
|
||||
SerializedWindowBounds(WindowBounds::Maximized(Bounds {
|
||||
origin: point(x.into(), y.into()),
|
||||
size: size(width.into(), height.into()),
|
||||
}))
|
||||
}
|
||||
"FullScreen" => {
|
||||
let ((x, y, width, height), _) = Column::column(statement, next_index)?;
|
||||
let x: i32 = x;
|
||||
let y: i32 = y;
|
||||
let width: i32 = width;
|
||||
let height: i32 = height;
|
||||
SerializedWindowBounds(WindowBounds::Fullscreen(Bounds {
|
||||
origin: point(x.into(), y.into()),
|
||||
size: size(width.into(), height.into()),
|
||||
}))
|
||||
}
|
||||
"Windowed" | "Fixed" => SerializedWindowBounds(WindowBounds::Windowed(bounds)),
|
||||
"Maximized" => SerializedWindowBounds(WindowBounds::Maximized(bounds)),
|
||||
"FullScreen" => SerializedWindowBounds(WindowBounds::Fullscreen(bounds)),
|
||||
_ => bail!("Window State did not have a valid string"),
|
||||
};
|
||||
|
||||
@ -158,16 +136,16 @@ impl Column for SerializedWindowBounds {
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
struct SerializedDevicePixels(gpui::DevicePixels);
|
||||
impl sqlez::bindable::StaticColumnCount for SerializedDevicePixels {}
|
||||
struct SerializedPixels(gpui::Pixels);
|
||||
impl sqlez::bindable::StaticColumnCount for SerializedPixels {}
|
||||
|
||||
impl sqlez::bindable::Bind for SerializedDevicePixels {
|
||||
impl sqlez::bindable::Bind for SerializedPixels {
|
||||
fn bind(
|
||||
&self,
|
||||
statement: &sqlez::statement::Statement,
|
||||
start_index: i32,
|
||||
) -> anyhow::Result<i32> {
|
||||
let this: i32 = self.0.into();
|
||||
let this: i32 = self.0 .0 as i32;
|
||||
this.bind(statement, start_index)
|
||||
}
|
||||
}
|
||||
|
@ -28,10 +28,10 @@ use futures::{
|
||||
};
|
||||
use gpui::{
|
||||
actions, canvas, impl_actions, point, relative, size, Action, AnyElement, AnyView, AnyWeakView,
|
||||
AppContext, AsyncAppContext, AsyncWindowContext, Bounds, DevicePixels, DragMoveEvent,
|
||||
Entity as _, EntityId, EventEmitter, FocusHandle, FocusableView, Global, KeyContext, Keystroke,
|
||||
ManagedView, Model, ModelContext, PathPromptOptions, Point, PromptLevel, Render, Size,
|
||||
Subscription, Task, View, WeakView, WindowBounds, WindowHandle, WindowOptions,
|
||||
AppContext, AsyncAppContext, AsyncWindowContext, Bounds, DragMoveEvent, Entity as _, EntityId,
|
||||
EventEmitter, FocusHandle, FocusableView, Global, KeyContext, Keystroke, ManagedView, Model,
|
||||
ModelContext, PathPromptOptions, Point, PromptLevel, Render, Size, Subscription, Task, View,
|
||||
WeakView, WindowBounds, WindowHandle, WindowOptions,
|
||||
};
|
||||
use item::{
|
||||
FollowableItem, FollowableItemHandle, Item, ItemHandle, ItemSettings, PreviewTabsSettings,
|
||||
@ -79,7 +79,7 @@ use theme::{ActiveTheme, SystemAppearance, ThemeSettings};
|
||||
pub use toolbar::{Toolbar, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView};
|
||||
pub use ui;
|
||||
use ui::{
|
||||
div, h_flex, Context as _, Div, FluentBuilder, InteractiveElement as _, IntoElement,
|
||||
div, h_flex, px, Context as _, Div, FluentBuilder, InteractiveElement as _, IntoElement,
|
||||
ParentElement as _, Pixels, SharedString, Styled as _, ViewContext, VisualContext as _,
|
||||
WindowContext,
|
||||
};
|
||||
@ -96,11 +96,11 @@ use crate::persistence::{
|
||||
use crate::{notifications::NotificationId, persistence::model::LocalPathsOrder};
|
||||
|
||||
lazy_static! {
|
||||
static ref ZED_WINDOW_SIZE: Option<Size<DevicePixels>> = env::var("ZED_WINDOW_SIZE")
|
||||
static ref ZED_WINDOW_SIZE: Option<Size<Pixels>> = env::var("ZED_WINDOW_SIZE")
|
||||
.ok()
|
||||
.as_deref()
|
||||
.and_then(parse_pixel_size_env_var);
|
||||
static ref ZED_WINDOW_POSITION: Option<Point<DevicePixels>> = env::var("ZED_WINDOW_POSITION")
|
||||
static ref ZED_WINDOW_POSITION: Option<Point<Pixels>> = env::var("ZED_WINDOW_POSITION")
|
||||
.ok()
|
||||
.as_deref()
|
||||
.and_then(parse_pixel_position_env_var);
|
||||
@ -3981,7 +3981,7 @@ impl Workspace {
|
||||
}
|
||||
}
|
||||
|
||||
fn window_bounds_env_override() -> Option<Bounds<DevicePixels>> {
|
||||
fn window_bounds_env_override() -> Option<Bounds<Pixels>> {
|
||||
ZED_WINDOW_POSITION
|
||||
.zip(*ZED_WINDOW_SIZE)
|
||||
.map(|(position, size)| Bounds {
|
||||
@ -5158,18 +5158,18 @@ pub fn reload(reload: &Reload, cx: &mut AppContext) {
|
||||
.detach_and_log_err(cx);
|
||||
}
|
||||
|
||||
fn parse_pixel_position_env_var(value: &str) -> Option<Point<DevicePixels>> {
|
||||
fn parse_pixel_position_env_var(value: &str) -> Option<Point<Pixels>> {
|
||||
let mut parts = value.split(',');
|
||||
let x: usize = parts.next()?.parse().ok()?;
|
||||
let y: usize = parts.next()?.parse().ok()?;
|
||||
Some(point((x as i32).into(), (y as i32).into()))
|
||||
Some(point(px(x as f32), px(y as f32)))
|
||||
}
|
||||
|
||||
fn parse_pixel_size_env_var(value: &str) -> Option<Size<DevicePixels>> {
|
||||
fn parse_pixel_size_env_var(value: &str) -> Option<Size<Pixels>> {
|
||||
let mut parts = value.split(',');
|
||||
let width: usize = parts.next()?.parse().ok()?;
|
||||
let height: usize = parts.next()?.parse().ok()?;
|
||||
Some(size((width as i32).into(), (height as i32).into()))
|
||||
Some(size(px(width as f32), px(height as f32)))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
Loading…
Reference in New Issue
Block a user