koibumi 0.0.10

An experimental Bitmessage client
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

use async_std::task;
use futures::{channel::mpsc::Sender, sink::SinkExt};
use iced::{
    widget::{button, scrollable, Column, Row, Text, TextInput},
    Command, Element, Length,
};
use log::error;

use koibumi_common::boxes::{Boxes, DEFAULT_USER_ID};
use koibumi_core::address::Address;
use koibumi_node::Command as NodeCommand;

use crate::{config::Config as GuiConfig, gui};

#[derive(Clone, Debug, Default)]
pub(crate) struct Tab {
    address_value: String,
}

impl Tab {
    pub(crate) fn update(
        &mut self,
        message: gui::Message,
        boxes: &mut Option<Boxes>,
        command_sender: &mut Sender<NodeCommand>,
    ) -> Command<gui::Message> {
        if boxes.is_none() {
            return Command::none();
        }
        let boxes = boxes.as_mut().unwrap();
        match message {
            gui::Message::SubscriptionsAddressChanged(address) => {
                self.address_value = address;
                Command::none()
            }
            gui::Message::SubscriptionsSubscribePressed => {
                let address = self.address_value.parse::<Address>();
                if let Err(err) = address {
                    error!("{}", err);
                    return Command::none();
                }
                let address = address.unwrap();
                if boxes.user().subscriptions().contains(&address) {
                    return Command::none();
                }
                if let Err(err) =
                    task::block_on(boxes.manager().subscribe(DEFAULT_USER_ID, &address))
                {
                    error!("{}", err);
                    return Command::none();
                }
                if let Err(err) = task::block_on(command_sender.send(NodeCommand::Subscribe {
                    id: DEFAULT_USER_ID.to_vec(),
                    address: address.clone(),
                })) {
                    error!("{}", err);
                    return Command::none();
                }
                boxes.user_mut().subscriptions_mut().push(address);
                self.address_value = String::new();
                Command::none()
            }
            _ => panic!("Program error"),
        }
    }

    pub(crate) fn view(
        &self,
        config: &GuiConfig,
        subscriptions: &[Address],
        boxes: &Option<Boxes>,
    ) -> Element<gui::Message> {
        let text_size = config.text_size();

        if boxes.is_none() {
            return Column::new()
                .push(Text::new("inbox/outbox database error").size(text_size))
                .into();
        }
        let boxes = boxes.as_ref().unwrap();

        let mut list = Column::new();
        for address in subscriptions {
            let alias = boxes.user().rich_alias(&address.to_string());
            list = list.push(Text::new(alias).size(text_size));
        }
        let list = scrollable(list).height(Length::Fill);
        // XXX .spacing(text_size / 4);

        let subscribe = Row::new()
            .spacing(text_size / 4)
            .push(
                TextInput::new("Address", &self.address_value)
                    .on_input(gui::Message::SubscriptionsAddressChanged)
                    .size(text_size)
                    .padding(4),
            )
            .push(
                button(Text::new("Subscribe").size(text_size))
                    .on_press(gui::Message::SubscriptionsSubscribePressed),
            );

        Column::new()
            .spacing(text_size / 4)
            .push(list)
            .push(subscribe)
            .into()
    }
}