xrack-layout 0.7.0

Layout, hit testing, and input routing for XRack UI
Documentation
use crate::{ControlInput, LayoutNode, Point, Rect, Size, Target, TextMeasurer, linear};
use xrack_runtime::{ControlAction, Node, RowKey, SwipeSide};

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SwipeDelegateGeometry {
    bounds: Rect,
    widths: [f32; 2],
    pub side: SwipeSide,
    offset: f32,
    preview: bool,
}

pub(crate) struct Region {
    pub(crate) bounds: Rect,
    pub(crate) clip: Rect,
    pub(crate) enabled: bool,
}

impl SwipeDelegateGeometry {
    pub(crate) fn new(node: &Node, bounds: Rect, text: &mut impl TextMeasurer) -> Self {
        let available = Size::new(bounds.width, bounds.height);
        let limit = (bounds.width - 24.0).max(0.0);
        let widths = [SwipeSide::Left, SwipeSide::Right].map(|side| {
            node.swipe_panel(side).map_or(0.0, |panel| {
                linear::measure(panel, available, text)
                    .x
                    .preferred
                    .min(limit)
            })
        });
        let mut geometry = Self {
            bounds,
            widths,
            side: SwipeSide::Closed,
            offset: 0.0,
            preview: false,
        };
        let side = node.swipe_side();
        if geometry.supports(side) {
            geometry.side = side;
            geometry.offset = geometry.position(side);
        }
        geometry
    }

    pub fn supports(&self, side: SwipeSide) -> bool {
        side == SwipeSide::Closed || self.position(side) != 0.0
    }

    pub fn toggle(&self) -> Option<(Rect, ControlAction)> {
        if self.preview || self.widths == [0.0, 0.0] {
            return None;
        }
        let content = self.region("SwipeContent").bounds.intersect(self.bounds);
        let width = content.width.min(28.0);
        let height = content.height.min(32.0);
        let rect = Rect::new(
            content.x + content.width - width,
            content.y + (content.height - height) * 0.5,
            width,
            height,
        );
        let side = if self.side != SwipeSide::Closed {
            SwipeSide::Closed
        } else if self.supports(SwipeSide::Right) {
            SwipeSide::Right
        } else {
            SwipeSide::Left
        };
        Some((rect, ControlAction::SwipeDelegate(side)))
    }

    fn position(&self, side: SwipeSide) -> f32 {
        match side {
            SwipeSide::Closed => 0.0,
            SwipeSide::Left => self.widths[0],
            SwipeSide::Right => -self.widths[1],
        }
    }

    pub(crate) fn set_preview(&mut self, offset: f32) {
        self.offset = offset.clamp(-self.widths[1], self.widths[0]);
        self.preview = true;
    }

    pub(crate) fn region(&self, kind: &str) -> Region {
        let bounds = self.bounds;
        let (bounds, clip, enabled) = match kind {
            "SwipeContent" => (
                Rect {
                    x: bounds.x + self.offset,
                    ..bounds
                },
                bounds,
                true,
            ),
            "SwipeLeft" => (
                Rect {
                    width: self.widths[0],
                    ..bounds
                },
                Rect {
                    width: self.offset.max(0.0),
                    ..bounds
                },
                self.side == SwipeSide::Left && !self.preview,
            ),
            "SwipeRight" => {
                let right = bounds.x + bounds.width;
                (
                    Rect {
                        x: right - self.widths[1],
                        width: self.widths[1],
                        ..bounds
                    },
                    Rect {
                        x: right + self.offset.min(0.0),
                        width: (-self.offset).max(0.0),
                        ..bounds
                    },
                    self.side == SwipeSide::Right && !self.preview,
                )
            }
            _ => (Rect::default(), Rect::default(), false),
        };
        Region {
            bounds,
            clip,
            enabled,
        }
    }
}

#[derive(Clone, Debug)]
pub(crate) struct SwipeDrag {
    pub(crate) target: Target,
    start: Point,
    initial: SwipeSide,
    geometry: SwipeDelegateGeometry,
    offset: Option<f32>,
}

impl SwipeDrag {
    pub(crate) fn new(
        target: Target,
        node: &Node,
        item: &LayoutNode,
        start: Point,
    ) -> Option<Self> {
        let geometry = *item.swipe_delegate.as_deref()?;
        (geometry.widths != [0.0, 0.0]).then_some(Self {
            target,
            start,
            initial: node.swipe_side(),
            geometry,
            offset: None,
        })
    }

    fn offset_at(&self, point: Point) -> f32 {
        (self.geometry.position(self.geometry.side) + point.x - self.start.x)
            .clamp(-self.geometry.widths[1], self.geometry.widths[0])
    }

    pub(crate) fn accepts_direction(&self, point: Point) -> bool {
        (point.x - self.start.x).abs() > (point.y - self.start.y).abs()
            && self.offset_at(point) != self.geometry.position(self.geometry.side)
    }

    fn matches(&self, node: &Node, geometry: &SwipeDelegateGeometry, row: Option<RowKey>) -> bool {
        node.kind == "SwipeDelegate"
            && self.target.matches_node(node)
            && node.swipe_side() == self.initial
            && row == self.target.row_key
            && self.geometry.bounds == geometry.bounds
            && self.geometry.widths == geometry.widths
    }

    fn is_current(&self, scene: &Node, layout: &LayoutNode) -> bool {
        let path = &self.target.path;
        scene
            .interactive_at_path(path)
            .zip(layout.at_path(path))
            .is_some_and(|(node, item)| {
                item.enabled
                    && item.visible
                    && item.swipe_delegate.as_deref().is_some_and(|geometry| {
                        self.matches(node, geometry, scene.row_key_at(path))
                    })
            })
    }

    pub(crate) fn update(&mut self, scene: &Node, layout: &LayoutNode, point: Point) -> bool {
        let offset = self
            .is_current(scene, layout)
            .then(|| self.offset_at(point));
        let changed = self.offset != offset;
        self.offset = offset;
        changed
    }

    pub(crate) fn preview(
        &self,
        path: &[usize],
        node: &Node,
        geometry: &SwipeDelegateGeometry,
        row: Option<RowKey>,
    ) -> Option<f32> {
        self.offset
            .filter(|_| self.target.path == path && self.matches(node, geometry, row))
    }

    pub(crate) fn has_preview(&self) -> bool {
        self.offset.is_some()
    }

    pub(crate) fn preview_state(&self) -> Option<(&[usize], Option<RowKey>, f32)> {
        Some((&self.target.path, self.target.row_key, self.offset?))
    }

    pub(crate) fn finish(&self, scene: &Node, layout: &LayoutNode) -> Option<ControlInput> {
        let offset = self.offset?;
        let side = if offset > 0.0 && offset >= self.geometry.widths[0] * 0.5 {
            SwipeSide::Left
        } else if offset < 0.0 && -offset >= self.geometry.widths[1] * 0.5 {
            SwipeSide::Right
        } else {
            SwipeSide::Closed
        };
        (side != self.initial && self.is_current(scene, layout)).then(|| ControlInput {
            path: self.target.path.clone(),
            action: ControlAction::SwipeDelegate(side),
        })
    }
}