mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 07:35:02 +00:00
Thumb rows: a split thumb moves as a pair on every input and with Alt as one half, coinciding halves take the press's side, presses off the thumbs follow the row, and spans mark ranges (C4)
- RowRules: keys, the wheel, AccessKit and resets of a split half move the pair, keeping the spread; Alt (the fine flag on keys, Alt on the wheel) moves the half alone by the plain step. A drag reads Alt in every frame, so holding it mid-drag moves the half alone from where the drag began. The pair's bounds leave out the partner's own order. - A press on coinciding halves takes the half on its side of the tip. - OffThumbs: Jump (levels), Nearest (Blend If: a tap only focuses), Ignore (hue range thumbs). - ThumbSpan bands under the thumbs, for the hue editor's range extents. - BlendIfBar and HueSaturationEditor keep their axis in RTL. - BlendIfRange::moved goes: the thumb row rules replace it.
This commit is contained in:
@@ -222,36 +222,6 @@ impl BlendIfRange {
|
||||
}
|
||||
BlendIfRange(q)
|
||||
}
|
||||
|
||||
/// Handle `handle` (0..4) moved to `to`. `split` (Alt held): only that half moves. Otherwise
|
||||
/// the pair (0 and 1, or 2 and 3) moves by the same amount, keeping its spread, each half
|
||||
/// clamped to 0..=255. Then the order is restored by pushing: handles before `handle` are
|
||||
/// lowered to at most its value, handles after it raised to at least it, and each value
|
||||
/// raised to at least the one before.
|
||||
// pc: crates/ui-egui/src/dialogs/layer_style.rs:1399-1430 (the drag in `blend_if_bar`).
|
||||
pub fn moved(self, handle: usize, to: u8, split: bool) -> BlendIfRange {
|
||||
let Some(¤t) = self.0.get(handle) else {
|
||||
return self;
|
||||
};
|
||||
let mut n = self.0;
|
||||
if split {
|
||||
n[handle] = to;
|
||||
} else {
|
||||
let delta = i16::from(to) - i16::from(current);
|
||||
let pair = if handle < 2 { 0 } else { 2 };
|
||||
for v in &mut n[pair..pair + 2] {
|
||||
*v = u8::try_from((i16::from(*v) + delta).clamp(0, 255)).unwrap_or(*v);
|
||||
}
|
||||
}
|
||||
for i in 0..4 {
|
||||
if i < handle {
|
||||
n[i] = n[i].min(n[handle]);
|
||||
} else if i > handle {
|
||||
n[i] = n[i].max(n[handle]);
|
||||
}
|
||||
}
|
||||
BlendIfRange::ordered(n)
|
||||
}
|
||||
}
|
||||
|
||||
/// The Blend If ranges of one channel entry.
|
||||
|
||||
@@ -76,23 +76,10 @@ fn shadow_drag_uses_whole_degrees_and_pixels_and_moves_the_global_angle() {
|
||||
// The blend defaults of a spec become the host's keys; unknown names stay. Bevel & Emboss has two
|
||||
// Blend fields: only the one defaulting to Multiply is renamed.
|
||||
|
||||
// `BlendIfRange::ordered` and `moved` always give black low ≤ black high ≤ white low ≤ white
|
||||
// high, pushing the other handles.
|
||||
// `BlendIfRange::ordered` raises each value to at least the one before it.
|
||||
#[trial]
|
||||
fn blend_if_edits_keep_the_four_values_ordered() {
|
||||
fn blend_if_ranges_read_ordered() {
|
||||
assert_eq!(BlendIfRange::ordered([10, 5, 200, 100]), BlendIfRange([10, 10, 200, 200]));
|
||||
let start = BlendIfRange([10, 30, 200, 220]);
|
||||
for handle in 0..4 {
|
||||
for to in (0..=255u8).step_by(5) {
|
||||
for split in [false, true] {
|
||||
let r = start.moved(handle, to, split).0;
|
||||
assert!(r.windows(2).all(|w| w[0] <= w[1]), "{handle} {to} {split}: {r:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
// A split move past a neighbour pushes it.
|
||||
assert_eq!(start.moved(1, 210, true), BlendIfRange([10, 210, 210, 220]));
|
||||
assert_eq!(start.moved(9, 0, false), start);
|
||||
}
|
||||
|
||||
// A `StyleValue::Other` key no field shows survives `set_param`, `toggle` and
|
||||
|
||||
@@ -13,7 +13,7 @@ use craft_ui::form::Field;
|
||||
use craft_ui::pickers::Select;
|
||||
use craft_ui::runtime::env::{Env, Label, UnitKind};
|
||||
use craft_ui::style::{DataColor, TypeRole};
|
||||
use craft_ui::value_drag::{Anchor, Thumb, ThumbRow, TrackFace};
|
||||
use craft_ui::value_drag::{Anchor, OffThumbs, SpanInk, Thumb, ThumbRow, ThumbSpan, TrackFace};
|
||||
use egui::{Color32, Ui};
|
||||
|
||||
use super::sliders::{Run, editor_group, lifted, read, words};
|
||||
@@ -35,6 +35,8 @@ const COLORIZE_SATURATION: f64 = 25.0;
|
||||
const TURN: f64 = 360.0;
|
||||
/// The most a range spans: the end thumb is at most this far past the start.
|
||||
const MAX_SPAN: f64 = 359.0;
|
||||
/// The bands under a range's thumbs: the whole range faint, its full-strength part muted.
|
||||
const RANGE_SPANS: [ThumbSpan; 2] = [ThumbSpan::new(0, 3, SpanInk::Faint), ThumbSpan::new(1, 2, SpanInk::Muted)];
|
||||
|
||||
/// One of Hue/Saturation's six colour ranges (Reds, Yellows, Greens, Cyans, Blues, Magentas).
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
@@ -251,8 +253,9 @@ impl std::ops::Deref for HueSaturationOutput {
|
||||
/// [`adjusted_spectrum`](Self::adjusted_spectrum) below (the same 37 hues after the adjustment; the input bar again
|
||||
/// without it). Not mirrored in right-to-left layouts: they are scales of the image.
|
||||
/// - **Range thumbs** (a range shown): four thumbs under the lower bar as one thumb row that wraps through 0° and keeps
|
||||
/// its order going round from the first thumb. A drag moves a thumb with [`HueRangeValue::move_bound`], whole
|
||||
/// degrees. Under the bars a readout "a° / b° · c° \ d°", each bound within one turn.
|
||||
/// its order going round from the first thumb, over a faint band from the first thumb to the last and a muted one
|
||||
/// between the middle two. A drag on a thumb moves it with [`HueRangeValue::move_bound`], whole degrees; a press
|
||||
/// off the thumbs does nothing. The row is not mirrored either. Under the bars a readout "a° / b° · c° \ d°", each bound within one turn.
|
||||
#[must_use = "show the editor with `show`"]
|
||||
#[derive(Pattern)]
|
||||
pub struct HueSaturationEditor<'a> {
|
||||
@@ -377,8 +380,11 @@ impl<'a> HueSaturationEditor<'a> {
|
||||
.step(1.0)
|
||||
.anchor(Anchor::new(0, MAX_SPAN))
|
||||
.thumbs(thumbs)
|
||||
.off_thumbs(OffThumbs::Ignore)
|
||||
.spans(&RANGE_SPANS)
|
||||
.track_face(TrackFace::new(ToneRamp::new(&after)))
|
||||
.label(words.spectrum_after.clone())
|
||||
.ltr_axis()
|
||||
.show(ui)
|
||||
.edit;
|
||||
run.push(cx, row, move |now: &HueSaturation, row: &[Mixed<f64>; 4]| now.with_thumbs(r, row));
|
||||
|
||||
@@ -10,7 +10,7 @@ use craft_ui::layout::RowAlign;
|
||||
use craft_ui::layout_components::{Row, Stack};
|
||||
use craft_ui::runtime::env::{Env, Label};
|
||||
use craft_ui::style::{DataColor, TypeRole};
|
||||
use craft_ui::value_drag::{Neighbours, Order, Thumb, ThumbRow, TrackFace};
|
||||
use craft_ui::value_drag::{Neighbours, OffThumbs, Order, Thumb, ThumbRow, TrackFace};
|
||||
use egui::{Color32, Ui};
|
||||
|
||||
use crate::layer_style::BlendIfRange;
|
||||
@@ -61,11 +61,14 @@ impl BlendIfRange {
|
||||
/// A Blend If slider: a black-to-white ramp with a black and a white handle under it, each split into two halves by
|
||||
/// Alt (the layer fades between them). A split pair shows two half triangles; a pair whose halves coincide, one whole
|
||||
/// triangle. The readout ("0 / 20 255": a split side as "low / high") sits above the bar at the trailing end. The
|
||||
/// bar mirrors with the row, like every thumb row.
|
||||
/// bar never mirrors: it is a tone scale.
|
||||
///
|
||||
/// - Pointer: a press picks the nearest handle; a drag moves its pair, keeping the spread, or with Alt the half alone.
|
||||
/// A handle pushes the handles it runs into along, so the order holds. One gesture per drag; Esc cancels.
|
||||
/// - Keys: the four handles are Tab stops in order. Arrows, Page keys, Home, End and the wheel move one half.
|
||||
/// - Pointer: a press picks the nearest handle, and on a triangle of coinciding halves the half on its side of the
|
||||
/// tip. A drag moves the handle's pair to the pointer, keeping the spread; while Alt is held, the half alone. A
|
||||
/// handle pushes the handles it runs into along, so the order holds. One gesture per drag; Esc cancels. A tap
|
||||
/// focuses the nearest handle and moves nothing.
|
||||
/// - Keys: the four handles are Tab stops in order. Arrows, Page keys, Home, End and the wheel move the focused
|
||||
/// handle's pair, Shift by ten levels; with Alt the focused half alone.
|
||||
/// - AccessKit: each handle is a slider named by [`BlendIfWords::handle`] ("Black low, This Layer").
|
||||
#[must_use = "show the bar with `show`"]
|
||||
#[derive(craft_ui::contract::Pattern)]
|
||||
@@ -120,8 +123,10 @@ impl<'a> BlendIfBar<'a> {
|
||||
.step(1.0)
|
||||
.thumbs(thumbs)
|
||||
.neighbours(Neighbours::Push)
|
||||
.off_thumbs(OffThumbs::Nearest)
|
||||
.track_face(TrackFace::new(ToneRamp::new(&ramp)))
|
||||
.label(label.clone())
|
||||
.ltr_axis()
|
||||
.show(ui)
|
||||
.edit
|
||||
.map(|row| BlendIfRange::of_row(&row));
|
||||
|
||||
@@ -12,6 +12,9 @@ pub use angle_dial::{AngleDial, AngleDialStyle, AngleOrientation};
|
||||
pub use point_picker::{Backdrop, PointPicker, PointPickerStyle, PointPickerWords};
|
||||
pub use range_slider::{RangeSlider, RangeSliderStyle};
|
||||
pub use slider::{Slider, SliderStyle, SliderThumb};
|
||||
pub use thumb_row::{Anchor, Follow, Neighbours, Order, RowOp, RowRules, Thumb, ThumbHold, ThumbOp, ThumbRow, ThumbRowOutput, ThumbRowStyle};
|
||||
pub use thumb_row::{
|
||||
Anchor, Follow, Neighbours, OffThumbs, Order, RowOp, RowRules, SpanInk, Thumb, ThumbHold, ThumbOp, ThumbRow, ThumbRowOutput, ThumbRowStyle,
|
||||
ThumbSpan,
|
||||
};
|
||||
pub use track::{SliderScale, TrackFace};
|
||||
pub use words::ValueDragWords;
|
||||
|
||||
@@ -2,10 +2,11 @@
|
||||
//! editor do. One leaf with a focusable thumb part per value. A press on a thumb grabs it and a drag moves it by the
|
||||
//! pointer's travel; a press elsewhere on the row jumps the nearest thumb there; arrows, the wheel and AccessKit step
|
||||
//! the focused thumb. Each value is mixed or not on its own. The row's rules (order, wrap, split halves) are
|
||||
//! `RowRules`.
|
||||
//! `RowRules`; what a press off the thumbs does is the row's [`OffThumbs`].
|
||||
//!
|
||||
//! Alt keeps the meaning it has in Photoshop's levels: a drag that begins with Alt held moves one half of a split
|
||||
//! thumb alone, at full rate. On a thumb that is not split, Alt scales a drag finer as on every value control.
|
||||
//! Alt keeps the meaning it has in Photoshop's Blend If: on a split thumb it moves one half alone, at full rate on a
|
||||
//! drag (from the moment it is held) and by the plain step on a key or the wheel; without it the pair moves together.
|
||||
//! On a thumb that is not split, Alt scales a move finer as on every value control.
|
||||
|
||||
use super::track::{self, Pick, Press, Scale, SliderScale, ThumbRing, TrackFace, Travel, travel};
|
||||
use super::words::ValueDragWords;
|
||||
@@ -25,7 +26,7 @@ use craft_behavior::{
|
||||
};
|
||||
use craft_keymap::Mods;
|
||||
use craft_theme::{Rgba, Stateful, States};
|
||||
use egui::{Pos2, Rangef, Rect, Vec2, pos2};
|
||||
use egui::{CornerRadius, Pos2, Rangef, Rect, Vec2, pos2};
|
||||
use std::ops::RangeInclusive;
|
||||
|
||||
#[cfg(feature = "testing")]
|
||||
@@ -56,6 +57,12 @@ pub struct ThumbRowStyle {
|
||||
track: TrackLook,
|
||||
/// The length a row asks for along its axis.
|
||||
length: f32,
|
||||
/// The ink of a [`SpanInk::Faint`] span.
|
||||
span_faint: StyleColor,
|
||||
/// The ink of a [`SpanInk::Muted`] span.
|
||||
span_muted: StyleColor,
|
||||
/// The thickness of a span.
|
||||
span: f32,
|
||||
}
|
||||
|
||||
/// How a thumb's value is kept among the row's other values.
|
||||
@@ -95,6 +102,49 @@ pub enum Neighbours {
|
||||
Push,
|
||||
}
|
||||
|
||||
/// What a press off the thumbs does: one beyond the reach of every thumb.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
#[non_exhaustive]
|
||||
pub enum OffThumbs {
|
||||
/// The nearest thumb jumps to the pointer, on a tap and on a drag: a levels row.
|
||||
#[default]
|
||||
Jump,
|
||||
/// A drag takes the nearest thumb to the pointer; a tap only focuses it: a Blend If bar.
|
||||
Nearest,
|
||||
/// Nothing: only a press on a thumb moves one. The range thumbs of a hue editor.
|
||||
Ignore,
|
||||
}
|
||||
|
||||
/// The ink of a [`ThumbSpan`].
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
#[non_exhaustive]
|
||||
pub enum SpanInk {
|
||||
/// The theme's faint text colour.
|
||||
Faint,
|
||||
/// The theme's muted text colour.
|
||||
Muted,
|
||||
}
|
||||
|
||||
/// A band along the row from one thumb to another, under the thumbs' tips: the extent of a hue range and of its
|
||||
/// full-strength part. In a wrapping row it runs forward from `from` round to `to`.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
#[non_exhaustive]
|
||||
pub struct ThumbSpan {
|
||||
/// The thumb the span starts at.
|
||||
pub from: usize,
|
||||
/// The thumb the span ends at.
|
||||
pub to: usize,
|
||||
/// Its ink.
|
||||
pub ink: SpanInk,
|
||||
}
|
||||
|
||||
impl ThumbSpan {
|
||||
/// A span from thumb `from` to thumb `to` in `ink`.
|
||||
pub const fn new(from: usize, to: usize, ink: SpanInk) -> Self {
|
||||
ThumbSpan { from, to, ink }
|
||||
}
|
||||
}
|
||||
|
||||
/// Where a thumb sits that a function of the row's values places (a levels gamma thumb, between the black and the
|
||||
/// white one). Both functions get the row's values as drawn.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
@@ -191,9 +241,11 @@ impl Thumb {
|
||||
/// drawn as the left half of a triangle; the next one only brings its own face, range and order. The pair's
|
||||
/// values `[low, high]` sit in consecutive entries with `low <= high`.
|
||||
///
|
||||
/// A press that begins without Alt moves the pair together, keeping the spread; with Alt it moves only the half
|
||||
/// it grabs, at full rate (Alt is not the fine scale on that drag). Where the halves coincide they draw as one triangle. Keys, the wheel and AccessKit move one half. A
|
||||
/// row does not combine a split thumb with wrapping.
|
||||
/// A drag, a key, the wheel and an AccessKit change of either half move the pair together, keeping the spread.
|
||||
/// While Alt is held a drag moves only the half it grabs, at full rate, and a key or the wheel moves the focused
|
||||
/// half alone by the plain step: Alt is not the fine scale on a split thumb. Where the halves coincide they draw
|
||||
/// as one triangle, and a press takes the half on its side of the tip. A row does not combine a split thumb with
|
||||
/// wrapping.
|
||||
#[must_use]
|
||||
pub fn split(mut self) -> Self {
|
||||
self.split = true;
|
||||
@@ -313,6 +365,11 @@ impl<const N: usize> RowRules<'_, N> {
|
||||
/// Where thumb `i` may go among the thumbs it is ordered with, which are at `values`. In a wrapping row the
|
||||
/// bounds are measured the short way round from the thumb's own value, and open where it has no neighbour.
|
||||
fn order_bounds(&self, values: &[f64; N], i: usize) -> (f64, f64) {
|
||||
self.order_bounds_besides(values, i, None)
|
||||
}
|
||||
|
||||
/// [`order_bounds`](Self::order_bounds), with thumb `except` not counted: it moves with thumb `i`.
|
||||
fn order_bounds_besides(&self, values: &[f64; N], i: usize, except: Option<usize>) -> (f64, f64) {
|
||||
if let Some(anchor) = self.anchored {
|
||||
return self.anchored_bounds(values, i, anchor);
|
||||
}
|
||||
@@ -324,7 +381,7 @@ impl<const N: usize> RowRules<'_, N> {
|
||||
}
|
||||
let Order::Between { below, above, gap } = self.thumbs[i].order else { return open };
|
||||
let side = |j: Option<usize>, gap: f64, end: f64| {
|
||||
j.and_then(|j| values.get(j)).map_or(end, |v| {
|
||||
j.filter(|j| Some(*j) != except).and_then(|j| values.get(j)).map_or(end, |v| {
|
||||
if self.wrap.is_some() { values[i] + self.short(v - values[i]) + gap } else { (v + gap).clamp(scale.min, scale.max) }
|
||||
})
|
||||
};
|
||||
@@ -461,10 +518,49 @@ impl<const N: usize> RowRules<'_, N> {
|
||||
(lo, hi)
|
||||
}
|
||||
|
||||
/// The bounds AccessKit reports for thumb `i`: the range of a wrapping row, else [`bounds`](Self::bounds).
|
||||
/// Where thumb `i` may go when its split partner `j` moves with it, keeping the spread: within its own bounds
|
||||
/// among the other thumbs while the partner stays within its own.
|
||||
fn pair_bounds(&self, values: &[f64; N], i: usize, j: usize) -> (f64, f64) {
|
||||
let (lo_i, hi_i) = self.order_bounds_besides(values, i, Some(j));
|
||||
let (lo_j, hi_j) = self.order_bounds_besides(values, j, Some(i));
|
||||
let hi = (hi_i - values[i]).min(hi_j - values[j]);
|
||||
let lo = (lo_i - values[i]).max(lo_j - values[j]).min(hi);
|
||||
(values[i] + lo, values[i] + hi)
|
||||
}
|
||||
|
||||
/// The split partner a move of thumb `i` takes along: none when the thumb is not split or moves `alone`.
|
||||
fn taken_along(&self, i: usize, alone: bool) -> Option<usize> {
|
||||
self.partner(i).filter(|_| !alone)
|
||||
}
|
||||
|
||||
/// Where a move of thumb `i` may take it: with its partner, if it takes one, or else alone among the others.
|
||||
fn move_bounds(&self, values: &[f64; N], i: usize, alone: bool) -> (f64, f64) {
|
||||
match self.taken_along(i, alone) {
|
||||
Some(j) => self.pair_bounds(values, i, j),
|
||||
None => self.bounds(values, i),
|
||||
}
|
||||
}
|
||||
|
||||
/// `row`, whose values are drawn at `values`, with thumb `i` moved to `to_i`, a value settled within its
|
||||
/// [`move_bounds`](Self::move_bounds): a split half takes its partner along by the same amount unless it moves
|
||||
/// `alone`, and the thumbs they run into are pushed along.
|
||||
fn moved_to(&self, row: &[Mixed<f64>; N], values: &[f64; N], i: usize, to_i: f64, alone: bool) -> [Mixed<f64>; N] {
|
||||
let mut to = *values;
|
||||
to[i] = to_i;
|
||||
match self.taken_along(i, alone) {
|
||||
Some(j) => {
|
||||
to[j] = values[j] + (to[i] - values[i]);
|
||||
self.with_moved(row, to, &[i, j])
|
||||
}
|
||||
None => self.with_moved(row, to, &[i]),
|
||||
}
|
||||
}
|
||||
|
||||
/// The bounds AccessKit reports for thumb `i`: the range of a wrapping row, else where a change of its value may
|
||||
/// take it (a split half with its partner).
|
||||
fn reported_bounds(&self, values: &[f64; N], i: usize) -> (f64, f64) {
|
||||
let scale = self.scale_of(i);
|
||||
if self.wrap.is_some() { (scale.min, scale.max) } else { self.bounds(values, i) }
|
||||
if self.wrap.is_some() { (scale.min, scale.max) } else { self.move_bounds(values, i, false) }
|
||||
}
|
||||
|
||||
/// `value` for thumb `i`: within `bounds` and on its stops; in a wrapping row, then wrapped.
|
||||
@@ -479,13 +575,25 @@ impl<const N: usize> RowRules<'_, N> {
|
||||
|
||||
/// `row` with `op` applied to its thumb: from where the thumb is drawn (an unset or mixed thumb steps from where
|
||||
/// it sits), on its stops and within its bounds among the others, so the order and the gap hold. The thumb takes
|
||||
/// a number; the other thumbs keep `row`'s values, mixed or not.
|
||||
/// a number; the other thumbs keep `row`'s values, mixed or not. On a half of a split thumb the op moves the pair,
|
||||
/// keeping the spread; a move with the fine flag (Alt) or a wheel event with Alt moves the half alone, by the
|
||||
/// plain step.
|
||||
pub fn apply(&self, op: &RowOp, row: &[Mixed<f64>; N]) -> [Mixed<f64>; N] {
|
||||
let values = self.placed(row);
|
||||
let i = op.thumb;
|
||||
let mut to = values;
|
||||
to[i] = if self.wrap.is_some() { self.apply_wrapped(&op.op, &values, i) } else { self.apply_plain(&op.op, &values, i) };
|
||||
self.with_moved(row, to, &[i])
|
||||
let (op, alone) = match (self.partner(i), op.op) {
|
||||
(None, op) => (op, false),
|
||||
(Some(_), ThumbOp::Move(mv, mods)) => (ThumbOp::Move(mv, mods.fine(false)), mods.fine),
|
||||
(Some(_), ThumbOp::Wheel(wheel, rtl)) => {
|
||||
let mut plain = wheel;
|
||||
plain.mods.alt = false;
|
||||
(ThumbOp::Wheel(plain, rtl), wheel.mods.alt)
|
||||
}
|
||||
(Some(_), op @ ThumbOp::Set(_)) => (op, false),
|
||||
};
|
||||
let bounds = self.move_bounds(&values, i, alone);
|
||||
let to = if self.wrap.is_some() { self.apply_wrapped(&op, &values, i, bounds) } else { self.apply_plain(&op, &values, i, bounds) };
|
||||
self.moved_to(row, &values, i, to, alone)
|
||||
}
|
||||
|
||||
/// What `op` does to the step maths: a move or a wheel event gives the new value from `steps`.
|
||||
@@ -497,9 +605,9 @@ impl<const N: usize> RowRules<'_, N> {
|
||||
}
|
||||
}
|
||||
|
||||
fn apply_plain(&self, op: &ThumbOp, values: &[f64; N], i: usize) -> f64 {
|
||||
/// The value `op` gives thumb `i`, which may go within `bounds`.
|
||||
fn apply_plain(&self, op: &ThumbOp, values: &[f64; N], i: usize, bounds: (f64, f64)) -> f64 {
|
||||
let scale = self.scale_of(i);
|
||||
let bounds = self.bounds(values, i);
|
||||
let small = scale.small();
|
||||
let steps = ValueSteps::new(values[i], bounds.0, bounds.1, small, small * LARGE_STEPS);
|
||||
match Self::stepped(op, &steps) {
|
||||
@@ -511,9 +619,8 @@ impl<const N: usize> RowRules<'_, N> {
|
||||
/// [`apply_plain`](Self::apply_plain) for a wrapping row: a step goes on past the range's end and comes back at
|
||||
/// its start, and Home and End go to the neighbours, or the range's start and its end less a step where there
|
||||
/// are none.
|
||||
fn apply_wrapped(&self, op: &ThumbOp, values: &[f64; N], i: usize) -> f64 {
|
||||
fn apply_wrapped(&self, op: &ThumbOp, values: &[f64; N], i: usize, bounds: (f64, f64)) -> f64 {
|
||||
let scale = self.scale_of(i);
|
||||
let bounds = self.bounds(values, i);
|
||||
let from = if self.anchored.is_some() { self.aim(values, i, values[i]) } else { values[i] };
|
||||
let target = match op {
|
||||
ThumbOp::Set(value) => self.aim(values, i, *value),
|
||||
@@ -542,10 +649,11 @@ struct Layout<'r, const N: usize> {
|
||||
pick: Pick,
|
||||
/// The press moves only the half of a split thumb it grabs.
|
||||
alone: bool,
|
||||
off: OffThumbs,
|
||||
}
|
||||
|
||||
impl<'r, const N: usize> Layout<'r, N> {
|
||||
fn new(rules: RowRules<'r, N>, rect: Rect, thumb: Vec2, rtl: bool, reach: f32, alone: bool) -> Self {
|
||||
fn new(rules: RowRules<'r, N>, rect: Rect, thumb: Vec2, rtl: bool, reach: f32, alone: bool, off: OffThumbs) -> Self {
|
||||
let travel = travel(rect, thumb.x);
|
||||
let (left, right) = (travel.min, travel.max);
|
||||
// A wrapping row's period in points; 0 when the row does not wrap.
|
||||
@@ -553,7 +661,7 @@ impl<'r, const N: usize> Layout<'r, N> {
|
||||
Some(period) if rules.scale.span() > 0.0 => ((right - left) as f64 * period / rules.scale.span()) as f32,
|
||||
_ => 0.0,
|
||||
};
|
||||
Layout { rules, left, right, rtl, pick: Pick { reach, overlap: thumb.x, period, span: false }, alone }
|
||||
Layout { rules, left, right, rtl, pick: Pick { reach, overlap: thumb.x, period, span: false }, alone, off }
|
||||
}
|
||||
|
||||
fn x_of(&self, value: f64) -> f32 {
|
||||
@@ -570,9 +678,49 @@ impl<'r, const N: usize> Layout<'r, N> {
|
||||
std::array::from_fn(|i| self.x_of(self.at(values, i)))
|
||||
}
|
||||
|
||||
/// What a press at `x` moves, with the thumbs at `values`.
|
||||
/// What a press at `x` moves, with the thumbs at `values`: none off the thumbs in a row that ignores such a
|
||||
/// press.
|
||||
fn press(&self, values: &[f64; N], x: f32) -> Option<Press> {
|
||||
self.pick.press(&self.xs(values), x)
|
||||
let xs = self.xs(values);
|
||||
let press = self.side_of_tip(self.pick.press(&xs, x)?, &xs, x);
|
||||
match (press, self.off) {
|
||||
(Press::Jump(_), OffThumbs::Ignore) => None,
|
||||
_ => Some(press),
|
||||
}
|
||||
}
|
||||
|
||||
/// `press` on a split thumb whose halves coincide, drawn as one triangle at `xs`, as a press on the half on the
|
||||
/// side of the tip where `x` is: the low half toward the lower values. Other presses are as they are.
|
||||
fn side_of_tip(&self, press: Press, xs: &[f32; N], x: f32) -> Press {
|
||||
let pair = match press {
|
||||
Press::Either { first, last } => Some((first, last)),
|
||||
Press::Grab(i) | Press::Jump(i) => self.rules.partner(i).map(|j| (i.min(j), i.max(j))),
|
||||
Press::Span => None,
|
||||
};
|
||||
let Some((low, high)) = pair.filter(|&(low, high)| self.rules.partner(low) == Some(high) && xs[low] == xs[high]) else {
|
||||
return press;
|
||||
};
|
||||
let toward_low = if self.rtl { x > xs[low] } else { x <= xs[low] };
|
||||
let half = if toward_low { low } else { high };
|
||||
if let Press::Jump(_) = press { Press::Jump(half) } else { Press::Grab(half) }
|
||||
}
|
||||
|
||||
/// The pieces of `span` along the row, as x ranges: between its thumbs, and in a wrapping row forward from the
|
||||
/// first round to the second, in two pieces when that passes the end of the range.
|
||||
fn span_xs(&self, values: &[f64; N], span: &ThumbSpan) -> Vec<(f32, f32)> {
|
||||
if span.from >= N || span.to >= N {
|
||||
return Vec::new();
|
||||
}
|
||||
let (a, b) = (self.at(values, span.from), self.at(values, span.to));
|
||||
let scale = &self.rules.scale;
|
||||
let pieces = if self.rules.wrap.is_some() && b < a { vec![(a, scale.max), (scale.min, b)] } else { vec![(a.min(b), a.max(b))] };
|
||||
pieces
|
||||
.into_iter()
|
||||
.map(|(lo, hi)| {
|
||||
let (x, y) = (self.x_of(lo), self.x_of(hi));
|
||||
(x.min(y), x.max(y))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The values with `press` dragged to the position `state` holds: the moved thumb from where it was at `anchor`
|
||||
@@ -592,7 +740,6 @@ impl<'r, const N: usize> Layout<'r, N> {
|
||||
let from = rules.placed(anchor);
|
||||
let placed_at = if rules.anchored.is_some() { rules.aim(&from, i, self.at(&from, i)) } else { self.at(&from, i) };
|
||||
let travel = Travel { track: self.left..self.right, units: rules.scale.min..=rules.scale.max, rtl: self.rtl };
|
||||
let half = rules.partner(i).filter(|_| !self.alone);
|
||||
// Alt moves one half of a split thumb alone: that drag is not scaled finer.
|
||||
let fine = !click && !rules.thumbs[i].alt_reports && !(self.alone && rules.partner(i).is_some());
|
||||
let Some(at) = travel.value(press, placed_at, state, fine) else { return out };
|
||||
@@ -605,20 +752,8 @@ impl<'r, const N: usize> Layout<'r, N> {
|
||||
} else {
|
||||
from[i] + rules.short(value - from[i])
|
||||
};
|
||||
if let Some(j) = half {
|
||||
let (lo_i, hi_i) = rules.order_bounds(&from, i);
|
||||
let (lo_j, hi_j) = rules.order_bounds(&from, j);
|
||||
let (lo, hi) = ((lo_i - from[i]).max(lo_j - from[j]), (hi_i - from[i]).min(hi_j - from[j]));
|
||||
let lo = lo.min(hi);
|
||||
let moved = rules.scale_of(i).snap(from[i] + (value - from[i]).clamp(lo, hi)).clamp(from[i] + lo, from[i] + hi);
|
||||
let mut to = from;
|
||||
to[i] = moved;
|
||||
to[j] = from[j] + (moved - from[i]);
|
||||
return rules.with_moved(anchor, to, &[i, j]);
|
||||
}
|
||||
let mut to = from;
|
||||
to[i] = rules.settle(i, value, rules.bounds(&from, i));
|
||||
rules.with_moved(anchor, to, &[i])
|
||||
let to = rules.settle(i, value, rules.move_bounds(&from, i, self.alone));
|
||||
rules.moved_to(anchor, &from, i, to, self.alone)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -646,12 +781,11 @@ fn triangle(tip: Pos2, size: Vec2, half: Option<Half>, rtl: bool) -> Vec<Pos2> {
|
||||
vec![tip, pos2(right, tip.y + size.y), pos2(left, tip.y + size.y)]
|
||||
}
|
||||
|
||||
/// The values of the running drag when it began, the press it resolved to, and whether it moves a half alone.
|
||||
/// The values of the running drag when it began and the press it resolved to.
|
||||
#[derive(Clone, Default)]
|
||||
struct Held {
|
||||
anchor: Vec<Mixed<f64>>,
|
||||
press: Option<Press>,
|
||||
alone: bool,
|
||||
/// The thumb the pointer moves now, and the modifiers held in the latest pass of the drag.
|
||||
thumb: Option<usize>,
|
||||
mods: Mods,
|
||||
@@ -736,6 +870,12 @@ pub struct ThumbRow<'a, const N: usize> {
|
||||
/// What a thumb does when a move takes it into a thumb it is ordered with: stop (the default) or push it along.
|
||||
#[prop]
|
||||
neighbours: Neighbours,
|
||||
/// What a press off the thumbs does: the nearest thumb jumps there (the default), only takes a drag, or nothing.
|
||||
#[prop]
|
||||
off_thumbs: OffThumbs,
|
||||
/// Bands along the row between thumbs, under their tips; none by default.
|
||||
#[prop]
|
||||
spans: &'a [ThumbSpan],
|
||||
/// Paints a groove above the thumbs with `face`, a component shown as the look of the track (a colour gradient);
|
||||
/// the thumbs point up at it.
|
||||
#[prop]
|
||||
@@ -773,6 +913,8 @@ impl<'a, const N: usize> ThumbRow<'a, N> {
|
||||
wrap: false,
|
||||
anchor: None,
|
||||
neighbours: Neighbours::Stop,
|
||||
off_thumbs: OffThumbs::Jump,
|
||||
spans: &[],
|
||||
track_face: None,
|
||||
}
|
||||
}
|
||||
@@ -817,6 +959,9 @@ impl<const N: usize> Component for ThumbRow<'_, N> {
|
||||
thumb: Vec2::new(cx.tokens.size.marker.width, cx.tokens.size.marker.height),
|
||||
track: TrackLook { thickness: cx.tokens.size.ramp.bar, ..cx.track() },
|
||||
length,
|
||||
span_faint: cx.color(colors.text.faint),
|
||||
span_muted: cx.color(colors.text.muted),
|
||||
span: cx.tokens.size.ramp.groove,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -848,7 +993,7 @@ impl<const N: usize> Component for ThumbRow<'_, N> {
|
||||
let row = cx.value().cloned().unwrap_or_else(all_mixed);
|
||||
let shown = rules.placed(&row);
|
||||
let size = cx.style.thumb;
|
||||
let layout = Layout::new(rules, rect, size, cx.flow.is_rtl(), 0.0, false);
|
||||
let layout = Layout::new(rules, rect, size, cx.flow.is_rtl(), 0.0, false, self.off_thumbs);
|
||||
let xs = layout.xs(&shown);
|
||||
let groove = self.track_face.is_some().then_some(cx.style.track.thickness);
|
||||
let thumbs = band(rect, groove);
|
||||
@@ -882,7 +1027,7 @@ impl<const N: usize> Component for ThumbRow<'_, N> {
|
||||
|
||||
fn update(&mut self, cx: &mut Cx<'_, Self>) {
|
||||
let rules = self.rules();
|
||||
let (rect, rtl, reach) = (cx.rect, cx.flow.is_rtl(), cx.style.hit);
|
||||
let (rect, rtl, reach, off) = (cx.rect, cx.flow.is_rtl(), cx.style.hit, self.off_thumbs);
|
||||
let size = cx.style.thumb;
|
||||
let row = cx.value().cloned().unwrap_or_else(all_mixed);
|
||||
let parts: Vec<PartRef> = std::iter::once(PartRef::from(ROW)).chain((0..N).map(|i| Thumb::PART.at(i as u64))).collect();
|
||||
@@ -890,10 +1035,11 @@ impl<const N: usize> Component for ThumbRow<'_, N> {
|
||||
let press = cx.part(part).press;
|
||||
match press.phase {
|
||||
PressPhase::DragStart { start, pos, .. } => {
|
||||
let layout = Layout::new(rules, rect, size, rtl, reach, press.mods.alt);
|
||||
// Alt moves a half of a split thumb alone while it is held, from the values the drag began at.
|
||||
let layout = Layout::new(rules, rect, size, rtl, reach, press.mods.alt, off);
|
||||
if let Some(picked) = layout.press(&rules.placed(&row), start.origin.x) {
|
||||
let thumb = picked.thumb(start.origin.x, pos.x);
|
||||
*cx.memory::<Held>() = Held { anchor: row.to_vec(), press: Some(picked), alone: press.mods.alt, thumb, mods: press.mods };
|
||||
*cx.memory::<Held>() = Held { anchor: row.to_vec(), press: Some(picked), thumb, mods: press.mods };
|
||||
if let Some(thumb) = thumb {
|
||||
cx.focus_part(Thumb::PART.at(thumb as u64));
|
||||
}
|
||||
@@ -909,7 +1055,7 @@ impl<const N: usize> Component for ThumbRow<'_, N> {
|
||||
now.mods = press.mods;
|
||||
}
|
||||
if let (Some(picked), Ok(anchor)) = (held.press, <[Mixed<f64>; N]>::try_from(held.anchor)) {
|
||||
let layout = Layout::new(rules, rect, size, rtl, reach, held.alone);
|
||||
let layout = Layout::new(rules, rect, size, rtl, reach, press.mods.alt, off);
|
||||
cx.propose(layout.moved(&anchor, picked, &press, false));
|
||||
}
|
||||
}
|
||||
@@ -917,18 +1063,20 @@ impl<const N: usize> Component for ThumbRow<'_, N> {
|
||||
if cx.gesture().is_some() {
|
||||
let held = cx.memory::<Held>().clone();
|
||||
if let (Some(picked), Ok(anchor)) = (held.press, <[Mixed<f64>; N]>::try_from(held.anchor)) {
|
||||
let layout = Layout::new(rules, rect, size, rtl, reach, held.alone);
|
||||
let layout = Layout::new(rules, rect, size, rtl, reach, press.mods.alt, off);
|
||||
cx.propose(layout.moved(&anchor, picked, &press, false));
|
||||
}
|
||||
cx.commit();
|
||||
} else if click && start.clicks < 2 {
|
||||
// A tap off the thumbs moves the nearest one there; a tap on a thumb moves none. A second
|
||||
// click is the reset, which the pipeline applies.
|
||||
let layout = Layout::new(rules, rect, size, rtl, reach, false);
|
||||
if let Some(picked @ Press::Jump(thumb)) = layout.press(&rules.placed(&row), start.origin.x)
|
||||
&& let Some(&target) = layout.moved(&row, picked, &press, true)[thumb].same()
|
||||
{
|
||||
cx.set(rules.apply(&RowOp::new(thumb, ThumbOp::Set(target)), &row));
|
||||
// A tap off the thumbs focuses the nearest one and, in a row whose thumbs jump, moves it there;
|
||||
// a tap on a thumb moves none. A second click is the reset, which the pipeline applies.
|
||||
let layout = Layout::new(rules, rect, size, rtl, reach, false, off);
|
||||
if let Some(picked @ Press::Jump(thumb)) = layout.press(&rules.placed(&row), start.origin.x) {
|
||||
if off == OffThumbs::Jump
|
||||
&& let Some(&target) = layout.moved(&row, picked, &press, true)[thumb].same()
|
||||
{
|
||||
cx.set(rules.apply(&RowOp::new(thumb, ThumbOp::Set(target)), &row));
|
||||
}
|
||||
cx.focus_part(Thumb::PART.at(thumb as u64));
|
||||
}
|
||||
}
|
||||
@@ -1001,7 +1149,7 @@ impl<const N: usize> Component for ThumbRow<'_, N> {
|
||||
let row = cx.value().cloned().unwrap_or_else(all_mixed);
|
||||
let shown = rules.placed(&row);
|
||||
let size = style.thumb;
|
||||
let layout = Layout::new(rules, cx.rect, size, cx.flow.is_rtl(), style.hit, false);
|
||||
let layout = Layout::new(rules, cx.rect, size, cx.flow.is_rtl(), style.hit, false, self.off_thumbs);
|
||||
let xs = layout.xs(&shown);
|
||||
let running = cx.gesture().and_then(|_| cx.recall::<Held>().press);
|
||||
let hovered = std::iter::once(PartRef::from(ROW))
|
||||
@@ -1011,6 +1159,15 @@ impl<const N: usize> Component for ThumbRow<'_, N> {
|
||||
let thumbs = band(cx.rect, self.track_face.is_some().then_some(style.track.thickness));
|
||||
let top = thumbs.top();
|
||||
let halves = self.halves(&rules, &shown);
|
||||
for span in self.spans {
|
||||
let ink = match span.ink {
|
||||
SpanInk::Faint => style.span_faint,
|
||||
SpanInk::Muted => style.span_muted,
|
||||
};
|
||||
for (left, right) in layout.span_xs(&shown, span) {
|
||||
draw.fill(&PaintShape::Rect(Rect::from_x_y_ranges(left..=right, top..=top + style.span), CornerRadius::ZERO), ink);
|
||||
}
|
||||
}
|
||||
for i in 0..N {
|
||||
// Coinciding halves are one triangle, which the low half draws.
|
||||
if halves[i].is_none() && rules.partner(i).is_some_and(|j| j < i) {
|
||||
|
||||
@@ -1,9 +1,12 @@
|
||||
//! `ThumbRow` rules: the order thumbs keep, split halves, wrapping.
|
||||
//! `ThumbRow` rules: the order thumbs keep, split halves, wrapping; and what a press on the row moves.
|
||||
|
||||
use craft_behavior::{Mixed, MoveMods, NavMove};
|
||||
use craft_ui::contract::Bind;
|
||||
use craft_ui::testing::trial;
|
||||
use craft_ui::value_drag::{Anchor, Neighbours, Order, RowOp, Thumb, ThumbOp, ThumbRow};
|
||||
use craft_behavior::{Mixed, MotionMode, MoveMods, NavMove};
|
||||
use craft_ui::contract::{Bind, Props as _, Show as _};
|
||||
use craft_ui::testing::{Fixture, pointer, trial};
|
||||
use craft_ui::value_drag::{Anchor, Neighbours, OffThumbs, Order, RowOp, Thumb, ThumbOp, ThumbRow};
|
||||
use egui::{Modifiers, Pos2, Rangef, Rect, Vec2};
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::rc::Rc;
|
||||
|
||||
fn forward(thumb: usize) -> RowOp {
|
||||
RowOp::new(thumb, ThumbOp::Move(NavMove::Forward, MoveMods::PLAIN))
|
||||
@@ -24,8 +27,8 @@ fn an_anchored_row_keeps_its_span_and_order() {
|
||||
}
|
||||
|
||||
/// Two split pairs ordered black below white, as a Blend If bar's handles: in a row that pushes, setting the black
|
||||
/// high half past the white pair pushes the white pair along and the order holds; in a row that stops, the half stops
|
||||
/// at the white pair.
|
||||
/// high half past the white pair moves the black pair there and pushes the white pair along, and the order holds; in
|
||||
/// a row that stops, the black pair stops at the white pair.
|
||||
#[trial]
|
||||
fn a_pushing_row_moves_the_thumbs_ahead_and_a_stopping_row_stops_at_them() {
|
||||
let ordered = |below, above| Order::between(below, above, 0.0);
|
||||
@@ -40,7 +43,114 @@ fn a_pushing_row_moves_the_thumbs_ahead_and_a_stopping_row_stops_at_them() {
|
||||
let at = Mixed::each([10.0, 20.0, 100.0, 120.0]);
|
||||
let set = RowOp::new(1, ThumbOp::Set(150.0));
|
||||
let pushing = ThumbRow::new(Bind::given(at), 0.0..=255.0).step(1.0).thumbs(thumbs()).neighbours(Neighbours::Push);
|
||||
assert_eq!(pushing.rules().apply(&set, &at), Mixed::each([10.0, 150.0, 150.0, 150.0]));
|
||||
assert_eq!(pushing.rules().apply(&set, &at), Mixed::each([140.0, 150.0, 150.0, 150.0]));
|
||||
let stopping = ThumbRow::new(Bind::given(at), 0.0..=255.0).step(1.0).thumbs(thumbs());
|
||||
assert_eq!(stopping.rules().apply(&set, &at), Mixed::each([10.0, 100.0, 100.0, 120.0]));
|
||||
assert_eq!(stopping.rules().apply(&set, &at), Mixed::each([90.0, 100.0, 100.0, 120.0]));
|
||||
}
|
||||
|
||||
/// A key, the wheel or a set value on either half of a split thumb moves the pair and keeps the spread, up to where
|
||||
/// the pair meets the end; with Alt (the fine flag) the focused half moves alone, by the plain step.
|
||||
#[trial]
|
||||
fn a_split_thumb_moves_as_a_pair_and_with_alt_as_one_half() {
|
||||
let at = Mixed::each([10.0, 20.0]);
|
||||
let row = ThumbRow::new(Bind::given(at), 0.0..=255.0).step(1.0).thumbs([Thumb::new("low").split(), Thumb::new("high")]);
|
||||
let rules = row.rules();
|
||||
assert_eq!(rules.apply(&forward(1), &at), Mixed::each([11.0, 21.0]));
|
||||
let alt = RowOp::new(1, ThumbOp::Move(NavMove::Forward, MoveMods::PLAIN.fine(true)));
|
||||
assert_eq!(rules.apply(&alt, &at), Mixed::each([10.0, 21.0]));
|
||||
assert_eq!(rules.apply(&RowOp::new(0, ThumbOp::Set(100.0)), &at), Mixed::each([100.0, 110.0]));
|
||||
assert_eq!(rules.apply(&RowOp::new(0, ThumbOp::Set(250.0)), &at), Mixed::each([245.0, 255.0]));
|
||||
}
|
||||
|
||||
const FIELD: Rect = Rect { min: Pos2::new(20.0, 20.0), max: Pos2::new(276.0, 50.0) };
|
||||
|
||||
/// A split thumb shown in `FIELD` over 0..=255, holding its values and where its thumbs travel.
|
||||
struct Split {
|
||||
values: RefCell<[Mixed<f64>; 2]>,
|
||||
travel: Cell<Rangef>,
|
||||
off: OffThumbs,
|
||||
}
|
||||
|
||||
impl Split {
|
||||
/// The split thumb at `values` in a row whose presses off the thumbs do `off`, shown and settled.
|
||||
fn rig(values: [f64; 2], off: OffThumbs) -> (Rc<Split>, Fixture) {
|
||||
let split = Rc::new(Split { values: RefCell::new(Mixed::each(values)), travel: Cell::new(Rangef::NOTHING), off });
|
||||
let shown = Rc::clone(&split);
|
||||
let mut fixture = Fixture::new(move |ui| shown.show(ui));
|
||||
fixture.motion(MotionMode::Off).settle();
|
||||
(split, fixture)
|
||||
}
|
||||
|
||||
fn show(&self, ui: &mut egui::Ui) {
|
||||
let thumbs = [Thumb::new("low").split(), Thumb::new("high")];
|
||||
let mut values = self.values.borrow_mut();
|
||||
let row = ThumbRow::new(Bind::bound(&mut *values), 0.0..=255.0).step(1.0).thumbs(thumbs).off_thumbs(self.off).label("Blend");
|
||||
self.travel.set(row.show_at(ui, FIELD).travel);
|
||||
}
|
||||
|
||||
/// The point on the row at `value`.
|
||||
fn at(&self, value: f64) -> Pos2 {
|
||||
let travel = self.travel.get();
|
||||
Pos2::new(travel.min + travel.span() * (value / 255.0) as f32, FIELD.center().y)
|
||||
}
|
||||
|
||||
fn values(&self) -> [f64; 2] {
|
||||
let values = *self.values.borrow();
|
||||
values.map(|value| value.same().copied().unwrap_or(f64::NAN))
|
||||
}
|
||||
}
|
||||
|
||||
/// Presses at `from`, moves `by` along the row in four frames, with Alt held from the third on when `alt`, and
|
||||
/// releases.
|
||||
fn drag(fixture: &mut Fixture, from: Pos2, by: f32, alt: bool) {
|
||||
fixture.frame(vec![pointer::moved(from)]);
|
||||
fixture.frame(vec![pointer::press(from)]);
|
||||
for step in 1..=4 {
|
||||
if alt && step == 3 {
|
||||
fixture.hold(Modifiers::ALT);
|
||||
}
|
||||
fixture.frame(vec![pointer::moved(from + Vec2::new(by * step as f32 / 4.0, 0.0))]);
|
||||
}
|
||||
fixture.frame(vec![pointer::release(from + Vec2::new(by, 0.0))]);
|
||||
fixture.hold(Modifiers::NONE).settle();
|
||||
}
|
||||
|
||||
/// The thumb that has the focus.
|
||||
fn focused(fixture: &Fixture) -> Option<u64> {
|
||||
fixture.focused_stop().and_then(|(_, part)| part).and_then(|part| part.index)
|
||||
}
|
||||
|
||||
/// A drag on a half of a split thumb moves the pair; once Alt is held, the half alone, from where the drag began.
|
||||
#[trial]
|
||||
fn a_drag_moves_a_split_pair_and_with_alt_held_its_half() {
|
||||
let (split, mut fixture) = Split::rig([100.0, 150.0], OffThumbs::Jump);
|
||||
drag(&mut fixture, split.at(150.0), 20.0, false);
|
||||
let [low, high] = split.values();
|
||||
assert!(high > 150.0 && high - low == 50.0, "the pair did not move together: {low}, {high}");
|
||||
drag(&mut fixture, split.at(high), 20.0, true);
|
||||
let [alone_low, alone_high] = split.values();
|
||||
assert!(alone_low == low && alone_high > high, "the high half did not move alone: {alone_low}, {alone_high}");
|
||||
}
|
||||
|
||||
/// A press on the triangle of coinciding halves takes the half on its side of the tip, even as it drags toward the
|
||||
/// other side.
|
||||
#[trial]
|
||||
fn a_press_on_coinciding_halves_takes_the_half_on_its_side_of_the_tip() {
|
||||
for (side, half) in [(-3.0_f32, 0), (3.0, 1)] {
|
||||
let (split, mut fixture) = Split::rig([100.0, 100.0], OffThumbs::Jump);
|
||||
drag(&mut fixture, split.at(100.0) + Vec2::new(side, 0.0), -20.0 * side.signum(), false);
|
||||
assert_eq!(focused(&fixture), Some(half), "a press {side} points from the tip took another half");
|
||||
}
|
||||
}
|
||||
|
||||
/// A tap off the thumbs focuses the nearest thumb in a row whose presses off them take the nearest, and does nothing
|
||||
/// in a row that ignores them; neither moves a thumb.
|
||||
#[trial]
|
||||
fn a_tap_off_the_thumbs_focuses_the_nearest_or_does_nothing_as_the_row_says() {
|
||||
for (off, expected) in [(OffThumbs::Nearest, Some(1)), (OffThumbs::Ignore, None)] {
|
||||
let (split, mut fixture) = Split::rig([100.0, 150.0], off);
|
||||
fixture.click_at(split.at(220.0)).settle();
|
||||
assert_eq!(split.values(), [100.0, 150.0], "a tap in a {off:?} row moved a thumb");
|
||||
assert_eq!(focused(&fixture), expected, "a tap in a {off:?} row focused another thumb");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user