Merge branch 'dl/contract' into dl/all

This commit is contained in:
aiongg
2026-11-16 13:39:10 +00:00
40 changed files with 277 additions and 218 deletions
+7 -3
View File
@@ -18,7 +18,8 @@ pub(crate) const EGUI_ROOTS: [&str; 7] = ["egui", "epaint", "emath", "ecolor", "
#[derive(Debug, Default)]
pub(crate) struct Args {
pub count: usize,
/// Every identifier inside the arguments, nested ones included.
/// Every identifier inside the arguments, nested ones included, except inside a closure argument: its body is
/// read as sites of its own, so a call there does not count as an argument of this one.
pub idents: Vec<String>,
/// Whether a numeric literal appears.
pub has_literal: bool,
@@ -140,9 +141,12 @@ fn args_of<'a>(args: impl IntoIterator<Item = &'a Expr>) -> Args {
let mut out = Args::default();
for e in args {
out.count += 1;
out.has_closure |= matches!(e, Expr::Closure(_));
let closure = matches!(e, Expr::Closure(_));
out.has_closure |= closure;
let tokens = e.to_token_stream();
summarize(tokens.clone(), &mut out.idents);
if !closure {
summarize(tokens.clone(), &mut out.idents);
}
out.has_literal |= has_number(tokens);
}
out
+8
View File
@@ -103,3 +103,11 @@ fn family_modules_neither_import_runtime_egui_nor_build_egui_text() {
let shell = analyze_contract(&src, Path::new("crates/x/src/shell/app.rs"), &layered, false);
assert!(shell.iter().all(|f| f.rule != "contract/runtime-egui"), "layer 7 hosts the adapter");
}
#[test]
fn a_salt_inside_a_scope_closure_is_not_the_scope_builders() {
let inner = "fn f(ui: &mut Ui) {\n ui.scope_builder(UiBuilder::new().max_rect(r), |ui| Button::new(\"a\").id_salt(\"b\").show(ui));\n}\n";
assert!(!rules_at(inner, "src/ui/a.rs", &scope()).contains(&"contract/memory"));
let salted = "fn f(ui: &mut Ui) {\n ui.scope_builder(UiBuilder::new().id_salt(\"b\"), |ui| ());\n}\n";
assert!(rules_at(salted, "src/ui/a.rs", &scope()).contains(&"contract/memory"));
}
+1 -1
View File
@@ -483,7 +483,7 @@ impl CropSession {
/// The first frame edit from the hidden overlay, a ratio or size change or a Straighten press:
/// the default frame shows again.
pub fn show(&mut self) {
pub fn show_frame(&mut self) {
self.dismissed = None;
}
+4 -4
View File
@@ -284,7 +284,7 @@ impl CropTool {
}
if !edit.events.is_empty() {
// The first edit of a hidden default frame draws a new frame.
self.session.show();
self.session.show_frame();
}
for event in edit.events {
match &event {
@@ -303,7 +303,7 @@ impl CropTool {
if straightened.is_some() || straighten_ended {
// The button was armed when the line began: a line made with Cmd alone turns the frame in place.
let fit = self.session.straighten().armed();
self.session.show();
self.session.show_frame();
// A click with no line spends the armed button too.
self.session.straighten_mut().disarm();
if let Some(angle) = straightened {
@@ -367,7 +367,7 @@ impl CropTool {
/// began with while `editing`, as one box step. Returns the frame's `Set` for the host's mirror, or
/// `None` when nothing changed. In image mode the next pass turns the view with the frame.
pub fn refit(&mut self, settings: &CropSettings, document: &CropDocument, units: &Units, editing: bool) -> Option<CropEvent> {
self.session.show();
self.session.show_frame();
let base = self.session.ratio_base(editing);
self.end_nudges();
if self.dragging {
@@ -429,7 +429,7 @@ impl CropTool {
}
let frame = self.session.frame()?;
self.end_nudges();
self.session.show();
self.session.show_frame();
let event = self.session.set(frame, false, &self.step);
self.synced = None;
Some(CropEvent::Frame(event))
+2 -2
View File
@@ -8,7 +8,7 @@ use craft_color::ui::gradient::{GradientEditor, GradientStops, StopColor, StopRe
use craft_theme::Srgba;
use craft_ui::buttons::Button;
use craft_ui::choice::{Checkbox, Segmented};
use craft_ui::contract::{Bind, Entry, Outcome, Props as _, Show as _, ShowContainer as _};
use craft_ui::contract::{Bind, Entry, Outcome, Props as _, Show as _, ShowContainer as _, clicked};
use craft_ui::display::Text;
use craft_ui::layout_components::{Row, Stack};
use craft_ui::patterns::presets::PresetState;
@@ -206,7 +206,7 @@ impl<'a> GradientFillEditor<'a> {
let align = Checkbox::new(Bind::given(now.align)).label(words.align.clone()).show(ui);
absorb(&mut events, lift(align.events, &now, |fill, on| fill.align = on));
let reset = Button::new(words.reset_alignment.clone()).enabled(now.offset != kurbo::Vec2::ZERO).show(ui);
if reset.clicked() {
if clicked(&reset) {
let mut centred = now.clone();
centred.offset = kurbo::Vec2::ZERO;
events.push(EditEvent::set(Mixed::Same(now.clone()), centred, Arc::from(words.reset_alignment.as_str()), None));
+8 -3
View File
@@ -67,10 +67,8 @@ impl<'a> AdjustmentsPanel<'a> {
let AdjustmentsPanel { label, kinds } = self;
let env = Env::of(ui);
let words = env.words::<AdjustWords>();
// An icon button is square at the control height; the grid steps by the columns that fit the width given.
let side = env.tokens.tokens().size.control.md;
let gap = BUTTON_GAP.points(ui);
let columns = (((ui.available_width() + gap) / (side + gap)).floor() as usize).clamp(1, kinds.len().max(1));
let columns = ButtonGrid::columns(&StyleCx::of_env(ui.ctx(), &env), ui.available_width(), gap, kinds.len());
let mut picked = None;
let shown = ButtonGrid::new(label, columns).show(ui, |ui, _| {
for &kind in kinds {
@@ -105,6 +103,13 @@ struct ButtonGrid {
}
impl ButtonGrid {
/// How many of `count` buttons fit across `width` with `gap` between them. An icon button is square at the
/// control height.
fn columns(cx: &StyleCx<'_>, width: f32, gap: f32, count: usize) -> usize {
let side = cx.tokens.size.control.md;
(((width + gap) / (side + gap)).floor() as usize).clamp(1, count.max(1))
}
fn new(label: Label, columns: usize) -> Self {
let props = ContainerProps::new()
.pad(Pad::None)
+3 -3
View File
@@ -12,8 +12,9 @@ use craft_ui::contract::{Bind, Role};
use craft_ui::dialog::{HostedWorkspace, stories::hosted};
use craft_ui::primitives::Revision;
use craft_ui::runtime::pending::Job;
use craft_ui::testing::input::key_press;
use craft_ui::testing::{Drive, Fixture, StoryData, StoryOutput, story};
use egui::{Color32, ColorImage, Event, Key, Modifiers, Ui};
use egui::{Color32, ColorImage, Key, Modifiers, Ui};
use super::{
Demosaic, RawDevelopOpen, RawDevelopPanel, RawDevelopSource, RawDevelopWorkspace, RawFilmItem, RawFilmstrip, RawFloatingScope, RawPreviewRequest,
@@ -141,8 +142,7 @@ fn smart_filter_with_edits(ui: &mut Ui, data: &mut StoryData) -> StoryOutput {
/// Y goes down and stays down: the workspace shows the picture before the settings.
fn hold_before(fixture: &mut Fixture) {
let key = |pressed| Event::Key { key: Key::Y, physical_key: Some(Key::Y), pressed, repeat: false, modifiers: Modifiers::NONE };
fixture.frame(vec![key(true)]);
fixture.frame(vec![key_press(Key::Y, Modifiers::NONE)]);
}
#[story(RawDevelopWorkspace, covers = [], drive = Drive::Custom(hold_before))]
-24
View File
@@ -660,27 +660,3 @@ impl<T: EdgeTracer> CanvasTool for SelectToolPass<'_, MagneticLassoTool<T>> {
fn close_radius(cx: &ToolContext<'_>, place: &Place) -> f64 {
reach(cx).close / place.zoom().max(0.01)
}
#[cfg(test)]
mod tests {
#[test]
fn width_steps_by_one_and_shift_jumps_to_the_limits() {
let mut settings = MagneticSettings { width: 10.4, ..MagneticSettings::default() };
settings.step_width(1, false);
assert_eq!(settings.width, 11.0, "a step adds one to the rounded width");
settings.width = 1.0;
settings.step_width(-1, false);
assert_eq!(settings.width, 1.0, "the step stops at the minimum");
settings.width = 256.0;
settings.step_width(1, false);
assert_eq!(settings.width, 256.0, "the step stops at the maximum");
settings.step_width(-1, true);
assert_eq!(settings.width, 1.0, "Shift+[ goes to the minimum");
settings.step_width(1, true);
assert_eq!(settings.width, 256.0, "Shift+] goes to the maximum");
settings.width = f32::NAN;
settings.step_width(1, false);
assert_eq!(settings.width, MagneticSettings::default().width, "a width that is no number goes back to the default");
}
}
+2 -2
View File
@@ -487,7 +487,7 @@ impl SelectMaskWorkspace {
let common = env.words::<CommonWords>();
let title = FullWindowTitle::new(words.name.clone()).subject(self.subject.clone()).zoom(self.zoom_percent).label(&env);
let slots = SelectMaskTool::slots();
self.begin_pass(ui.ctx());
self.start_pass(ui.ctx());
let request = self.request_now();
let key = format!("{request:?}");
let reset = Cell::new(false);
@@ -665,7 +665,7 @@ impl SelectMaskWorkspace {
/// The start of a pass: the first pass reads the stored settings, a change the app made to the settings since the
/// last pass reaches the view and the refinement values, and the edits `perform` recorded are reported.
fn begin_pass(&mut self, ctx: &Context) {
fn start_pass(&mut self, ctx: &Context) {
if !std::mem::replace(&mut self.recalled, true)
&& let Some(key) = &self.remember
{
+3 -3
View File
@@ -119,7 +119,7 @@ impl CylinderValues {
/// silhouettes and the edges keep their order (a moved one stops 1 unit short of the other) and a depth stays
/// within the half axis, or within its own reach when it already lies past that (a cylinder read from a file). A
/// drag by nothing changes nothing.
fn dragged(self, handle: CylinderHandle, by: DocVec) -> Self {
fn moved(self, handle: CylinderHandle, by: DocVec) -> Self {
let mut v = self;
let a = ((self.right - self.left) / 2.0).max(MIN_SIDE / 2.0);
match handle {
@@ -288,7 +288,7 @@ impl<'a> CylinderWarp<'a> {
held.began = true;
*cx.press_slot::<Press>() = Some(held.clone());
}
cx.propose(held.values.dragged(held.handle, view.to_doc(pos) - held.origin));
cx.propose(held.values.moved(held.handle, view.to_doc(pos) - held.origin));
}
PressPhase::Release { .. } => {
if cx.press_slot::<Press>().take().is_some_and(|held| held.began) {
@@ -310,7 +310,7 @@ impl<'a> CylinderWarp<'a> {
let Some(handle) = focused else { return };
if let Some((direction, mods)) = cx.intents().take_nudge() {
let step = if mods.shift { NUDGE_FAR } else { NUDGE };
cx.set(values.dragged(handle, space.view.unmap_vec(direction) * step));
cx.set(values.moved(handle, space.view.unmap_vec(direction) * step));
}
}
}
+23 -2
View File
@@ -4,8 +4,8 @@
use craft_behavior::geometry::{Constraint, SelectionOperation, SnapKind, SnapOptions, SnapTarget, SnapTargets};
use craft_behavior::{Axis, CancelReason, EditEvent, PixelSize, PointerButton};
use craft_imaging::ui::select::{
DragKind, EdgeSearch, EdgeTracer, LassoTool, MagneticLassoTool, MarqueeKind, MarqueeTool, PolygonLassoTool, SelectEvent, SelectPhase,
SelectToolPass, SelectionDrag, SelectionProbe, SelectionShape,
DragKind, EdgeSearch, EdgeTracer, LassoTool, MagneticLassoTool, MagneticSettings, MarqueeKind, MarqueeTool, PolygonLassoTool, SelectEvent,
SelectPhase, SelectToolPass, SelectionDrag, SelectionProbe, SelectionShape,
};
use craft_keymap::{Mods, Platform};
use craft_ui::canvas::{CanvasTool, Snap, ToolAccess, ToolContext, ToolHost, ToolInput, ToolKey, ToolPath, ToolPointer};
@@ -910,3 +910,24 @@ fn the_magnetic_lasso_shows_the_width_circle_under_the_precise_cursor() {
assert_eq!(circle, caps_lock, "Caps Lock {caps_lock}: {cursor:?}");
}
}
#[trial]
fn width_steps_by_one_and_shift_jumps_to_the_limits() {
let mut settings = MagneticSettings::default();
settings.width = 10.4;
settings.step_width(1, false);
assert_eq!(settings.width, 11.0, "a step adds one to the rounded width");
settings.width = 1.0;
settings.step_width(-1, false);
assert_eq!(settings.width, 1.0, "the step stops at the minimum");
settings.width = 256.0;
settings.step_width(1, false);
assert_eq!(settings.width, 256.0, "the step stops at the maximum");
settings.step_width(-1, true);
assert_eq!(settings.width, 1.0, "Shift+[ goes to the minimum");
settings.step_width(1, true);
assert_eq!(settings.width, 256.0, "Shift+] goes to the maximum");
settings.width = f32::NAN;
settings.step_width(1, false);
assert_eq!(settings.width, MagneticSettings::default().width, "a width that is no number goes back to the default");
}
+2 -2
View File
@@ -277,9 +277,9 @@ pub(super) fn show_list(ui: &mut Ui, stack: &mut BodyCx<'_>, selected: &RefCell<
if let Some(comp) = comp_at(cx.comps, item.at)
&& !comp.comment.is_empty()
{
let comment: &str = &comp.comment;
let comment = comp.comment.clone();
item.tip(move |ui| {
ui.label(comment);
let _ = Text::new(comment).show(ui);
});
}
build_row(cx, item.at)
+7 -8
View File
@@ -57,7 +57,6 @@ pub use raster::{DetailPlan, Extent, RasterDisplay, RasterDisplayOutput, RasterS
mod opacity_keys;
mod snap;
pub use opacity_keys::OpacityDigit;
pub(crate) use rulers::LABEL_STEP_MIN;
pub use rulers::{NUDGE, NUDGE_FAR};
pub use snap::{GestureSnap, Snap, canvas_snap, snap_suspended, snap_tolerance};
pub(crate) use space::context_menu;
@@ -81,7 +80,9 @@ pub use zoom_motion::{HoldZoom, ZoomAnimation, ZoomDrag, easing_view};
mod rulers;
mod scrollbars;
pub use rulers::{INCH_EIGHTHS, INCH_SIXTEENTHS, RulerCommands, RulerMargins, RulerPart, RulerTick, Rulers, RulersOutput, StepLadder, TickRule};
pub use rulers::{
INCH_EIGHTHS, INCH_SIXTEENTHS, LABEL_STEP_MIN, RulerCommands, RulerMargins, RulerPart, RulerTick, Rulers, RulersOutput, StepLadder, TickRule,
};
pub use scrollbars::{CanvasScrollbars, CanvasScrollbarsOutput};
// canvas-navigator-a
@@ -113,7 +114,7 @@ use craft_behavior::{
CanvasTransform, CanvasView, EditEvent, HitLevel, HitPriority, Intent, Metrics, Mixed, PartKey, PointerButton, PressPhase, PressState, Sense,
WheelNotch,
};
use egui::{Pos2, Rect, Response, Shape, Vec2};
use egui::{Pos2, Rect, Response, Vec2};
use zoom_motion::{Steer, ViewMotion};
pub(crate) const BACKGROUND: PartKey = PartKey::new("background");
@@ -203,7 +204,7 @@ pub struct Canvas<'a> {
#[prop(name = "view_follows_pointer")]
follows_pointer: bool,
/// The slot the body's paint reserved for the picture, published in the [`CanvasSpace`]; none in a measuring pass.
picture: Option<space::PictureSlot>,
picture: Option<crate::primitives::PaintSlot>,
}
/// A canvas's view in one pass.
@@ -549,10 +550,8 @@ impl Component for Canvas<'_> {
}
/// Reserves the slot the picture paints into, under every canvas control of the body (`CanvasSpace::paint_picture`).
fn paint(&mut self, _ui: &mut PaintUi<'_>, cx: &Cx<'_, Self>) {
let layer = cx.response.layer_id;
let idx = cx.core.ctx.graphics_mut(|graphics| graphics.entry(layer).add(cx.content_rect, Shape::Noop));
self.picture = Some(space::PictureSlot { layer, idx });
fn paint(&mut self, ui: &mut PaintUi<'_>, cx: &Cx<'_, Self>) {
self.picture = Some(ui.reserve_slot(cx.content_rect));
}
/// The view of this pass, kept for the body and `finish`.
+5 -15
View File
@@ -24,7 +24,8 @@ use super::{AppPaint, PixelRect, RasterSource, canvas_space};
use crate::contract::{Access, Common, Component, Cx, NoValue, Outcome, PaintUi, Props as _, Role};
use crate::primitives::textures::UNTINTED;
use crate::primitives::{
CachedTexture, Checker, CheckerArea, Draw, Revision, RuleKind, TextureState, TextureStore, TextureStoreOptions, texture_factor, texture_side,
CachedTexture, Checker, CheckerArea, Draw, PaintSlot, Revision, RuleKind, TextureState, TextureStore, TextureStoreOptions, texture_factor,
texture_side,
};
use crate::runtime::env::Label;
use crate::runtime::memory::Remember as _;
@@ -34,7 +35,6 @@ use craft_behavior::kurbo::{Point as Point64, Rect as Rect64};
use craft_behavior::{CanvasView, Metrics, PixelSize};
use detail::{texel_extent, texel_origin};
use egui::epaint::{Mesh, Vertex};
use egui::layers::ShapeIdx;
use egui::{Color32, ColorImage, Context, Id, Pos2, Response, Shape, TextureFilter, TextureOptions, Vec2, pos2};
use std::collections::HashMap;
use std::ops::RangeInclusive;
@@ -515,7 +515,7 @@ impl Component for RasterDisplay<'_> {
// slot at the end, in show order with every other picture. Outside a canvas, or in a space with no slot, it
// paints in place.
let space = canvas_space(&cx.env);
let first = (self.under_controls && space.and_then(|space| space.picture_slot()).is_some()).then(|| painter.painter.add(Shape::Noop));
let first = (self.under_controls && space.and_then(|space| space.picture_slot()).is_some()).then(|| PaintSlot::reserve(&painter.painter));
// The picture's area on screen: the document, or the mapped area. A mapped area with nothing of the unit
// square in it has no checkerboard and no edge.
let corners = match &self.mapping {
@@ -568,18 +568,8 @@ impl Component for RasterDisplay<'_> {
painter.with_draw(|draw| edge(draw, corners));
}
if let (Some(first), Some(space)) = (first, space) {
let last = painter.painter.add(Shape::Noop);
let (ctx, layer) = (painter.painter.ctx().clone(), painter.painter.layer_id());
let shapes: Vec<Shape> = ctx.graphics_mut(|layers| {
let list = layers.entry(layer);
(first.0 + 1..last.0)
.map(|at| {
let mut taken = Shape::Noop;
list.mutate_shape(ShapeIdx(at), |clipped| std::mem::swap(&mut clipped.shape, &mut taken));
taken
})
.collect()
});
let ctx = painter.painter.ctx().clone();
let shapes = first.take_after(&ctx);
space.paint_picture(&ctx, shapes);
}
}
+1 -2
View File
@@ -6,9 +6,8 @@
mod stories;
mod ticks;
pub use ticks::{INCH_EIGHTHS, INCH_SIXTEENTHS, RulerTick, StepLadder, TickRule};
pub use ticks::{INCH_EIGHTHS, INCH_SIXTEENTHS, LABEL_STEP_MIN, RulerTick, StepLadder, TickRule};
pub(crate) use self::ticks::LABEL_STEP_MIN;
use super::words::CanvasWords;
use super::{CanvasRulers, CanvasSpace, GuideDrag, RulerText, Snap, canvas_snap, canvas_space, context_menu, readout};
use crate::contract::overlay::Anchor;
+1 -4
View File
@@ -10,7 +10,7 @@ pub const INCH_SIXTEENTHS: [u32; 4] = [16, 8, 4, 2];
pub const INCH_EIGHTHS: [u32; 3] = [8, 4, 2];
/// The least distance between labelled ticks, in points.
pub(crate) const LABEL_STEP_MIN: f32 = 60.0;
pub const LABEL_STEP_MIN: f32 = 60.0;
/// The metric rule's subdivisions of a labelled step.
const METRIC_SUBDIVISIONS: f32 = 10.0;
@@ -141,6 +141,3 @@ pub fn ticks(units: &RulerUnits, rule: TickRule<'_>, zoom: f64, values: RangeInc
})
.collect()
}
#[cfg(test)]
mod tests;
+6 -26
View File
@@ -7,6 +7,7 @@
use super::PasteboardColor;
use crate::contract::{Component, Cx, Focus as _, Pointer as _};
use crate::primitives::PaintSlot;
use crate::runtime::env::{AppValues, EnvValue, EnvView, UnitKind, Units};
use craft_behavior::canvas::zoom;
use craft_behavior::kurbo::{Point, Size};
@@ -38,16 +39,7 @@ pub struct CanvasSpace {
precise: bool,
/// The canvas's picture slot for this pass, which [`paint_picture`](Self::paint_picture) appends to; `None` in a
/// measuring pass.
picture: Option<PictureSlot>,
}
/// The shape the canvas reserved in its paint hook for the picture: its layer and index, which
/// [`CanvasSpace::paint_picture`] grows into a `Shape::Vec` in show order. The space is `Copy` and holds no painter,
/// so the slot is named by these two.
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct PictureSlot {
pub(crate) layer: egui::LayerId,
pub(crate) idx: egui::layers::ShapeIdx,
picture: Option<PaintSlot>,
}
impl CanvasSpace {
@@ -159,33 +151,21 @@ impl CanvasSpace {
/// context because the space holds none. Outside a canvas's paint (a measuring pass) there is no slot, and it
/// paints nothing.
pub fn paint_picture(&self, ctx: &egui::Context, shapes: Vec<egui::Shape>) {
let Some(slot) = self.picture else { return };
if shapes.is_empty() {
return;
if let Some(slot) = self.picture {
slot.extend(ctx, shapes);
}
ctx.graphics_mut(|layers| {
layers.entry(slot.layer).mutate_shape(slot.idx, |clipped| {
if let egui::Shape::Vec(list) = &mut clipped.shape {
list.extend(shapes);
return;
}
let reserved = std::mem::replace(&mut clipped.shape, egui::Shape::Noop);
let list = if matches!(reserved, egui::Shape::Noop) { shapes } else { std::iter::once(reserved).chain(shapes).collect() };
clipped.shape = egui::Shape::Vec(list);
});
});
}
/// This space with the canvas's picture slot of this pass.
#[must_use]
pub(crate) fn with_picture(mut self, slot: PictureSlot) -> Self {
pub(crate) fn with_picture(mut self, slot: PaintSlot) -> Self {
self.picture = Some(slot);
self
}
/// The slot the canvas reserved this pass, `None` before its paint step ran or outside a canvas: a display that
/// paints under the controls paints in place without one.
pub(crate) fn picture_slot(&self) -> Option<PictureSlot> {
pub(crate) fn picture_slot(&self) -> Option<PaintSlot> {
self.picture
}
@@ -22,7 +22,7 @@ const ESCAPE_DRAG_START: Vec2 = Vec2::new(0.25, 0.25);
/// The id a [`ToolFixture`] gives its canvas labelled `label`: what a body hands to a control keyed by its canvas
/// ([`Guides::new`](crate::canvas_controls::Guides::new)), as an app names its own canvas.
pub fn canvas_id(label: &'static str) -> Id {
Id::unique(("tool fixture canvas", label))
crate::runtime::memory::unique(("tool fixture canvas", label))
}
/// A tool shown on a canvas that fills the fixture's room, with the gesture phases the host reported.
@@ -17,8 +17,7 @@ use crate::testing::{Drive, StoryData, StoryOutput, story};
use craft_behavior::kurbo::{Point, Rect as DocRect, Vec2};
use craft_behavior::{CancelReason, CanvasView, Cursor, PaintedCursor, PointerButton};
use craft_keymap::Mods;
use egui::{Id, Rect, Ui};
use std::sync::{Arc, Mutex, PoisonError};
use egui::{Rect, Ui};
/// The zoom, in percent of one device pixel per document pixel.
const ZOOM: f64 = 400.0;
@@ -66,25 +65,24 @@ fn stamped(y: f64) -> CoverageMask {
}
/// The footprint of one tone. The mask is kept across passes (stamped once), so the trail uploads only what changed.
fn footprint_of(ui: &mut Ui, name: &'static str, label: &'static str, tone: TrailTone, y: f64) -> StoryOutput {
let kept = ui.data_mut(|data| data.get_temp_mut_or_insert_with(Id::unique(("footprint", name)), || Arc::new(Mutex::new(stamped(y)))).clone());
let mut mask = kept.lock().unwrap_or_else(PoisonError::into_inner);
on_canvas_view(ui, brush_view, Some(&StoryDocument::STANDARD), |ui, rect, _| StrokeTrail::new(label, &mut mask).tone(tone).show_at(ui, rect))
fn footprint_of(ui: &mut Ui, data: &mut StoryData, label: &'static str, tone: TrailTone, y: f64) -> StoryOutput {
let mask = data.note::<Option<CoverageMask>>("footprint", None).get_or_insert_with(|| stamped(y));
on_canvas_view(ui, brush_view, Some(&StoryDocument::STANDARD), |ui, rect, _| StrokeTrail::new(label, mask).tone(tone).show_at(ui, rect))
}
#[story(StrokeTrail<'static>, covers = [Default])]
fn footprint_light(ui: &mut Ui, _: &mut StoryData) -> StoryOutput {
footprint_of(ui, "light", "Light footprint", TrailTone::Light, 100.0)
fn footprint_light(ui: &mut Ui, data: &mut StoryData) -> StoryOutput {
footprint_of(ui, data, "Light footprint", TrailTone::Light, 100.0)
}
#[story(StrokeTrail<'static>, covers = [Default])]
fn footprint_shade(ui: &mut Ui, _: &mut StoryData) -> StoryOutput {
footprint_of(ui, "shade", "Shade footprint", TrailTone::Shade, 100.0)
fn footprint_shade(ui: &mut Ui, data: &mut StoryData) -> StoryOutput {
footprint_of(ui, data, "Shade footprint", TrailTone::Shade, 100.0)
}
#[story(StrokeTrail<'static>, covers = [Default])]
fn footprint_danger(ui: &mut Ui, _: &mut StoryData) -> StoryOutput {
footprint_of(ui, "danger", "Danger footprint", TrailTone::Danger, 100.0)
fn footprint_danger(ui: &mut Ui, data: &mut StoryData) -> StoryOutput {
footprint_of(ui, data, "Danger footprint", TrailTone::Danger, 100.0)
}
#[story(SourceMarker, covers = [Default])]
+2
View File
@@ -14,6 +14,8 @@ mod pasteboard;
mod raster;
mod rulers;
mod scrollbars;
mod snap;
@@ -1,6 +1,9 @@
use super::{INCH_EIGHTHS, INCH_SIXTEENTHS, LABEL_STEP_MIN, StepLadder, TickRule, ticks};
use crate::primitives::TickRank;
//! The ruler tick rule (`Rulers::ticks`): labelled ticks stay at least `LABEL_STEP_MIN` apart at every zoom.
use craft_behavior::{RulerUnits, Ticks};
use craft_ui::canvas::{INCH_EIGHTHS, INCH_SIXTEENTHS, LABEL_STEP_MIN, Rulers, StepLadder, TickRule};
use craft_ui::primitives::TickRank;
use craft_ui::testing::trial;
/// Screen points per document unit, from far out to deep in.
const ZOOMS: [f64; 10] = [0.01, 0.0625, 0.25, 1.0 / 3.0, 1.0, 3.7, 16.0, 64.0, 320.0, 3200.0];
@@ -8,7 +11,7 @@ const ZOOMS: [f64; 10] = [0.01, 0.0625, 0.25, 1.0 / 3.0, 1.0, 3.7, 16.0, 64.0, 3
/// The least distance in points between two consecutive labelled ticks of `rule` at `zoom`, over a ruler 2000 points
/// long.
fn least_label_gap(units: &RulerUnits, rule: TickRule<'_>, zoom: f64) -> f64 {
let labelled: Vec<f64> = ticks(units, rule, zoom, 0.0..=2000.0 / zoom * units.per_doc)
let labelled: Vec<f64> = Rulers::ticks(units, rule, zoom, 0.0..=2000.0 / zoom * units.per_doc)
.into_iter()
.filter(|tick| tick.rank == TickRank::Major)
.map(|tick| tick.value)
@@ -17,7 +20,7 @@ fn least_label_gap(units: &RulerUnits, rule: TickRule<'_>, zoom: f64) -> f64 {
labelled.windows(2).map(|pair| (pair[1] - pair[0]) / units.per_doc * zoom).fold(f64::INFINITY, f64::min)
}
#[test]
#[trial]
fn labelled_ticks_never_touch_at_any_zoom() {
let pixels = RulerUnits::pixels();
let centimetres = RulerUnits::new(2.54 / 72.0, Ticks::decimal(false));
+7 -1
View File
@@ -7,7 +7,7 @@ use super::{ContentPainter, Cx, Show, TipFn};
use super::{InsideLabel, SideLabel};
use crate::primitives::sensing::PartResults;
use crate::primitives::text_adapter;
use crate::primitives::{ContentPainterCx, DataMode, Draw, DrawEnv, PaintRecord, TextRun};
use crate::primitives::{ContentPainterCx, DataMode, Draw, DrawEnv, PaintRecord, PaintSlot, TextRun};
use crate::runtime::access;
use crate::runtime::egui::{alloc, child};
use crate::runtime::env::{Env, Label};
@@ -244,6 +244,12 @@ impl PaintUi<'_> {
own.faces.push(record);
}
/// Reserves an empty shape at the end of the component's layer, clipped to `clip`, for shapes added later by code
/// that holds no painter (`PaintSlot::extend`).
pub fn reserve_slot(&self, clip: Rect) -> PaintSlot {
PaintSlot::reserve_on(self.ui.ctx(), self.response.layer_id, clip)
}
/// The raw painter for an allowlisted content painter, clipped to the component's own rect. Its data paths paint
/// data colours as [`draw`](Self::draw) does.
pub fn content_painter<C: ContentPainter>(&self, cx: &Cx<'_, C>) -> ContentPainterCx<'_> {
@@ -3,10 +3,11 @@
use crate::contract::Pointer as _;
use crate::contract::cx::CxCore;
use crate::primitives::{FocusKind, FocusRing, PaintShape, StateLayer, StateLayerKind, surface_look_shapes};
use crate::runtime::egui::areas::Layer;
use crate::runtime::env::{Env, EnvValue};
use crate::style::{Ink, StateSet, StyleView, surface_style};
use craft_theme::Opacity;
use egui::{Color32, LayerId, Shape, Ui};
use egui::{Color32, Shape, Ui};
/// The ink the surface reads in: the surface kind of the state, else `inherited`.
pub(crate) fn surface_ink(look: Option<&crate::style::SurfaceLook>, state: &StateSet, inherited: Ink) -> Ink {
@@ -16,7 +17,7 @@ pub(crate) fn surface_ink(look: Option<&crate::style::SurfaceLook>, state: &Stat
/// Where a faded component's shapes start in its layer's paint list, and the ground its veil takes.
#[derive(Clone, Copy)]
pub(crate) struct Fade {
layer: LayerId,
layer: Layer,
from: usize,
ground: Color32,
/// The component lies under the veil of a faded owner that shows it from its paint: it paints its enabled look
@@ -27,7 +28,7 @@ pub(crate) struct Fade {
/// The layer whose open veil the components shown here lie under: set by `PaintUi` for the children a faded
/// component shows while its paint runs, which its veil covers.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct UnderVeil(pub Option<LayerId>);
pub(crate) struct UnderVeil(pub Option<Layer>);
impl EnvValue for UnderVeil {
fn root() -> Self {
+1 -15
View File
@@ -8,7 +8,6 @@ use crate::runtime::egui::text_layout;
use crate::runtime::env::Env;
use crate::style::{DataColor, Ink, StyleCx, UiTokens, ink_color};
use craft_i18n::Direction;
use craft_theme::Variant;
use egui::epaint::text::{FontId, TextDirection};
use egui::text::{LayoutJob, TextFormat};
use egui::{Color32, Context, FontFamily, Painter, Stroke};
@@ -55,20 +54,7 @@ impl<'a> ContentPainterCx<'a> {
/// it draws the face of.
#[doc(hidden)]
pub fn style_cx(&self) -> StyleCx<'_> {
let env = self.env;
StyleCx::new(
self.painter.ctx(),
&env.tokens,
&env.values,
env.size,
Variant::SECONDARY,
env.direction,
env.scale,
env.os,
env.active,
env.key,
env.line_ratio,
)
StyleCx::of_env(self.painter.ctx(), self.env)
}
/// Runs `paint` with a `Draw` over this painter, in the scope's tokens and direction.
+2
View File
@@ -12,6 +12,7 @@ mod icon;
mod ime_surface;
mod kit;
mod marker;
mod paint_slot;
pub(crate) mod pointer_art;
mod record;
mod reset_mark;
@@ -43,6 +44,7 @@ pub use kit::{
fill_polygon, grid_lines, grid_lines_with, marching_ants, outline, ramp, ticks,
};
pub use marker::{Marker, MarkerSize};
pub use paint_slot::PaintSlot;
pub use reset_mark::ResetMark;
pub use rule::{RectSide, Rule, RuleKind};
pub use scroll_bar::{HiddenContent, ScrollBar};
@@ -0,0 +1,58 @@
//! `PaintSlot`: a place in a layer's paint list, reserved while a component paints and filled or read later by code
//! that holds no painter.
use crate::runtime::egui::areas::Layer;
use egui::layers::ShapeIdx;
use egui::{Context, Painter, Rect, Shape};
/// An empty shape reserved in a layer's paint list. Shapes added to it later paint at its place in the paint order;
/// shapes painted on the layer after it can be taken out to move them elsewhere.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PaintSlot {
layer: Layer,
idx: ShapeIdx,
}
impl PaintSlot {
/// Reserves an empty shape at the end of `painter`'s layer, clipped like the painter.
pub fn reserve(painter: &Painter) -> Self {
PaintSlot { layer: painter.layer_id(), idx: painter.add(Shape::Noop) }
}
/// Reserves an empty shape at the end of `layer`, clipped to `clip`.
pub(crate) fn reserve_on(ctx: &Context, layer: Layer, clip: Rect) -> Self {
PaintSlot { layer, idx: ctx.graphics_mut(|graphics| graphics.entry(layer).add(clip, Shape::Noop)) }
}
/// Adds `shapes` to the slot, after the shapes it holds, keeping the slot's clip.
pub fn extend(self, ctx: &Context, shapes: Vec<Shape>) {
if shapes.is_empty() {
return;
}
ctx.graphics_mut(|graphics| {
graphics.entry(self.layer).mutate_shape(self.idx, |clipped| {
if let Shape::Vec(list) = &mut clipped.shape {
list.extend(shapes);
return;
}
let reserved = std::mem::replace(&mut clipped.shape, Shape::Noop);
let list = if matches!(reserved, Shape::Noop) { shapes } else { std::iter::once(reserved).chain(shapes).collect() };
clipped.shape = Shape::Vec(list);
});
});
}
/// Takes the shapes painted on the slot's layer after it, in paint order, leaving empty shapes in their places.
pub fn take_after(self, ctx: &Context) -> Vec<Shape> {
ctx.graphics_mut(|graphics| {
let list = graphics.entry(self.layer);
(self.idx.0 + 1..list.next_idx().0)
.map(|at| {
let mut taken = Shape::Noop;
list.mutate_shape(ShapeIdx(at), |clipped| std::mem::swap(&mut clipped.shape, &mut taken));
taken
})
.collect()
})
}
}
@@ -319,6 +319,7 @@ pub(crate) fn type_on(pen: &Pen, path: bool) {
.collect()
};
let dot = |centre: Vec2, grow: f32, color: Color32| {
// design: allow[literal-size/vec2](pointer art is a fixed bitmap-like drawing around the hotspot, not a layout size)
pen.push(Mark::Block(Rect::from_center_size(centre.to_pos2(), Vec2::splat(DOT_SIDE)).expand(grow), 0.0, color));
};
// The dots' halos go under the beam and their fills over it, so a dot on the stem stays whole.
@@ -333,6 +334,7 @@ pub(crate) fn type_on(pen: &Pen, path: bool) {
/// The locator: a square frame centred on the pointer between halo frames a hairline outside and inside it.
pub(crate) fn locator(pen: &Pen) {
// design: allow[literal-size/vec2](pointer art is a fixed bitmap-like drawing around the hotspot, not a layout size)
let rect = Rect::from_center_size(Pos2::ZERO, Vec2::splat(LOCATOR_SIDE));
let halo = Stroke::new(pen.thin, pen.halo);
pen.push(Mark::Frame(rect.expand(pen.thin), halo));
@@ -327,19 +327,6 @@ fn arrows_from_end(ctx: &Context, widget: Id, len: usize) {
}
}
/// Removes this pass's Tab and Shift+Tab presses from the input events; returns whether there was one. A Tab with
/// Ctrl, Cmd or Alt is the window's, not the field's, and stays.
fn take_tab(ctx: &Context) -> bool {
ctx.input_mut(|input| {
let before = input.events.len();
input.events.retain(|event| {
!matches!(event, egui::Event::Key { key: egui::Key::Tab, pressed: true, modifiers, .. }
if !modifiers.ctrl && !modifiers.command && !modifiers.mac_cmd && !modifiers.alt)
});
input.events.len() != before
})
}
/// The modifiers held in this pass, which are the Enter press's.
fn held_mods(ctx: &Context) -> Mods {
let os = crate::runtime::windows::os_of(ctx);
@@ -400,7 +387,7 @@ pub(crate) fn run(state: &mut TextState, mut input: AdapterIn<'_>) -> AdapterOut
}
let separated = input.focused && !input.read_only && state.preedit.is_none() && egui_input::take_separator(ctx, input.options.commit_on);
// The part keeps Tab (`keys_of`), so the focus service left it here; it is taken before the widget would insert it.
if input.focused && input.options.tab_rewrites && !input.read_only && state.preedit.is_none() && take_tab(ctx) {
if input.focused && input.options.tab_rewrites && !input.read_only && state.preedit.is_none() && egui_input::take_tab(ctx) {
state.end = Some(End::Rewrite { refuses: true });
}
let filter = egui_focus::event_filter(input.keys.keep, false);
@@ -463,8 +450,7 @@ pub(crate) fn run(state: &mut TextState, mut input: AdapterIn<'_>) -> AdapterOut
&& !input.options.multiline()
&& state.preedit.is_none()
&& state.draft.is_some()
&& ctx
.input(|i| [egui::Key::ArrowUp, egui::Key::ArrowDown, egui::Key::PageUp, egui::Key::PageDown].into_iter().any(|key| i.key_pressed(key)));
&& egui_input::step_key_pressed(ctx);
let submitted =
(shown.entered && shown.focused).then(|| held_mods(ctx)).filter(|mods| !input.options.multiline() || (input.options.submits && mods.cmd));
if let Some(mods) = submitted {
@@ -648,3 +648,21 @@ pub(crate) fn held_press_origin(ctx: &Context) -> Option<Pos2> {
pub(crate) fn plain_horizontal_arrow_pressed(ctx: &Context) -> bool {
ctx.input(|input| input.modifiers.is_none() && (input.key_pressed(Key::ArrowLeft) || input.key_pressed(Key::ArrowRight)))
}
/// An Up, Down, Page Up or Page Down press reached egui this pass.
pub(crate) fn step_key_pressed(ctx: &Context) -> bool {
ctx.input(|input| [Key::ArrowUp, Key::ArrowDown, Key::PageUp, Key::PageDown].into_iter().any(|key| input.key_pressed(key)))
}
/// Removes this pass's Tab and Shift+Tab presses from the input events; returns whether there was one. A Tab with
/// Ctrl, Cmd or Alt is the window's, not the field's, and stays.
pub(crate) fn take_tab(ctx: &Context) -> bool {
ctx.input_mut(|input| {
let before = input.events.len();
input.events.retain(|event| {
!matches!(event, Event::Key { key: Key::Tab, pressed: true, modifiers, .. }
if !modifiers.ctrl && !modifiers.command && !modifiers.mac_cmd && !modifiers.alt)
});
input.events.len() != before
})
}
+2 -2
View File
@@ -12,7 +12,7 @@ use crate::runtime::pointer;
use craft_behavior::OwnerClass;
use craft_behavior::overlay::Side;
use egui::emath::TSTransform;
use egui::{Context, Id, LayerId, Pos2, Rect, ViewportId};
use egui::{Context, Id, Pos2, Rect, ViewportId};
use smallvec::SmallVec;
use std::collections::HashMap;
@@ -385,7 +385,7 @@ pub fn top(ctx: &Context) -> Option<Id> {
/// Whether `layer` is the layer of a popup open above `below` in last pass's overlay stack: `layer` belongs to a
/// non-exiting popup entry, and `below` is the window's base layer (no entry's layer) or the layer of an entry
/// opened before it. The stack, not egui's area order, says which layer was opened above which.
pub(crate) fn popup_above(ctx: &Context, layer: LayerId, below: LayerId) -> bool {
pub(crate) fn popup_above(ctx: &Context, layer: Layer, below: Layer) -> bool {
with_pass(ctx, |pass| {
// Entries are recorded parent first, so an earlier entry was opened before a later one.
let Some(at) = pass.last.iter().position(|entry| entry.layer == layer && entry.rank == Rank::Popup && !entry.exiting) else {
+12 -7
View File
@@ -163,11 +163,10 @@ impl<'a> StyleCx<'a> {
}
}
/// Runs `f` with the style context of the root scope (`Env::of_root(ctx)`), for code with no `Ui` that reads a
/// component's style, such as the dock's sizes outside a style pass.
pub fn with_root<R>(ctx: &Context, f: impl FnOnce(&StyleCx<'_>) -> R) -> R {
let env = crate::runtime::env::Env::of_root(ctx);
let cx = StyleCx::new(
/// The style context of the scope `env` describes, in the secondary variant: for code outside a style function
/// that works out a layout from a component's style or the scope's tokens.
pub fn of_env(ctx: &'a Context, env: &'a crate::runtime::env::Env) -> Self {
StyleCx::new(
ctx,
&env.tokens,
&env.values,
@@ -179,8 +178,14 @@ impl<'a> StyleCx<'a> {
env.active,
env.key,
env.line_ratio,
);
f(&cx)
)
}
/// Runs `f` with the style context of the root scope (`Env::of_root(ctx)`), for code with no `Ui` that reads a
/// component's style, such as the dock's sizes outside a style pass.
pub fn with_root<R>(ctx: &Context, f: impl FnOnce(&StyleCx<'_>) -> R) -> R {
let env = crate::runtime::env::Env::of_root(ctx);
f(&StyleCx::of_env(ctx, &env))
}
/// The same context with another variant.
+3 -3
View File
@@ -111,10 +111,10 @@ impl Flyout {
if bounded { overlay.bounds(self.within) } else { overlay }
}
/// Shows the flyout of `popup` while it is open, its top left at `anchor` (a point, or a rect's top left), and
/// returns what it showed; `None` while it is closed. `body` returns the height it measures for
/// Shows the flyout as the layer of `popup` while it is open, its top left at `anchor` (a point, or a rect's top
/// left), and returns what it showed; `None` while it is closed. `body` returns the height it measures for
/// `GroupAt::Measure`, or `None` to take the flyout's own height.
pub fn show(
pub fn show_popup(
mut self,
ui: &mut OverlayUi<'_>,
popup: PopupHandle,
+1 -1
View File
@@ -553,7 +553,7 @@ impl<P: Value + Hash + 'static> Component for IconicColumn<'_, P> {
let mut resized = None;
for (at, plan) in plans.into_iter().enumerate() {
let Some(FlyoutPlan { group, top_left, size, fixed, icons_top }) = plan else { continue };
let shown = Flyout::new(edge, size, auto_collapse).within(bounds).least(least).show(
let shown = Flyout::new(edge, size, auto_collapse).within(bounds).least(least).show_popup(
ui,
popup.at(at),
Anchor::Point(top_left),
+9 -18
View File
@@ -4,6 +4,7 @@ use super::flyout::GroupAt;
use super::spec::PanelSpec;
use crate::contract::BodyCx;
use crate::menu::PanelRow;
use crate::runtime::memory;
use craft_behavior::dock::{Action, Permissions};
use egui::{Context, Id, Ui};
@@ -54,7 +55,7 @@ pub trait DockPanels<P> {
type Running<P> = Vec<Vec<Action<P>>>;
fn running_id() -> Id {
Id::unique("dock area requests")
memory::unique("dock area requests")
}
/// Hands `actions` to the dock area over panels `P` whose pass is running on `ctx`: a panel body, or code a body
@@ -64,33 +65,23 @@ fn running_id() -> Id {
///
/// With no such pass running, the actions come back for the caller to apply.
pub fn request_actions<P: Clone + Send + Sync + 'static>(ctx: &Context, actions: Vec<Action<P>>) -> Result<(), Vec<Action<P>>> {
ctx.data_mut(|data| {
let running = data.get_temp_mut_or_default::<Running<P>>(running_id());
if let Some(open) = running.last_mut() {
memory::with_session(ctx, running_id(), |running: &mut Running<P>| match running.last_mut() {
Some(open) => {
open.extend(actions);
return Ok(());
Ok(())
}
data.remove::<Running<P>>(running_id());
Err(actions)
None => Err(actions),
})
}
/// Opens the request list of a dock area's pass on `ctx`. The area calls it before its bodies run.
#[doc(hidden)]
pub fn open_requests<P: Clone + Send + Sync + 'static>(ctx: &Context) {
ctx.data_mut(|data| data.get_temp_mut_or_default::<Running<P>>(running_id()).push(Vec::new()));
memory::with_session(ctx, running_id(), |running: &mut Running<P>| running.push(Vec::new()));
}
/// Closes the innermost request list on `ctx` and returns what it took. The area calls it when its bodies have run;
/// the last close leaves nothing in the context.
/// Closes the innermost request list on `ctx` and returns what it took. The area calls it when its bodies have run.
#[doc(hidden)]
pub fn close_requests<P: Clone + Send + Sync + 'static>(ctx: &Context) -> Vec<Action<P>> {
ctx.data_mut(|data| {
let running = data.get_temp_mut_or_default::<Running<P>>(running_id());
let requested = running.pop().unwrap_or_default();
if running.is_empty() {
data.remove::<Running<P>>(running_id());
}
requested
})
memory::with_session(ctx, running_id(), |running: &mut Running<P>| running.pop().unwrap_or_default())
}
@@ -110,14 +110,15 @@ fn a_new_guide_remembers_its_confirmed_values_for_the_next_open() {
let position = fixture.by_label("Position").expect("the Position field");
fixture.click(&position).settle();
fixture.key(egui::Key::A, egui::Modifiers::COMMAND);
fixture.type_text("120");
let typed = 120.0;
fixture.type_text(&typed.to_string());
fixture.key(egui::Key::Enter, egui::Modifiers::NONE).settle();
assert!(!open.get(), "Enter is OK");
let confirmed: Vec<_> = made.borrow().iter().map(|guide| (guide.along, guide.position, guide.color)).collect();
assert_eq!(confirmed, [(Axis::Y, 120.0, Some(GuideColor::Magenta.rgba()))], "OK makes the guide of the edited values");
assert_eq!(confirmed, [(Axis::Y, typed, Some(GuideColor::Magenta.rgba()))], "OK makes the guide of the edited values");
reopen(&mut fixture);
assert_eq!(*values.borrow(), NewGuideValues::new(Axis::Y, 120.0, GuideColor::Magenta), "the next open starts from the confirmed values");
assert_eq!(*values.borrow(), NewGuideValues::new(Axis::Y, typed, GuideColor::Magenta), "the next open starts from the confirmed values");
let horizontal = fixture.by_label("Horizontal").expect("the orientation offers Horizontal");
fixture.click(&horizontal).settle();
assert_eq!(values.borrow().along, Axis::X, "the click edits the values");
@@ -126,5 +127,5 @@ fn a_new_guide_remembers_its_confirmed_values_for_the_next_open() {
assert_eq!(made.borrow().len(), 1, "Cancel makes no guide");
reopen(&mut fixture);
assert_eq!(*values.borrow(), NewGuideValues::new(Axis::Y, 120.0, GuideColor::Magenta), "Cancel stored nothing: the OK'd values come back");
assert_eq!(*values.borrow(), NewGuideValues::new(Axis::Y, typed, GuideColor::Magenta), "Cancel stored nothing: the OK'd values come back");
}
@@ -12,6 +12,7 @@ use super::state::{PresetState, PresetView};
use super::words::PresetWords;
use crate::contract::{Bind, Entry, NoValue, Outcome, Pattern, Props, Show as _, ShowContainer as _};
use crate::dialog::{Dialog, DialogId, DialogResult, DialogStack, StackDialog, dialog_id};
use crate::layout_components::Stack;
use crate::list::RowTest;
use crate::pickers::Select;
use crate::runtime::env::{Env, Label};
@@ -142,8 +143,11 @@ impl<'a, G: Value, K: Clone + Eq + Hash + Send + Sync + 'static> PresetManager<'
}
let shown = dialog.show(ui, |ui, _| {
let kind_pick = Select::new(words.manager_kind.clone(), kind.reborrowed(), kinds).show(ui).value().cloned();
let events: Vec<PresetEvent<K>> = ui
.push_id(("preset-kind", index), |ui| {
// Each kind's browser keeps its own state: its search, scroll and open groups.
let events: Vec<PresetEvent<K>> = Stack::new()
.id_salt(("preset-kind", index))
.fill_width()
.show(ui, |ui, _| {
PresetBrowser::new(title.clone(), Bind::<PresetState<K>>::kept(), rows)
.view_lock(PresetView::List)
.toolbar(false)
@@ -156,7 +160,8 @@ impl<'a, G: Value, K: Clone + Eq + Hash + Send + Sync + 'static> PresetManager<'
.show(ui)
.events
})
.inner;
.inner
.unwrap_or_default();
(kind_pick, events)
});
+3 -14
View File
@@ -34,7 +34,6 @@ impl CaptionIcon {
}
/// The icon name the freedesktop themes give the glyph.
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn theme_name(self) -> &'static str {
match self {
CaptionIcon::Minimize => "window-minimize-symbolic",
@@ -121,20 +120,10 @@ impl std::fmt::Debug for CaptionIcons {
}
}
/// The four glyph SVGs of icon theme `theme` (with its parents and `hicolor`), in [`CaptionIcon::ALL`] order.
#[cfg(target_os = "linux")]
/// The four glyph SVGs of icon theme `theme` (with its parents and `hicolor`), in [`CaptionIcon::ALL`] order; none
/// where the platform has no icon themes.
fn theme_files(theme: &str) -> [Option<Arc<[u8]>>; 4] {
use craft_window::desktop::{IconTheme, base_dirs, read_small};
let Some(found) = IconTheme::load(theme, &base_dirs(&|key: &str| std::env::var(key).ok())) else {
return Default::default();
};
CaptionIcon::ALL.map(|icon| found.find_svg(icon.theme_name()).and_then(|path| read_small(&path)).map(Arc::<[u8]>::from))
}
/// The freedesktop lookup is Linux's; elsewhere every glyph is the family's own.
#[cfg(not(target_os = "linux"))]
fn theme_files(_theme: &str) -> [Option<Arc<[u8]>>; 4] {
Default::default()
craft_window::desktop::theme_svgs(theme, CaptionIcon::ALL.map(CaptionIcon::theme_name)).map(|file| file.map(Arc::<[u8]>::from))
}
/// Bytes drawing one caption icon may allocate, its target included.
+12 -10
View File
@@ -15,6 +15,7 @@ use crate::primitives::{RectSide, RuleKind};
use crate::runtime::access::Name;
use crate::runtime::egui::pass;
use crate::runtime::env::Env;
use crate::runtime::memory;
use crate::runtime::windows::{self, WindowAction, WindowHost};
use crate::shell::app_shell::RegionBody;
use crate::shell::{Caption, CaptionButton, CaptionIcons, Frame, ShellWords, SlotSize};
@@ -287,14 +288,15 @@ impl Container for TitleBar<'_> {
/// `CaptionIcons::for_desktop` once per desktop value and kept for the app's bars while the desktop stays the same.
fn desktop_icons(ctx: &egui::Context) -> Option<CaptionIcons> {
let desktop = WindowHost::of(ctx).desktop()?;
let key = egui::Id::unique("craft_ui.title_bar.desktop_icons");
let kept = ctx.data(|data| data.get_temp::<(Desktop, Option<CaptionIcons>)>(key));
if let Some((seen, icons)) = &kept
&& *seen == desktop
{
return icons.clone();
}
let icons = CaptionIcons::for_desktop(&desktop, kept.and_then(|(_, icons)| icons));
ctx.data_mut(|data| data.insert_temp(key, (desktop, icons.clone())));
icons
let key = memory::unique("craft_ui.title_bar.desktop_icons");
memory::with_session(ctx, key, |kept: &mut Option<(Desktop, Option<CaptionIcons>)>| {
if let Some((seen, icons)) = kept.as_ref()
&& *seen == desktop
{
return icons.clone();
}
let icons = CaptionIcons::for_desktop(&desktop, kept.take().and_then(|(_, icons)| icons));
*kept = Some((desktop, icons.clone()));
icons
})
}
+17
View File
@@ -50,6 +50,23 @@ impl Desktop {
}
}
/// The SVG file of each freedesktop icon name in `icons`, looked up in icon theme `theme` with its parents and
/// `hicolor` and read only when small (`read_small`). Icon themes are Linux's: elsewhere every entry is `None`.
pub fn theme_svgs<const N: usize>(theme: &str, icons: [&str; N]) -> [Option<Vec<u8>>; N] {
#[cfg(target_os = "linux")]
{
let Some(found) = IconTheme::load(theme, &base_dirs(&|key: &str| std::env::var(key).ok())) else {
return [const { None }; N];
};
icons.map(|icon| found.find_svg(icon).and_then(|path| read_small(&path)))
}
#[cfg(not(target_os = "linux"))]
{
let _ = (theme, icons);
[const { None }; N]
}
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", test))]
/// Compositors and window managers that tile, matched against the `XDG_CURRENT_DESKTOP` entries.
const TILING: &[&str] = &["sway", "hyprland", "i3", "niri", "river", "bspwm", "awesome", "dwl", "qtile", "herbstluftwm", "leftwm", "xmonad", "dwm"];
@@ -1 +1,9 @@
config_version = 1
[[exception]]
name = "pointer-art-sides"
kind = "marker"
rule = "literal-size/vec2"
path = "crates/ui-contract/src/primitives/pointer_art.rs"
reason = "Painted pointers are drawn in points around the hotspot like an OS cursor bitmap; their sides are art data, not layout sizes."
count = 2