tarsier 1.5.0

A simple image editor
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Edition mode

use bladvak::eframe::egui;

/// Drawing mode
#[derive(serde::Deserialize, serde::Serialize, PartialEq, Debug, Clone, Copy)]
pub(crate) struct DrawingMode {
    /// Drawing mode
    pub drawing_blend: bool,
    /// Continuous line when drawing when dragged
    pub drawing_continuous_line: bool,
    /// Others settings
    /// Pen radius
    pub pen_radius: u32,
    /// Pen color
    pub(crate) pen_color: [u8; 4],
}

impl Default for DrawingMode {
    fn default() -> Self {
        Self {
            drawing_blend: false,
            drawing_continuous_line: true,
            pen_radius: 1,
            pen_color: [0, 0, 0, 255],
        }
    }
}

impl DrawingMode {
    /// Button to draw settings
    pub(crate) fn show(&mut self, ui: &mut egui::Ui, max_radius: u32) {
        ui.add(egui::Slider::new(&mut self.pen_radius, 1..=max_radius / 4))
            .on_hover_text("Pen radius");
        let [r, g, b, a] = self.pen_color;
        let mut color = egui::Color32::from_rgba_premultiplied(r, g, b, a);
        egui::color_picker::color_edit_button_srgba(
            ui,
            &mut color,
            egui::color_picker::Alpha::OnlyBlend,
        )
        .on_hover_text("Pen color");
        self.pen_color = [color.r(), color.g(), color.b(), color.a()];
        ui.checkbox(&mut self.drawing_blend, "Blend");
        ui.checkbox(&mut self.drawing_continuous_line, "Continuous line");
    }
}

/// Edit mode
#[derive(serde::Deserialize, serde::Serialize, Debug, Clone)]
pub(crate) struct Mode {
    /// current mode
    pub(crate) current: EditMode,
    /// drawing mode
    pub(crate) drawing: DrawingMode,
}

impl Default for Mode {
    fn default() -> Self {
        Self {
            current: EditMode::Cursor,
            drawing: DrawingMode::default(),
        }
    }
}

/// Mode
#[derive(serde::Deserialize, serde::Serialize, PartialEq, Debug, Clone, Copy)]
pub(crate) enum EditMode {
    /// Cursor
    Cursor,
    /// Selection mode
    Selection,
    /// Drawing mode
    Drawing,
}

impl std::fmt::Display for EditMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            EditMode::Cursor => write!(f, "Cursor"),
            EditMode::Selection => write!(f, "Selection"),
            EditMode::Drawing => write!(f, "Drawing"),
        }
    }
}

/// Cursor state
#[derive(serde::Deserialize, serde::Serialize, Debug, Clone)]
pub struct SelectionState {
    /// Selection rectangle
    #[serde(skip)]
    pub rectangle: Option<egui::Rect>,

    /// Start selection position
    #[serde(skip)]
    pub start_selection: egui::Pos2,

    /// Start selection position
    #[serde(skip)]
    pub last_drawing_point: Option<egui::Pos2>,

    /// Is currently selecting
    #[serde(skip)]
    pub is_selecting: bool,

    /// Selection as windows
    pub cursor_op_as_window: bool,

    /// Remove selection after operation
    pub remove_selection_after_op: bool,
}

impl Default for SelectionState {
    fn default() -> Self {
        Self {
            rectangle: None,
            cursor_op_as_window: false,
            start_selection: egui::Pos2::ZERO,
            last_drawing_point: None,
            is_selecting: false,
            remove_selection_after_op: false,
        }
    }
}