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

Change ViewportBuilder how it's working

Browse Source
This commit is contained in:
Konkitoman
2023-08-10 16:53:31 +03:00
parent 70a5772f8d
commit 9c6044aa7d
5 changed files with 143 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -106,7 +106,11 @@ pub fn window_builder<E>(
.with_maximized(*maximized)
.with_resizable(*resizable)
.with_transparent(*transparent)
.with_window_icon(icon_data.clone().map(|d| (d.width, d.height, d.rgba)))
.with_window_icon(
icon_data
.clone()
.map(|d| Arc::new((d.width, d.height, d.rgba))),
)
.with_active(*active)
// Keep hidden until we've painted something. See https://github.com/emilk/egui/pull/2279
// We must also keep the window hidden until AccessKit is initialized.
@@ -127,10 +131,12 @@ pub fn window_builder<E>(
}
if let Some(min_size) = *min_window_size {
window_builder = window_builder.with_min_inner_size((min_size.x as u32, min_size.y as u32));
window_builder =
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 {
window_builder = window_builder.with_max_inner_size((max_size.x as u32, max_size.y as u32));
window_builder =
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);
@@ -144,14 +150,16 @@ pub fn window_builder<E>(
window_settings.inner_size_points()
} else {
if let Some(pos) = *initial_window_pos {
window_builder = window_builder.with_position((pos.x as i32, pos.y as i32));
window_builder = window_builder.with_position(Some((pos.x as i32, pos.y as i32)));
}
if let Some(initial_window_size) = *initial_window_size {
let initial_window_size =
initial_window_size.at_most(largest_monitor_point_size(event_loop));
window_builder = window_builder
.with_inner_size((initial_window_size.x as u32, initial_window_size.y as u32));
window_builder = window_builder.with_inner_size(Some((
initial_window_size.x as u32,
initial_window_size.y as u32,
)));
}
*initial_window_size
@@ -164,7 +172,7 @@ pub fn window_builder<E>(
if monitor_size.width > 0.0 && monitor_size.height > 0.0 {
let x = (monitor_size.width - inner_size.x as f64) / 2.0;
let y = (monitor_size.height - inner_size.y as f64) / 2.0;
window_builder = window_builder.with_position((x as i32, y as i32));
window_builder = window_builder.with_position(Some((x as i32, y as i32)));
}
}
}

46
crates/eframe/src/native/run.rs
View File

@@ -3,7 +3,7 @@
use std::{sync::Arc, time::Instant};
use egui::{epaint::ahash::HashMap, mutex::RwLock, ViewportBuilder, ViewportId};
use egui::{epaint::ahash::HashMap, mutex::RwLock, ViewportBuilder, ViewportCommand, ViewportId};
use raw_window_handle::{HasRawDisplayHandle as _, HasRawWindowHandle as _};
use winit::{
event_loop::{ControlFlow, EventLoop, EventLoopBuilder, EventLoopProxy, EventLoopWindowTarget},
@@ -1104,11 +1104,6 @@ mod glow_integration {
if let Some(w) = glutin_ctx.read().windows.get(id) {
let mut w = w.write();
if w.builder != *builder {
if let Some(window) = &mut w.window {
if let Ok(pos) = window.read().outer_position() {
builder.position = Some((pos.x, pos.y));
}
}
w.window = None;
w.gl_surface = None;
w.render = render.clone();
@@ -2526,49 +2521,50 @@ fn extremely_far_future() -> std::time::Instant {
fn create_winit_window_builder(builder: &ViewportBuilder) -> winit::window::WindowBuilder {
let mut window_builder = winit::window::WindowBuilder::new()
.with_title(builder.title.clone())
.with_transparent(builder.transparent)
.with_decorations(builder.decorations)
.with_resizable(builder.resizable)
.with_visible(builder.visible)
.with_transparent(builder.transparent.map_or(false, |e| e))
.with_decorations(builder.decorations.map_or(false, |e| e))
.with_resizable(builder.resizable.map_or(false, |e| e))
.with_visible(builder.visible.map_or(false, |e| e))
.with_fullscreen(
builder
.fullscreen
.then_some(winit::window::Fullscreen::Borderless(None)),
.map(|e| e.then(|| winit::window::Fullscreen::Borderless(None)))
.flatten(),
)
.with_enabled_buttons(
WindowButtons::MAXIMIZE
| WindowButtons::MINIMIZE
| if builder.close_button {
WindowButtons::CLOSE
} else {
WindowButtons::empty()
},
| builder
.close_button
.map(|v| v.then(|| WindowButtons::CLOSE))
.flatten()
.unwrap_or(WindowButtons::empty()),
)
.with_active(builder.active);
if let Some(inner_size) = builder.inner_size {
.with_active(builder.active.map_or(false, |e| e));
if let Some(Some(inner_size)) = builder.inner_size {
window_builder = window_builder
.with_inner_size(winit::dpi::PhysicalSize::new(inner_size.0, inner_size.1));
}
if let 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(
min_inner_size.0,
min_inner_size.1,
));
}
if let 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(
max_inner_size.0,
max_inner_size.1,
));
}
if let Some(position) = builder.position {
if let Some(Some(position)) = builder.position {
window_builder =
window_builder.with_position(winit::dpi::PhysicalPosition::new(position.0, position.1));
}
if let Some(icon) = builder.icon.clone() {
if let Some(Some(icon)) = builder.icon.clone() {
window_builder = window_builder.with_window_icon(load_icon(crate::IconData {
rgba: icon.2,
rgba: icon.2.clone(),
width: icon.0,
height: icon.1,
}));
@@ -2576,3 +2572,7 @@ fn create_winit_window_builder(builder: &ViewportBuilder) -> winit::window::Wind
window_builder
}
fn changes_betwen_builders(now: &ViewportBuilder, last: &ViewportBuilder) -> Vec<ViewportCommand> {
vec![]
}