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

Now viewport pos and size are stored in InputState::{viewport_inner_pos, viewport_outer_pos, viewport_inner_size, viewport_outer_size}

Browse Source 
This fixes a lot of problems
This commit is contained in:
Konkitoman
2023-08-24 09:14:48 +03:00
parent 9c73c2f4b1
commit 6c91562c7b
7 changed files with 289 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -16,7 +16,7 @@ pub use accesskit_winit;
pub use egui;
#[cfg(feature = "accesskit")]
use egui::accesskit;
use egui::{mutex::RwLock, ViewportBuilder, ViewportCommand, ViewportId};
use egui::{mutex::RwLock, Pos2, ViewportBuilder, ViewportCommand, ViewportId};
pub use winit;
pub mod clipboard;
@@ -183,10 +183,39 @@ impl State {
});
self.egui_input.screen_rect = if getting_info {
Some(egui::Rect::from_min_size(
egui::Pos2::ZERO,
screen_size_in_points,
))
Some(egui::Rect::from_min_size(Pos2::ZERO, screen_size_in_points))
} else {
None
};
self.egui_input.viewport_inner_pos = if getting_info {
window
.inner_position()
.map(|pos| Pos2::new(pos.x as f32, pos.y as f32))
.ok()
} else {
None
};
self.egui_input.viewport_outer_pos = if getting_info {
window
.outer_position()
.map(|pos| Pos2::new(pos.x as f32, pos.y as f32))
.ok()
} else {
None
};
self.egui_input.viewport_inner_size = if getting_info {
let size = window.inner_size();
Some(Pos2::new(size.width as f32, size.height as f32))
} else {
None
};
self.egui_input.viewport_outer_size = if getting_info {
let size = window.outer_size();
Some(Pos2::new(size.width as f32, size.height as f32))
} else {
None
};

33
crates/egui/src/containers/window.rs
View File

