diff options
| -rw-r--r-- | src/commands/mod.rs | 16 | ||||
| -rw-r--r-- | src/commands/twete.rs | 122 | ||||
| -rw-r--r-- | src/display/mod.rs | 142 | ||||
| -rw-r--r-- | src/main.rs | 122 | ||||
| -rw-r--r-- | src/tw/mod.rs | 17 |
5 files changed, 327 insertions, 92 deletions
diff --git a/src/commands/mod.rs b/src/commands/mod.rs index 49b2cba..9ec6c4b 100644 --- a/src/commands/mod.rs +++ b/src/commands/mod.rs @@ -7,14 +7,14 @@ pub struct Command { pub exec: fn(line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer) } -mod show_cache; -mod twete; -mod look_up; -mod view; -mod quit; -mod fav; -mod follow; -mod thread; +pub mod show_cache; +pub mod twete; +pub mod look_up; +pub mod view; +pub mod quit; +pub mod fav; +pub mod follow; +pub mod thread; pub static COMMANDS: &[&Command] = &[ &show_cache::SHOW_CACHE, diff --git a/src/commands/twete.rs b/src/commands/twete.rs index f057e5f..4452df9 100644 --- a/src/commands/twete.rs +++ b/src/commands/twete.rs @@ -36,13 +36,23 @@ fn del(line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer) { pub static TWETE: Command = Command { keyword: "t", - params: 1, + params: 0, exec: twete }; fn twete(line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer) { - let text = line.trim(); - let substituted = ::url_encode(text); + // if there's text, send it. + // if it's just "t", enter compose mode. + let text = line.trim().to_owned(); + if text.len() == 0 { + tweeter.display_info.mode = Some(::display::DisplayMode::Compose(text)); + } else { + send_twete(text, tweeter, queryer); + } +} + +pub fn send_twete(text: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer) { + let substituted = ::url_encode(&text); if text.len() <= 140 { match queryer.do_api_post(&format!("{}?status={}", CREATE_TWEET_URL, substituted)) { Ok(_) => (), @@ -61,6 +71,8 @@ pub static THREAD: Command = Command { exec: thread }; +// the difference between threading and replying is not including +// yourself in th @'s. fn thread(line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer) { let mut text: String = line.trim().to_string(); if let Some(id_end_idx) = text.find(" ") { @@ -75,11 +87,7 @@ fn thread(line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer) { let handle = &tweeter.retrieve_user(&twete.author_id).unwrap().handle.to_owned(); // TODO: definitely breaks if you change your handle right now if handle == &tweeter.current_user.handle { - let substituted = ::url_encode(reply); - match queryer.do_api_post(&format!("{}?status={}&in_reply_to_status_id={}", CREATE_TWEET_URL, substituted, twete.id)) { - Ok(_) => (), - Err(e) => tweeter.display_info.status(e) - } + send_reply(reply.to_owned(), twid, tweeter, queryer); } else { tweeter.display_info.status("you can only thread your own tweets".to_owned()); // ask if it should .@ instead? @@ -100,58 +108,70 @@ fn thread(line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer) { pub static REP: Command = Command { keyword: "rep", - params: 2, + params: 1, exec: rep }; fn rep(line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer) { let mut text: String = line.trim().to_string(); - if let Some(id_end_idx) = text.find(" ") { - let reply_bare = text.split_off(id_end_idx + 1); - let reply = reply_bare.trim(); - let id_str = text.trim(); - if reply.len() > 0 { - let maybe_id = TweetId::parse(id_str.to_owned()); - match maybe_id { - Ok(twid) => { - if let Some(twete) = tweeter.retrieve_tweet(&twid).map(|x| x.clone()) { // TODO: no clone when this stops taking &mut self - // get handles to reply to... - let author_handle = tweeter.retrieve_user(&twete.author_id).unwrap().handle.to_owned(); - let mut ats: Vec<String> = twete.get_mentions(); //std::collections::HashSet::new(); - /* - for handle in twete.get_mentions() { - ats.insert(handle); - } - */ - ats.remove_item(&author_handle); - ats.insert(0, author_handle); - if let Some(rt_tweet) = twete.rt_tweet.and_then(|id| tweeter.retrieve_tweet(&TweetId::Twitter(id))).map(|x| x.clone()) { - let rt_author_handle = tweeter.retrieve_user(&rt_tweet.author_id).unwrap().handle.to_owned(); - ats.remove_item(&rt_author_handle); - ats.insert(1, rt_author_handle); - } - //let ats_vec: Vec<&str> = ats.into_iter().collect(); - //let full_reply = format!("{} {}", ats_vec.join(" "), reply); - let decorated_ats: Vec<String> = ats.into_iter().map(|x| format!("@{}", x)).collect(); - let full_reply = format!("{} {}", decorated_ats.join(" "), reply); - let substituted = ::url_encode(&full_reply); - match queryer.do_api_post(&format!("{}?status={}&in_reply_to_status_id={}", CREATE_TWEET_URL, substituted, twete.id)) { - Ok(_) => (), - Err(e) => tweeter.display_info.status(e) - } - } else { - tweeter.display_info.status(format!("No tweet for id: {:?}", twid)); - } - }, - Err(e) => { - tweeter.display_info.status(format!("Cannot parse input: {:?} ({})", id_str, e)); + let reply_bare = match text.find(" ") { + None => "".to_owned(), + Some(id_end_idx) => { + text.split_off(id_end_idx + 1) + } + }; + let reply = reply_bare.trim(); + let id_str = text.trim(); + let maybe_id = TweetId::parse(id_str.to_owned()); + match maybe_id { + Ok(twid) => { + if let Some(twete) = tweeter.retrieve_tweet(&twid).map(|x| x.clone()) { // TODO: no clone when this stops taking &mut self + // get handles to reply to... + let author_handle = tweeter.retrieve_user(&twete.author_id).unwrap().handle.to_owned(); + let mut ats: Vec<String> = twete.get_mentions(); //std::collections::HashSet::new(); + ats.remove_item(&author_handle); + ats.insert(0, author_handle); + if let Some(rt_tweet) = twete.rt_tweet.and_then(|id| tweeter.retrieve_tweet(&TweetId::Twitter(id))).map(|x| x.clone()) { + let rt_author_handle = tweeter.retrieve_user(&rt_tweet.author_id).unwrap().handle.to_owned(); + ats.remove_item(&rt_author_handle); + ats.insert(1, rt_author_handle); } + + // if you're directly replying to yourself, i trust you know what you're doing and + // want to @ yourself again (this keeps self-replies from showing up on your + // profile as threaded tweets, f.ex) + if !(ats.len() > 0 && &ats[0] == &tweeter.current_user.handle) { + ats.remove_item(&tweeter.current_user.handle); + } + //let ats_vec: Vec<&str> = ats.into_iter().collect(); + //let full_reply = format!("{} {}", ats_vec.join(" "), reply); + let decorated_ats: Vec<String> = ats.into_iter().map(|x| format!("@{}", x)).collect(); + let full_reply = format!("{} {}", decorated_ats.join(" "), reply); + + if reply.len() > 0 { + send_reply(full_reply, twid, tweeter, queryer); + } else { + tweeter.display_info.mode = Some(::display::DisplayMode::Reply(twid, full_reply)); + } + } else { + tweeter.display_info.status(format!("No tweet for id: {:?}", twid)); } - } else { - tweeter.display_info.status("rep <id> your sik reply".to_owned()); + }, + Err(e) => { + tweeter.display_info.status(format!("Cannot parse input: {:?} ({})", id_str, e)); + } + } +} + +pub fn send_reply(text: String, twid: TweetId, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer) { + if let Some(twete) = tweeter.retrieve_tweet(&twid).map(|x| x.clone()) { // TODO: no clone when this stops taking &mut self + let substituted = ::url_encode(&text); + match queryer.do_api_post(&format!("{}?status={}&in_reply_to_status_id={}", CREATE_TWEET_URL, substituted, twete.id)) { + Ok(_) => (), + Err(e) => tweeter.display_info.status(e) } } else { - tweeter.display_info.status("rep <id> your sik reply".to_owned()); + tweeter.display_info.status(format!("Tweet stopped existing: {:?}", twid)); } } diff --git a/src/display/mod.rs b/src/display/mod.rs index 73a1e09..4480855 100644 --- a/src/display/mod.rs +++ b/src/display/mod.rs @@ -13,6 +13,12 @@ use ::tw::TweetId; use std; #[derive(Clone)] +pub enum DisplayMode { + Compose(String), + Reply(TweetId, String) +} + +#[derive(Clone)] pub enum Infos { Tweet(TweetId), TweetWithContext(TweetId, String), @@ -22,20 +28,29 @@ pub enum Infos { User(tw::user::User) } +const COMPOSE_HEIGHT: u16 = 5; pub struct DisplayInfo { + pub log_height: u16, + pub prompt_height: u16, + pub mode: Option<DisplayMode>, pub log_seek: u32, pub infos_seek: u32, pub log: Vec<String>, - pub infos: Vec<Infos> + pub infos: Vec<Infos>, + pub input_buf: Vec<char> } impl Default for DisplayInfo { fn default() -> Self { DisplayInfo { + log_height: 4, + prompt_height: 3, + mode: None, log_seek: 0, infos_seek: 0, log: Vec::new(), - infos: Vec::new() + infos: Vec::new(), + input_buf: Vec::new() } } } @@ -48,15 +63,34 @@ impl DisplayInfo { pub fn recv(&mut self, info: Infos) { self.infos.push(info); } + + pub fn ui_height(&self) -> u16 { + self.log_height + self.prompt_height + } +} + +/* + * wraps x so each line is indentation or fewer characters, after splitting by \n. + */ +fn into_display_lines(x: Vec<String>, width: u16) -> Vec<String> { + let split_on_newline: Vec<String> = x.into_iter() + .flat_map(|x| x.split("\n") + .map(|x| x.to_owned()) + .collect::<Vec<String>>() + ).collect(); + let wrapped: Vec<String> = split_on_newline.iter() + .map(|x| x.chars().collect::<Vec<char>>()) + .flat_map(|x| x.chunks(width as usize) + .map(|x| x.into_iter().collect::<String>()) + .collect::<Vec<String>>()) + .collect(); + wrapped } pub fn paint(tweeter: &mut ::tw::TwitterCache) -> Result<(), std::io::Error> { match termion::terminal_size() { - Ok((_width, height)) => { + Ok((width, height)) => { // draw input prompt - print!("{}{}", cursor::Goto(1, height - 6), clear::CurrentLine); - print!("{}{}>", cursor::Goto(1, height - 5), clear::CurrentLine); - print!("{}{}", cursor::Goto(1, height - 4), clear::CurrentLine); let mut i = 0; let log_size = 4; let last_elem = tweeter.display_info.log.len().saturating_sub(log_size); @@ -76,18 +110,68 @@ pub fn paint(tweeter: &mut ::tw::TwitterCache) -> Result<(), std::io::Error> { let last_twevent = tweeter.display_info.infos.len().saturating_sub(height as usize - 4).saturating_sub(tweeter.display_info.infos_seek as usize); let last_few_twevent: Vec<Infos> = tweeter.display_info.infos[last_twevent..].iter().map(|x| x.clone()).rev().collect::<Vec<Infos>>(); - let mut h = 7; + let mut h = tweeter.display_info.ui_height(); + + /* + * draw in whatever based on mode... + */ + match tweeter.display_info.mode.clone() { + None => { + print!("{}{}", cursor::Goto(1, height - 6), clear::CurrentLine); + print!("{}{}@{}>{}", cursor::Goto(1, height - 5), clear::CurrentLine, tweeter.current_user.handle, tweeter.display_info.input_buf.clone().into_iter().collect::<String>()); + print!("{}{}", cursor::Goto(1, height - 4), clear::CurrentLine); + } + Some(DisplayMode::Compose(x)) => { + let mut lines: Vec<String> = into_display_lines(x.split("\n").map(|x| x.to_owned()).collect(), width - 2); + if lines.len() == 0 { + lines.push("".to_owned()); + } + // TODO: properly probe tweet length lim + lines.push(format!("{}/{}", x.len(), 140)); + lines.insert(0, "".to_owned()); + let mut lines_drawn: u16 = 0; + for line in lines.into_iter().rev() { + print!("{}{} {}{}{}{}", + cursor::Goto(1, height - 4 - lines_drawn), clear::CurrentLine, + color::Bg(color::Blue), line, std::iter::repeat(" ").take((width as usize).saturating_sub(line.len() + 2)).collect::<String>(), termion::style::Reset + ); + lines_drawn += 1; + } + h += (lines_drawn - 3); + } + Some(DisplayMode::Reply(twid, msg)) => { + let mut lines = into_display_lines(render_twete(&twid, tweeter), width - 2); + lines.push(" -------- ".to_owned()); + lines.extend(into_display_lines(msg.split("\n").map(|x| x.to_owned()).collect(), width - 2)); + if lines.len() == 0 { + lines.push("".to_owned()); + } + // TODO: properly probe tweet length lim + lines.push(format!("{}/{}", msg.len(), 140)); + lines.insert(0, "".to_owned()); + let mut lines_drawn: u16 = 0; + for line in lines.into_iter().rev() { + print!("{}{} {}{}{}{}", + cursor::Goto(1, height - 4 - lines_drawn), clear::CurrentLine, + color::Bg(color::Blue), line, std::iter::repeat(" ").take((width as usize).saturating_sub(line.len() + 2)).collect::<String>(), termion::style::Reset + ); + lines_drawn += 1; + } + h += (lines_drawn - 3); + } + Some(_) => { } + } + for info in last_few_twevent { let to_draw: Vec<String> = match info { Infos::Tweet(id) => { let pre_split: Vec<String> = render_twete(&id, tweeter); - let split_on_newline: Vec<String> = pre_split.into_iter().flat_map(|x| x.split("\n").map(|x| x.to_owned()).collect::<Vec<String>>()).collect(); - let wrapped: Vec<String> = split_on_newline.iter() - .map(|x| x.chars().collect::<Vec<char>>()) - .flat_map(|x| x.chunks(_width as usize) - .map(|x| x.into_iter().collect::<String>()) - .collect::<Vec<String>>()) - .collect(); + let total_length: usize = pre_split.iter().map(|x| x.len()).sum(); + let wrapped = if total_length <= 1024 { + into_display_lines(pre_split, width) + } else { + vec!["This tweet discarded for your convenience".to_owned()] + }; wrapped.into_iter().rev().collect() } Infos::TweetWithContext(id, context) => { @@ -95,14 +179,34 @@ pub fn paint(tweeter: &mut ::tw::TwitterCache) -> Result<(), std::io::Error> { lines.push(context); lines } - Infos::Thread(_ids) => { - let mut lines = vec![format!("{}{}I'd show a thread if I knew how", cursor::Goto(1, height - h), clear::CurrentLine)]; + Infos::Thread(ids) => { + let mut tweets: Vec<Vec<String>> = ids.iter().rev().map(|x| into_display_lines(render_twete(x, tweeter), width)).collect(); + let last = tweets.pop(); + let mut lines = tweets.into_iter().fold(Vec::new(), |mut sum, lines| { + sum.extend(lines); + sum.extend(vec![ + " ^".to_owned(), + " |".to_owned() + ]); + sum + }); + if let Some(last_lines) = last { + lines.extend(last_lines); + } + //let mut lines = vec![format!("{}{}I'd show a thread if I knew how", cursor::Goto(1, height - h), clear::CurrentLine)]; lines.push("".to_owned()); // lines.push(format!("link: https://twitter.com/i/web/status/{}", id)); - lines + lines.into_iter().rev().collect() }, Infos::Event(e) => { - e.clone().render(tweeter).into_iter().rev().collect() + let pre_split = e.clone().render(tweeter); + let total_length: usize = pre_split.iter().map(|x| x.len()).sum(); + let wrapped = if total_length <= 1024 { + into_display_lines(pre_split, width) + } else { + vec!["This tweet discarded for your convenience".to_owned()] + }; + wrapped.into_iter().rev().collect() }, Infos::DM(msg) => { vec![format!("{}{}DM: {}", cursor::Goto(1, height - h), clear::CurrentLine, msg)] @@ -132,7 +236,7 @@ pub fn paint(tweeter: &mut ::tw::TwitterCache) -> Result<(), std::io::Error> { print!("{}{}", cursor::Goto(1, height - h), clear::CurrentLine); h = h + 1; } - print!("{}", cursor::Goto(2, height - 5)); + print!("{}", cursor::Goto(2 + 1 + tweeter.current_user.handle.len() as u16 + tweeter.display_info.input_buf.len() as u16, height - 5)); stdout().flush()?; }, Err(e) => { diff --git a/src/main.rs b/src/main.rs index c46fec1..f8276ed 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,8 +1,17 @@ #![feature(vec_remove_item)] extern crate serde_json; +extern crate termion; +extern crate termios; + +use termios::{Termios, TCSANOW, ECHO, ICANON, tcsetattr}; + +use termion::input::TermRead; +use termion::event::{Event, Key}; + use std::str; //use std::io::BufRead; +use std::io::stdin; #[macro_use] extern crate chan; @@ -174,15 +183,13 @@ fn main() { // let url = "https://stream.twitter.com/1.1/statuses/filter.json"; // let url = "https://stream.twitter.com/1.1/statuses/sample.json"; - let (ui_tx, mut ui_rx) = chan::sync::<Vec<u8>>(0); + let (ui_tx, mut ui_rx) = chan::sync::<Result<termion::event::Event, std::io::Error>>(0); let mut twete_rx = connect_twitter_stream(); std::thread::spawn(move || { - loop { - let mut line = String::new(); - std::io::stdin().read_line(&mut line).unwrap(); - ui_tx.send(line.into_bytes()); + for input in stdin().events() { + ui_tx.send(input); } }); @@ -211,6 +218,13 @@ fn main() { core: c2 }; + let termios = Termios::from_fd(0).unwrap(); + let mut new_termios = termios.clone(); + + // fix terminal to not echo, thanks + new_termios.c_lflag &= !(ICANON | ECHO); + + tcsetattr(0, TCSANOW, &new_termios).unwrap(); loop { match do_ui(ui_rx, twete_rx, &mut tweeter, &mut queryer) { Some((new_ui_rx, new_twete_rx)) => { @@ -222,9 +236,82 @@ fn main() { } } } + tcsetattr(0, TCSANOW, &termios); } -fn do_ui(ui_rx_orig: chan::Receiver<Vec<u8>>, twete_rx: chan::Receiver<Vec<u8>>, mut tweeter: &mut tw::TwitterCache, mut queryer: &mut ::Queryer) -> Option<(chan::Receiver<Vec<u8>>, chan::Receiver<Vec<u8>>)> { +fn handle_input(event: termion::event::Event, tweeter: &mut tw::TwitterCache, queryer: &mut ::Queryer) { + match event { + Event::Key(Key::Backspace) => { + match tweeter.display_info.mode.clone() { + None => { tweeter.display_info.input_buf.pop(); }, + Some(display::DisplayMode::Compose(msg)) => { + let mut newstr = msg.clone(); + newstr.pop(); + tweeter.display_info.mode = Some(display::DisplayMode::Compose(newstr)); + }, + Some(display::DisplayMode::Reply(twid, msg)) => { + let mut newstr = msg.clone(); + newstr.pop(); + tweeter.display_info.mode = Some(display::DisplayMode::Reply(twid, newstr)); + } + } + } + // would Shift('\n') but.. that doesn't exist. + // would Ctrl('\n') but.. that doesn't work. + Event::Key(Key::Ctrl('n')) => { + match tweeter.display_info.mode.clone() { + Some(display::DisplayMode::Compose(msg)) => { + tweeter.display_info.mode = Some(display::DisplayMode::Compose(format!("{}{}", msg, "\n"))); + } + _ => {} + } + } + Event::Key(Key::Char(x)) => { + match tweeter.display_info.mode.clone() { + None => { + if x == '\n' { + let line = tweeter.display_info.input_buf.drain(..).collect::<String>(); + tweeter.handle_user_input(line.into_bytes(), queryer); + } else { + tweeter.display_info.input_buf.push(x); + } + } + Some(display::DisplayMode::Compose(msg)) => { + if x == '\n' { + // TODO: move this somewhere better. + ::commands::twete::send_twete(msg, tweeter, queryer); + tweeter.display_info.mode = None; + } else { + tweeter.display_info.mode = Some(display::DisplayMode::Compose(format!("{}{}", msg, x))); + } + } + Some(display::DisplayMode::Reply(twid, msg)) => { + if x == '\n' { + // TODO: move this somewhere better. + ::commands::twete::send_reply(msg, twid, tweeter, queryer); + tweeter.display_info.mode = None; + } else { + tweeter.display_info.mode = Some(display::DisplayMode::Reply(twid, format!("{}{}", msg, x))); + } + } + } + }, + Event::Key(Key::PageUp) => { + tweeter.display_info.infos_seek += 1; + } + Event::Key(Key::PageDown) => { + tweeter.display_info.infos_seek = tweeter.display_info.infos_seek.saturating_sub(1); + } + Event::Key(Key::Esc) => { + tweeter.display_info.mode = None; + } + Event::Key(_) => { } + Event::Mouse(_) => { } + Event::Unsupported(_) => {} + } +} + +fn do_ui(ui_rx_orig: chan::Receiver<Result<termion::event::Event, std::io::Error>>, twete_rx: chan::Receiver<Vec<u8>>, mut tweeter: &mut tw::TwitterCache, mut queryer: &mut ::Queryer) -> Option<(chan::Receiver<Result<termion::event::Event, std::io::Error>>, chan::Receiver<Vec<u8>>)> { loop { let ui_rx_a = &ui_rx_orig; let ui_rx_b = &ui_rx_orig; @@ -243,27 +330,38 @@ fn do_ui(ui_rx_orig: chan::Receiver<Vec<u8>>, twete_rx: chan::Receiver<Vec<u8>>, tweeter.display_info.status("Twitter stream hung up...".to_owned()); chan_select! { ui_rx_b.recv() -> input => match input { - Some(line) => { - if line == "reconnect\n".as_bytes() { - return Some((ui_rx_orig.clone(), connect_twitter_stream())); + Some(maybe_event) => { + if let Ok(event) = maybe_event { + handle_input(event, tweeter, queryer); } else { - tweeter.handle_user_input(line, &mut queryer); + // stdin closed? } } + // twitter stream closed, ui thread closed, uhh.. None => std::process::exit(0) } } } }, ui_rx_a.recv() -> user_input => match user_input { - Some(line) => { - tweeter.handle_user_input(line, &mut queryer); + Some(maybe_event) => { + if let Ok(event) = maybe_event { + handle_input(event, tweeter, queryer); // eventually DisplayInfo too, as a separate piece of data... + } else { + // dunno how we'd reach this... stdin closed? + } }, None => tweeter.display_info.status("UI thread hung up...".to_owned()) } // and then we can introduce a channel that just sends a message every 100 ms or so // that acts as a clock! } + + match tweeter.state { + tw::AppState::Reconnect => return Some((ui_rx_orig.clone(), connect_twitter_stream())), + _ => () + }; + // one day display_info should be distinct match display::paint(tweeter) { Ok(_) => (), diff --git a/src/tw/mod.rs b/src/tw/mod.rs index 82dfe10..b1bc9c2 100644 --- a/src/tw/mod.rs +++ b/src/tw/mod.rs @@ -22,6 +22,16 @@ use self::tweet::Tweet; pub mod user; use self::user::User; +pub enum AppState { + Reconnect, + Compose, + View +} + +impl Default for AppState { + fn default() -> AppState { AppState::View } +} + pub fn full_twete_text(twete: &serde_json::map::Map<String, serde_json::Value>) -> String { if twete.contains_key("retweeted_status") { return full_twete_text(twete["retweeted_status"].as_object().unwrap()) @@ -103,7 +113,9 @@ pub struct TwitterCache { #[serde(skip)] id_conversions: IdConversions, #[serde(skip)] - pub display_info: display::DisplayInfo + pub display_info: display::DisplayInfo, + #[serde(skip)] + pub state: AppState } // Internally, a monotonically increasin i64 is always the id used. @@ -259,7 +271,8 @@ impl TwitterCache { current_user: User::default(), threads: HashMap::new(), id_conversions: IdConversions::default(), - display_info: display::DisplayInfo::default() + display_info: display::DisplayInfo::default(), + state: AppState::View } } |