tarsila 0.1.1

GUI image editor for pixel art
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use crate::{Effect, UiEvent, UiState};
use lapix::{Position, Size, Tool};
use macroquad::prelude::*;

mod layers;
mod menu;
mod palette;
mod preview;
mod status;
mod toolbar;

use layers::LayersPanel;
use menu::MenuBar;
use palette::Palette;
use preview::Preview;
use status::StatusBar;
use toolbar::Toolbar;

#[derive(Debug, Clone)]
pub struct GuiSyncParams {
    pub main_color: [u8; 4],
    pub num_layers: usize,
    pub active_layer: usize,
    pub layers_vis: Vec<bool>,
    pub layers_alpha: Vec<u8>,
    pub palette: Vec<[u8; 4]>,
    pub mouse_canvas: Position<i32>,
    pub is_on_canvas: bool,
    pub selected_tool: Tool,
    pub visible_pixel_on_mouse: Option<[u8; 4]>,
    pub canvas_size: Size<i32>,
    pub spritesheet: Size<u8>,
    pub zoom: f32,
    pub fps: f32,
}

pub struct Gui {
    toolbar: Toolbar,
    layers_panel: LayersPanel,
    preview: Preview,
    palette: Palette,
    status_bar: StatusBar,
    menu: MenuBar,
    mouse_on_canvas: bool,
    selected_tool: Tool,
}

impl Gui {
    pub fn new() -> Self {
        Self {
            toolbar: Toolbar::new(),
            layers_panel: LayersPanel::new(),
            preview: Preview::new(),
            palette: Palette::new(),
            status_bar: StatusBar::new(),
            menu: MenuBar::new(),
            mouse_on_canvas: false,
            selected_tool: Tool::Brush,
        }
    }

    pub fn sync(&mut self, params: GuiSyncParams) {
        self.mouse_on_canvas = params.is_on_canvas;

        self.toolbar.sync(params.main_color);
        self.selected_tool = params.selected_tool;
        self.layers_panel.sync(
            params.num_layers,
            params.active_layer,
            params.layers_vis.clone(),
            params.layers_alpha.clone(),
        );
        self.preview.sync(
            params.spritesheet,
            params.canvas_size,
            params.layers_vis.clone(),
            params.layers_alpha.clone(),
        );
        self.palette.sync(params.palette.clone());
        self.menu.sync(params.canvas_size, params.spritesheet);
        self.status_bar.sync(params);
    }

    pub fn update(&mut self) -> Vec<Effect> {
        let mut events = Vec::new();

        let widget_color = egui::Color32::from_rgb(150, 150, 150);
        let widget_weak_color = egui::Color32::from_rgb(150, 150, 150);
        let bg_color = egui::Color32::from_rgb(175, 175, 175);
        let bg_strong_color = egui::Color32::from_rgb(230, 230, 230);
        let bg_weak_color = egui::Color32::from_rgb(150, 150, 150);
        let text_color = Some(egui::Color32::from_rgb(0, 0, 0));

        egui_macroquad::ui(|egui_ctx| {
            let mut visuals = egui_ctx.style().visuals.clone();
            visuals.dark_mode = false;
            visuals.menu_rounding = 2.0.into();
            visuals.window_rounding = 2.0.into();
            visuals.widgets.noninteractive.bg_fill = bg_color;
            visuals.widgets.noninteractive.weak_bg_fill = bg_weak_color;
            visuals.widgets.active.bg_fill = widget_color;
            visuals.widgets.active.weak_bg_fill = widget_weak_color;
            visuals.widgets.inactive.bg_fill = widget_color;
            visuals.widgets.inactive.weak_bg_fill = widget_weak_color;
            visuals.widgets.hovered.bg_fill = widget_color;
            visuals.widgets.hovered.weak_bg_fill = widget_weak_color;
            visuals.faint_bg_color = bg_weak_color;
            visuals.extreme_bg_color = bg_strong_color;
            visuals.panel_fill = bg_color;
            visuals.window_fill = bg_color;
            visuals.override_text_color = text_color;
            egui_ctx.set_visuals(visuals);

            let mut palette_events = self.palette.update(egui_ctx);
            events.append(&mut palette_events);

            let mut toolbar_events = self.toolbar.update(egui_ctx, self.selected_tool);
            events.append(&mut toolbar_events);

            let mut layers_events = self.layers_panel.update(egui_ctx);
            events.append(&mut layers_events);

            let mut menu_events = self.menu.update(egui_ctx);
            events.append(&mut menu_events);

            self.preview.update(egui_ctx);
            self.status_bar.update(egui_ctx);

            let mut canvas_panel_events = self.update_canvas_panel(egui_ctx);
            events.append(&mut canvas_panel_events);

            if self.mouse_on_canvas {
                egui_ctx.output_mut(|o| o.cursor_icon = egui::CursorIcon::None);
            }
        });

        events
    }

    pub fn draw_preview(&self, state: &UiState) {
        self.preview.draw(state);
    }

    fn update_canvas_panel(&mut self, egui_ctx: &egui::Context) -> Vec<Effect> {
        let mut events = Vec::new();

        if egui_ctx.is_pointer_over_area() {
            events.push(Effect::UiEvent(UiEvent::MouseOverGui));
        }

        events
    }
}