Enum Shape 

pub enum Shape {
    Rect(Rect),
    Circle {
        cx: i32,
        cy: i32,
        r: i32,
    },
    Ellipse {
        cx: i32,
        cy: i32,
        rx: i32,
        ry: i32,
    },
    Triangle {
        ax: i32,
        ay: i32,
        bx: i32,
        by: i32,
        cx: i32,
        cy: i32,
    },
    Poly {
        points: Vec<Point>,
    },
}

A committed or in-progress selection shape.

Serializes untagged: a rect is {x, y, w, h}, a circle is {cx, cy, r}, a triangle is its three vertices {ax, ay, bx, by, cx, cy} (apex, then base-left, then base-right as drawn — though any triangle is representable). The field sets are disjoint, so deserialization is unambiguous; the session schema also stores the discriminant in a sibling shape field.

Variants

Rect(Rect)

Circle

Fields

cx: i32

cy: i32

r: i32

Ellipse

Axis-aligned ellipse; rotation, like a rect’s, is metadata. The field set is disjoint from every other variant, so the untagged serde representation stays unambiguous.

Fields

cx: i32

cy: i32

rx: i32

ry: i32

Triangle

Fields

ax: i32

ay: i32

bx: i32

by: i32

cx: i32

cy: i32

Poly

An arbitrary closed polygon — regular N-gons and freehand paths alike. Rotation is baked into the vertices, triangle-style, and the winding may be either direction.

Fields

points: Vec<Point>

Implementations

impl Shape

pub fn compute_preview( tool: ToolKind, start: Point, current: Point, region: Rect, lock: bool, ) -> Option<Self>

Shape previewed while dragging from start to current, or None while the drag is still degenerate. current is clamped into bounds so dragging off-screen keeps the preview on-screen. lock constrains the proportions (Shift held): an ellipse locks to a perfect circle.

pub const fn kind(&self) -> ToolKind

pub fn bbox(&self) -> Rect

Axis-aligned bounding box. Saturating math so absurd deserialized values (e.g. r near i32::MAX) misreport rather than panic.

pub fn hit_test(&self, p: Point) -> bool

Whether p lies inside the shape (used for cursor hit-testing). Distance math is done in i64 so extreme coordinates cannot overflow.

pub fn covers(&self, x: i32, y: i32) -> bool

Whether the shape covers pixel (x, y) — identical to hit_test, named separately because it is the crop/mask predicate.

pub fn click_point(&self) -> Point

The point a click should aim for: the bbox center for rects (the rotation pivot, so it holds for rotated rects unchanged), a circle’s center, and the centroid for triangles — always interior, where a thin diagonal triangle’s bbox center may fall outside. i64 arithmetic so extreme deserialized vertices cannot overflow.

pub fn grab_origin(&self) -> Point

The reference point a drag-move grabs: bbox origin, or a circle’s center.

pub fn clamp_move( &self, grab_offset: Point, cursor: Point, region: Rect, ) -> Self

New shape position for a drag-move, clamped so the shape cannot leave bounds. grab_offset is cursor-at-grab minus grab_origin.

pub fn resize_grab(&self, p: Point, tolerance: i32) -> Option<ResizeHandle>

Which resize handle, if any, p grabs: the rim of a circle, or an edge/corner of a rect, within tolerance pixels on either side of the border.

pub fn resize_to( &self, handle: ResizeHandle, cursor: Point, region: Rect, keep_aspect: bool, ) -> Self

The shape resized by dragging handle to cursor (clamped into bounds), anchored on the parts not being dragged: a circle keeps its center, a rect keeps its ungrabbed edges. Dimensions never drop below 2, so a resize can’t destroy a shape.

keep_aspect (Shift held) preserves self’s width:height ratio — the ratio at drag start, so it stays stable through the whole drag. On a corner the opposite corner anchors and the dominant cursor axis sets the scale; on a single edge the perpendicular axis scales with it, centered. Circles are inherently proportional and ignore it.

pub fn translated(&self, dx: i32, dy: i32) -> Self

The same shape translated by (dx, dy) — used to derive global desktop coordinates from monitor-local ones.

impl Shape

pub fn pivot(&self) -> Point

The pivot every rotation turns around: the unrotated bbox center.

pub fn rotated_bbox(&self, deg: i32) -> Rect

AABB of the shape after rotating it deg about its pivot.

pub fn hit_test_rotated(&self, deg: i32, p: Point) -> bool

hit_test/covers for the shape rotated deg about its pivot: the point is inverse-rotated into the shape’s local space.

pub fn resize_grab_rotated( &self, deg: i32, p: Point, tolerance: i32, ) -> Option<ResizeHandle>

resize_grab in the rotated frame: the cursor is inverse-rotated, so grips sit on the shape as the user sees it.

pub fn resize_to_rotated( &self, deg: i32, handle: ResizeHandle, cursor: Point, region: Rect, keep_aspect: bool, ) -> Self

resize_to in the rotated frame; rotation itself is unchanged.

pub fn clamp_move_rotated( &self, deg: i32, grab_offset: Point, cursor: Point, region: Rect, ) -> Self

clamp_move keeping the rotated silhouette on screen.

pub fn grab_origin_rotated(&self, deg: i32) -> Point

The grab reference for a rotated move: the rotated AABB origin.

pub fn with_rotation_baked(&self, deg: i32) -> Self

A triangle with the rotation baked into its vertices (exact, single rounding); other shapes are returned unchanged — rects carry their rotation as metadata instead.

Trait Implementations

impl Clone for Shape

fn clone(&self) -> Shape

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Shape

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Shape

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Shape

impl PartialEq for Shape

fn eq(&self, other: &Shape) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Shape

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Shape