mold-ai-tui 0.13.1

Terminal UI for mold — interactive AI image generation
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

use ratatui::prelude::*;
use ratatui::widgets::{
    Block, Borders, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState,
};

use crate::app::{GenerateState, ParamField};
use crate::ui::theme::Theme;

/// Render the parameter form panel.
pub fn render(frame: &mut Frame, theme: &Theme, state: &GenerateState, area: Rect, focused: bool) {
    let border_style = if focused {
        theme.border_focused()
    } else {
        theme.border()
    };

    let block = Block::default()
        .borders(Borders::ALL)
        .border_style(border_style)
        .title(" Parameters ")
        .title_style(if focused {
            theme.title_focused()
        } else {
            theme.title()
        })
        .style(Style::default().bg(theme.bg));

    let inner = block.inner(area);
    frame.render_widget(block, area);

    if inner.height == 0 || inner.width == 0 {
        return;
    }

    // Build the lines for all visible fields
    let mut lines: Vec<Line> = Vec::new();
    let mut selected_line: Option<usize> = None;

    for (i, field) in state.visible_fields.iter().enumerate() {
        // Section header
        if let Some(header) = field.section_header() {
            lines.push(Line::from(vec![
                Span::styled(
                    format!("\u{2500}\u{2500} {header} "),
                    Style::default()
                        .fg(theme.text_dim)
                        .add_modifier(Modifier::BOLD),
                ),
                Span::styled(
                    "\u{2500}".repeat(inner.width.saturating_sub(header.len() as u16 + 5) as usize),
                    Style::default().fg(theme.border),
                ),
            ]));
        }

        let is_selected = focused && i == state.param_index;
        if is_selected {
            selected_line = Some(lines.len());
        }

        let label = format!("{:<10}", field.label());
        let value = state.params.display_value(field);

        let (label_style, value_style) = if is_selected {
            (theme.param_selected(), theme.param_selected())
        } else {
            (theme.param_label(), theme.param_value())
        };

        // Add indicator for dropdown/toggle fields
        let suffix = match field {
            ParamField::Model => " \u{25bc}", // down triangle
            ParamField::Format | ParamField::Mode | ParamField::Expand | ParamField::Offload
                if is_selected =>
            {
                " \u{25c0}\u{25b6}"
            } // left/right arrows
            ParamField::Width
            | ParamField::Height
            | ParamField::Steps
            | ParamField::Guidance
            | ParamField::Batch
            | ParamField::Frames
            | ParamField::Fps
            | ParamField::Strength
            | ParamField::ControlScale
                if is_selected =>
            {
                " \u{25c0}\u{25b6}"
            }
            _ => "",
        };

        lines.push(Line::from(vec![
            Span::styled(label, label_style),
            Span::styled(value, value_style),
            Span::styled(
                suffix,
                if is_selected {
                    theme.param_selected()
                } else {
                    theme.dim()
                },
            ),
        ]));
    }

    // Scroll to keep the selected line visible
    let scroll_offset = if let Some(sel) = selected_line {
        if sel >= inner.height as usize {
            sel.saturating_sub(inner.height as usize / 2)
        } else {
            0
        }
    } else {
        0
    };

    let paragraph = Paragraph::new(lines.clone()).scroll((scroll_offset as u16, 0));
    frame.render_widget(paragraph, inner);

    // Scrollbar if content overflows
    if lines.len() > inner.height as usize {
        let mut scrollbar_state =
            ScrollbarState::new(lines.len().saturating_sub(inner.height as usize))
                .position(scroll_offset);
        let scrollbar = Scrollbar::new(ScrollbarOrientation::VerticalRight)
            .style(Style::default().fg(theme.border));
        frame.render_stateful_widget(scrollbar, inner, &mut scrollbar_state);
    }
}