2bc41aeb8602
chrome.rs
//! Window chrome: application bar (menus), Control bar, document tabs, status bar.
use std::borrow::Cow;
use std::sync::Arc;
use egui::{CornerRadius, Sense, Stroke, Ui, vec2};
use serde_json::json;
use vectorcraft_doc::NodeKind;
use crate::panels::stroke as stroke_panel;
use crate::state::{ROTATE_VIEW_ANGLES, ZOOM_STOPS, zoom_label};
use crate::theme::{self, Tokens};
use crate::widgets;
use crate::{VectorcraftApp, icons, menus, titlebar};
mod control_bar;
mod hints;
mod status_bar;
mod tabs;
pub use control_bar::{
AnchorControls, CONTROL_BAR_EDGES, CONTROL_BAR_GROUPS, anchor_buttons, anchor_controls, control_bar, control_bar_moving, control_bar_placement,
read_hidden_groups,
};
#[cfg(test)]
use control_bar::{CONTROL_BAR_FLOAT_AT, ISOLATION_BUTTON};
pub(crate) use control_bar::{Fit, group_separator, left_out, link_reserve};
#[cfg(test)]
use hints::hint_segments;
pub(crate) use hints::tool_hint;
pub use hints::{hint_bar, hint_strings};
pub use status_bar::{StatusBarShow, deserialize_status_bar_show, set_status_bar_show, status_bar};
#[cfg(test)]
use status_bar::{StatusReadoutWidths, color_profile_name, date_time_label, status_readouts};
#[cfg(test)]
use tabs::{CLOSE_BEFORE_TITLE, first_tab_shown, leading_tab, shortened_title, tab_drop, tab_groups, tab_room, tab_title};
pub use tabs::{doc_tabs, isolation_bar, step_document};
pub(crate) use tabs::{document_window_title, show_document, window_tab};
/// The application bar's height, in points (compact).
pub const APP_BAR_HEIGHT: f32 = 32.0;
/// The brand mark's side.
const MARK: f32 = 18.0;
/// Height of the workspace switcher.
const WIDGET_H: f32 = 22.0;
/// The application bar: brand mark, Home, menus, then Discord, search and the workspace switcher
/// at the right. With [`VectorcraftApp::custom_titlebar`] it is also the window's title bar
/// ([`titlebar`]): the caption buttons take the ends [`VectorcraftApp::caption_layout`] names and the
/// rest of the bar drags the window.
/// On macOS, under the system's transparent title bar, its empty space drags and zooms the window
/// too ([`titlebar::drag_area`]). With the system title bar (Windows and Linux, `system_title_bar`) the OS draws its own icon and
/// title, so the in-app bar shows Home, menus and workspace controls only: no brand mark.
pub fn app_bar(app: &mut VectorcraftApp, ui: &mut Ui) {
let t = Tokens::get(ui.ctx());
let custom = app.custom_titlebar;
let system = system_title_bar(app);
let left = app.titlebar_inset.clamp(8.0, f32::from(i8::MAX)) as i8;
// The room the caption buttons take at each end of the bar.
let (captions_left, captions_right) = if custom { (app.caption_layout.left_width(), app.caption_layout.right_width()) } else { (0.0, 0.0) };
let right_margin = if captions_right > 0.0 { 0 } else { 14 };
let frame = egui::Frame::NONE.fill(t.app_bar).inner_margin(egui::Margin { left, right: right_margin, top: 0, bottom: 0 });
let bar = egui::Panel::top("app_bar").exact_size(APP_BAR_HEIGHT).frame(frame.stroke(Stroke::new(1.0, t.border))).show(ui, |ui| {
// macOS draws the bar under its transparent title bar, so the bar gets the title bar's
// clicks: without this a double-click there zooms nothing (#1932).
if custom || cfg!(target_os = "macos") {
titlebar::drag_area(ui, ui.max_rect());
}
ui.horizontal_centered(|ui| {
if captions_left > 0.0 {
ui.add_space(captions_left);
}
// With the system title bar the OS draws its own icon: no in-app brand mark.
if !system {
let (r, _) = ui.allocate_exact_size(vec2(MARK, MARK), Sense::hover());
crate::brand::paint_mark(ui, r);
ui.add_space(6.0);
}
let on_home = menus::home_showing(app);
if widgets::icon_button(ui, "house", tl!("Home"), on_home, 20.0).clicked() {
app.run("app.home", json!({})).ok();
}
ui.add_space(2.0);
// With the macOS menu bar the menus are at the top of the screen instead.
let menus_end = if app.services.native_menu.is_some() { ui.cursor().min.x } else { menus::menu_bar(app, ui) };
// The right-side group fills the space after the menus from the right, in the order
// [`fit_right_group`] gives.
let full = ui.max_rect();
let right_edge = if captions_right > 0.0 { full.right() - captions_right - 10.0 } else { full.right() };
let right = egui::Rect::from_min_max(egui::pos2(menus_end + 8.0, full.top()), egui::pos2(right_edge, full.bottom()));
// In Safe Mode, a label that stays in the bar whatever document is open, and opens
// Help › Safe Mode; the other controls fit in the room it leaves, and the workspace
// switcher (also under Window › Workspace) goes when a minimal one doesn't fit.
let safe = vectorcraft_plugins::safe_mode::active().then(|| egui::RichText::new(tl!("Safe Mode")).color(t.warning).size(12.0));
let safe_w = safe.as_ref().map_or(0.0, |label| {
let text = ui.painter().layout_no_wrap(label.text().to_string(), egui::FontId::proportional(12.0), t.warning);
text.size().x + 2.0 * ui.spacing().button_padding.x + 8.0 + ui.spacing().item_spacing.x
});
// Built-in workspace names translate; the user's own stay as typed.
let ws_name =
if crate::workspaces::is_builtin(&app.ui.workspace) { tl!(&app.ui.workspace).to_string() } else { app.ui.workspace.clone() };
let ws = ui.painter().layout_no_wrap(ws_name, egui::FontId::proportional(12.0), t.text);
let shortcut = menus::shortcut_of("help.commandPalette").map(menus::shown_shortcut);
let field = SearchField::new(ui, &t, shortcut);
let fit = fit_right_group(&RightWidths {
room: (right.width() - safe_w).max(0.0),
safe_mode: safe.is_some(),
switcher: (ws.size().x + 36.0).clamp(112.0, 190.0),
field: field.width,
icon: BAR_ICON,
gap: ui.spacing().item_spacing.x,
community: crate::community::discord_width(ui, false),
});
let (switcher, ws_w, arrange, learn, discord) = (fit.switcher, fit.switcher_w, fit.arrange, fit.learn, fit.community);
let mut rui = ui.new_child(egui::UiBuilder::new().max_rect(right).layout(egui::Layout::right_to_left(egui::Align::Center)));
let ui = &mut rui;
// Workspace switcher: shows the current workspace, opens Window → Workspace.
if switcher {
let (wr, wresp) = ui.allocate_exact_size(vec2(ws_w, WIDGET_H), Sense::click());
ui.painter().rect_filled(wr, CornerRadius::same(4), if wresp.hovered() { t.hover } else { t.panel });
ui.painter().with_clip_rect(wr.shrink2(vec2(4.0, 0.0))).galley(wr.left_center() + vec2(10.0, -ws.size().y / 2.0), ws, t.text);
icons::paint(ui, "chevron-down", egui::Rect::from_center_size(wr.right_center() - vec2(12.0, 0.0), vec2(12.0, 12.0)), t.text_dim);
let wresp = wresp.on_hover_text(tl!("Switch workspace"));
egui::Popup::menu(&wresp).show(|ui| crate::workspaces::popup(app, ui));
ui.add_space(8.0);
}
if let Some(label) = safe {
if ui.add(egui::Button::new(label).frame(false)).on_hover_text(tl!("Safe Mode…")).clicked() {
app.run("help.safeMode", json!({})).ok();
}
ui.add_space(8.0);
}
// Arrange Documents: Consolidate All Windows and the Tile layouts.
if arrange {
let resp = widgets::icon_button(ui, "layout-grid", tl!("Arrange Documents"), app.ui.tiled, BAR_ICON);
egui::Popup::menu(&resp).show(|ui| arrange_documents_popup(app, ui));
}
// Search → command palette (its shortcut opens it too).
let with_shortcut = |text: &str| match &field.shortcut {
Some(sc) => format!("{text} ({sc})"),
None => text.to_string(),
};
let tip = with_shortcut(tl!("Search commands, tools, panels and effects"));
let name = with_shortcut(tl!("Search commands"));
// The field and the icon toggle the palette as its shortcut does, and like the shortcut
// they do nothing while a dialog is open, so they are drawn disabled then.
let enabled = app.ui.dialog.is_none();
let open = app.ui.palette_open;
let clicked = ui
.add_enabled_ui(enabled, |ui| match fit.search {
Search::Field => field.show(ui, &t, &name, &tip, open).clicked(),
Search::Icon => {
let (_, resp) = ui.allocate_exact_size(vec2(BAR_ICON, BAR_ICON), Sense::click());
widgets::paint_icon_button_named(ui, resp, "search", &name, &tip, open).clicked()
}
Search::Hidden => false,
})
.inner;
if clicked && enabled {
app.ui.palette_open = !app.ui.palette_open;
app.ui.palette_query.clear();
}
if learn {
let shown = crate::panels::learn::visible(&app.ui);
if widgets::icon_button(ui, "graduation-cap", tl!("Explore tutorials"), shown, BAR_ICON).clicked()
&& let Err(e) = app.run("window.learn", json!({}))
{
app.ui.status = e;
}
}
if discord {
ui.add_space(10.0);
crate::community::discord_button(app, ui, false);
}
if app.services.native_menu.is_some() {
let title = ui.painter().layout_no_wrap("VectorCraft".into(), egui::FontId::proportional(13.5), t.text);
let title_rect = egui::Rect::from_center_size(full.center(), title.size());
// Keep the title centered only while the interactive groups leave room for it.
if title_rect.left() >= menus_end + 8.0 && title_rect.right() <= ui.min_rect().left() - 8.0 {
ui.painter().galley(title_rect.min, title, t.text);
}
}
});
});
if custom {
titlebar::caption_buttons(app, ui, bar.response.rect);
}
}
/// The Arrange Documents menu ([`menus::arrange_documents_items`]): each item as the Window menu
/// shows it, grayed out while its command can't run, the Tile layout the panes show checked.
fn arrange_documents_popup(app: &mut VectorcraftApp, ui: &mut Ui) {
ui.set_min_width(200.0);
let mut clicked = None;
for it in menus::arrange_documents_items() {
match it {
menus::Item::Sep => {
ui.separator();
}
menus::Item::Cmd(label, id, p) => {
let Some((enabled, checked)) = menus::shown_state(app, id, &p) else { continue };
let label = crate::i18n::t_id(id, label);
let text = if checked == Some(true) { format!("✓ {label}") } else { format!(" {label}") };
if ui.add_enabled(enabled, egui::Button::new(text).min_size(vec2(200.0, 0.0))).clicked() {
clicked = Some((id, if p.is_null() { json!({}) } else { p }));
ui.close();
}
}
_ => {}
}
}
if let Some((id, p)) = clicked {
menus::invoke(app, id, p);
}
}
/// The side of the app bar's square icon buttons (the search icon, Arrange Documents, Explore tutorials).
const BAR_ICON: f32 = 28.0;
/// The narrowest the workspace switcher gets.
const MIN_SWITCHER: f32 = 64.0;
/// How the app bar shows the search that opens the command palette.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Search {
/// A field with the magnifier, "Search commands" and the palette's shortcut.
Field,
/// The magnifier alone.
Icon,
/// Not in the bar; the palette stays under its shortcut and Help › Search Commands….
Hidden,
}
/// The widths [`fit_right_group`] fits into `room`, in points.
#[derive(Clone, Copy, Debug)]
struct RightWidths {
/// The room after the menus, less the Safe Mode label's.
room: f32,
/// Whether the bar shows the Safe Mode label.
safe_mode: bool,
/// The workspace switcher's full width.
switcher: f32,
/// The search field's width.
field: f32,
/// The side of a square icon button.
icon: f32,
/// The space between two controls.
gap: f32,
/// The community button's width.
community: f32,
}
/// What the right-hand group of the app bar shows.
#[derive(Clone, Copy, Debug, PartialEq)]
struct RightGroup {
/// Whether the workspace switcher shows.
switcher: bool,
/// The workspace switcher's width.
switcher_w: f32,
/// How the search shows.
search: Search,
/// Whether Arrange Documents shows.
arrange: bool,
/// Whether Explore tutorials shows.
learn: bool,
/// Whether the community button shows.
community: bool,
}
/// The right-hand group for the room it has. As the room runs short, the community button goes first
/// (it is also under Help), then Explore tutorials (also Window › Learn), then Arrange Documents (also Window ›
/// Arrange), then the search field becomes the search icon, then the workspace switcher narrows to [`MIN_SWITCHER`], then the icon goes. In Safe
/// Mode the label's width is taken first, and the switcher (also under Window › Workspace) goes when
/// a minimal one does not fit.
fn fit_right_group(w: &RightWidths) -> RightGroup {
let room = w.room;
let switcher = !w.safe_mode || room >= MIN_SWITCHER + 8.0;
let icon = switcher && room >= MIN_SWITCHER + 8.0 + w.gap + w.icon;
let field = icon && room >= w.switcher + 8.0 + w.gap + w.field;
let search = if field {
Search::Field
} else if icon {
Search::Icon
} else {
Search::Hidden
};
let search_w = match search {
Search::Field => w.gap + w.field,
Search::Icon => w.gap + w.icon,
Search::Hidden => 0.0,
};
let switcher_w = w.switcher.min(room - 8.0 - search_w).max(MIN_SWITCHER);
let arrange_end = switcher_w + 8.0 + search_w + w.gap + w.icon;
let arrange = field && room >= arrange_end;
let learn_end = arrange_end + w.gap + w.icon;
let learn = arrange && room >= learn_end;
let community = learn && room >= learn_end + 10.0 + w.gap + w.community;
RightGroup { switcher, switcher_w, search, arrange, learn, community }
}
/// The app bar's search field: a button drawn as a field. The command palette's popup holds the
/// only text field.
struct SearchField {
hint: Arc<egui::Galley>,
/// The palette's shortcut as the menus show it; none when the user cleared it.
shortcut: Option<String>,
key: Option<Arc<egui::Galley>>,
width: f32,
}
impl SearchField {
/// Space from the field's left edge to the hint text (the magnifier sits in it).
const TEXT_LEFT: f32 = 26.0;
/// The widest the field gets.
const MAX_WIDTH: f32 = 220.0;
fn new(ui: &Ui, t: &Tokens, shortcut: Option<String>) -> SearchField {
let hint = ui.painter().layout_no_wrap(tl!("Search commands").to_string(), egui::FontId::proportional(12.0), t.text_dim);
let text_w = Self::TEXT_LEFT + hint.size().x + 8.0;
// A shortcut that leaves no room for the hint in the widest field is left to the tooltip.
let key = shortcut
.as_ref()
.map(|s| ui.painter().layout_no_wrap(s.clone(), egui::FontId::proportional(11.0), t.text_dim))
.filter(|k| text_w + 12.0 + k.size().x <= Self::MAX_WIDTH);
let key_w = key.as_ref().map_or(0.0, |k| 12.0 + k.size().x);
let width = (text_w + key_w + 24.0).clamp(120.0, Self::MAX_WIDTH);
SearchField { hint, shortcut, key, width }
}
/// Draws the field. A click, or Enter or Space with the keyboard on it, clicks it. Screen
/// readers get a button called `name`, and hovering it shows `tip`.
fn show(self, ui: &mut Ui, t: &Tokens, name: &str, tip: &str, open: bool) -> egui::Response {
let (r, resp) = ui.allocate_exact_size(vec2(self.width, WIDGET_H), Sense::click());
let fill = if open {
t.tool_active
} else if resp.hovered() {
t.hover
} else {
t.input
};
let border = if resp.has_focus() { t.accent } else { t.input_border };
ui.painter().rect(r, CornerRadius::same(4), fill, Stroke::new(1.0, border), egui::StrokeKind::Inside);
icons::paint(ui, "search", egui::Rect::from_center_size(r.left_center() + vec2(14.0, 0.0), vec2(14.0, 14.0)), t.icon);
let mut text_right = r.right() - 8.0;
if let Some(key) = self.key {
let at = egui::pos2(text_right - key.size().x, r.center().y - key.size().y / 2.0);
text_right = at.x - 12.0;
ui.painter().with_clip_rect(r).galley(at, key, t.text_dim);
}
let clip = egui::Rect::from_min_max(r.min, egui::pos2(text_right.max(r.left()), r.bottom()));
let at = egui::pos2(r.left() + Self::TEXT_LEFT, r.center().y - self.hint.size().y / 2.0);
ui.painter().with_clip_rect(clip).galley(at, self.hint, t.text_dim);
resp.widget_info(|| widgets::icon_button_info(ui.is_enabled(), open, name));
resp.on_hover_text(tip)
}
}
/// Whether the window shows the system's title bar instead of the app drawing its own
/// ([`VectorcraftApp::desktop_frame`]): Windows with Preferences › User Interface › System Title
/// Bar, and Linux whenever the desktop draws the frame, with or without the preference. The
/// preference is read when the app starts, so changing it later does not change this. macOS
/// always has system decorations, but keeps the in-app brand mark, so it never counts as system
/// mode here; nor does the web build (the browser tab has no document title), nor an embedder
/// without a window of its own.
pub fn system_title_bar(app: &VectorcraftApp) -> bool {
app.desktop_frame && !app.custom_titlebar && !cfg!(any(target_os = "macos", target_arch = "wasm32"))
}
/// The OS window title: the active document's name suffixed with the app name (a `*` prefix
/// marks unsaved changes, like the `*` in the document tabs), or just the app name with no
/// document open; in Safe Mode, followed by "(Safe Mode)".
pub fn window_title(app: &VectorcraftApp) -> String {
let title = app
.session
.active()
.map(|d| format!("{}{} \u{2014} VectorCraft", if d.is_dirty() { "*" } else { "" }, d.title()))
.unwrap_or_else(|| "VectorCraft".into());
if vectorcraft_plugins::safe_mode::active() { format!("{title} ({})", tl!("Safe Mode")) } else { title }
}
/// Keep the OS window title (and the taskbar / Alt-Tab entry) on the active file. Sends
/// `ViewportCommand::Title` only when the title changed since the last frame.
pub fn sync_window_title(app: &mut VectorcraftApp, ctx: &egui::Context) {
let want = window_title(app);
if app.last_window_title != want {
app.last_window_title = want.clone();
ctx.send_viewport_cmd(egui::ViewportCommand::Title(want));
// One more frame: a new title makes AppKit lay its title bar out again, putting the window
// buttons back where it keeps them until the next frame centres them on the bar (#968).
ctx.request_repaint();
}
}
/// Full Screen Mode and Presentation Mode fill the screen (#4365: the taskbar and the window's
/// frame stayed): the window goes full screen when one of them starts, and back when a mode with
/// the menu bar returns. A window that was full screen already stays so.
pub fn sync_fullscreen(app: &mut VectorcraftApp, ctx: &egui::Context) {
let want = app.ui.screen_mode >= 2;
let is = ctx.input(|i| i.viewport().fullscreen.unwrap_or(false));
if want && !is && !app.fullscreen_for_mode {
ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(true));
app.fullscreen_for_mode = true;
} else if !want && app.fullscreen_for_mode {
if is {
ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(false));
}
app.fullscreen_for_mode = false;
}
}
#[cfg(test)]
mod tests;
#[cfg(test)]
mod visual_regressions {
use super::*;
fn scaled_input(size: egui::Vec2, scale: f32) -> egui::RawInput {
let mut input = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), ..Default::default() };
input.viewports.entry(egui::ViewportId::ROOT).or_default().native_pixels_per_point = Some(scale);
input
}
struct NativeMenus;
impl crate::native_menu::Backend for NativeMenus {
fn sync(&mut self, _: &crate::native_menu::MenuBar) {}
fn drain(&mut self) -> Vec<crate::native_menu::Event> {
Vec::new()
}
}
#[test]
fn capture_chrome_visual_fixtures() {
let Some(directory) = std::env::var_os("CRAFT_UI_VISUAL_FIXTURES").map(std::path::PathBuf::from) else {
return;
};
std::fs::create_dir_all(&directory).unwrap();
for brightness in theme::Brightness::ALL {
for width in [800.0, 1280.0] {
for scale in [1.0, 1.5, 2.0] {
let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
app.services.native_menu = Some(crate::native_menu::NativeMenu::new(Box::new(NativeMenus)));
app.ui.status = format!("Saved /Users/example/Documents/{}/illustration.svg", "long-folder-name/".repeat(10));
let mut ready = false;
let mut harness =
egui_kittest::Harness::builder().with_size(vec2(width, 200.0)).with_pixels_per_point(scale).wgpu().build_ui_state(
move |ui, app: &mut VectorcraftApp| {
if !ready {
egui_extras::install_image_loaders(ui.ctx());
theme::install_fonts(ui.ctx());
theme::apply(ui.ctx(), brightness);
ready = true;
return;
}
app_bar(app, ui);
status_bar(app, ui);
},
app,
);
harness.input_mut().max_texture_side = Some(8192);
harness.run_steps(4);
let stem = format!("vectorcraft-chrome-{brightness:?}-{width}-{scale}x");
harness.render().unwrap().save(directory.join(format!("{stem}.png"))).unwrap();
let mut regions = serde_json::Map::new();
for id in ["app_bar", "status_bar"] {
let rect = egui::containers::panel::PanelState::load(&harness.ctx, egui::Id::unique(id)).unwrap().outer_rect;
regions.insert(id.into(), json!([rect.left(), rect.top(), rect.width(), rect.height()]));
}
let dynamic: Vec<_> = harness
.output()
.shapes
.iter()
.filter_map(|shape| match &shape.shape {
egui::Shape::Text(text) if text.galley.job.text.contains(" fps") => {
let r = text.visual_bounding_rect();
Some(json!([r.left(), r.top(), r.width(), r.height()]))
}
_ => None,
})
.collect();
std::fs::write(
directory.join(format!("{stem}.json")),
serde_json::to_vec_pretty(&json!({
"screen": [width, 200.0], "scale": scale, "regions": regions, "native_dynamic_text_regions": dynamic
}))
.unwrap(),
)
.unwrap();
}
}
}
}
#[test]
fn native_title_does_not_overlap_header_controls() {
for brightness in theme::Brightness::ALL {
for width in [800.0, 1280.0] {
for scale in [1.0, 1.5, 2.0] {
let ctx = egui::Context::default();
egui_extras::install_image_loaders(&ctx);
theme::install_fonts(&ctx);
theme::apply(&ctx, brightness);
let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
app.services.native_menu = Some(crate::native_menu::NativeMenu::new(Box::new(NativeMenus)));
let mut output = ctx.run_ui(scaled_input(vec2(width, 640.0), scale), |ui| app_bar(&mut app, ui));
output.textures_delta.clear();
assert_eq!(ctx.content_rect().size(), vec2(width, 640.0));
assert_eq!(ctx.pixels_per_point(), scale);
let texts: Vec<_> = output
.shapes
.iter()
.filter_map(|shape| match &shape.shape {
egui::Shape::Text(text) => Some(text),
_ => None,
})
.collect();
let title = texts.iter().find(|text| text.galley.job.text == "VectorCraft");
if width >= 1280.0 {
assert!(title.is_some(), "the title remains visible when the header has room");
}
if let Some(title) = title {
for text in texts.iter().filter(|text| text.galley.job.text != "VectorCraft") {
assert!(
!title.visual_bounding_rect().intersects(text.visual_bounding_rect()),
"{width}: title overlaps {:?}",
text.galley.job.text
);
}
}
}
}
}
}
#[test]
fn long_status_stays_between_navigation_and_performance_readouts() {
for brightness in theme::Brightness::ALL {
for width in [800.0, 1280.0] {
for scale in [1.0, 1.5, 2.0] {
let ctx = egui::Context::default();
egui_extras::install_image_loaders(&ctx);
theme::install_fonts(&ctx);
theme::apply(&ctx, brightness);
let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
app.ui.status = format!("Saved /Users/example/Documents/{}/illustration.svg", "long-folder-name/".repeat(10));
let mut output = ctx.run_ui(scaled_input(vec2(width, 640.0), scale), |ui| status_bar(&mut app, ui));
output.textures_delta.clear();
assert_eq!(ctx.content_rect().size(), vec2(width, 640.0));
assert_eq!(ctx.pixels_per_point(), scale);
let texts: Vec<_> = output
.shapes
.iter()
.filter_map(|shape| match &shape.shape {
egui::Shape::Text(text) => Some(text),
_ => None,
})
.collect();
let status = texts.iter().find(|text| text.galley.job.text.starts_with("Saved ")).expect("status stays visible");
assert_eq!(status.galley.rows.len(), 1, "status is one line");
assert!(status.galley.elided, "long status retains the full text for the label tooltip");
let bounds = status.visual_bounding_rect();
assert!(bounds.left() >= 0.0 && bounds.right() <= width, "{width}: {bounds:?}");
for text in texts.iter().filter(|text| !text.galley.job.text.starts_with("Saved ")) {
assert!(!bounds.intersects(text.visual_bounding_rect()), "{width}: status overlaps {:?}", text.galley.job.text);
}
}
}
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.