quetty 0.1.9

Terminal-based Azure Service Bus queue manager with intuitive TUI interface
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use super::content::{HelpContent, HelpSection, Shortcut};
use crate::theme::ThemeManager;
use tuirealm::ratatui::{
    layout::{Alignment, Constraint, Layout, Rect},
    style::{Modifier, Style},
    text::{Line, Span, Text},
    widgets::{Block, Paragraph as RatatuiParagraph},
};

/// Utility for rendering help content with consistent styling
pub struct HelpRenderer {
    key_width: usize,
}

impl HelpRenderer {
    pub fn new() -> Self {
        Self { key_width: 20 }
    }

    /// Render the complete help content split into two columns
    pub fn render_help_content<'a>(&self, content: &'a HelpContent) -> (Text<'a>, Text<'a>) {
        let sections = &content.sections;
        let mid_point = sections.len().div_ceil(2);

        let left_sections = &sections[0..mid_point];
        let right_sections = &sections[mid_point..];

        let left_content = self.render_sections(left_sections);
        let right_content = self.render_sections(right_sections);

        (left_content, right_content)
    }

    /// Render header content (instructions and warnings)
    pub fn render_header<'a>(&self, content: &'a HelpContent) -> Text<'a> {
        Text::from(vec![
            Line::from(vec![Span::styled(
                &content.header_message,
                Style::default()
                    .fg(ThemeManager::shortcut_description())
                    .add_modifier(Modifier::BOLD),
            )]),
            Line::from(vec![Span::styled(
                &content.warning_message,
                Style::default().fg(ThemeManager::status_warning()),
            )]),
        ])
    }

    /// Render multiple sections into a single Text
    fn render_sections<'a>(&self, sections: &'a [HelpSection]) -> Text<'a> {
        let mut lines = Vec::new();

        for section in sections {
            // Handle note section specially
            if section.title == "Note" {
                lines.push(Line::from(vec![Span::styled(
                    "Note: Operations work on selected messages in bulk mode,",
                    Style::default().fg(ThemeManager::status_info()),
                )]));
                lines.push(Line::from(vec![Span::styled(
                    "      or on current message when no selections exist.",
                    Style::default().fg(ThemeManager::status_info()),
                )]));
                lines.push(Line::from(""));
                continue;
            }

            // Add section title (skip if empty)
            if !section.title.is_empty() {
                lines.push(Line::from(vec![Span::styled(
                    format!("{} {}", section.icon, section.title),
                    Style::default()
                        .fg(ThemeManager::help_section_title())
                        .add_modifier(Modifier::BOLD),
                )]));
                lines.push(Line::from(""));
            }

            // Add shortcuts for this section
            for shortcut in &section.shortcuts {
                lines.push(self.render_shortcut(shortcut));
            }

            // Add spacing between sections
            if !section.title.is_empty() {
                lines.push(Line::from(""));
            }
        }

        Text::from(lines)
    }

    /// Render a single shortcut with consistent formatting
    fn render_shortcut<'a>(&self, shortcut: &'a Shortcut) -> Line<'a> {
        let key_text = if shortcut.keys.len() == 1 {
            shortcut.keys[0].clone()
        } else {
            shortcut.keys.join(" ")
        };

        // Handle special case for note lines (no description)
        if shortcut.description.is_empty() {
            return Line::from(vec![Span::styled(
                key_text,
                Style::default().fg(ThemeManager::status_info()),
            )]);
        }

        Line::from(vec![
            Span::styled(
                format!("  {:width$}", key_text, width = self.key_width),
                Style::default()
                    .fg(ThemeManager::shortcut_key())
                    .add_modifier(Modifier::BOLD),
            ),
            Span::styled(
                &shortcut.description,
                Style::default().fg(ThemeManager::shortcut_description()),
            ),
        ])
    }

    /// Create a styled paragraph with the given text and alignment
    pub fn create_paragraph<'a>(
        &self,
        text: Text<'a>,
        alignment: Alignment,
    ) -> RatatuiParagraph<'a> {
        RatatuiParagraph::new(text)
            .alignment(alignment)
            .block(Block::default())
    }

    /// Split area into header and content sections
    pub fn layout_help_screen(&self, area: Rect) -> (Rect, Rect, Rect) {
        let chunks = Layout::default()
            .constraints([Constraint::Length(3), Constraint::Min(0)])
            .margin(1)
            .split(area);

        let columns = Layout::default()
            .direction(tuirealm::ratatui::layout::Direction::Horizontal)
            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
            .split(chunks[1]);

        (chunks[0], columns[0], columns[1])
    }
}

impl Default for HelpRenderer {
    fn default() -> Self {
        Self::new()
    }
}