a7n-gui 0.26.2

Desktop interface for the Apeirogon software KVM
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

// SPDX-License-Identifier: GPL-3.0-or-later

use a7n_ipc::{MachineId, Placement};
use eframe::egui;

use super::SNAP_DISTANCE_PX;
use super::snap::{Snapped, overlaps, snap};

pub(super) struct Drag {
    start: Placement,
    delta: [f64; 2],
    last_valid: Placement,
}

impl Drag {
    pub(super) fn new(start: Placement) -> Self {
        Self {
            start,
            delta: [0.0; 2],
            last_valid: start,
        }
    }

    pub(super) fn machine(&self) -> MachineId {
        self.start.id
    }

    pub(super) fn update(
        &mut self,
        placement: &mut Placement,
        others: &[Placement],
        delta: egui::Vec2,
        scale: f64,
    ) -> Snapped {
        let raw = self.advance(delta, scale);
        let (candidate, snapped) = snap(raw, others, f64::from(SNAP_DISTANCE_PX) / scale);
        *placement = candidate;
        if !overlaps(&candidate, others) {
            self.last_valid = candidate;
        }
        snapped
    }

    pub(super) fn finish(self) -> Placement {
        self.last_valid
    }

    #[allow(
        clippy::cast_possible_truncation,
        reason = "float-to-int casts saturate at the layout coordinate limits"
    )]
    fn advance(&mut self, delta: egui::Vec2, scale: f64) -> Placement {
        self.delta[0] += f64::from(delta.x) / scale;
        self.delta[1] += f64::from(delta.y) / scale;
        Placement {
            x: (f64::from(self.start.x) + self.delta[0]).round() as i32,
            y: (f64::from(self.start.y) + self.delta[1]).round() as i32,
            ..self.start
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn placement(id: u8, x: i32) -> Placement {
        Placement {
            id: MachineId::try_from([id; 16].as_slice()).unwrap(),
            x,
            y: 0,
            width: 100,
            height: 100,
            blocked: 0,
        }
    }

    #[test]
    fn finish_overlapping_drag_returns_last_valid_or_start_position() {
        // Arrange
        let others = [placement(1, 0)];
        for (valid_delta, expected) in [(0.0, 150), (50.0, 200)] {
            let mut current = placement(2, 150);
            let mut drag = Drag::new(current);
            drag.update(&mut current, &others, egui::vec2(valid_delta, 0.0), 1.0);
            drag.update(
                &mut current,
                &others,
                egui::vec2(-100.0 - valid_delta, 0.0),
                1.0,
            );

            // Act
            let final_placement = drag.finish();

            // Assert
            assert_eq!(final_placement.x, expected);
        }
    }
}