zte 0.1.5

A buffer/window-driven text editor that takes inspiration from Howl
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

mod config;
mod display;
mod input;
mod event;
mod draw;
mod ui;
mod buffer;
mod state;

use std::{panic, env};
use backtrace::Backtrace;
use clap::{App, Arg};
use crate::{
    config::Config,
    display::{Display, Color},
    event::{Dir, Event},
    draw::Canvas,
    ui::{MainUi, Theme},
    buffer::{BufferId, BufferHandle, Line, Cursor, CursorId},
    state::State,
};

const LOG_FILENAME: &str = concat!(env!("CARGO_PKG_NAME"), ".log");

fn setup() -> Config {
    // Set up panic hook
    panic::set_hook(Box::new(move |info| {
        log::error!("{}", info);
        log::error!("{:?}", Backtrace::new());
        eprintln!("Panic: {}", info);
    }));

    // Enable logging
    if let Ok(fname) = env::var("ZTE_LOG") {
        simple_logging::log_to_file(
            if fname.len() == 0 {
                &fname
            } else {
                LOG_FILENAME
            },
            log::LevelFilter::Info,
        )
            .expect("Failed to enable logging");
    }

    // Load config
    Config::load().unwrap_or_else(|err| {
        log::warn!("Failed to load config: {:?}", err);
        Config::default()
    })
}

fn main() {
    let config = setup();

    let matches = App::new(env!("CARGO_PKG_NAME"))
        .version(env!("CARGO_PKG_VERSION"))
        .author(env!("CARGO_PKG_AUTHORS"))
        .about(env!("CARGO_PKG_DESCRIPTION"))
        .arg(Arg::with_name("PATH")
            .help("Specify a file to edit")
            .multiple(true))
        .get_matches();


    let mut display = Display::new();

    let (state, buffers, _) = match matches.values_of("PATH") {
        Some(paths) => State::from_paths(paths.map(|path| path.to_string().into())),
        None => (State::default(), Vec::new(), Vec::new()),
    };

    let mut ui = MainUi::new(Theme::default(), state, buffers);

    let event_rx = input::begin_reading();
    loop {
        ui.update(&mut display);
        ui.render(&mut display);
        display.render();

        match event_rx.recv().unwrap() {
            Event::Tick => display.update_size(),
            event => if ui.handle(event) {
                break;
            } else {},
        }
    }

    log::info!("Quitting...");
}