feat(term): handle terminal focus event

crates/synd_term/src/application/mod.rs

@@ -50,9 +50,6 @@ pub use auth::authenticator::{Authenticator, DeviceFlows, JwtService};
 mod clock;
 pub(crate) use clock::{Clock, SystemClock};
 
-mod flags;
-use flags::Should;
-
 mod cache;
 pub use cache::Cache;
 
@@ -64,10 +61,9 @@ pub use app_config::Config;
 
 pub(crate) mod event;
 
-enum Screen {
-    Login,
-    Browse,
-}
+mod state;
+pub(crate) use state::TerminalFocus;
+use state::{Should, State};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Populate {
@@ -92,8 +88,7 @@ pub struct Application {
     categories: Categories,
     latest_release: Option<Version>,
 
-    screen: Screen,
-    flags: Should,
+    state: State,
 }
 
 impl Application {
@@ -128,6 +123,10 @@ impl Application {
             key_handlers.push(event::KeyHandler::Keymaps(keymaps));
             key_handlers
         };
+        let mut state = State::new();
+        if dry_run {
+            state.flags = Should::Quit;
+        }
 
         Self {
             clock: Box::new(SystemClock),
@@ -141,16 +140,11 @@ impl Application {
             cache,
             theme,
             idle_timer: Box::pin(tokio::time::sleep(config.idle_timer_interval)),
-            screen: Screen::Login,
             config,
             key_handlers,
             categories,
             latest_release: None,
-            flags: if dry_run {
-                Should::Quit
-            } else {
-                Should::empty()
-            },
+            state,
         }
     }
 
@@ -185,7 +179,7 @@ impl Application {
         match self.terminal.init() {
             Ok(()) => Ok(()),
             Err(err) => {
-                if self.flags.contains(Should::Quit) {
+                if self.state.flags.contains(Should::Quit) {
                     tracing::warn!("Failed to init terminal: {err}");
                     Ok(())
                 } else {
@@ -220,7 +214,6 @@ impl Application {
         self.keymaps().enable(KeymapId::Tabs);
         self.keymaps().enable(KeymapId::Entries);
         self.keymaps().enable(KeymapId::Filter);
-        self.screen = Screen::Browse;
         self.reset_idle_timer();
         self.should_render();
     }
@@ -292,14 +285,14 @@ impl Application {
                 self.apply(command);
             }
 
-            if self.flags.contains(Should::Render) {
+            if self.state.flags.contains(Should::Render) {
                 self.render();
-                self.flags.remove(Should::Render);
+                self.state.flags.remove(Should::Render);
                 self.components.prompt.clear_error_message();
             }
 
-            if self.flags.contains(Should::Quit) {
-                self.flags.remove(Should::Quit); // for testing
+            if self.state.flags.contains(Should::Quit) {
+                self.state.flags.remove(Should::Quit); // for testing
                 break ControlFlow::Break(());
             }
         }
@@ -313,7 +306,7 @@ impl Application {
         while let Some(command) = next.take() {
             match command {
                 Command::Nop => {}
-                Command::Quit => self.flags.insert(Should::Quit),
+                Command::Quit => self.state.flags.insert(Should::Quit),
                 Command::ResizeTerminal { .. } => {
                     self.should_render();
                 }
@@ -632,14 +625,15 @@ impl Application {
 
     #[inline]
     fn should_render(&mut self) {
-        self.flags.insert(Should::Render);
+        self.state.flags.insert(Should::Render);
     }
 
     fn render(&mut self) {
         let cx = ui::Context {
             theme: &self.theme,
             in_flight: &self.in_flight,
             categories: &self.categories,
+            focus: self.state.focus(),
         };
         let root = Root::new(&self.components, cx);
 
@@ -654,6 +648,14 @@ impl Application {
                 _columns: columns,
                 _rows: rows,
             }),
+            CrosstermEvent::FocusGained => {
+                self.should_render();
+                self.state.focus_gained()
+            }
+            CrosstermEvent::FocusLost => {
+                self.should_render();
+                self.state.focus_lost()
+            }
             CrosstermEvent::Key(KeyEvent {
                 kind: KeyEventKind::Release,
                 ..
@@ -1001,7 +1003,7 @@ impl Application {
         #[cfg(feature = "integration")]
         {
             tracing::debug!("Quit for idle");
-            self.flags.insert(Should::Quit);
+            self.state.flags.insert(Should::Quit);
         }
     }
 

crates/synd_term/src/application/state.rs

@@ -0,0 +1,45 @@
+use crate::command::Command;
+
+use bitflags::bitflags;
+
+bitflags! {
+    pub(super) struct Should: u64 {
+        const Render = 1 << 0;
+        const Quit = 1 << 1;
+
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum TerminalFocus {
+    Gained,
+    Lost,
+}
+
+pub(super) struct State {
+    pub(super) flags: Should,
+    focus: TerminalFocus,
+}
+
+impl State {
+    pub(super) fn new() -> Self {
+        Self {
+            flags: Should::empty(),
+            focus: TerminalFocus::Gained,
+        }
+    }
+
+    pub(super) fn focus(&self) -> TerminalFocus {
+        self.focus
+    }
+
+    pub(super) fn focus_gained(&mut self) -> Option<Command> {
+        self.focus = TerminalFocus::Gained;
+        None
+    }
+
+    pub(super) fn focus_lost(&mut self) -> Option<Command> {
+        self.focus = TerminalFocus::Lost;
+        None
+    }
+}

crates/synd_term/src/terminal/mod.rs

@@ -1,5 +1,5 @@
 use crossterm::{
-    event::EventStream,
+    event::{EnableFocusChange, EventStream},
     terminal::{self, EnterAlternateScreen, LeaveAlternateScreen},
     ExecutableCommand,
 };
@@ -36,7 +36,7 @@ impl Terminal {
     /// Initialize terminal
     pub fn init(&mut self) -> io::Result<()> {
         terminal::enable_raw_mode()?;
-        crossterm::execute!(io::stdout(), EnterAlternateScreen)?;
+        crossterm::execute!(io::stdout(), EnterAlternateScreen, EnableFocusChange)?;
 
         let panic_hook = std::panic::take_hook();
         std::panic::set_hook(Box::new(move |panic| {

crates/synd_term/src/ui/components/entries.rs

@@ -132,7 +132,12 @@ impl Entries {
             .header(header.style(cx.theme.entries.header))
             .column_spacing(2)
             .highlight_symbol(ui::TABLE_HIGHLIGHT_SYMBOL)
-            .highlight_style(cx.theme.entries.selected_entry)
+            .highlight_style(
+                cx.theme
+                    .entries
+                    .selected_entry
+                    .add_modifier(cx.table_highlight_modifier()),
+            )
             .highlight_spacing(ratatui::widgets::HighlightSpacing::WhenSelected);
 
         StatefulWidget::render(entries, entries_area, buf, &mut entries_state);

crates/synd_term/src/ui/components/subscription.rs

@@ -196,7 +196,12 @@ impl Subscription {
             .column_spacing(2)
             .style(cx.theme.subscription.background)
             .highlight_symbol(ui::TABLE_HIGHLIGHT_SYMBOL)
-            .highlight_style(cx.theme.subscription.selected_feed)
+            .highlight_style(
+                cx.theme
+                    .subscription
+                    .selected_feed
+                    .add_modifier(cx.table_highlight_modifier()),
+            )
             .highlight_spacing(HighlightSpacing::WhenSelected);
 
         StatefulWidget::render(feeds, feeds_area, buf, &mut feeds_state);

crates/synd_term/src/ui/mod.rs

@@ -1,10 +1,10 @@
 use std::{str::FromStr, sync::OnceLock};
 
-use ratatui::style::Color;
+use ratatui::style::{Color, Modifier};
 use synd_feed::types::{Category, Requirement};
 
 use crate::{
-    application::InFlight,
+    application::{InFlight, TerminalFocus},
     config::{Categories, Icon, IconColor},
     ui::theme::Theme,
 };
@@ -39,6 +39,16 @@ pub struct Context<'a> {
     pub theme: &'a Theme,
     pub in_flight: &'a InFlight,
     pub categories: &'a Categories,
+    pub(crate) focus: TerminalFocus,
+}
+
+impl<'a> Context<'a> {
+    fn table_highlight_modifier(&self) -> Modifier {
+        match self.focus {
+            TerminalFocus::Gained => Modifier::empty(),
+            TerminalFocus::Lost => Modifier::DIM,
+        }
+    }
 }
 
 #[cfg(test)]