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
156
157
158
159
160
161
162
163
164
165
166
167
168
|
use std::cell::RefCell;
use std::rc::Rc;
use zellij_tile::prelude::*;
use crate::pages::{Page, TextOrCustomRender};
#[derive(Debug)]
pub struct ActiveComponent {
text_no_hover: TextOrCustomRender,
text_hover: Option<TextOrCustomRender>,
left_click_action: Option<ClickAction>,
last_rendered_coordinates: Option<ComponentCoordinates>,
pub is_active: bool,
}
impl ActiveComponent {
pub fn new(text_no_hover: TextOrCustomRender) -> Self {
ActiveComponent {
text_no_hover,
text_hover: None,
left_click_action: None,
is_active: false,
last_rendered_coordinates: None,
}
}
pub fn with_hover(mut self, text_hover: TextOrCustomRender) -> Self {
self.text_hover = Some(text_hover);
self
}
pub fn with_left_click_action(mut self, left_click_action: ClickAction) -> Self {
self.left_click_action = Some(left_click_action);
self
}
pub fn render(&mut self, x: usize, y: usize, rows: usize, columns: usize) -> usize {
let mut component_width = 0;
match self.text_hover.as_mut() {
Some(text) if self.is_active => {
let text_len = text.render(x, y, rows, columns);
component_width += text_len;
},
_ => {
let text_len = self.text_no_hover.render(x, y, rows, columns);
component_width += text_len;
},
}
self.last_rendered_coordinates = Some(ComponentCoordinates::new(x, y, 1, columns));
component_width
}
pub fn left_click_action(&mut self) -> Option<Page> {
match self.left_click_action.take() {
Some(ClickAction::ChangePage(go_to_page)) => Some(go_to_page()),
Some(ClickAction::OpenLink(link, executable)) => {
self.left_click_action =
Some(ClickAction::OpenLink(link.clone(), executable.clone()));
run_command(&[&executable.borrow(), &link], Default::default());
None
},
Some(ClickAction::LaunchPlugin(plugin_url)) => {
open_plugin_pane_floating(
&plugin_url,
Default::default(),
None,
Default::default(),
);
self.left_click_action = Some(ClickAction::LaunchPlugin(plugin_url));
None
},
None => None,
}
}
pub fn handle_left_click_at_position(&mut self, x: usize, y: usize) -> Option<Page> {
let Some(last_rendered_coordinates) = &self.last_rendered_coordinates else {
return None;
};
if last_rendered_coordinates.contains(x, y) {
self.left_click_action()
} else {
None
}
}
pub fn handle_hover_at_position(&mut self, x: usize, y: usize) -> bool {
let Some(last_rendered_coordinates) = &self.last_rendered_coordinates else {
return false;
};
if last_rendered_coordinates.contains(x, y) && self.text_hover.is_some() {
self.is_active = true;
true
} else {
false
}
}
pub fn handle_selection(&mut self) -> Option<Page> {
if self.is_active {
self.left_click_action()
} else {
None
}
}
pub fn column_count(&self) -> usize {
match self.text_hover.as_ref() {
Some(text) if self.is_active => text.len(),
_ => self.text_no_hover.len(),
}
}
pub fn clear_hover(&mut self) {
self.is_active = false;
}
}
#[derive(Debug)]
struct ComponentCoordinates {
x: usize,
y: usize,
rows: usize,
columns: usize,
}
impl ComponentCoordinates {
pub fn contains(&self, x: usize, y: usize) -> bool {
x >= self.x && x < self.x + self.columns && y >= self.y && y < self.y + self.rows
}
}
impl ComponentCoordinates {
pub fn new(x: usize, y: usize, rows: usize, columns: usize) -> Self {
ComponentCoordinates {
x,
y,
rows,
columns,
}
}
}
pub enum ClickAction {
ChangePage(Box<dyn FnOnce() -> Page>),
OpenLink(String, Rc<RefCell<String>>), // (destination, executable)
LaunchPlugin(String), // plugin URL (e.g. "zellij:share")
}
impl std::fmt::Debug for ClickAction {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ClickAction::ChangePage(_) => write!(f, "ChangePage"),
ClickAction::OpenLink(destination, executable) => {
write!(f, "OpenLink: {}, {:?}", destination, executable)
},
ClickAction::LaunchPlugin(url) => {
write!(f, "LaunchPlugin: {}", url)
},
}
}
}
impl ClickAction {
pub fn new_change_page<F>(go_to_page: F) -> Self
where
F: FnOnce() -> Page + 'static,
{
ClickAction::ChangePage(Box::new(go_to_page))
}
pub fn new_open_link(destination: String, executable: Rc<RefCell<String>>) -> Self {
ClickAction::OpenLink(destination, executable)
}
pub fn new_launch_plugin(plugin_url: String) -> Self {
ClickAction::LaunchPlugin(plugin_url)
}
}
|
