tgt 1.0.0

A simple TUI for Telegram
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

use {
    crate::{
        action::Action,
        app_context::AppContext,
        components::component_traits::{Component, HandleFocus},
    },
    ratatui::{
        layout::Rect,
        symbols::{
            border::{Set, PLAIN},
            line::NORMAL,
        },
        text::{Line, Span, Text},
        widgets::{block::Block, Borders, Paragraph, Wrap},
    },
    std::{io, sync::Arc},
    tokio::sync::mpsc,
};

/// `ReplyMessage` is a struct that represents a window for replying to messages.
/// It is responsible for managing the layout and rendering of the reply message window.
pub struct ReplyMessage {
    /// The application configuration.
    app_context: Arc<AppContext>,
    /// The name of the `ReplyMessage`.
    name: String,
    /// An unbounded sender that send action for processing.
    command_tx: Option<mpsc::UnboundedSender<Action>>,
    /// Indicates whether the `ReplyMessage` is focused or not.
    focused: bool,
}
/// Implementation of `ReplyMessage` struct.
impl ReplyMessage {
    pub fn new(app_context: Arc<AppContext>) -> Self {
        let command_tx = None;
        let name = "".to_string();
        let focused = false;
        ReplyMessage {
            app_context,
            command_tx,
            name,
            focused,
        }
    }
    /// Set the name of the `ReplyMessage`.
    ///
    /// # Arguments
    /// * `name` - The name of the `ReplyMessage`.
    ///
    /// # Returns
    /// * `Self` - The modified instance of the `ReplyMessage`.
    pub fn with_name(mut self, name: impl AsRef<str>) -> Self {
        self.name = name.as_ref().to_string();
        self
    }
}

/// Implement the `HandleFocus` trait for the `ReplyMessage` struct.
/// This trait allows the `ReplyMessage` to be focused or unfocused.
impl HandleFocus for ReplyMessage {
    /// Set the `focused` flag for the `ReplyMessage`.
    fn focus(&mut self) {
        self.focused = true;
    }
    /// Set the `focused` flag for the `ReplyMessage`.
    fn unfocus(&mut self) {
        self.focused = false;
    }
}

/// Implement the `Component` trait for the `ReplyMessage` struct.
impl Component for ReplyMessage {
    fn register_action_handler(&mut self, tx: mpsc::UnboundedSender<Action>) -> io::Result<()> {
        self.command_tx = Some(tx);
        Ok(())
    }

    fn draw(&mut self, frame: &mut ratatui::Frame<'_>, area: Rect) -> io::Result<()> {
        let mut text = Text::default();
        text.extend(vec![Line::from(vec![Span::styled(
            (*self.app_context.tg_context().reply_message_text()).to_string(),
            self.app_context.style_reply_message_message_text(),
        )])]);

        let collapsed_border = Set {
            top_left: NORMAL.vertical_right,
            top_right: NORMAL.vertical_left,
            bottom_left: NORMAL.vertical_right,
            bottom_right: NORMAL.vertical_left,
            ..PLAIN
        };

        let block = Block::new()
            .border_set(collapsed_border)
            .borders(Borders::RIGHT | Borders::LEFT | Borders::TOP)
            .title("Reply Message")
            .border_style(self.app_context.style_reply_message())
            .style(self.app_context.style_reply_message());

        let paragraph = Paragraph::new(text)
            .block(block)
            .style(self.app_context.style_reply_message())
            // .alignment(Alignment::Center)
            .wrap(Wrap { trim: true });

        frame.render_widget(paragraph, area);

        Ok(())
    }
}