blockworx/panels/

notices.rs

//! What the session has to tell the user about its document: why the canvas is
//! read-only, what will be overwritten by the next save, and the load that did
//! not work.
//!
//! Two kinds, because they end differently. A standing fact stands until the
//! fact does — dismissing "read-only" would not make the container writable. A
//! failure happened once, so it carries an acknowledgement and is gone for the
//! rest of the session once it is given.
//!
//! The strip hangs below the chrome along the top of the canvas rather than
//! over it: a message that buries the toolbar takes the editor with it
//! (docs/ui-issues.md).

use crate::grid::GRID_SIZE;
pub use crate::kernel::{Acknowledged, Notice};
use crate::panels::chrome::Panel;

/// The widest a notice runs before it wraps, as a share of the canvas.
const MAX_WIDTH: f32 = 0.4;

/// Draw `notices` down the canvas's left edge, starting below `above` — the
/// chrome band along the top (the main menu and the toolbar), which nothing
/// here may cover.
pub fn draw(
    ui: &mut egui::Ui,
    viewport: egui::Rect,
    above: egui::Rect,
    notices: &[Notice],
) -> Option<Acknowledged> {
    if notices.is_empty() {
        return None;
    }
    let top = if above.is_positive() {
        above.bottom() + GRID_SIZE
    } else {
        viewport.top() + GRID_SIZE
    };
    let strip = egui::Rect::from_min_max(
        egui::pos2(viewport.left() + GRID_SIZE, top),
        viewport.right_bottom(),
    );
    let mut child = ui.new_child(
        Panel::DocumentNotices
            .ui_builder()
            .max_rect(strip)
            .layout(egui::Layout::top_down(egui::Align::Min)),
    );
    let mut acknowledged = None;
    let drawn = egui::Frame::popup(child.style()).show(&mut child, |ui| {
        ui.set_max_width(viewport.width() * MAX_WIDTH);
        let mut failures = 0;
        for notice in notices {
            match notice {
                Notice::Standing(text) => {
                    ui.label(egui::RichText::new(text).small());
                }
                Notice::Failure(text) => {
                    let failure = failures;
                    failures += 1;
                    ui.horizontal(|ui| {
                        // A row lays its children out unwrapped, and a failure
                        // names a path: without this the line runs off the
                        // canvas, taking its acknowledgement with it.
                        ui.add(egui::Label::new(egui::RichText::new(text).small()).wrap());
                        if ui
                            .small_button(DISMISS)
                            .on_hover_text("Done with this message")
                            .clicked()
                        {
                            acknowledged = Some(Acknowledged(failure));
                        }
                    });
                }
            }
        }
    });
    let pass = ui.ctx().cumulative_pass_nr();
    ui.ctx().data_mut(|d| {
        d.insert_temp(
            Panel::DocumentNotices.measurement("rect"),
            (pass, drawn.response.rect),
        );
    });
    acknowledged
}

/// Where the strip stood last frame, if it was drawn — see
/// [`crate::panels::overlay::bar_rect`].
pub(crate) fn strip_rect(ctx: &egui::Context) -> Option<egui::Rect> {
    let (pass, rect) =
        ctx.data(|d| d.get_temp::<(u64, egui::Rect)>(Panel::DocumentNotices.measurement("rect")))?;
    (pass + 1 == ctx.cumulative_pass_nr()).then_some(rect)
}

/// The acknowledgement button's label. A word, not a glyph: the canvas fonts
/// are chosen for diagrams and carry no ✕, which draws as an empty box.
pub(crate) const DISMISS: &str = "Dismiss";

#[cfg(test)]
mod tests {
    use super::*;
    use crate::canvas::convert::{IntoEgui as _, IntoGeom as _};
    use crate::panels::painted::Chrome;
    use egui::{Rect, pos2, vec2};

    fn viewport() -> Rect {
        Rect::from_min_size(pos2(0.0, 0.0), vec2(1000.0, 800.0))
    }

    /// A toolbar-shaped band across the top of the canvas, as the real one
    /// stashes each frame.
    fn toolbar() -> Rect {
        Rect::from_min_size(pos2(380.0, 8.0), vec2(240.0, 40.0))
    }

    /// The bug this strip was rewritten for: a notice over the toolbar leaves
    /// the editor unusable. Long enough to have run across it before.
    #[test]
    fn the_strip_never_covers_the_chrome_above_it() {
        let long = "Read-only \u{2014} the log does not verify at record 41 of 128, whose \
                    stamp names a fold this build does not produce";
        let mut chrome = Chrome::new(viewport().geom());
        chrome.settle(|ui| {
            let notices = [
                Notice::Standing(long.to_owned()),
                Notice::Failure(long.to_owned()),
            ];
            let _ = draw(ui, viewport(), toolbar(), &notices);
        });
        assert!(
            chrome.shows(DISMISS),
            "the failure carries no acknowledgement: {:?}",
            chrome.texts(),
        );
        let drawn = chrome
            .rect(long)
            .expect("the notices drew their text")
            .union(chrome.rect(DISMISS).expect("and the dismiss button"));
        assert!(
            drawn.top() > toolbar().bottom(),
            "the notices at {drawn:?} sit over the toolbar at {:?}",
            toolbar(),
        );
        assert!(
            viewport().contains_rect(drawn.egui()),
            "the notices at {drawn:?} left the canvas",
        );
    }

    /// Acknowledging a failure names *that* failure, so the session can drop
    /// the one the user was done with and keep the rest.
    #[test]
    fn dismissing_names_the_failure_it_dismissed() {
        let mut chrome = Chrome::new(viewport().geom());
        let mut acknowledged = None;
        let notices = || {
            [
                Notice::Failure("first".to_owned()),
                Notice::Standing("Read-only \u{2014} another blockworx has it".to_owned()),
                Notice::Failure("second".to_owned()),
            ]
        };
        chrome.settle(|ui| {
            let _ = draw(ui, viewport(), toolbar(), &notices());
        });
        // The second failure's own button: the two dismiss buttons are
        // identical, so they are told apart by the line they sit on.
        let second = chrome.rect("second").expect("the second failure drew");
        let dismiss = chrome
            .rects(DISMISS)
            .into_iter()
            .find(|rect| (rect.center().y - second.center().y).abs() < 4.0)
            .expect("the second failure carries a dismiss button");
        assert_eq!(chrome.rects(DISMISS).len(), 2, "a standing notice grew one");
        chrome.click_at(dismiss.center(), |ui| {
            if let Some(hit) = draw(ui, viewport(), toolbar(), &notices()) {
                acknowledged = Some(hit.0);
            }
        });
        assert_eq!(acknowledged, Some(1));
    }
}