multiplexer.rs
/*
ENSnano, a 3d graphical application for DNA nanostructures.
Copyright (C) 2021 Nicolas Levy <nicolaspierrelevy@gmail.com> and Nicolas Schabanel <nicolas.schabanel@ens-lyon.fr>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
//! This modules handles the separation of the window into different regions.
//!
//! The layout manager split the window into different regions and attribute each region to an
//! an application or a gui component.
//!
//! In addition, the multiplexer holds a Vec of overlays which are floating regions.
//!
//! When an event is recieved by the window, the multiplexer is in charge of forwarding it to the
//! appropriate application, gui component or overlay. The multiplexer also handles some events
//! like resizing events of keyboard input that should be handled independently of the foccussed
//! region.
//!
//!
//!
//! The multiplexer is also in charge of drawing to the frame.
use super::{save_before_open, save_before_quit};
use crate::gui::{Requests, UiSize};
use crate::mediator::{ActionMode, SelectionMode};
use crate::utils::texture::SampledTexture;
use crate::PhySize;
use iced_wgpu::wgpu;
use iced_winit::winit;
use iced_winit::winit::event::*;
use std::rc::Rc;
use std::sync::{Arc, Mutex};
use wgpu::Device;
use winit::{
dpi::{PhysicalPosition, PhysicalSize},
event::{ElementState, WindowEvent},
window::CursorIcon,
};
mod layout_manager;
use layout_manager::{LayoutTree, PixelRegion};
/// A structure that represents an area on which an element can be drawn
#[derive(Clone, Copy, Debug)]
pub struct DrawArea {
/// The top left corner of the element
pub position: PhysicalPosition<u32>,
/// The *physical* size of the element
pub size: PhySize,
}
/// The different elements represented on the scene. Each element is instanciated once.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ElementType {
/// The top menu bar
TopBar,
/// The 3D scene
Scene,
/// The flat Scene
FlatScene,
/// The Left Panel
LeftPanel,
/// The status bar
StatusBar,
GridPanel,
/// An overlay area
Overlay(usize),
/// An area that has not been attributed to an element
Unattributed,
}
impl ElementType {
pub fn is_gui(&self) -> bool {
match self {
ElementType::TopBar | ElementType::LeftPanel | ElementType::StatusBar => true,
_ => false,
}
}
pub fn is_scene(&self) -> bool {
match self {
ElementType::Scene | ElementType::FlatScene => true,
_ => false,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum SplitMode {
Flat,
Scene3D,
Both,
}
/// A structure that handles the division of the window into different `DrawArea`
pub struct Multiplexer {
/// The *physical* size of the window
pub window_size: PhySize,
/// The scale factor of the window
pub scale_factor: f64,
/// The object mapping pixels to drawing areas
layout_manager: LayoutTree,
/// The Element on which the mouse cursor is currently on.
focus: Option<ElementType>,
/// The *physical* position of the cursor on the focus area
cursor_position: PhysicalPosition<f64>,
/// The area that are drawn on top of the application
overlays: Vec<Overlay>,
/// The texture on which the scene is rendered
scene_texture: Option<SampledTexture>,
/// The texture on which the top bar gui is rendered
top_bar_texture: Option<SampledTexture>,
/// The texture on which the left pannel is rendered
left_pannel_texture: Option<SampledTexture>,
/// The textures on which the overlays are rendered
overlays_textures: Vec<SampledTexture>,
/// The texture on wich the grid is rendered
grid_panel_texture: Option<SampledTexture>,
/// The texutre on which the flat scene is rendered,
status_bar_texture: Option<SampledTexture>,
flat_scene_texture: Option<SampledTexture>,
/// The pointer the node that separate the left pannel from the scene
left_pannel_split: usize,
/// The pointer to the node that separate the top bar from the scene
top_bar_split: usize,
/// The pointer to the node that separtate the status bar from the scene
status_bar_split: usize,
device: Rc<Device>,
pipeline: Option<wgpu::RenderPipeline>,
split_mode: SplitMode,
requests: Arc<Mutex<Requests>>,
state: State,
modifiers: ModifiersState,
ui_size: UiSize,
pub invert_y_scroll: bool,
}
const MAX_LEFT_PANNEL_WIDTH: f64 = 200.;
const MAX_STATUS_BAR_HEIGHT: f64 = 50.;
impl Multiplexer {
/// Create a new multiplexer for a window with size `window_size`.
pub fn new(
window_size: PhySize,
scale_factor: f64,
device: Rc<Device>,
requests: Arc<Mutex<Requests>>,
) -> Self {
let ui_size: UiSize = Default::default();
let mut layout_manager = LayoutTree::new();
let top_pannel_prop =
exact_proportion(ui_size.top_bar() * scale_factor, window_size.height as f64);
let top_bar_split = 0;
let (top_bar, scene) = layout_manager.hsplit(0, top_pannel_prop, false);
let left_pannel_split = scene;
let left_pannel_prop = proportion(
0.2,
MAX_LEFT_PANNEL_WIDTH * scale_factor,
window_size.width as f64,
);
let (left_pannel, scene) = layout_manager.vsplit(scene, left_pannel_prop, true);
let scene_height = (1. - top_pannel_prop) * window_size.height as f64;
let status_bar_prop = exact_proportion(MAX_STATUS_BAR_HEIGHT * scale_factor, scene_height);
let status_bar_split = scene;
let (scene, status_bar) = layout_manager.hsplit(scene, 1. - status_bar_prop, false);
//let (scene, grid_panel) = layout_manager.hsplit(scene, 0.8);
layout_manager.attribute_element(top_bar, ElementType::TopBar);
layout_manager.attribute_element(scene, ElementType::Scene);
layout_manager.attribute_element(status_bar, ElementType::StatusBar);
layout_manager.attribute_element(left_pannel, ElementType::LeftPanel);
//layout_manager.attribute_element(grid_panel, ElementType::GridPanel);
let mut ret = Self {
window_size,
scale_factor,
layout_manager,
focus: None,
cursor_position: PhysicalPosition::new(-1., -1.),
scene_texture: None,
flat_scene_texture: None,
top_bar_texture: None,
left_pannel_texture: None,
grid_panel_texture: None,
status_bar_texture: None,
overlays: Vec::new(),
overlays_textures: Vec::new(),
device,
pipeline: None,
split_mode: SplitMode::Scene3D,
requests,
left_pannel_split,
status_bar_split,
top_bar_split,
state: State::Normal {
mouse_position: PhysicalPosition::new(-1., -1.),
},
modifiers: ModifiersState::empty(),
ui_size,
invert_y_scroll: false,
};
ret.generate_textures();
ret
}
/// Return a view of the texture on which the element must be rendered
pub fn get_texture_view(&self, element_type: ElementType) -> Option<&wgpu::TextureView> {
match element_type {
ElementType::Scene => self.scene_texture.as_ref().map(|t| &t.view),
ElementType::LeftPanel => self.left_pannel_texture.as_ref().map(|t| &t.view),
ElementType::TopBar => self.top_bar_texture.as_ref().map(|t| &t.view),
ElementType::Overlay(n) => Some(&self.overlays_textures[n].view),
ElementType::GridPanel => self.grid_panel_texture.as_ref().map(|t| &t.view),
ElementType::FlatScene => self.flat_scene_texture.as_ref().map(|t| &t.view),
ElementType::StatusBar => self.status_bar_texture.as_ref().map(|t| &t.view),
ElementType::Unattributed => unreachable!(),
}
}
pub fn update_modifiers(&mut self, modifiers: ModifiersState) {
self.modifiers = modifiers
}
pub fn draw(&mut self, encoder: &mut wgpu::CommandEncoder, target: &wgpu::TextureView) {
if self.pipeline.is_none() {
let bg_layout = &self.top_bar_texture.as_ref().unwrap().bg_layout;
self.pipeline = Some(create_pipeline(self.device.as_ref(), bg_layout));
}
let clear_color = wgpu::Color {
r: 0.,
g: 0.,
b: 0.,
a: 1.,
};
let msaa_texture = None;
let attachment = if msaa_texture.is_some() {
msaa_texture.as_ref().unwrap()
} else {
target
};
let resolve_target = if msaa_texture.is_some() {
Some(target)
} else {
None
};
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: None,
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment,
resolve_target,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(clear_color),
store: true,
},
}],
depth_stencil_attachment: None,
});
if self.window_size.width > 0 && self.window_size.height > 0 {
for element in [
ElementType::TopBar,
ElementType::LeftPanel,
ElementType::GridPanel,
ElementType::Scene,
ElementType::FlatScene,
ElementType::StatusBar,
]
.iter()
{
if let Some(area) = self.get_draw_area(*element) {
render_pass.set_bind_group(0, self.get_bind_group(element), &[]);
render_pass.set_viewport(
area.position.x as f32,
area.position.y as f32,
area.size.width as f32,
area.size.height as f32,
0.0,
1.0,
);
let width = area
.size
.width
.min(self.window_size.width - area.position.x);
let height = area
.size
.height
.min(self.window_size.height - area.position.y);
render_pass.set_scissor_rect(area.position.x, area.position.y, width, height);
render_pass.set_pipeline(self.pipeline.as_ref().unwrap());
render_pass.draw(0..4, 0..1);
}
}
}
}
fn get_bind_group(&self, element_type: &ElementType) -> &wgpu::BindGroup {
match element_type {
ElementType::TopBar => &self.top_bar_texture.as_ref().unwrap().bind_group,
ElementType::LeftPanel => &self.left_pannel_texture.as_ref().unwrap().bind_group,
ElementType::Scene => &self.scene_texture.as_ref().unwrap().bind_group,
ElementType::FlatScene => &self.flat_scene_texture.as_ref().unwrap().bind_group,
ElementType::GridPanel => &self.grid_panel_texture.as_ref().unwrap().bind_group,
ElementType::Overlay(n) => &self.overlays_textures[*n].bind_group,
ElementType::StatusBar => &self.status_bar_texture.as_ref().unwrap().bind_group,
ElementType::Unattributed => unreachable!(),
}
}
/// Return the drawing area attributed to an element.
pub fn get_draw_area(&self, element_type: ElementType) -> Option<DrawArea> {
use ElementType::Overlay;
let (position, size) = if let Overlay(n) = element_type {
(self.overlays[n].position, self.overlays[n].size)
} else {
let (left, top, right, bottom) = self.layout_manager.get_area(element_type)?;
let top = top * self.window_size.height as f64;
let left = left * self.window_size.width as f64;
let bottom = bottom * self.window_size.height as f64;
let right = right * self.window_size.width as f64;
(
PhysicalPosition::new(left, top).cast::<u32>(),
PhysicalSize::new(right - left, bottom - top).cast::<u32>(),
)
};
Some(DrawArea { position, size })
}
pub fn check_scale_factor(&mut self, window: &crate::Window) -> bool {
if self.scale_factor != window.scale_factor() {
self.scale_factor = window.scale_factor();
self.window_size = window.inner_size();
self.resize(self.window_size, self.scale_factor);
if self.window_size.width > 0 && self.window_size.height > 0 {
self.generate_textures();
}
true
} else {
false
}
}
/// Forwards event to the elment on which they happen.
pub fn event(
&mut self,
mut event: WindowEvent<'static>,
resized: &mut bool,
scale_factor_changed: &mut bool,
) -> (
Option<(WindowEvent<'static>, ElementType)>,
Option<CursorIcon>,
) {
let mut icon = None;
let mut captured = false;
match &mut event {
WindowEvent::CursorMoved { position, .. } => match &mut self.state {
State::Resizing {
region,
mouse_position,
clicked_position,
old_proportion,
} => {
*mouse_position = *position;
let mut position = position.clone();
position.x /= self.window_size.width as f64;
position.y /= self.window_size.height as f64;
*resized = true;
self.layout_manager.resize_click(
*region,
&position,
&clicked_position,
*old_proportion,
);
icon = Some(CursorIcon::EwResize);
captured = true;
}
State::Normal { mouse_position, .. } => {
*mouse_position = *position;
let &mut PhysicalPosition { x, y } = position;
if x > 0.0 || y > 0.0 {
let element = self.pixel_to_element(*position);
let area = match element {
PixelRegion::Resize(_) => {
icon = Some(CursorIcon::EwResize);
None
}
PixelRegion::Element(element) => {
icon = Some(CursorIcon::Arrow);
self.focus = Some(element);
self.get_draw_area(element)
}
PixelRegion::Area(_) => unreachable!(),
}
.or(self.focus.and_then(|e| self.get_draw_area(e)));
if let Some(area) = area {
self.cursor_position.x = position.x - area.position.cast::<f64>().x;
self.cursor_position.y = position.y - area.position.cast::<f64>().y;
}
}
}
State::Interacting {
mouse_position,
element,
} => {
*mouse_position = *position;
let element = element.clone();
let area = self.get_draw_area(element);
if let Some(area) = area {
self.cursor_position.x = position.x - area.position.cast::<f64>().x;
self.cursor_position.y = position.y - area.position.cast::<f64>().y;
}
}
},
WindowEvent::Resized(new_size) => {
self.window_size = *new_size;
self.resize(*new_size, self.scale_factor);
*resized = true;
if self.window_size.width > 0 && self.window_size.height > 0 {
self.generate_textures();
}
}
WindowEvent::ScaleFactorChanged {
scale_factor,
new_inner_size,
} => {
self.scale_factor = *scale_factor;
self.window_size = **new_inner_size;
self.resize(self.window_size, self.scale_factor);
*resized = true;
*scale_factor_changed = true;
if self.window_size.width > 0 && self.window_size.height > 0 {
self.generate_textures();
}
}
WindowEvent::MouseInput { state, .. } => {
let element = self.pixel_to_element(self.state.mouse_position());
let mouse_position = self.state.mouse_position();
match element {
PixelRegion::Resize(n) if *state == ElementState::Pressed => {
let mut clicked_position = mouse_position.clone();
clicked_position.x /= self.window_size.width as f64;
clicked_position.y /= self.window_size.height as f64;
let old_proportion = self.layout_manager.get_proportion(n).unwrap();
self.state = State::Resizing {
mouse_position,
clicked_position,
region: n,
old_proportion,
};
}
PixelRegion::Resize(_) => {
self.state = State::Normal { mouse_position };
}
PixelRegion::Element(element) => match state {
ElementState::Pressed => {
self.state = State::Interacting {
mouse_position,
element,
};
}
ElementState::Released => {
self.state = State::Normal { mouse_position };
}
},
_ => unreachable!(),
}
}
WindowEvent::KeyboardInput {
input:
KeyboardInput {
virtual_keycode: Some(key),
state: ElementState::Pressed,
..
},
..
} => {
captured = true;
match *key {
VirtualKeyCode::Escape => {
self.requests.lock().unwrap().action_mode = Some(ActionMode::Normal)
}
VirtualKeyCode::C if ctrl(&self.modifiers) => {
self.requests.lock().unwrap().copy = true;
}
VirtualKeyCode::V if ctrl(&self.modifiers) => {
self.requests.lock().unwrap().paste = true;
}
VirtualKeyCode::J if ctrl(&self.modifiers) => {
self.requests.lock().unwrap().duplication = true;
}
VirtualKeyCode::L if ctrl(&self.modifiers) => {
self.requests.lock().unwrap().anchor = true;
}
VirtualKeyCode::R if !ctrl(&self.modifiers) => {
self.requests.lock().unwrap().action_mode = Some(ActionMode::Rotate)
}
VirtualKeyCode::T => {
self.requests.lock().unwrap().action_mode = Some(ActionMode::Translate)
}
VirtualKeyCode::N => {
self.requests.lock().unwrap().selection_mode =
Some(SelectionMode::Nucleotide)
}
VirtualKeyCode::H => {
self.requests.lock().unwrap().selection_mode = Some(SelectionMode::Helix)
}
VirtualKeyCode::S if ctrl(&self.modifiers) => {
self.requests.lock().unwrap().save_shortcut = Some(());
}
VirtualKeyCode::O if ctrl(&self.modifiers) => {
save_before_open(self.requests.clone());
}
VirtualKeyCode::Q if ctrl(&self.modifiers) && cfg!(target_os = "macos") => {
save_before_quit(self.requests.clone());
}
VirtualKeyCode::S => {
self.requests.lock().unwrap().selection_mode = Some(SelectionMode::Strand)
}
/*
VirtualKeyCode::K => {
self.requests.lock().unwrap().recolor_stapples = true;
}*/
VirtualKeyCode::Delete | VirtualKeyCode::Back => {
self.requests.lock().unwrap().delete_selection = true;
}
_ => captured = false,
}
}
WindowEvent::MouseWheel { delta, .. } => {
if self.invert_y_scroll {
match delta {
MouseScrollDelta::LineDelta(_, y) => {
*y *= -1.;
}
MouseScrollDelta::PixelDelta(position) => {
position.y *= -1.;
}
}
}
}
_ => {}
}
if let Some(focus) = self.focus.filter(|_| !captured) {
(Some((event, focus)), icon)
} else {
(None, icon)
}
}
pub fn change_ui_size(&mut self, ui_size: UiSize, window: &iced_winit::winit::window::Window) {
self.ui_size = ui_size;
self.resize(window.inner_size(), window.scale_factor());
self.generate_textures();
}
pub fn change_split(&mut self, split_mode: SplitMode) {
if split_mode != self.split_mode {
match self.split_mode {
SplitMode::Both => {
let new_type = match split_mode {
SplitMode::Scene3D => ElementType::Scene,
SplitMode::Flat => ElementType::FlatScene,
SplitMode::Both => unreachable!(),
};
self.layout_manager.merge(ElementType::Scene, new_type);
}
SplitMode::Scene3D | SplitMode::Flat => {
let id = self
.layout_manager
.get_area_id(ElementType::Scene)
.or(self.layout_manager.get_area_id(ElementType::FlatScene))
.unwrap();
match split_mode {
SplitMode::Both => {
let (scene, flat_scene) = self.layout_manager.vsplit(id, 0.5, true);
self.layout_manager
.attribute_element(scene, ElementType::Scene);
self.layout_manager
.attribute_element(flat_scene, ElementType::FlatScene);
}
SplitMode::Scene3D => self
.layout_manager
.attribute_element(id, ElementType::Scene),
SplitMode::Flat => self
.layout_manager
.attribute_element(id, ElementType::FlatScene),
}
}
}
}
self.split_mode = split_mode;
self.generate_textures();
}
fn resize(&mut self, window_size: PhySize, scale_factor: f64) {
let top_pannel_prop = exact_proportion(
self.ui_size.top_bar() * scale_factor,
window_size.height as f64,
);
let left_pannel_prop = proportion(
0.2,
MAX_LEFT_PANNEL_WIDTH * scale_factor,
window_size.width as f64,
);
let scene_height = (1. - top_pannel_prop) * window_size.height as f64;
let status_bar_prop = exact_proportion(MAX_STATUS_BAR_HEIGHT * scale_factor, scene_height);
self.layout_manager
.resize(self.left_pannel_split, left_pannel_prop);
self.layout_manager
.resize(self.top_bar_split, top_pannel_prop);
self.layout_manager
.resize(self.status_bar_split, 1. - status_bar_prop);
}
fn texture(&mut self, element_type: ElementType) -> Option<SampledTexture> {
self.get_draw_area(element_type)
.filter(|a| a.size.height > 0 && a.size.width > 0)
.map(|a| SampledTexture::create_target_texture(self.device.as_ref(), &a.size))
}
pub fn generate_textures(&mut self) {
self.scene_texture = self.texture(ElementType::Scene);
self.top_bar_texture = self.texture(ElementType::TopBar);
self.left_pannel_texture = self.texture(ElementType::LeftPanel);
self.grid_panel_texture = self.texture(ElementType::GridPanel);
self.flat_scene_texture = self.texture(ElementType::FlatScene);
self.status_bar_texture = self.texture(ElementType::StatusBar);
self.overlays_textures.clear();
for overlay in self.overlays.iter() {
let size = overlay.size;
self.overlays_textures
.push(SampledTexture::create_target_texture(
self.device.as_ref(),
&size,
));
}
}
/// Maps *physical* pixels to an element
fn pixel_to_element(&self, pixel: PhysicalPosition<f64>) -> PixelRegion {
let pixel_u32 = pixel.cast::<u32>();
for (n, overlay) in self.overlays.iter().enumerate() {
if overlay.contains_pixel(pixel_u32) {
return PixelRegion::Element(ElementType::Overlay(n));
}
}
self.layout_manager.get_area_pixel(
pixel.x / self.window_size.width as f64,
pixel.y / self.window_size.height as f64,
)
}
/// Get the drawing area attributed to an element.
pub fn get_element_area(&self, element: ElementType) -> Option<DrawArea> {
self.get_draw_area(element)
}
/// Return the *physical* position of the cursor, in the foccused element coordinates
pub fn get_cursor_position(&self) -> PhysicalPosition<f64> {
self.cursor_position
}
/// Return the foccused element
pub fn foccused_element(&self) -> Option<ElementType> {
self.focus
}
pub fn set_overlays(&mut self, overlays: Vec<Overlay>) {
self.overlays = overlays;
self.overlays_textures.clear();
for overlay in self.overlays.iter_mut() {
let size = overlay.size;
self.overlays_textures
.push(SampledTexture::create_target_texture(
self.device.as_ref(),
&size,
));
}
}
pub fn is_showing(&self, area: &ElementType) -> bool {
match area {
ElementType::LeftPanel | ElementType::TopBar | ElementType::StatusBar => true,
ElementType::Scene => {
self.split_mode == SplitMode::Scene3D || self.split_mode == SplitMode::Both
}
ElementType::FlatScene => {
self.split_mode == SplitMode::Flat || self.split_mode == SplitMode::Both
}
_ => false,
}
}
}
#[derive(Clone)]
pub struct Overlay {
pub position: PhysicalPosition<u32>,
pub size: PhysicalSize<u32>,
}
impl Overlay {
pub fn contains_pixel(&self, pixel: PhysicalPosition<u32>) -> bool {
pixel.x >= self.position.x
&& pixel.y >= self.position.y
&& pixel.x < self.position.x + self.size.width
&& pixel.y < self.position.y + self.size.height
}
}
fn create_pipeline(device: &Device, bg_layout: &wgpu::BindGroupLayout) -> wgpu::RenderPipeline {
let vs_module =
&device.create_shader_module(&wgpu::include_spirv!("multiplexer/draw.vert.spv"));
let fs_module =
&device.create_shader_module(&wgpu::include_spirv!("multiplexer/draw.frag.spv"));
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
bind_group_layouts: &[bg_layout],
push_constant_ranges: &[],
label: None,
});
let targets = &[wgpu::ColorTargetState {
format: wgpu::TextureFormat::Bgra8UnormSrgb,
color_blend: wgpu::BlendState::REPLACE,
alpha_blend: wgpu::BlendState::REPLACE,
write_mask: wgpu::ColorWrite::ALL,
}];
let primitive = wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleStrip,
strip_index_format: Some(wgpu::IndexFormat::Uint16),
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::None,
..Default::default()
};
let desc = wgpu::RenderPipelineDescriptor {
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &vs_module,
entry_point: "main",
buffers: &[],
},
fragment: Some(wgpu::FragmentState {
module: &fs_module,
entry_point: "main",
targets,
}),
primitive,
depth_stencil: None,
multisample: wgpu::MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
label: None,
};
device.create_render_pipeline(&desc)
}
fn proportion(min_prop: f64, max_size: f64, length: f64) -> f64 {
let max_prop = max_size / length;
max_prop.min(min_prop)
}
fn exact_proportion(size: f64, length: f64) -> f64 {
size / length
}
enum State {
Resizing {
mouse_position: PhysicalPosition<f64>,
clicked_position: PhysicalPosition<f64>,
region: usize,
old_proportion: f64,
},
Normal {
mouse_position: PhysicalPosition<f64>,
},
Interacting {
mouse_position: PhysicalPosition<f64>,
element: ElementType,
},
}
impl State {
fn mouse_position(&self) -> PhysicalPosition<f64> {
match self {
Self::Resizing { mouse_position, .. }
| Self::Normal { mouse_position }
| Self::Interacting { mouse_position, .. } => *mouse_position,
}
}
}
fn ctrl(modifiers: &ModifiersState) -> bool {
if cfg!(target_os = "macos") {
modifiers.logo()
} else {
modifiers.ctrl()
}
}
