aboutsummaryrefslogtreecommitdiffstats
path: root/default-plugins/share/src/main.rs
diff options
context:
space:
mode:
authorAram Drevekenin <aram@poor.dev>2025-06-23 19:19:37 +0200
committerGitHub <noreply@github.com>2025-06-23 19:19:37 +0200
commitc5ac7968809ddb1033b625562eae22019cccc2f4 (patch)
tree932cf07d898dfbcc6ec6a9d4cf5353c06a47accc /default-plugins/share/src/main.rs
parentfeat(ui): add optional tooltip with key hints to the compact bar (#4225) (diff)
downloadsl0ppij-c5ac7968809ddb1033b625562eae22019cccc2f4.tar.gz
sl0ppij-c5ac7968809ddb1033b625562eae22019cccc2f4.tar.xz
sl0ppij-c5ac7968809ddb1033b625562eae22019cccc2f4.zip
Feature: web-client/server to share your sessions in the browser (#4242)
* work * moar work * notes * work * separate to terminal and control channels * stdin working * serve html web client initial * serve static assets loaded with include_dir * merge * enable_web_server config parameter * compile time flag to disable web server capability * rustfmt * add license to all xterm.js assets * mouse working except copy/paste * helpful comment * web client improvements - move script to js file - add favicon - add nerd font - change title TODO: investigate if font license embedded in otf is sufficient * get mouse to work properly * kitty keyboard support initial * fix wrong type in preload link * wip axum websocket handlers - upgrade axum to v0.8.1, enable ws feature - begin setup of websocket handlers - tidy up imports * replace control listener * handle terminal websocket with axum * cleanup Cargo.toml * kitty fixes and bracketed paste * fix(mouse): pane not found crash * initial session switching infra * add `web_client_font` option * session switching, creation and resurrection working through the session manager * move session module to zellij-utils and share logic with web-client * some cleanups * require restart for enable-web-server * use session name from router * write config to disk and watch for config changes * rename session name to ipc path * add basic panic handler, make render_to_client exit on channel close * use while let instead of loop * handle websocket close * add mouse motions * make clipboard work * add weblink handling and webgl rendering * add todo * fix: use session name instead of patch on session switch * use "default" layout for new sessions * ui indication for session being shared * share this session ui * plugin assets * Fix process crash on mac with notify watcher. Use poll watcher instead of recommended as a workaround. * make url session switching and creation work * start welcome screen on root url * scaffold control messages, set font from config * set dimensions on session start * bring back session name from url * send bytes on terminal websocket instead of json - create web client os input and id before websocket connection * draft ui * work * refactor ui * remove otf font, remove margins to avoid scrollbar * version query endpoint for server status * web session info query endpoint * refactor: move stuff around * add web client info to session metadata * make tests pass * populate real data in session list * remove unnecessary endpoint * add web_client node to config, add font option * remove web_client_font * allow disabling the web session through the config - WIP * formalize sharing/not-sharing configuration * fix tests * allow shutting down web server * display error when web clients are forbidden to attach * only show sessions that allow web clients if this is a web client * style(fmt): rustfmt * fix: query web server from Zellij rather than from each plugin * remove log spam * handle some error paths better in the web client * allow controlling the web server through the cli * allow configuring the web server's ip/port * fix tests and format code * use direct WebServerStatus event instead of piggy-backing on SessionInfo * plugin revamp initial * make plugin responsive * adjust plugin title * refactor: share plugin * refactor: share plugin * add cors middleware * some fixes for running without a compiled web server capability * display error when starting the share plugin without web server support * clarify config * add pipelines to compile zellij without web support * display error when unable to start web server * only query web server when share plugin is running * refactor(web-client): connection table * give zellij_server_listener access to the control channel * fixes and clarifications * refactor: consolidate generate_unique_session_name * give proper error when trying to attach to a forbidden session * change browser URL when switching sessions * add keyboard shortcut * enforce https when bound to non-loopback ip * initial authentication token implementation * background color from theme * initial web client theme config * basic token generation ui * refactor set config message creation * also set body background * allow editing scrollback for plugins too * set scrollback to 0 * properly parse colors in config * generate token from plugin * nice login modals * initial token management screen * implement token authentication * refactor(share): token management screen * style(fmt): rustfmt * fix(plugin): some minor bugs * refactor(share): main screen * refactor(share): token screen * refactor(share): main * refactor(share): ui components * fix(responsiveness): properly send usage_width to the render function * fix cli commands and add some verbosity * add support for settings ansi and selection colors * add cursor and cursor accent * basic web client tests * fix tests * refactor: web client * use session tokens for authentication * improve modals * move shutdown to ipc * refactor: ipc logic * serialize theme config for web client * update tests * refactor: move some stuff around to prepare for config hot reload * config live reloading for the web clients * change remember-me UI wording * improve xterm.js link handling * make sure terminal is focused on mousemove * remove deprecated sharing indication from compact-bar * gate deps and functionality behind the web_server_compatibility feature * feat(build): add --no-web flag in all the places * fix some other build flows * add new assets * update CI for no-web (untested) * make more dependencies optional * update axum-extra * add web client configuration options * gracefully close connections on server exit * tests for graceful connection closing * handle client-side reconnect when server is down * fix: make sure ipc bus folder exists before starting * add commands to manage login tokens from the cli * style(fmt): rustfmt * some cleanups * fix(ux): allow alt-right-click on the web client without opening the context menu * fix: prevent attaching to welcome screen * fix: reload config issues * fix long socket path on macos * normalize config conversion and fix color gap in browser * revoke session_token cookie if it is not valid * fix: visual bug with multiple clients in extremely small screen sizes * fix: only include rusqlite for the web server capability builds * update e2e snapshots * refactor(web): client side js * some cleanups * moar cleanups * fix(tests): wait for server instead of using a fixed timeout * debug CI * fix(tests): use spawn_blocking for running the test web server * fix(tests): wait for http rather than tcp port * fix(tests): properly pass config path - hopefully this is the issue... * success! bring back the rest of the tests * attempt to fix the macos CI issue * docs(changelog): add PR --------- Co-authored-by: Thomas Linford <linford.t@gmail.com>
Diffstat (limited to 'default-plugins/share/src/main.rs')
-rw-r--r--default-plugins/share/src/main.rs647
1 files changed, 647 insertions, 0 deletions
diff --git a/default-plugins/share/src/main.rs b/default-plugins/share/src/main.rs
new file mode 100644
index 00000000..1708e495
--- /dev/null
+++ b/default-plugins/share/src/main.rs
@@ -0,0 +1,647 @@
+mod main_screen;
+mod token_management_screen;
+mod token_screen;
+mod ui_components;
+
+use std::net::IpAddr;
+use zellij_tile::prelude::*;
+
+use std::collections::{BTreeMap, HashMap};
+
+use main_screen::MainScreen;
+use token_management_screen::TokenManagementScreen;
+use token_screen::TokenScreen;
+
+static WEB_SERVER_QUERY_DURATION: f64 = 0.4; // Doherty threshold
+
+#[derive(Debug, Default)]
+struct App {
+ web_server: WebServerState,
+ ui: UIState,
+ tokens: TokenManager,
+ state: AppState,
+}
+
+register_plugin!(App);
+
+impl ZellijPlugin for App {
+ fn load(&mut self, _configuration: BTreeMap<String, String>) {
+ self.initialize();
+ }
+
+ fn update(&mut self, event: Event) -> bool {
+ if !self.web_server.capability && !matches!(event, Event::ModeUpdate(_)) {
+ return false;
+ }
+
+ match event {
+ Event::Timer(_) => self.handle_timer(),
+ Event::ModeUpdate(mode_info) => self.handle_mode_update(mode_info),
+ Event::WebServerStatus(status) => self.handle_web_server_status(status),
+ Event::Key(key) => self.handle_key_input(key),
+ Event::Mouse(mouse_event) => self.handle_mouse_event(mouse_event),
+ Event::RunCommandResult(exit_code, _stdout, _stderr, context) => {
+ self.handle_command_result(exit_code, context)
+ },
+ Event::FailedToStartWebServer(error) => self.handle_web_server_error(error),
+ _ => false,
+ }
+ }
+
+ fn render(&mut self, rows: usize, cols: usize) {
+ if !self.web_server.capability {
+ self.render_no_capability_message(rows, cols);
+ return;
+ }
+
+ self.ui.reset_render_state();
+ match &self.state.current_screen {
+ Screen::Main => self.render_main_screen(rows, cols),
+ Screen::Token(token) => self.render_token_screen(rows, cols, token),
+ Screen::ManageTokens => self.render_manage_tokens_screen(rows, cols),
+ }
+ }
+}
+
+impl App {
+ fn initialize(&mut self) {
+ self.subscribe_to_events();
+ self.state.own_plugin_id = Some(get_plugin_ids().plugin_id);
+ self.retrieve_token_list();
+ self.query_link_executable();
+ self.set_plugin_title();
+ }
+
+ fn subscribe_to_events(&self) {
+ subscribe(&[
+ EventType::Key,
+ EventType::ModeUpdate,
+ EventType::WebServerStatus,
+ EventType::Mouse,
+ EventType::RunCommandResult,
+ EventType::FailedToStartWebServer,
+ EventType::Timer,
+ ]);
+ }
+
+ fn set_plugin_title(&self) {
+ if let Some(plugin_id) = self.state.own_plugin_id {
+ rename_plugin_pane(plugin_id, "Share Session");
+ }
+ }
+
+ fn handle_timer(&mut self) -> bool {
+ query_web_server_status();
+ self.retrieve_token_list();
+ set_timeout(WEB_SERVER_QUERY_DURATION);
+ false
+ }
+
+ fn handle_mode_update(&mut self, mode_info: ModeInfo) -> bool {
+ let mut should_render = false;
+
+ self.state.session_name = mode_info.session_name;
+
+ if let Some(web_clients_allowed) = mode_info.web_clients_allowed {
+ self.web_server.clients_allowed = web_clients_allowed;
+ should_render = true;
+ }
+
+ if let Some(web_sharing) = mode_info.web_sharing {
+ self.web_server.sharing = web_sharing;
+ should_render = true;
+ }
+
+ if let Some(web_server_ip) = mode_info.web_server_ip {
+ self.web_server.ip = Some(web_server_ip);
+ should_render = true;
+ }
+
+ if let Some(web_server_port) = mode_info.web_server_port {
+ self.web_server.port = Some(web_server_port);
+ should_render = true;
+ }
+
+ if let Some(web_server_capability) = mode_info.web_server_capability {
+ self.web_server.capability = web_server_capability;
+ if self.web_server.capability && !self.state.timer_running {
+ self.state.timer_running = true;
+ set_timeout(WEB_SERVER_QUERY_DURATION);
+ }
+ should_render = true;
+ }
+
+ should_render
+ }
+
+ fn handle_web_server_status(&mut self, status: WebServerStatus) -> bool {
+ match status {
+ WebServerStatus::Online(base_url) => {
+ self.web_server.base_url = base_url;
+ self.web_server.started = true;
+ self.web_server.different_version_error = None;
+ },
+ WebServerStatus::Offline => {
+ self.web_server.started = false;
+ self.web_server.different_version_error = None;
+ },
+ WebServerStatus::DifferentVersion(version) => {
+ self.web_server.started = false;
+ self.web_server.different_version_error = Some(version);
+ },
+ }
+ true
+ }
+
+ fn handle_key_input(&mut self, key: KeyWithModifier) -> bool {
+ if self.clear_error_or_info() {
+ return true;
+ }
+
+ match self.state.current_screen {
+ Screen::Main => self.handle_main_screen_keys(key),
+ Screen::Token(_) => self.handle_token_screen_keys(key),
+ Screen::ManageTokens => self.handle_manage_tokens_keys(key),
+ }
+ }
+
+ fn clear_error_or_info(&mut self) -> bool {
+ self.web_server.error.take().is_some() || self.state.info.take().is_some()
+ }
+
+ fn handle_main_screen_keys(&mut self, key: KeyWithModifier) -> bool {
+ match key.bare_key {
+ BareKey::Enter if key.has_no_modifiers() && !self.web_server.started => {
+ start_web_server();
+ false
+ },
+ BareKey::Char('c') if key.has_modifiers(&[KeyModifier::Ctrl]) => {
+ stop_web_server();
+ false
+ },
+ BareKey::Char(' ') if key.has_no_modifiers() => {
+ self.toggle_session_sharing();
+ false
+ },
+ BareKey::Char('t') if key.has_no_modifiers() => {
+ self.handle_token_action();
+ true
+ },
+ BareKey::Esc if key.has_no_modifiers() => {
+ close_self();
+ false
+ },
+ _ => false,
+ }
+ }
+
+ fn toggle_session_sharing(&self) {
+ match self.web_server.sharing {
+ WebSharing::Disabled => {},
+ WebSharing::On => stop_sharing_current_session(),
+ WebSharing::Off => share_current_session(),
+ }
+ }
+
+ fn handle_token_action(&mut self) {
+ if self.tokens.list.is_empty() {
+ self.generate_new_token(None);
+ } else {
+ self.change_to_manage_tokens_screen();
+ }
+ }
+
+ fn handle_token_screen_keys(&mut self, key: KeyWithModifier) -> bool {
+ match key.bare_key {
+ BareKey::Esc if key.has_no_modifiers() => {
+ self.change_to_previous_screen();
+ true
+ },
+ _ => false,
+ }
+ }
+
+ fn handle_manage_tokens_keys(&mut self, key: KeyWithModifier) -> bool {
+ if self.tokens.handle_text_input(&key) {
+ return true;
+ }
+
+ match key.bare_key {
+ BareKey::Esc if key.has_no_modifiers() => self.handle_escape_key(),
+ BareKey::Down if key.has_no_modifiers() => self.tokens.navigate_down(),
+ BareKey::Up if key.has_no_modifiers() => self.tokens.navigate_up(),
+ BareKey::Char('n') if key.has_no_modifiers() => {
+ self.tokens.start_new_token_input();
+ true
+ },
+ BareKey::Enter if key.has_no_modifiers() => self.handle_enter_key(),
+ BareKey::Char('r') if key.has_no_modifiers() => {
+ self.tokens.start_rename_input();
+ true
+ },
+ BareKey::Char('x') if key.has_no_modifiers() => self.revoke_selected_token(),
+ BareKey::Char('x') if key.has_modifiers(&[KeyModifier::Ctrl]) => {
+ self.revoke_all_tokens();
+ true
+ },
+ _ => false,
+ }
+ }
+
+ fn handle_escape_key(&mut self) -> bool {
+ let was_editing = self.tokens.cancel_input();
+
+ if !was_editing {
+ self.change_to_main_screen();
+ }
+ true
+ }
+
+ fn handle_enter_key(&mut self) -> bool {
+ if let Some(token_name) = self.tokens.finish_new_token_input() {
+ self.generate_new_token(token_name);
+ return true;
+ }
+
+ if let Some(new_name) = self.tokens.finish_rename_input() {
+ self.rename_current_token(new_name);
+ return true;
+ }
+
+ false
+ }
+
+ fn generate_new_token(&mut self, name: Option<String>) {
+ match generate_web_login_token(name) {
+ Ok(token) => self.change_to_token_screen(token),
+ Err(e) => self.web_server.error = Some(e),
+ }
+ }
+
+ fn rename_current_token(&mut self, new_name: String) {
+ if let Some(current_token) = self.tokens.get_selected_token() {
+ match rename_web_token(&current_token.0, &new_name) {
+ Ok(_) => {
+ self.retrieve_token_list();
+ if self.tokens.adjust_selection_after_list_change() {
+ self.change_to_main_screen();
+ }
+ },
+ Err(e) => self.web_server.error = Some(e),
+ }
+ }
+ }
+
+ fn revoke_selected_token(&mut self) -> bool {
+ if let Some(token) = self.tokens.get_selected_token() {
+ match revoke_web_login_token(&token.0) {
+ Ok(_) => {
+ self.retrieve_token_list();
+ if self.tokens.adjust_selection_after_list_change() {
+ self.change_to_main_screen();
+ }
+ self.state.info = Some("Revoked. Connected clients not affected.".to_owned());
+ },
+ Err(e) => self.web_server.error = Some(e),
+ }
+ return true;
+ }
+ false
+ }
+
+ fn revoke_all_tokens(&mut self) {
+ match revoke_all_web_tokens() {
+ Ok(_) => {
+ self.retrieve_token_list();
+ if self.tokens.adjust_selection_after_list_change() {
+ self.change_to_main_screen();
+ }
+ self.state.info = Some("Revoked. Connected clients not affected.".to_owned());
+ },
+ Err(e) => self.web_server.error = Some(e),
+ }
+ }
+
+ fn handle_mouse_event(&mut self, event: Mouse) -> bool {
+ match event {
+ Mouse::LeftClick(line, column) => self.handle_link_click(line, column),
+ Mouse::Hover(line, column) => {
+ self.ui.hover_coordinates = Some((column, line as usize));
+ true
+ },
+ _ => false,
+ }
+ }
+
+ fn handle_link_click(&mut self, line: isize, column: usize) -> bool {
+ for (coordinates, url) in &self.ui.clickable_urls {
+ if coordinates.contains(column, line as usize) {
+ if let Some(executable) = self.ui.link_executable {
+ run_command(&[executable, url], Default::default());
+ }
+ return true;
+ }
+ }
+ false
+ }
+
+ fn handle_command_result(
+ &mut self,
+ exit_code: Option<i32>,
+ context: BTreeMap<String, String>,
+ ) -> bool {
+ if context.contains_key("xdg_open_cli") && exit_code == Some(0) {
+ self.ui.link_executable = Some("xdg-open");
+ } else if context.contains_key("open_cli") && exit_code == Some(0) {
+ self.ui.link_executable = Some("open");
+ }
+ false
+ }
+
+ fn handle_web_server_error(&mut self, error: String) -> bool {
+ self.web_server.error = Some(error);
+ true
+ }
+
+ fn query_link_executable(&self) {
+ let mut xdg_context = BTreeMap::new();
+ xdg_context.insert("xdg_open_cli".to_owned(), String::new());
+ run_command(&["xdg-open", "--help"], xdg_context);
+
+ let mut open_context = BTreeMap::new();
+ open_context.insert("open_cli".to_owned(), String::new());
+ run_command(&["open", "--help"], open_context);
+ }
+
+ fn render_no_capability_message(&self, rows: usize, cols: usize) {
+ let full_text = "This version of Zellij was compiled without web sharing capabilities";
+ let short_text = "No web server capabilities";
+ let text = if cols >= full_text.chars().count() {
+ full_text
+ } else {
+ short_text
+ };
+
+ let text_element = Text::new(text).color_range(3, ..);
+ let text_x = cols.saturating_sub(text.chars().count()) / 2;
+ let text_y = rows / 2;
+ print_text_with_coordinates(text_element, text_x, text_y, None, None);
+ }
+
+ fn change_to_token_screen(&mut self, token: String) {
+ self.retrieve_token_list();
+ set_self_mouse_selection_support(true);
+ self.state.previous_screen = Some(self.state.current_screen.clone());
+ self.state.current_screen = Screen::Token(token);
+ }
+
+ fn change_to_manage_tokens_screen(&mut self) {
+ self.retrieve_token_list();
+ set_self_mouse_selection_support(false);
+ self.tokens.selected_index = Some(0);
+ self.state.previous_screen = None;
+ self.state.current_screen = Screen::ManageTokens;
+ }
+
+ fn change_to_main_screen(&mut self) {
+ self.retrieve_token_list();
+ set_self_mouse_selection_support(false);
+ self.state.previous_screen = None;
+ self.state.current_screen = Screen::Main;
+ }
+
+ fn change_to_previous_screen(&mut self) {
+ self.retrieve_token_list();
+ match self.state.previous_screen.take() {
+ Some(Screen::ManageTokens) => self.change_to_manage_tokens_screen(),
+ _ => self.change_to_main_screen(),
+ }
+ }
+
+ fn render_main_screen(&mut self, rows: usize, cols: usize) {
+ let state_changes = MainScreen::new(
+ self.tokens.list.is_empty(),
+ self.web_server.started,
+ &self.web_server.error,
+ &self.web_server.different_version_error,
+ &self.web_server.base_url,
+ self.web_server.ip,
+ self.web_server.port,
+ &self.state.session_name,
+ self.web_server.sharing,
+ self.ui.hover_coordinates,
+ &self.state.info,
+ &self.ui.link_executable,
+ )
+ .render(rows, cols);
+
+ self.ui.currently_hovering_over_link = state_changes.currently_hovering_over_link;
+ self.ui.currently_hovering_over_unencrypted =
+ state_changes.currently_hovering_over_unencrypted;
+ self.ui.clickable_urls = state_changes.clickable_urls;
+ }
+
+ fn render_token_screen(&self, rows: usize, cols: usize, token: &str) {
+ let token_screen =
+ TokenScreen::new(token.to_string(), self.web_server.error.clone(), rows, cols);
+ token_screen.render();
+ }
+
+ fn render_manage_tokens_screen(&self, rows: usize, cols: usize) {
+ TokenManagementScreen::new(
+ &self.tokens.list,
+ self.tokens.selected_index,
+ &self.tokens.renaming_token,
+ &self.tokens.entering_new_name,
+ &self.web_server.error,
+ &self.state.info,
+ rows,
+ cols,
+ )
+ .render();
+ }
+
+ fn retrieve_token_list(&mut self) {
+ if let Err(e) = self.tokens.retrieve_list() {
+ self.web_server.error = Some(e);
+ }
+ }
+}
+
+#[derive(Debug, Default)]
+struct WebServerState {
+ started: bool,
+ sharing: WebSharing,
+ clients_allowed: bool,
+ error: Option<String>,
+ different_version_error: Option<String>,
+ ip: Option<IpAddr>,
+ port: Option<u16>,
+ base_url: String,
+ capability: bool,
+}
+
+#[derive(Debug, Default)]
+struct UIState {
+ hover_coordinates: Option<(usize, usize)>,
+ clickable_urls: HashMap<CoordinatesInLine, String>,
+ link_executable: Option<&'static str>,
+ currently_hovering_over_link: bool,
+ currently_hovering_over_unencrypted: bool,
+}
+
+impl UIState {
+ fn reset_render_state(&mut self) {
+ self.currently_hovering_over_link = false;
+ self.clickable_urls.clear();
+ }
+}
+
+#[derive(Debug, Default)]
+struct TokenManager {
+ list: Vec<(String, String)>,
+ selected_index: Option<usize>,
+ entering_new_name: Option<String>,
+ renaming_token: Option<String>,
+}
+
+impl TokenManager {
+ fn retrieve_list(&mut self) -> Result<(), String> {
+ match list_web_login_tokens() {
+ Ok(tokens) => {
+ self.list = tokens;
+ Ok(())
+ },
+ Err(e) => Err(format!("Failed to retrieve login tokens: {}", e)),
+ }
+ }
+
+ fn get_selected_token(&self) -> Option<&(String, String)> {
+ self.selected_index.and_then(|i| self.list.get(i))
+ }
+
+ fn adjust_selection_after_list_change(&mut self) -> bool {
+ if self.list.is_empty() {
+ self.selected_index = None;
+ true // indicates should change to main screen
+ } else if self.selected_index >= Some(self.list.len()) {
+ self.selected_index = Some(self.list.len().saturating_sub(1));
+ false
+ } else {
+ false
+ }
+ }
+
+ fn navigate_down(&mut self) -> bool {
+ if let Some(ref mut index) = self.selected_index {
+ *index = if *index < self.list.len().saturating_sub(1) {
+ *index + 1
+ } else {
+ 0
+ };
+ return true;
+ }
+ false
+ }
+
+ fn navigate_up(&mut self) -> bool {
+ if let Some(ref mut index) = self.selected_index {
+ *index = if *index == 0 {
+ self.list.len().saturating_sub(1)
+ } else {
+ *index - 1
+ };
+ return true;
+ }
+ false
+ }
+
+ fn start_new_token_input(&mut self) {
+ self.entering_new_name = Some(String::new());
+ }
+
+ fn start_rename_input(&mut self) {
+ self.renaming_token = Some(String::new());
+ }
+
+ fn handle_text_input(&mut self, key: &KeyWithModifier) -> bool {
+ match key.bare_key {
+ BareKey::Char(c) if key.has_no_modifiers() => {
+ if let Some(ref mut name) = self.entering_new_name {
+ name.push(c);
+ return true;
+ }
+ if let Some(ref mut name) = self.renaming_token {
+ name.push(c);
+ return true;
+ }
+ },
+ BareKey::Backspace if key.has_no_modifiers() => {
+ if let Some(ref mut name) = self.entering_new_name {
+ name.pop();
+ return true;
+ }
+ if let Some(ref mut name) = self.renaming_token {
+ name.pop();
+ return true;
+ }
+ },
+ _ => {},
+ }
+ false
+ }
+
+ fn finish_new_token_input(&mut self) -> Option<Option<String>> {
+ self.entering_new_name
+ .take()
+ .map(|name| if name.is_empty() { None } else { Some(name) })
+ }
+
+ fn finish_rename_input(&mut self) -> Option<String> {
+ self.renaming_token.take()
+ }
+
+ fn cancel_input(&mut self) -> bool {
+ self.entering_new_name.take().is_some() || self.renaming_token.take().is_some()
+ }
+}
+
+#[derive(Debug, Default)]
+struct AppState {
+ session_name: Option<String>,
+ own_plugin_id: Option<u32>,
+ timer_running: bool,
+ current_screen: Screen,
+ previous_screen: Option<Screen>,
+ info: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+enum Screen {
+ Main,
+ Token(String),
+ ManageTokens,
+}
+
+impl Default for Screen {
+ fn default() -> Self {
+ Screen::Main
+ }
+}
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct CoordinatesInLine {
+ x: usize,
+ y: usize,
+ width: usize,
+}
+
+impl CoordinatesInLine {
+ pub fn new(x: usize, y: usize, width: usize) -> Self {
+ CoordinatesInLine { x, y, width }
+ }
+
+ pub fn contains(&self, x: usize, y: usize) -> bool {
+ x >= self.x && x <= self.x + self.width && self.y == y
+ }
+}