migrations/egui
1
0
Fork 0
mirror of https://github.com/emilk/egui.git synced 2026-08-31 05:40:03 -04:00
Code Activity

Now in ViewportBuilder, InputState, RawInput: viewport_inner_pos, viewport_outer_pos, viewport_inner_size, viewport_outer_size are stored as inner_pos, outer_pos, inner_size, outer_pos and Now every (i32, i32) is stored as egui::Pos2

Browse Source 
Addes some documentation
This commit is contained in:
Konkitoman
2023-09-04 14:23:21 +03:00
parent 4a9e087e92
commit 7c4a85ebda
7 changed files with 149 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
crates/eframe/src/native/epi_integration.rs
View File

@@ -124,12 +124,10 @@ pub fn window_builder<E>(
} }
if let Some(min_size) = *min_window_size { if let Some(min_size) = *min_window_size {
window_builder = window_builder = window_builder.with_min_inner_size(Some(min_size.to_pos2()));
window_builder.with_min_inner_size(Some((min_size.x as u32, min_size.y as u32)));
} }
if let Some(max_size) = *max_window_size { if let Some(max_size) = *max_window_size {
window_builder = window_builder = window_builder.with_max_inner_size(Some(max_size.to_pos2()));
window_builder.with_max_inner_size(Some((max_size.x as u32, max_size.y as u32)));
} }
window_builder = window_builder.with_drag_and_drop(*drag_and_drop_support); window_builder = window_builder.with_drag_and_drop(*drag_and_drop_support);
@@ -147,16 +145,13 @@ pub fn window_builder<E>(
window_settings.inner_size_points() window_settings.inner_size_points()
} else { } else {
if let Some(pos) = *initial_window_pos { if let Some(pos) = *initial_window_pos {
window_builder = window_builder.with_position(Some((pos.x as i32, pos.y as i32))); window_builder = window_builder.with_position(Some(pos));
} }
if let Some(initial_window_size) = *initial_window_size { if let Some(initial_window_size) = *initial_window_size {
let initial_window_size = let initial_window_size =
initial_window_size.at_most(largest_monitor_point_size(event_loop)); initial_window_size.at_most(largest_monitor_point_size(event_loop));
window_builder = window_builder.with_inner_size(Some(( window_builder = window_builder.with_inner_size(Some(initial_window_size.to_pos2()));
initial_window_size.x as u32,
initial_window_size.y as u32,
)));
} }
*initial_window_size *initial_window_size
@@ -165,12 +160,12 @@ pub fn window_builder<E>(
#[cfg(not(target_os = "ios"))] #[cfg(not(target_os = "ios"))]
if *centered { if *centered {
if let Some(monitor) = event_loop.available_monitors().next() { if let Some(monitor) = event_loop.available_monitors().next() {
let monitor_size = monitor.size().to_logical::<f64>(monitor.scale_factor()); let monitor_size = monitor.size().to_logical::<f32>(monitor.scale_factor());
let inner_size = inner_size_points.unwrap_or(egui::Vec2 { x: 800.0, y: 600.0 }); let inner_size = inner_size_points.unwrap_or(egui::Vec2 { x: 800.0, y: 600.0 });
if monitor_size.width > 0.0 && monitor_size.height > 0.0 { if monitor_size.width > 0.0 && monitor_size.height > 0.0 {
let x = (monitor_size.width - inner_size.x as f64) / 2.0; let x = (monitor_size.width - inner_size.x) / 2.0;
let y = (monitor_size.height - inner_size.y as f64) / 2.0; let y = (monitor_size.height - inner_size.y) / 2.0;
window_builder = window_builder.with_position(Some((x as i32, y as i32))); window_builder = window_builder.with_position(Some(egui::Pos2::new(x, y)));
} }
} }
} }

65
crates/egui-winit/src/lib.rs
View File

@@ -188,7 +188,7 @@ impl State {
None None
}; };
self.egui_input.viewport_inner_pos = if getting_info { self.egui_input.inner_pos = if getting_info {
window window
.inner_position() .inner_position()
.map(|pos| Pos2::new(pos.x as f32, pos.y as f32)) .map(|pos| Pos2::new(pos.x as f32, pos.y as f32))
@@ -197,7 +197,7 @@ impl State {
None None
}; };
self.egui_input.viewport_outer_pos = if getting_info { self.egui_input.outer_pos = if getting_info {
window window
.outer_position() .outer_position()
.map(|pos| Pos2::new(pos.x as f32, pos.y as f32)) .map(|pos| Pos2::new(pos.x as f32, pos.y as f32))
@@ -206,14 +206,14 @@ impl State {
None None
}; };
self.egui_input.viewport_inner_size = if getting_info { self.egui_input.inner_size = if getting_info {
let size = window.inner_size(); let size = window.inner_size();
Some(Pos2::new(size.width as f32, size.height as f32)) Some(Pos2::new(size.width as f32, size.height as f32))
} else { } else {
None None
}; };
self.egui_input.viewport_outer_size = if getting_info { self.egui_input.outer_size = if getting_info {
let size = window.outer_size(); let size = window.outer_size();
Some(Pos2::new(size.width as f32, size.height as f32)) Some(Pos2::new(size.width as f32, size.height as f32))
} else { } else {
@@ -950,7 +950,6 @@ pub fn process_viewport_commands(
focused: Option<ViewportId>, focused: Option<ViewportId>,
window: &Arc<RwLock<winit::window::Window>>, window: &Arc<RwLock<winit::window::Window>>,
) { ) {
use winit::dpi::PhysicalSize;
use winit::window::ResizeDirection; use winit::window::ResizeDirection;
let win = window.read(); let win = window.read();
@@ -965,10 +964,10 @@ pub fn process_viewport_commands(
} }
} }
} }
egui::ViewportCommand::InnerSize(width, height) => { egui::ViewportCommand::InnerSize(size) => {
let width = width.max(1); let width = size.x.max(1.0);
let height = height.max(1); let height = size.y.max(1.0);
win.set_inner_size(PhysicalSize::new(width, height)); win.set_inner_size(LogicalSize::new(width, height));
} }
egui::ViewportCommand::Resize(top, bottom, right, left) => { egui::ViewportCommand::Resize(top, bottom, right, left) => {
// TODO posibile return the error to `egui::Context` // TODO posibile return the error to `egui::Context`
@@ -986,17 +985,17 @@ pub fn process_viewport_commands(
ViewportCommand::Title(title) => win.set_title(&title), ViewportCommand::Title(title) => win.set_title(&title),
ViewportCommand::Transparent(v) => win.set_transparent(v), ViewportCommand::Transparent(v) => win.set_transparent(v),
ViewportCommand::Visible(v) => win.set_visible(v), ViewportCommand::Visible(v) => win.set_visible(v),
ViewportCommand::OuterPosition(x, y) => { ViewportCommand::OuterPosition(pos) => {
win.set_outer_position(LogicalPosition::new(x, y)); win.set_outer_position(LogicalPosition::new(pos.x, pos.y));
} }
ViewportCommand::MinInnerSize(s) => { ViewportCommand::MinInnerSize(s) => {
win.set_min_inner_size(s.map(|s| LogicalSize::new(s.0, s.1))); win.set_min_inner_size(s.map(|s| LogicalSize::new(s.x, s.y)));
} }
ViewportCommand::MaxInnerSize(s) => { ViewportCommand::MaxInnerSize(s) => {
win.set_max_inner_size(s.map(|s| LogicalSize::new(s.0, s.1))); win.set_max_inner_size(s.map(|s| LogicalSize::new(s.x, s.y)));
} }
ViewportCommand::ResizeIncrements(s) => { ViewportCommand::ResizeIncrements(s) => {
win.set_resize_increments(s.map(|s| LogicalSize::new(s.0, s.1))); win.set_resize_increments(s.map(|s| LogicalSize::new(s.x, s.y)));
} }
ViewportCommand::Resizable(v) => win.set_resizable(v), ViewportCommand::Resizable(v) => win.set_resizable(v),
ViewportCommand::EnableButtons { ViewportCommand::EnableButtons {
@@ -1035,7 +1034,9 @@ pub fn process_viewport_commands(
.expect("Invalid ICON data!") .expect("Invalid ICON data!")
})); }));
} }
ViewportCommand::IMEPosition(x, y) => win.set_ime_position(LogicalPosition::new(x, y)), ViewportCommand::IMEPosition(pos) => {
win.set_ime_position(LogicalPosition::new(pos.x, pos.y));
}
ViewportCommand::IMEAllowed(v) => win.set_ime_allowed(v), ViewportCommand::IMEAllowed(v) => win.set_ime_allowed(v),
ViewportCommand::IMEPurpose(o) => win.set_ime_purpose(match o { ViewportCommand::IMEPurpose(o) => win.set_ime_purpose(match o {
1 => winit::window::ImePurpose::Password, 1 => winit::window::ImePurpose::Password,
@@ -1057,8 +1058,8 @@ pub fn process_viewport_commands(
} }
})), })),
ViewportCommand::ContentProtected(v) => win.set_content_protected(v), ViewportCommand::ContentProtected(v) => win.set_content_protected(v),
ViewportCommand::CursorPosition(x, y) => { ViewportCommand::CursorPosition(pos) => {
if let Err(err) = win.set_cursor_position(LogicalPosition::new(x, y)) { if let Err(err) = win.set_cursor_position(LogicalPosition::new(pos.x, pos.y)) {
log::error!("{err}"); log::error!("{err}");
} }
} }
@@ -1097,9 +1098,9 @@ pub fn create_winit_window_builder(builder: &ViewportBuilder) -> winit::window::
let mut window_builder = winit::window::WindowBuilder::new() let mut window_builder = winit::window::WindowBuilder::new()
.with_title(builder.title.clone()) .with_title(builder.title.clone())
.with_transparent(builder.transparent.map_or(false, |e| e)) .with_transparent(builder.transparent.map_or(false, |e| e))
.with_decorations(builder.decorations.map_or(false, |e| e)) .with_decorations(builder.decorations.map_or(true, |e| e))
.with_resizable(builder.resizable.map_or(false, |e| e)) .with_resizable(builder.resizable.map_or(true, |e| e))
.with_visible(builder.visible.map_or(false, |e| e)) .with_visible(builder.visible.map_or(true, |e| e))
.with_maximized(builder.minimized.map_or(false, |e| e)) .with_maximized(builder.minimized.map_or(false, |e| e))
.with_maximized(builder.maximized.map_or(false, |e| e)) .with_maximized(builder.maximized.map_or(false, |e| e))
.with_fullscreen( .with_fullscreen(
@@ -1122,25 +1123,29 @@ pub fn create_winit_window_builder(builder: &ViewportBuilder) -> winit::window::
.unwrap_or(WindowButtons::empty()), .unwrap_or(WindowButtons::empty()),
) )
.with_active(builder.active.map_or(false, |e| e)); .with_active(builder.active.map_or(false, |e| e));
if let Some(Some(inner_size)) = builder.inner_size { if let Some(Some(inner_size)) = builder.inner_size {
window_builder = window_builder window_builder = window_builder
.with_inner_size(winit::dpi::PhysicalSize::new(inner_size.0, inner_size.1)); .with_inner_size(winit::dpi::LogicalSize::new(inner_size.x, inner_size.y));
} }
if let Some(Some(min_inner_size)) = builder.min_inner_size { if let Some(Some(min_inner_size)) = builder.min_inner_size {
window_builder = window_builder.with_min_inner_size(winit::dpi::PhysicalSize::new( window_builder = window_builder.with_min_inner_size(winit::dpi::LogicalSize::new(
min_inner_size.0, min_inner_size.x,
min_inner_size.1, min_inner_size.y,
)); ));
} }
if let Some(Some(max_inner_size)) = builder.max_inner_size { if let Some(Some(max_inner_size)) = builder.max_inner_size {
window_builder = window_builder.with_max_inner_size(winit::dpi::PhysicalSize::new( window_builder = window_builder.with_max_inner_size(winit::dpi::LogicalSize::new(
max_inner_size.0, max_inner_size.x,
max_inner_size.1, max_inner_size.y,
)); ));
} }
if let Some(Some(position)) = builder.position { if let Some(Some(position)) = builder.position {
window_builder = window_builder =
window_builder.with_position(winit::dpi::PhysicalPosition::new(position.0, position.1)); window_builder.with_position(winit::dpi::LogicalPosition::new(position.x, position.y));
} }
if let Some(Some(icon)) = builder.icon.clone() { if let Some(Some(icon)) = builder.icon.clone() {
@@ -1181,7 +1186,7 @@ pub fn changes_between_builders(
if Some(position) != last.position { if Some(position) != last.position {
last.position = Some(position); last.position = Some(position);
if let Some(position) = position { if let Some(position) = position {
commands.push(ViewportCommand::OuterPosition(position.0, position.1)); commands.push(ViewportCommand::OuterPosition(position));
} }
} }
} }
@@ -1190,7 +1195,7 @@ pub fn changes_between_builders(
if Some(inner_size) != last.inner_size { if Some(inner_size) != last.inner_size {
last.inner_size = Some(inner_size); last.inner_size = Some(inner_size);
if let Some(inner_size) = inner_size { if let Some(inner_size) = inner_size {
commands.push(ViewportCommand::InnerSize(inner_size.0, inner_size.1)); commands.push(ViewportCommand::InnerSize(inner_size));
} }
} }
} }

