utu 0.0.1

TUI pixel art editor using plain text files
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

use std::path::PathBuf;

use orfail::OrFail;

use crate::{
    buffer::{TextBuffer, TextPosition},
    clipboard::Clipboard,
    config::Config,
    keybinding::KeySequence,
    marker::Marker,
};

#[derive(Debug)]
pub struct Editor {
    pub path: PathBuf,
    pub exit: bool,
    pub dirty: Dirty,
    pub cursor: TextPosition,
    pub buffer: TextBuffer,
    pub message: Option<String>,
    pub config: Config,
    pub pending_keys: KeySequence,
    pub marker: Option<Marker>,
    pub clipboard: Option<Clipboard>,
}

impl Editor {
    pub fn new(path: PathBuf, config: Config) -> orfail::Result<Self> {
        let mut buffer = TextBuffer::new();
        buffer.filter.fg_chars = config.keybindings.fg_chars().collect();

        Ok(Self {
            path,
            exit: false,
            dirty: Dirty {
                content: false,
                render: true,
            },
            cursor: TextPosition::default(),
            buffer,
            message: None,
            config,
            pending_keys: KeySequence::default(),
            marker: None,
            clipboard: None,
        })
    }

    pub fn set_message(&mut self, message: impl Into<String>) {
        self.message = Some(message.into());
        self.dirty.render = true;
    }

    pub fn clear_message(&mut self) {
        if self.message.take().is_some() {
            self.dirty.render = true;
        }
    }

    pub fn dot(&mut self, c: char) -> orfail::Result<()> {
        if let Some(marker) = self.marker.take() {
            // Handle marker: apply character to all marked positions
            let positions: Vec<_> = marker.marked_positions().collect();
            let updates = positions.into_iter().map(|pos| (pos, c));

            if self.buffer.update_bulk(updates) {
                self.dirty.content = true;
                self.dirty.render = true;
            } else {
                self.set_message("No effect");
            }
        } else {
            // Handle single character update at cursor
            if self.buffer.update(self.cursor, c) {
                self.dirty.content = true;
                self.dirty.render = true;
            } else {
                self.set_message("No effect");
            }
        }
        Ok(())
    }

    pub fn save(&mut self) -> orfail::Result<()> {
        if !self.dirty.content {
            self.set_message("No changes to save");
            return Ok(());
        }

        let mut content = self.buffer.lines().collect::<Vec<&str>>().join("\n");
        content.push('\n');
        std::fs::write(&self.path, content).or_fail()?;

        self.dirty.content = false;
        self.set_message(format!("Saved {}", self.path.display()));

        Ok(())
    }

    pub fn reload(&mut self) -> orfail::Result<()> {
        let text = std::fs::read_to_string(&self.path).or_fail()?;
        self.buffer.set_text(text);
        self.set_message(format!("Loaded {}", self.path.display()));

        self.dirty.content = false;
        self.dirty.render = true;

        Ok(())
    }
}

#[derive(Debug)]
pub struct Dirty {
    pub content: bool, // File content needs to be saved
    pub render: bool,  // Terminal needs to be re-rendered
}