cursive-image 0.0.6

Image view for the Cursive TUI library
Documentation 
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

use cursive::*;

//
// Vec2f
//

/// Floating point vector.
pub type Vec2f = XY<f64>;

//
// Vec2fUtilities
//

/// Utilities for [Vec2f].
pub trait Vec2fUtilities {
    /// Convert to [Vec2], rounding up.
    fn into_vec2(self) -> Vec2;

    /// Scale.
    fn scale(self, scale: f64) -> Self;

    /// Scale.
    fn scale_vec(self, scale: Self) -> Self;

    /// Reverse scale.
    fn reverse_scale_vec(self, scale: Self) -> Self;

    /// Scale to fit in constraint while keeping aspect ratio.
    fn scale_to_fit(self, constraint: Self) -> Self;

    /// Aspect ratio.
    fn aspect_ratio(self) -> f64;

    /// X over Y.
    fn x_over_y(self) -> f64;
}

impl Vec2fUtilities for Vec2f {
    fn into_vec2(self) -> Vec2 {
        (self.x.round() as usize, self.y.round() as usize).into()
    }

    fn scale(self, scale: f64) -> Self {
        (self.x * scale, self.y * scale).into()
    }

    fn scale_vec(self, scale: Self) -> Self {
        (self.x * scale.x, self.y * scale.y).into()
    }

    fn reverse_scale_vec(self, scale: Self) -> Self {
        (self.x / scale.x, self.y / scale.y).into()
    }

    fn scale_to_fit(self, constraint: Self) -> Self {
        // https://stackoverflow.com/q/6565703
        if constraint.x_over_y() > self.x_over_y() {
            (self.x * constraint.y / self.y, constraint.y).into()
        } else {
            (constraint.x, self.y * constraint.x / self.x).into()
        }
    }

    fn aspect_ratio(self) -> f64 {
        self.y / self.x
    }

    fn x_over_y(self) -> f64 {
        self.x / self.y
    }
}

//
// Vec2Utilities
//

/// Utilities for [Vec2].
pub trait Vec2Utilities {
    /// Convert to [Vec2f].
    fn into_vec2f(self) -> Vec2f;
}

impl Vec2Utilities for Vec2 {
    fn into_vec2f(self) -> Vec2f {
        (self.x as f64, self.y as f64).into()
    }
}