7
crates/egui-winit/src/window_settings.rs
View File

@@ -57,15 +57,12 @@ impl WindowSettings {
self.outer_position_pixels self.outer_position_pixels
}; };
if let Some(pos) = pos_px { if let Some(pos) = pos_px {
window = window.with_position(Some((pos.x as i32, pos.y as i32))); window = window.with_position(Some(pos));
} }
if let Some(inner_size_points) = self.inner_size_points { if let Some(inner_size_points) = self.inner_size_points {
window window
.with_inner_size(Some(( .with_inner_size(Some(inner_size_points.to_pos2()))
inner_size_points.x as u32,
inner_size_points.y as u32,
)))
.with_fullscreen(self.fullscreen) .with_fullscreen(self.fullscreen)
} else { } else {
window window

14
crates/egui/src/context.rs
View File

@@ -1618,19 +1618,19 @@ impl Context {
} }
pub fn viewport_inner_pos(&self) -> Pos2 { pub fn viewport_inner_pos(&self) -> Pos2 {
self.input(|i| i.viewport_inner_pos) self.input(|i| i.inner_pos)
} }
pub fn viewport_outer_pos(&self) -> Pos2 { pub fn viewport_outer_pos(&self) -> Pos2 {
self.input(|i| i.viewport_outer_pos) self.input(|i| i.outer_pos)
} }
pub fn viewport_inner_size(&self) -> Pos2 { pub fn viewport_inner_size(&self) -> Pos2 {
self.input(|i| i.viewport_inner_size) self.input(|i| i.inner_size)
} }
pub fn viewport_outer_size(&self) -> Pos2 { pub fn viewport_outer_size(&self) -> Pos2 {
self.input(|i| i.viewport_outer_size) self.input(|i| i.outer_size)
} }
/// How much space is still available after panels has been added. /// How much space is still available after panels has been added.
@@ -2261,7 +2261,11 @@ impl Context {
} }
/// With this you can send a command to a viewport /// With this you can send a command to a viewport
pub fn viewport_command(&self, id: ViewportId, command: ViewportCommand) { pub fn viewport_command(&self, command: ViewportCommand) {
self.viewport_command_for(self.get_viewport_id(), command);
}
pub fn viewport_command_for(&self, id: ViewportId, command: ViewportCommand) {
self.write(|ctx| ctx.viewport_commands.push((id, command))); self.write(|ctx| ctx.viewport_commands.push((id, command)));
} }

