plottery_editor 0.7.0

Graphical Editor of Plottery, a creative coding framework for generative vector graphics and pen plotting.
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

use std::sync::{Arc, Mutex};

use dioxus::signals::{Readable, SyncSignal};
use plottery_lib::rand_range_i;

#[derive(Debug, Clone)]
pub enum ConsoleMessageType {
    Info,
    Error,
    ProjectLog,
}

#[derive(Debug, Clone)]
pub struct ConsoleMessage {
    pub id: i32,
    pub msg: String,
    pub msg_type: ConsoleMessageType,
}

impl ConsoleMessage {
    pub fn new(msg: &str, msg_type: ConsoleMessageType) -> Self {
        Self {
            id: rand_range_i(i32::MIN, i32::MAX),
            msg: msg.to_string(),
            msg_type,
        }
    }
}

impl PartialEq for ConsoleMessage {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

#[derive(Debug, Clone)]
pub struct ConsoleMessages {
    entries: Arc<Mutex<Vec<ConsoleMessage>>>,
    change_counter: Arc<Mutex<SyncSignal<u32>>>,
}

impl ConsoleMessages {
    pub fn new(change_counter: SyncSignal<u32>) -> Self {
        Self {
            entries: Arc::new(Mutex::new(Vec::new())),
            change_counter: Arc::new(Mutex::new(change_counter)),
        }
    }
    fn trigger_change(&self) {
        let mut change_counter = self
            .change_counter
            .lock()
            .expect("Failed to lock change counter");
        *change_counter += 1;
    }

    pub fn get_change_counter(&self) -> u32 {
        let sig = *self
            .change_counter
            .lock()
            .expect("Failed to lock change counter");
        return *sig.read();
    }

    pub fn clear(&self) {
        self.entries
            .lock()
            .expect("Failed to lock console entries")
            .clear();
        self.trigger_change();
    }

    pub fn project_message(&self, msg: &str) {
        let formatted = format!("> {}", msg);
        self.entries
            .lock()
            .expect("Failed to lock console entries")
            .push(ConsoleMessage::new(
                &formatted,
                ConsoleMessageType::ProjectLog,
            ));
        log::info!("{}", formatted);
        self.trigger_change();
    }
    pub fn info(&self, msg: &str) {
        self.entries
            .lock()
            .expect("Failed to lock console entries")
            .push(ConsoleMessage::new(msg, ConsoleMessageType::Info));
        log::info!("{}", msg);
        self.trigger_change();
    }
    pub fn error(&self, msg: &str) {
        self.entries
            .lock()
            .expect("Failed to lock console entries")
            .push(ConsoleMessage::new(msg, ConsoleMessageType::Error));
        log::error!("{}", msg);
        self.trigger_change();
    }

    pub fn get_messages(&self) -> Vec<ConsoleMessage> {
        self.entries
            .lock()
            .expect("Failed to lock console entries")
            .clone()
    }
}