ghtui 0.2.5

A keyboard-driven terminal client for GitHub, with a pull request diff viewer that goes further than GitHub's
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

//! The mouse.

use super::*;
use crate::route::app;

pub fn on_mouse(state: &mut State, ev: MouseEvent) -> Cmds {
    let (x, y) = (ev.column, ev.row);
    match ev.kind {
        MouseEventKind::ScrollDown | MouseEventKind::ScrollUp => {
            let down = ev.kind == MouseEventKind::ScrollDown;
            if state.overlay.is_some() {
                return Cmds::new();
            }
            let height = state.page_height();
            match state.screen_mut() {
                Screen::Page(p) => {
                    scroll_by(p, if down { STEP } else { -STEP }, height);
                }
                Screen::Diff(_) => {
                    let action = if down { Action::Down } else { Action::Up };
                    return (0..3).flat_map(|_| apply(state, action)).collect();
                }
            }
            Cmds::new()
        }
        MouseEventKind::Down(button) => click(state, x, y, button),
        _ => Cmds::new(),
    }
}

pub(super) fn click(state: &mut State, x: u16, y: u16, button: MouseButton) -> Cmds {
    let inside = |r: Rect| r.contains((x, y).into());
    // Overlays first: a click outside closes them.
    match &state.overlay {
        Some(Overlay::Search(sb)) => {
            let (field, _) = state.search_field(sb);
            let (rows, picks): (Vec<_>, Vec<_>) = state.suggestions(sb).into_iter().unzip();
            let panel = chrome::SearchPanel {
                ctx: state.ctx(0),
                rows: &rows,
                selected: sb.selected,
                field,
            };
            let screen = Rect::new(0, 0, state.size.0, state.size.1);
            if inside(field) {
                return Cmds::new();
            }
            if inside(panel.area(screen)) {
                let pick = panel.row_at(screen, y).and_then(|r| picks.get(r));
                let Some(Some(pick)) = pick.cloned() else { return Cmds::new() };
                state.overlay = None;
                return choose(state, pick);
            }
            state.overlay = None;
            // Away from a filter, the header's field still searches GitHub.
            if inside(state.header_search()) {
                return state.open_search(true);
            }
            return Cmds::new();
        }
        Some(Overlay::Compose(_) | Overlay::Submit(_)) => return Cmds::new(),
        Some(_) => {
            state.overlay = None;
            return Cmds::new();
        }
        None => {}
    }
    let lay = state.layout();
    let chrome = state.chrome();
    if inside(lay.header) {
        let h = header_of(&chrome, lay.header);
        if inside(h.search) {
            return state.open_search(true);
        }
        if inside(h.logo) {
            return state.push(Route::App(app::Home));
        }
        let hit = |rects: &[Rect]| rects.iter().position(|r| inside(*r));
        // In the tab strip, a tab (or a hidden-tabs marker) switches to it.
        if let Some(&tab) = hit(&h.crumbs).and_then(|i| chrome.open_tabs.get(i)) {
            return state.switch_to_tab(tab);
        }
        let crumb = hit(&h.crumbs).and_then(|i| chrome.crumbs.get(i)?.1.clone());
        let right = hit(&h.right)
            .and_then(|i| chrome.right.get(i))
            .map(|(_, t)| t.clone());
        return crumb
            .or(right)
            .map_or_else(Cmds::new, |target| state.go(target.into()));
    }
    if let Some(tabs) = lay.tabs
        && inside(tabs)
    {
        return match tabs_of(&chrome, tabs)
            .iter()
            .position(|r| x >= r.x && x < r.right())
        {
            Some(i) => switch_tab(state, i + 1),
            None => Cmds::new(),
        };
    }
    let content = lay.content;
    if let Some((screen, diff)) = state.diff_parts() {
        crate::diff_screen::click(screen, diff, content, x, y);
        return Cmds::new();
    }
    let area = state.page_area();
    let height = state.page_height();
    let Screen::Page(p) = state.screen_mut() else { return Cmds::new() };
    if !inside(area) {
        return Cmds::new();
    }
    p.fresh = false;
    let hit = page::hit(&p.page, area, p.scroll, x, y);
    let item = hit.line.and_then(|l| p.page.item_at(l));
    if button == MouseButton::Right {
        p.selected = item.or(p.selected);
        open_menu(state);
        return Cmds::new();
    }
    if let Some(link) = hit.link.and_then(|l| p.page.target(l)) {
        let link = link.clone();
        p.selected = item.or(p.selected);
        return state.follow(&link);
    }
    match item {
        // A second click on a row opens it.
        Some(i) if p.selected == Some(i) => {
            let link = p.selected_link().cloned();
            link.map_or_else(Cmds::new, |l| state.follow(&l))
        }
        Some(i) => {
            p.selected = Some(i);
            reveal(p, i, height);
            Cmds::new()
        }
        None => Cmds::new(),
    }
}

impl State {
    /// The repository the screen is about.
    pub fn context_repo(&self) -> Option<&RepoId> {
        match self.screen() {
            Screen::Page(p) => p.route.repo(),
            Screen::Diff(d) => Some(d.of.repo()),
        }
    }
}