59
crates/egui/src/data/input.rs
View File

@@ -23,10 +23,21 @@ pub struct RawInput {
/// `None` will be treated as "same as last frame", with the default being a very big area. /// `None` will be treated as "same as last frame", with the default being a very big area.
pub screen_rect: Option<Rect>, pub screen_rect: Option<Rect>,
pub viewport_inner_pos: Option<Pos2>, /// Viewport inner position, only the drowable area
pub viewport_outer_pos: Option<Pos2>, /// If is not working as expected is a winit bug!
pub viewport_inner_size: Option<Pos2>, pub inner_pos: Option<Pos2>,
pub viewport_outer_size: Option<Pos2>,
/// Viewport outer position, drowable area + decorations
/// If is not working as expected is a winit bug!
pub outer_pos: Option<Pos2>,
/// Viewport inner size, only drowable area
/// If is not working as expected is a winit bug!
pub inner_size: Option<Pos2>,
/// Viewport outer size, drowable area + decorations
/// If is not working as expected is a winit bug!
pub outer_size: Option<Pos2>,
/// Also known as device pixel ratio, > 1 for high resolution screens. /// Also known as device pixel ratio, > 1 for high resolution screens.
/// If text looks blurry you probably forgot to set this. /// If text looks blurry you probably forgot to set this.
@@ -78,10 +89,10 @@ impl Default for RawInput {
fn default() -> Self { fn default() -> Self {
Self { Self {
screen_rect: None, screen_rect: None,
viewport_inner_pos: None, inner_pos: None,
viewport_outer_pos: None, outer_pos: None,
viewport_inner_size: None, inner_size: None,
viewport_outer_size: None, outer_size: None,
pixels_per_point: None, pixels_per_point: None,
max_texture_side: None, max_texture_side: None,
time: None, time: None,
@@ -103,10 +114,10 @@ impl RawInput {
pub fn take(&mut self) -> RawInput { pub fn take(&mut self) -> RawInput {
RawInput { RawInput {
screen_rect: self.screen_rect.take(), screen_rect: self.screen_rect.take(),
viewport_inner_pos: self.viewport_inner_pos.take(), inner_pos: self.inner_pos.take(),
viewport_outer_pos: self.viewport_outer_pos.take(), outer_pos: self.outer_pos.take(),
viewport_inner_size: self.viewport_inner_size.take(), inner_size: self.inner_size.take(),
viewport_outer_size: self.viewport_outer_size.take(), outer_size: self.outer_size.take(),
pixels_per_point: self.pixels_per_point.take(), pixels_per_point: self.pixels_per_point.take(),
max_texture_side: self.max_texture_side.take(), max_texture_side: self.max_texture_side.take(),
time: self.time.take(), time: self.time.take(),
@@ -123,10 +134,10 @@ impl RawInput {
pub fn append(&mut self, newer: Self) { pub fn append(&mut self, newer: Self) {
let Self { let Self {
screen_rect, screen_rect,
viewport_inner_pos, inner_pos: viewport_inner_pos,
viewport_outer_pos, outer_pos: viewport_outer_pos,
viewport_inner_size, inner_size: viewport_inner_size,
viewport_outer_size, outer_size: viewport_outer_size,
pixels_per_point, pixels_per_point,
max_texture_side, max_texture_side,
time, time,
@@ -139,10 +150,10 @@ impl RawInput {
} = newer; } = newer;
self.screen_rect = screen_rect.or(self.screen_rect); self.screen_rect = screen_rect.or(self.screen_rect);
self.viewport_inner_pos = viewport_inner_pos.or(self.viewport_inner_pos); self.inner_pos = viewport_inner_pos.or(self.inner_pos);
self.viewport_outer_pos = viewport_outer_pos.or(self.viewport_outer_pos); self.outer_pos = viewport_outer_pos.or(self.outer_pos);
self.viewport_inner_size = viewport_inner_size.or(self.viewport_inner_size); self.inner_size = viewport_inner_size.or(self.inner_size);
self.viewport_outer_size = viewport_outer_size.or(self.viewport_outer_size); self.outer_size = viewport_outer_size.or(self.outer_size);
self.pixels_per_point = pixels_per_point.or(self.pixels_per_point); self.pixels_per_point = pixels_per_point.or(self.pixels_per_point);
self.max_texture_side = max_texture_side.or(self.max_texture_side); self.max_texture_side = max_texture_side.or(self.max_texture_side);
self.time = time; // use latest time self.time = time; // use latest time
@@ -958,10 +969,10 @@ impl RawInput {
pub fn ui(&self, ui: &mut crate::Ui) { pub fn ui(&self, ui: &mut crate::Ui) {
let Self { let Self {
screen_rect, screen_rect,
viewport_inner_pos, inner_pos: viewport_inner_pos,
viewport_outer_pos, outer_pos: viewport_outer_pos,
viewport_inner_size, inner_size: viewport_inner_size,
viewport_outer_size, outer_size: viewport_outer_size,
pixels_per_point, pixels_per_point,
max_texture_side, max_texture_side,
time, time,

51
crates/egui/src/input_state.rs
View File

@@ -54,10 +54,21 @@ pub struct InputState {
/// Position and size of the egui area. /// Position and size of the egui area.
pub screen_rect: Rect, pub screen_rect: Rect,
pub viewport_inner_pos: Pos2, /// Viewport inner position, only the drowable area
pub viewport_outer_pos: Pos2, /// If is not working as expected is a winit bug!
pub viewport_inner_size: Pos2, pub inner_pos: Pos2,
pub viewport_outer_size: Pos2,
/// Viewport outer position, drowable area + decorations
/// If is not working as expected is a winit bug!
pub outer_pos: Pos2,
/// Viewport inner size, only drowable area
/// If is not working as expected is a winit bug!
pub inner_size: Pos2,
/// Viewport outer size, drowable area + decorations
/// If is not working as expected is a winit bug!
pub outer_size: Pos2,
/// Also known as device pixel ratio, > 1 for high resolution screens. /// Also known as device pixel ratio, > 1 for high resolution screens.
pub pixels_per_point: f32, pub pixels_per_point: f32,
@@ -143,10 +154,10 @@ impl Default for InputState {
modifiers: Default::default(), modifiers: Default::default(),
keys_down: Default::default(), keys_down: Default::default(),
events: Default::default(), events: Default::default(),
viewport_inner_pos: Pos2::ZERO, inner_pos: Pos2::ZERO,
viewport_outer_pos: Pos2::ZERO, outer_pos: Pos2::ZERO,
viewport_inner_size: pos2(10_000.0, 10_000.0), inner_size: pos2(10_000.0, 10_000.0),
viewport_outer_size: pos2(10_000.0, 10_000.0), outer_size: pos2(10_000.0, 10_000.0),
} }
} }
} }
@@ -170,10 +181,10 @@ impl InputState {
}; };
let screen_rect = new.screen_rect.unwrap_or(self.screen_rect); let screen_rect = new.screen_rect.unwrap_or(self.screen_rect);
let viewport_inner_pos = new.viewport_inner_pos.unwrap_or(self.viewport_inner_pos); let viewport_inner_pos = new.inner_pos.unwrap_or(self.inner_pos);
let viewport_outer_pos = new.viewport_outer_pos.unwrap_or(self.viewport_outer_pos); let viewport_outer_pos = new.outer_pos.unwrap_or(self.outer_pos);
let viewport_inner_size = new.viewport_inner_size.unwrap_or(self.viewport_inner_size); let viewport_inner_size = new.inner_size.unwrap_or(self.inner_size);
let viewport_outer_size = new.viewport_outer_size.unwrap_or(self.viewport_outer_size); let viewport_outer_size = new.outer_size.unwrap_or(self.outer_size);
self.create_touch_states_for_new_devices(&new.events); self.create_touch_states_for_new_devices(&new.events);
for touch_state in self.touch_states.values_mut() { for touch_state in self.touch_states.values_mut() {
@@ -229,10 +240,10 @@ impl InputState {
scroll_delta, scroll_delta,
zoom_factor_delta, zoom_factor_delta,
screen_rect, screen_rect,
viewport_inner_pos, inner_pos: viewport_inner_pos,
viewport_outer_pos, outer_pos: viewport_outer_pos,
viewport_inner_size, inner_size: viewport_inner_size,
viewport_outer_size, outer_size: viewport_outer_size,
pixels_per_point: new.pixels_per_point.unwrap_or(self.pixels_per_point), pixels_per_point: new.pixels_per_point.unwrap_or(self.pixels_per_point),
max_texture_side: new.max_texture_side.unwrap_or(self.max_texture_side), max_texture_side: new.max_texture_side.unwrap_or(self.max_texture_side),
time, time,
@@ -990,10 +1001,10 @@ impl InputState {
scroll_delta, scroll_delta,
zoom_factor_delta, zoom_factor_delta,
screen_rect, screen_rect,
viewport_inner_pos, inner_pos: viewport_inner_pos,
viewport_outer_pos, outer_pos: viewport_outer_pos,
viewport_inner_size, inner_size: viewport_inner_size,
viewport_outer_size, outer_size: viewport_outer_size,
pixels_per_point, pixels_per_point,
max_texture_side, max_texture_side,
time, time,

46
crates/egui/src/viewport.rs
View File

@@ -1,5 +1,7 @@
use std::{fmt::Display, sync::Arc}; use std::{fmt::Display, sync::Arc};
use epaint::Pos2;
use crate::{Context, Id}; use crate::{Context, Id};
/// This is used to send a command to a specific viewport /// This is used to send a command to a specific viewport
@@ -24,13 +26,13 @@ pub type ViewportRender = dyn Fn(&Context) + Sync + Send;
/// The filds in this struct should not be change directly, but is not problem tho! /// The filds in this struct should not be change directly, but is not problem tho!
/// Every thing is wrapped in Option<> indicates that thing should not be changed! /// Every thing is wrapped in Option<> indicates that thing should not be changed!
#[derive(Hash, PartialEq, Eq, Clone)] #[derive(PartialEq, Eq, Clone)]
pub struct ViewportBuilder { pub struct ViewportBuilder {
pub id: Id, pub id: Id,
pub title: String, pub title: String,
pub name: Option<(String, String)>, pub name: Option<(String, String)>,
pub position: Option<Option<(i32, i32)>>, pub position: Option<Option<Pos2>>,
pub inner_size: Option<Option<(u32, u32)>>, pub inner_size: Option<Option<Pos2>>,
pub fullscreen: Option<bool>, pub fullscreen: Option<bool>,
pub maximized: Option<bool>, pub maximized: Option<bool>,
pub minimized: Option<bool>, pub minimized: Option<bool>,
@@ -43,8 +45,8 @@ pub struct ViewportBuilder {
pub title_hidden: Option<bool>, pub title_hidden: Option<bool>,
pub titlebar_transparent: Option<bool>, pub titlebar_transparent: Option<bool>,
pub fullsize_content_view: Option<bool>, pub fullsize_content_view: Option<bool>,
pub min_inner_size: Option<Option<(u32, u32)>>, pub min_inner_size: Option<Option<Pos2>>,
pub max_inner_size: Option<Option<(u32, u32)>>, pub max_inner_size: Option<Option<Pos2>>,
pub drag_and_drop: Option<bool>, pub drag_and_drop: Option<bool>,
pub close_button: Option<bool>, pub close_button: Option<bool>,
@@ -61,7 +63,7 @@ impl ViewportBuilder {
title: "Dummy egui viewport".into(), title: "Dummy egui viewport".into(),
name: None, name: None,
position: None, position: None,
inner_size: Some(Some((300, 200))), inner_size: Some(Some(Pos2::new(300.0, 200.0))),
fullscreen: None, fullscreen: None,
maximized: None, maximized: None,
resizable: Some(true), resizable: Some(true),
@@ -181,17 +183,20 @@ impl ViewportBuilder {
self self
} }
pub fn with_inner_size(mut self, value: Option<(u32, u32)>) -> Self { /// Should be bigger then 0
pub fn with_inner_size(mut self, value: Option<Pos2>) -> Self {
self.inner_size = Some(value); self.inner_size = Some(value);
self self
} }
pub fn with_min_inner_size(mut self, value: Option<(u32, u32)>) -> Self { /// Should be bigger then 0
pub fn with_min_inner_size(mut self, value: Option<Pos2>) -> Self {
self.min_inner_size = Some(value); self.min_inner_size = Some(value);
self self
} }
pub fn with_max_inner_size(mut self, value: Option<(u32, u32)>) -> Self { /// Should be bigger then 0
pub fn with_max_inner_size(mut self, value: Option<Pos2>) -> Self {
self.max_inner_size = Some(value); self.max_inner_size = Some(value);
self self
} }
@@ -211,12 +216,13 @@ impl ViewportBuilder {
self self
} }
/// This currently only work on windows to be disabled!
pub fn with_drag_and_drop(mut self, value: bool) -> Self { pub fn with_drag_and_drop(mut self, value: bool) -> Self {
self.drag_and_drop = Some(value); self.drag_and_drop = Some(value);
self self
} }
pub fn with_position(mut self, value: Option<(i32, i32)>) -> Self { pub fn with_position(mut self, value: Option<Pos2>) -> Self {
self.position = Some(value); self.position = Some(value);
self self
} }
@@ -242,11 +248,17 @@ pub enum ViewportCommand {
Transparent(bool), Transparent(bool),
Visible(bool), Visible(bool),
Drag, Drag,
OuterPosition(i32, i32), OuterPosition(Pos2),
InnerSize(u32, u32),
MinInnerSize(Option<(u32, u32)>), /// Should be bigger then 0
MaxInnerSize(Option<(u32, u32)>), InnerSize(Pos2),
ResizeIncrements(Option<(u32, u32)>),
/// Should be bigger then 0
MinInnerSize(Option<Pos2>),
/// Should be bigger then 0
MaxInnerSize(Option<Pos2>),
ResizeIncrements(Option<Pos2>),
/// Top, Bottom, Right, Left /// Top, Bottom, Right, Left
Resize(bool, bool, bool, bool), Resize(bool, bool, bool, bool),
@@ -264,7 +276,7 @@ pub enum ViewportCommand {
/// 0 = Normal, 1 = AlwaysOnBottom, 2 = AlwaysOnTop /// 0 = Normal, 1 = AlwaysOnBottom, 2 = AlwaysOnTop
WindowLevel(u8), WindowLevel(u8),
WindowIcon(Option<(Vec<u8>, u32, u32)>), WindowIcon(Option<(Vec<u8>, u32, u32)>),
IMEPosition(u32, u32), IMEPosition(Pos2),
IMEAllowed(bool), IMEAllowed(bool),
/// 0 = Normal, 1 = Password, 2 = Terminal /// 0 = Normal, 1 = Password, 2 = Terminal
@@ -278,7 +290,7 @@ pub enum ViewportCommand {
ContentProtected(bool), ContentProtected(bool),
CursorPosition(i32, i32), CursorPosition(Pos2),
/// 0 = None, 1 = Confined, 2 = Locked /// 0 = None, 1 = Confined, 2 = Locked
CursorGrab(u8), CursorGrab(u8),