@@ -436,7 +436,7 @@ impl<'open> Window<'open> {
let mut resize = resize.id(resize_id);
let mut area = area.begin(ctx);
let win_size = ctx.input(|i| i.screen_rect.size());
let win_size = ctx.screen_rect().size();
area.state_mut().set_left_top_pos(Pos2::ZERO);
area.state_mut().size = win_size;
let title_content_spacing = 2.0 * ctx.style().spacing.item_spacing.y;
@@ -588,26 +588,31 @@ impl<'open> Window<'open> {
let full_response = area.end(ctx, area_content_ui);
if !collapsing.is_open() {
let size = ctx.round_vec_to_pixels(full_response.rect.size());
let size = full_response.rect.size() * ctx.pixels_per_point();
ctx.viewport_command(
ctx.get_viewport_id(),
ViewportCommand::InnerSize(size.x as u32, size.y as u32),
);
}
// let size = ctx.round_vec_to_pixels(full_response.rect.size());
if win_size.x < size.x {
println!("Set size!");
ctx.viewport_command(
ctx.get_viewport_id(),
ViewportCommand::InnerSize(size.x as u32, win_size.y as u32),
ViewportCommand::InnerSize(
(size.x * ctx.pixels_per_point()) as u32,
(win_size.y * ctx.pixels_per_point()) as u32,
),
);
}
if win_size.y < size.y {
println!("Set size!");
ctx.viewport_command(
ctx.get_viewport_id(),
ViewportCommand::InnerSize(win_size.x as u32, size.y as u32),
ViewportCommand::InnerSize(
(win_size.x * ctx.pixels_per_point()) as u32,
(size.y * ctx.pixels_per_point()) as u32,
),
);
}
if show_close_button && op != is_open {
@@ -825,8 +830,8 @@ impl<'open> Window<'open> {
'create_viewport: {
if !is_embedded && !ctx.force_embedding() {
if let Some(size) = ctx.data(|data| data.get_temp::<Vec2>(area.id.with("size"))) {
let size = size.round()
+ ctx.style().spacing.window_margin.sum() * ctx.pixels_per_point();
let size = (size.round() + ctx.style().spacing.window_margin.sum())
* ctx.pixels_per_point();
window_builder = window_builder
.with_inner_size(Some((size.x as u32 + 1, size.y as u32 + 1)));
} else {
@@ -893,7 +898,7 @@ impl<'open> Window<'open> {
let mut resize = resize.id(resize_id);
let mut area = area.begin(ctx);
let win_size = ctx.input(|i| i.screen_rect.size());
let win_size = ctx.viewport_inner_size().to_vec2() * ctx.pixels_per_point();
area.state_mut().set_left_top_pos(Pos2::ZERO);
area.state_mut().size = win_size;
let title_content_spacing = 2.0 * ctx.style().spacing.item_spacing.y;
@@ -1045,7 +1050,7 @@ impl<'open> Window<'open> {
let full_response = area.end(ctx, area_content_ui);
if !collapsing.is_open() {
let size = ctx.round_vec_to_pixels(full_response.rect.size());
let size = full_response.rect.size() * ctx.pixels_per_point();
ctx.viewport_command(
ctx.get_viewport_id(),
ViewportCommand::InnerSize(size.x as u32, size.y as u32),
@@ -1057,14 +1062,20 @@ impl<'open> Window<'open> {
println!("Set size!");
ctx.viewport_command(
ctx.get_viewport_id(),
ViewportCommand::InnerSize(size.x as u32, win_size.y as u32),
ViewportCommand::InnerSize(
(size.x * ctx.pixels_per_point()) as u32,
(win_size.y * ctx.pixels_per_point()) as u32,
),
);
}
if win_size.y < size.y {
println!("Set size!");
ctx.viewport_command(
ctx.get_viewport_id(),
ViewportCommand::InnerSize(win_size.x as u32, size.y as u32),
ViewportCommand::InnerSize(
(win_size.x * ctx.pixels_per_point()) as u32,
(size.y * ctx.pixels_per_point()) as u32,
),
);
}
if show_close_button && op != is_open {

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

@@ -267,15 +267,26 @@ impl ContextImpl {
self.repaint.start_frame(self.get_viewport_id());
if let Some(new_pixels_per_point) = self.memory.new_pixels_per_point {
new_raw_input.pixels_per_point = Some(new_pixels_per_point);
if self
.memory
.new_pixels_per_viewport
.get(&viewport_id)
.map(|pixels| *pixels != new_pixels_per_point)
.unwrap_or(true)
{
new_raw_input.pixels_per_point = Some(new_pixels_per_point);
self.memory
.new_pixels_per_viewport
.insert(viewport_id, new_pixels_per_point);
let input = self.input.entry(viewport_id).or_default();
// This is a bit hacky, but is required to avoid jitter:
let ratio = input.pixels_per_point / new_pixels_per_point;
let mut rect = input.screen_rect;
rect.min = (ratio * rect.min.to_vec2()).to_pos2();
rect.max = (ratio * rect.max.to_vec2()).to_pos2();
new_raw_input.screen_rect = Some(rect);
let input = self.input.entry(viewport_id).or_default();
// This is a bit hacky, but is required to avoid jitter:
let ratio = input.pixels_per_point / new_pixels_per_point;
let mut rect = input.screen_rect;
rect.min = (ratio * rect.min.to_vec2()).to_pos2();
rect.max = (ratio * rect.max.to_vec2()).to_pos2();
new_raw_input.screen_rect = Some(rect);
}
}
self.layer_rects_prev_frame = self
@@ -1493,6 +1504,9 @@ impl Context {
ctx.output.retain(|id, _| viewports.contains(id));
ctx.frame_state.retain(|id, _| viewports.contains(id));
ctx.graphics.retain(|id, _| viewports.contains(id));
ctx.memory
.new_pixels_per_viewport
.retain(|id, _| viewports.contains(id));
});
let repaint_after =
@@ -1604,6 +1618,22 @@ impl Context {
self.input(|i| i.screen_rect())
}
pub fn viewport_inner_pos(&self) -> Pos2 {
self.input(|i| i.viewport_inner_pos)
}
pub fn viewport_outer_pos(&self) -> Pos2 {
self.input(|i| i.viewport_outer_pos)
}
pub fn viewport_inner_size(&self) -> Pos2 {
self.input(|i| i.viewport_inner_size)
}
pub fn viewport_outer_size(&self) -> Pos2 {
self.input(|i| i.viewport_outer_size)
}
/// How much space is still available after panels has been added.
///
/// This is the "background" area, what egui doesn't cover with panels (but may cover with windows).

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

@@ -23,6 +23,11 @@ pub struct RawInput {
/// `None` will be treated as "same as last frame", with the default being a very big area.
pub screen_rect: Option<Rect>,
pub viewport_inner_pos: Option<Pos2>,
pub viewport_outer_pos: Option<Pos2>,
pub viewport_inner_size: Option<Pos2>,
pub viewport_outer_size: Option<Pos2>,
/// Also known as device pixel ratio, > 1 for high resolution screens.
/// If text looks blurry you probably forgot to set this.
/// Set this the first frame, whenever it changes, or just on every frame.
@@ -73,6 +78,10 @@ impl Default for RawInput {
fn default() -> Self {
Self {
screen_rect: None,
viewport_inner_pos: None,
viewport_outer_pos: None,
viewport_inner_size: None,
viewport_outer_size: None,
pixels_per_point: None,
max_texture_side: None,
time: None,
@@ -94,6 +103,10 @@ impl RawInput {
pub fn take(&mut self) -> RawInput {
RawInput {
screen_rect: self.screen_rect.take(),
viewport_inner_pos: self.viewport_inner_pos.take(),
viewport_outer_pos: self.viewport_outer_pos.take(),
viewport_inner_size: self.viewport_inner_size.take(),
viewport_outer_size: self.viewport_outer_size.take(),
pixels_per_point: self.pixels_per_point.take(),
max_texture_side: self.max_texture_side.take(),
time: self.time.take(),
@@ -110,6 +123,10 @@ impl RawInput {
pub fn append(&mut self, newer: Self) {
let Self {
screen_rect,
viewport_inner_pos,
viewport_outer_pos,
viewport_inner_size,
viewport_outer_size,
pixels_per_point,
max_texture_side,
time,
@@ -122,6 +139,10 @@ impl RawInput {
} = newer;
self.screen_rect = screen_rect.or(self.screen_rect);
self.viewport_inner_pos = viewport_inner_pos.or(self.viewport_inner_pos);
self.viewport_outer_pos = viewport_outer_pos.or(self.viewport_outer_pos);
self.viewport_inner_size = viewport_inner_size.or(self.viewport_inner_size);
self.viewport_outer_size = viewport_outer_size.or(self.viewport_outer_size);
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.time = time; // use latest time
@@ -934,6 +955,10 @@ impl RawInput {
pub fn ui(&self, ui: &mut crate::Ui) {
let Self {
screen_rect,
viewport_inner_pos,
viewport_outer_pos,
viewport_inner_size,
viewport_outer_size,
pixels_per_point,
max_texture_side,
time,
@@ -946,6 +971,14 @@ impl RawInput {
} = self;
ui.label(format!("screen_rect: {screen_rect:?} points"));
ui.label(format!("viewport_inner_pos: {viewport_inner_pos:?} pixels"));
ui.label(format!("viewport_outer_pos: {viewport_outer_pos:?} pixels"));
ui.label(format!(
"viewport_inner_size: {viewport_inner_size:?} pixels"
));
ui.label(format!(
"viewport_outer_size: {viewport_outer_size:?} pixels"
));
ui.label(format!("pixels_per_point: {pixels_per_point:?}"))
.on_hover_text(
"Also called HDPI factor.\nNumber of physical pixels per each logical pixel.",

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

@@ -54,6 +54,11 @@ pub struct InputState {
/// Position and size of the egui area.
pub screen_rect: Rect,
pub viewport_inner_pos: Pos2,
pub viewport_outer_pos: Pos2,
pub viewport_inner_size: Pos2,
pub viewport_outer_size: Pos2,
/// Also known as device pixel ratio, > 1 for high resolution screens.
pub pixels_per_point: f32,
@@ -138,6 +143,10 @@ impl Default for InputState {
modifiers: Default::default(),
keys_down: Default::default(),
events: Default::default(),
viewport_inner_pos: Pos2::ZERO,
viewport_outer_pos: Pos2::ZERO,
viewport_inner_size: pos2(10_000.0, 10_000.0),
viewport_outer_size: pos2(10_000.0, 10_000.0),
}
}
}
@@ -161,6 +170,11 @@ impl InputState {
};
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_outer_pos = new.viewport_outer_pos.unwrap_or(self.viewport_outer_pos);
let viewport_inner_size = new.viewport_inner_size.unwrap_or(self.viewport_inner_size);
let viewport_outer_size = new.viewport_outer_size.unwrap_or(self.viewport_outer_size);
self.create_touch_states_for_new_devices(&new.events);
for touch_state in self.touch_states.values_mut() {
touch_state.begin_frame(time, &new, self.pointer.interact_pos);
@@ -215,6 +229,10 @@ impl InputState {
scroll_delta,
zoom_factor_delta,
screen_rect,
viewport_inner_pos,
viewport_outer_pos,
viewport_inner_size,
viewport_outer_size,
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),
time,
@@ -972,6 +990,10 @@ impl InputState {
scroll_delta,
zoom_factor_delta,
screen_rect,
viewport_inner_pos,
viewport_outer_pos,
viewport_inner_size,
viewport_outer_size,
pixels_per_point,
max_texture_side,
time,
@@ -1007,6 +1029,14 @@ impl InputState {
ui.label(format!("scroll_delta: {scroll_delta:?} points"));
ui.label(format!("zoom_factor_delta: {zoom_factor_delta:4.2}x"));
ui.label(format!("screen_rect: {screen_rect:?} points"));
ui.label(format!("viewport_inner_pos: {viewport_inner_pos:?} pixels"));
ui.label(format!("viewport_outer_pos: {viewport_outer_pos:?} pixels"));
ui.label(format!(
"viewport_inner_size: {viewport_inner_size:?} pixels"
));
ui.label(format!(
"viewport_outer_size: {viewport_outer_size:?} pixels"
));
ui.label(format!(
"{pixels_per_point} physical pixels for each logical point"
));

3
crates/egui/src/memory.rs
View File

@@ -67,6 +67,9 @@ pub struct Memory {
#[cfg_attr(feature = "persistence", serde(skip))]
pub(crate) new_pixels_per_point: Option<f32>,
#[cfg_attr(feature = "persistence", serde(skip))]
pub(crate) new_pixels_per_viewport: HashMap<ViewportId, f32>,
/// new fonts that will be applied at the start of the next frame
#[cfg_attr(feature = "persistence", serde(skip))]
pub(crate) new_font_definitions: Option<epaint::text::FontDefinitions>,

226
examples/viewports/src/main.rs
View File

@@ -51,6 +51,8 @@ impl eframe::App for App {
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
ui.label("Look at the \"Frame: \" will tell you, what viewport is rendering!");
{
let mut force_embedding = ctx.force_embedding();
@@ -91,8 +93,8 @@ impl eframe::App for App {
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
ui.label(format!("Size: {:?}", ctx.screen_rect().max));
ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
ui.checkbox(&mut show_async_viewport2, "Show Async Viewport 2");
ui.checkbox(&mut show_sync_viewport2, "Show Sync Viewport 2");
@@ -119,8 +121,14 @@ impl eframe::App for App {
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
ui.label(format!("Size: {:?}", ctx.screen_rect().max));
ui.label(format!(
"Pos: {:?}",
ctx.viewport_outer_pos()
));
ui.label(format!(
"Size: {:?}",
ctx.viewport_inner_size()
));
ui.label(format!("Count: {state}"));
if ui.button("Add").clicked() {
@@ -159,8 +167,14 @@ impl eframe::App for App {
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
ui.label(format!("Size: {:?}", ctx.screen_rect().max));
ui.label(format!(
"Pos: {:?}",
ctx.viewport_outer_pos()
));
ui.label(format!(
"Size: {:?}",
ctx.viewport_inner_size()
));
ui.label(format!("Count: {state}"));
if ui.button("Add").clicked() {
@@ -206,106 +220,117 @@ impl eframe::App for App {
let async_viewport_state2 = self.async_viewport_state2.clone();
let sync_viewport_state2 = self.sync_viewport_state2.clone();
let content = |ui: &mut egui::Ui| {
ui.label(format!("Frame: {}", ctx.frame_nr()));
ui.label(format!("Current Viewport Id: {}", ctx.get_viewport_id()));
ui.label(format!(
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
ui.label(format!("Size: {:?}", ctx.screen_rect().max));
let content =
|ui: &mut egui::Ui| {
ui.label(format!("Frame: {}", ctx.frame_nr()));
ui.label(format!("Current Viewport Id: {}", ctx.get_viewport_id()));
ui.label(format!(
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
ui.checkbox(&mut show_async_viewport2, "Show Async Viewport");
ui.checkbox(&mut show_sync_viewport2, "Show Sync Viewport");
ui.checkbox(&mut show_async_viewport2, "Show Async Viewport");
ui.checkbox(&mut show_sync_viewport2, "Show Sync Viewport");
ui.label(format!("Count: {}", self.sync_viewport_state));
if ui.button("Add").clicked() {
self.sync_viewport_state += 1;
}
ui.label(format!("Count: {}", self.sync_viewport_state));
if ui.button("Add").clicked() {
self.sync_viewport_state += 1;
}
if *show_async_viewport2 {
ctx.create_viewport(
ViewportBuilder::new("Async Viewport in Sync Viewport")
.with_title("Async Viewport in Sync Viewport"),
move |ctx| {
let mut state = async_viewport_state2.write().unwrap();
if *show_async_viewport2 {
ctx.create_viewport(
ViewportBuilder::new("Async Viewport in Sync Viewport")
.with_title("Async Viewport in Sync Viewport"),
move |ctx| {
let mut state = async_viewport_state2.write().unwrap();
let content = move |ui: &mut egui::Ui| {
ui.label(format!("Frame: {}", ctx.frame_nr()));
ui.label(format!(
"Current Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!(
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
ui.label(format!("Size: {:?}", ctx.screen_rect().max));
let content = move |ui: &mut egui::Ui| {
ui.label(format!("Frame: {}", ctx.frame_nr()));
ui.label(format!(
"Current Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!(
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!(
"Pos: {:?}",
ctx.viewport_outer_pos()
));
ui.label(format!(
"Size: {:?}",
ctx.viewport_inner_size()
));
ui.label(format!("Count: {state}"));
if ui.button("Add").clicked() {
*state += 1;
}
};
ui.label(format!("Count: {state}"));
if ui.button("Add").clicked() {
*state += 1;
}
};
// This will make the viewport content, a popup if is in the main window
if ctx.get_viewport_id() == ViewportId::MAIN {
egui::Area::new("Async Viewport in Sync Viewport")
.show(ctx, |ui| {
egui::Frame::popup(ui.style())
.show(ui, content);
});
} else {
egui::CentralPanel::default().show(ctx, content);
};
},
);
}
// This will make the viewport content, a popup if is in the main window
if ctx.get_viewport_id() == ViewportId::MAIN {
egui::Area::new("Async Viewport in Sync Viewport")
.show(ctx, |ui| {
egui::Frame::popup(ui.style())
.show(ui, content);
});
} else {
egui::CentralPanel::default().show(ctx, content);
};
},
);
}
if *show_sync_viewport2 {
ctx.create_viewport_sync(
ViewportBuilder::new("Sync Viewport in Sync Viewport")
.with_title("Sync Viewport in Sync Viewport"),
move |ctx| {
let mut state = sync_viewport_state2.write().unwrap();
if *show_sync_viewport2 {
ctx.create_viewport_sync(
ViewportBuilder::new("Sync Viewport in Sync Viewport")
.with_title("Sync Viewport in Sync Viewport"),
move |ctx| {
let mut state = sync_viewport_state2.write().unwrap();
let content = move |ui: &mut egui::Ui| {
ui.label(format!("Frame: {}", ctx.frame_nr()));
ui.label(format!(
"Current Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!(
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
ui.label(format!("Size: {:?}", ctx.screen_rect().max));
let content = move |ui: &mut egui::Ui| {
ui.label(format!("Frame: {}", ctx.frame_nr()));
ui.label(format!(
"Current Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!(
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!(
"Pos: {:?}",
ctx.viewport_outer_pos()
));
ui.label(format!(
"Size: {:?}",
ctx.viewport_inner_size()
));
ui.label(format!("Count: {state}"));
if ui.button("Add").clicked() {
*state += 1;
}
};
ui.label(format!("Count: {state}"));
if ui.button("Add").clicked() {
*state += 1;
}
};
// This will make the viewport content, a popup if is in the main window
if ctx.get_viewport_id() == ViewportId::MAIN {
egui::Area::new("Sync Viewport in Sync Viewport").show(
ctx,
|ui| {
egui::Frame::popup(ui.style())
.show(ui, content);
},
);
} else {
egui::CentralPanel::default().show(ctx, content);
};
},
);
}
};
// This will make the viewport content, a popup if is in the main window
if ctx.get_viewport_id() == ViewportId::MAIN {
egui::Area::new("Sync Viewport in Sync Viewport")
.show(ctx, |ui| {
egui::Frame::popup(ui.style())
.show(ui, content);
});
} else {
egui::CentralPanel::default().show(ctx, content);
};
},
);
}
};
// This will make the viewport content, a popup if is in the main window
if ctx.get_viewport_id() == ViewportId::MAIN {
@@ -333,6 +358,8 @@ impl eframe::App for App {
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
ui.label(format!("Count: {state}"));
if ui.button("Add").clicked() {
*state += 1;
@@ -345,9 +372,14 @@ impl eframe::App for App {
egui::Window::new("Sync Window")
.default_embedded(false)
.show(ctx, |ui| {
ui.label(format!("Frame: {}", ui.ctx().frame_nr()));
ui.label(format!("Frame: {}", ctx.frame_nr()));
ui.label(format!("Current Viewport Id: {}", ctx.get_viewport_id()));
ui.label(format!(
"Current Parent Viewport Id: {}",
ctx.get_viewport_id()
));
ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
ui.label(format!("Count: {}", self.sync_window_state));
if ui.button("Add").clicked() {
self.sync_window_state += 1;