koibumi-sync 0.0.1

An experimental Bitmessage client (sync version)
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

use ::log::Level;
use conrod_core::{color, Color};

use crate::{config::Config as GuiConfig, ids::Ids};

#[derive(Clone, Debug)]
pub(crate) struct Entry {
    level: Level,
    message: String,
}

impl Entry {
    pub(crate) fn new(level: Level, message: String) -> Self {
        Self { level, message }
    }
}

#[derive(Clone, Debug, Default)]
pub(crate) struct Tab {
    entries: Vec<Entry>,
}

fn log_color(level: Level) -> Color {
    match level {
        Level::Error => color::LIGHT_RED,
        Level::Info => color::LIGHT_GREEN,
        _ => color::LIGHT_BLUE,
    }
}

impl Tab {
    pub(crate) fn log(&mut self, level: Level, message: String) {
        self.entries.push(Entry { level, message });
    }

    // Draw the Ui.
    pub(crate) fn set_widgets(
        &mut self,
        ui: &mut conrod_core::UiCell,
        ids: &mut Ids,
        config: &GuiConfig,
    ) {
        let text_size = config.text_size();

        use conrod_core::{widget, Colorable, Positionable, Sizeable, Widget};

        widget::Canvas::new()
            .top_left_of(ids.tabs_body)
            .wh_of(ids.tabs_body)
            .set(ids.log_canvas, ui);

        let (mut items, scrollbar) = widget::List::flow_down(self.entries.len())
            .top_left_with_margins_on(ids.log_canvas, 2.0, 2.0)
            .padded_wh_of(ids.log_canvas, 2.0)
            .item_size(text_size as f64 + 8.0)
            .scrollbar_on_top()
            .set(ids.log, ui);

        while let Some(item) = items.next(ui) {
            let i = item.i;
            let label = &self.entries[i].message;
            let text = widget::Text::new(label)
                .font_size(text_size as u32)
                .padded_w_of(ids.log_canvas, 2.0)
                .h(text_size as f64 + 8.0)
                .color(log_color(self.entries[i].level));
            item.set(text, ui);
        }

        if let Some(s) = scrollbar {
            s.set(ui)
        }
    }
}

#[derive(Clone, Debug, Default)]
pub(crate) struct Bar {
    entry: Option<Entry>,
}

impl Bar {
    pub(crate) fn log(&mut self, level: Level, message: String) {
        self.entry = Some(Entry::new(level, message));
    }

    // Draw the Ui.
    pub(crate) fn set_widgets(
        &mut self,
        ui: &mut conrod_core::UiCell,
        ids: &mut Ids,
        config: &GuiConfig,
    ) {
        let text_size = config.text_size();

        use conrod_core::{widget, Colorable, Positionable, Sizeable, Widget};

        if let Some(entry) = &self.entry {
            widget::Text::new(&entry.message)
                .top_left_with_margins_on(ids.footer, 2.0, 2.0)
                .padded_wh_of(ids.footer, 2.0)
                .color(log_color(entry.level))
                .font_size(text_size as u32)
                .set(ids.logbar, ui);
        }
    }
}

#[derive(Clone, Debug, Default)]
pub(crate) struct Logger {
    pub(crate) tab: Tab,
    pub(crate) bar: Bar,
}

impl Logger {
    pub(crate) fn log(&mut self, level: Level, message: &str) {
        let message = message.to_string();
        self.tab.log(level, message.clone());
        self.bar.log(level, message);
    }

    pub(crate) fn error(&mut self, message: &str) {
        self.log(Level::Error, message);
    }

    pub(crate) fn info(&mut self, message: &str) {
        self.log(Level::Info, message);
    }
}