paint-together 0.2.1

Classic Windows Paint, rebuilt in Rust, where kids on the same Wi-Fi draw on one picture together in real time
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

//! Undo/redo. Most edits store only the before/after pixels of the rectangle
//! they touched; edits that change the canvas size store whole images.

use image::{RgbaImage, imageops};

use crate::raster::{self, IRect};

/// Total pixel bytes kept for undo before the oldest steps are dropped.
const BUDGET_BYTES: usize = 1 << 30;

pub enum Change {
    Patch { x: u32, y: u32, before: RgbaImage, after: RgbaImage },
    Replace { before: RgbaImage, after: RgbaImage },
}

impl Change {
    /// The difference between two same-sized images within `r`, if any.
    pub fn patch(before: &RgbaImage, after: &RgbaImage, r: IRect) -> Option<Change> {
        let r = r.intersect(IRect::of_image(before)).intersect(IRect::of_image(after));
        if r.is_empty() {
            return None;
        }
        let b = raster::crop(before, r);
        let a = raster::crop(after, r);
        (b != a).then_some(Change::Patch { x: r.x0 as u32, y: r.y0 as u32, before: b, after: a })
    }

    fn bytes(&self) -> usize {
        match self {
            Change::Patch { before, after, .. } | Change::Replace { before, after } => before.len() + after.len(),
        }
    }

    fn apply(&self, img: &mut RgbaImage, undo: bool) {
        match self {
            Change::Patch { x, y, before, after } => {
                imageops::replace(img, if undo { before } else { after }, *x as i64, *y as i64);
            }
            Change::Replace { before, after } => *img = if undo { before } else { after }.clone(),
        }
    }
}

struct Edit {
    id: u64,
    change: Change,
}

#[derive(Default)]
pub struct History {
    undo: Vec<Edit>,
    redo: Vec<Edit>,
    next_id: u64,
}

impl History {
    pub fn push(&mut self, change: Change) {
        self.redo.clear();
        self.next_id += 1;
        self.undo.push(Edit { id: self.next_id, change });
        while self.undo.len() > 1 && self.undo.iter().map(|e| e.change.bytes()).sum::<usize>() > BUDGET_BYTES {
            self.undo.remove(0);
        }
    }

    pub fn undo(&mut self, img: &mut RgbaImage) -> bool {
        let Some(edit) = self.undo.pop() else { return false };
        edit.change.apply(img, true);
        self.redo.push(edit);
        true
    }

    pub fn redo(&mut self, img: &mut RgbaImage) -> bool {
        let Some(edit) = self.redo.pop() else { return false };
        edit.change.apply(img, false);
        self.undo.push(edit);
        true
    }

    /// Undo (`back`) or redo one step, but only if `apply` performs it.
    pub fn step_with(&mut self, back: bool, apply: impl FnOnce(&Change) -> bool) -> bool {
        let (from, to) = if back { (&mut self.undo, &mut self.redo) } else { (&mut self.redo, &mut self.undo) };
        let Some(edit) = from.last() else {
            return false;
        };
        if !apply(&edit.change) {
            return false;
        }
        to.push(from.pop().expect("checked above"));
        true
    }

    /// Identifies the step `redo` would bring back.
    pub fn redo_id(&self) -> u64 {
        self.redo.last().map_or(0, |e| e.id)
    }

    pub fn can_undo(&self) -> bool {
        !self.undo.is_empty()
    }

    pub fn can_redo(&self) -> bool {
        !self.redo.is_empty()
    }

    /// Identifies the current document state, for "unsaved changes" tracking.
    pub fn state_id(&self) -> u64 {
        self.undo.last().map_or(0, |e| e.id)
    }

    pub fn clear(&mut self) {
        self.undo.clear();
        self.redo.clear();
    }
}