rioterm 0.3.9

Rio terminal is a hardware-accelerated GPU terminal emulator, focusing to run in desktops and browsers.
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

use crate::constants;
use crate::layout::ContextDimension;
use rio_backend::config::navigation::Navigation;
use rio_backend::config::Config;
use rio_backend::sugarloaf::{SpanStyle, Sugarloaf};
use rio_window::window::Theme;

/// Add text to the currently selected text content with per-character
/// font fallback. Resolves each character against sugarloaf's glyph
/// cache, groups consecutive chars by resolved `font_id`, and emits
/// one span per group. The selected text id is whatever was last
/// passed to `Content::sel(...)` by the caller.
#[inline]
pub fn add_span_with_fallback(
    sugarloaf: &mut Sugarloaf,
    text: &str,
    base_style: SpanStyle,
) {
    let font_attrs = base_style.font_attrs;

    // First walk: resolve every char against sugarloaf's font cache
    // and group into runs by font_id. We can't push to `content` yet
    // because `resolve_glyph` borrows sugarloaf mutably to fill the
    // cache.
    let mut runs: Vec<(usize, String)> = Vec::new();
    let mut current_font_id: Option<usize> = None;
    let mut current_run = String::new();

    for ch in text.chars() {
        let glyph = sugarloaf.resolve_glyph(ch, font_attrs);
        if current_font_id == Some(glyph.font_id) {
            current_run.push(ch);
        } else {
            if !current_run.is_empty() {
                runs.push((
                    current_font_id.unwrap_or(0),
                    std::mem::take(&mut current_run),
                ));
            }
            current_font_id = Some(glyph.font_id);
            current_run.push(ch);
        }
    }
    if !current_run.is_empty() {
        runs.push((current_font_id.unwrap_or(0), current_run));
    }

    // Second walk: emit the runs. Now we can take `&mut Content`
    // because all the cache fills are done.
    let content = sugarloaf.content();
    for (font_id, run) in runs {
        content.add_span(
            &run,
            SpanStyle {
                font_id,
                ..base_style
            },
        );
    }
}

#[inline]
pub fn padding_top_from_config(
    navigation: &Navigation,
    padding_y_top: f32,
    #[allow(unused)] num_tabs: usize,
    #[allow(unused)] macos_use_unified_titlebar: bool,
) -> f32 {
    // When navigation is enabled (Tab mode), start content below island
    if navigation.is_enabled() {
        // On Linux/Windows, if hide_if_single is true and there's only one tab,
        // the island is hidden so render from 0 + configured margin
        #[cfg(not(target_os = "macos"))]
        if navigation.hide_if_single && num_tabs <= 1 {
            return constants::PADDING_Y + padding_y_top;
        }

        use crate::renderer::island::ISLAND_HEIGHT;
        return ISLAND_HEIGHT + padding_y_top;
    }

    let default_padding = constants::PADDING_Y + padding_y_top;

    #[cfg(target_os = "macos")]
    {
        use rio_backend::config::navigation::NavigationMode;
        if navigation.mode == NavigationMode::NativeTab {
            let additional = if macos_use_unified_titlebar {
                constants::ADDITIONAL_PADDING_Y_ON_UNIFIED_TITLEBAR
            } else {
                0.0
            };
            return additional + padding_y_top;
        }
    }

    default_padding
}

#[inline]
pub fn terminal_dimensions(layout: &ContextDimension) -> teletypewriter::WinsizeBuilder {
    let width = layout.width - layout.margin.left - layout.margin.right;
    let height = layout.height - layout.margin.top - layout.margin.bottom;
    teletypewriter::WinsizeBuilder {
        width: width as u16,
        height: height as u16,
        cols: layout.columns as u16,
        rows: layout.lines as u16,
    }
}

#[inline]
pub fn update_colors_based_on_theme(config: &mut Config, theme_opt: Option<Theme>) {
    if let Some(theme) = theme_opt {
        if let Some(adaptive_colors) = &config.adaptive_colors {
            match theme {
                Theme::Light => {
                    if let Some(light_colors) = adaptive_colors.light {
                        config.colors = light_colors;
                    }
                }
                Theme::Dark => {
                    if let Some(darkcolors) = adaptive_colors.dark {
                        config.colors = darkcolors;
                    }
                }
            }
        }
    }
}