`06bdaf3`

fix header text positioning and daemon connection handling

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 06bdaf389805eb6bb38ea8592c1b2a34b78d6af9
Parents: b4e3ac2
Tree: a93e835

2 changed files

Status	File	+	-
M	`gartop/src/gui/app.rs`	27	19
M	`gartop/src/gui/header.rs`	4	2

gartop/src/gui/app.rsmodified

      should_quit: bool,
      width: u32,
      height: u32,
 -    daemon_conn: Option<UnixStream>,
 +    daemon_available: bool,
      last_refresh: Instant,
      status: Option<StatusInfo>,
      cpu_stats: Option<CpuStats>,
          // Create header bar
          let header = HeaderBar::new(Rect::new(0, 0, width, HEADER_HEIGHT));
 -        // Try to connect to daemon
 -        let daemon_conn = Self::connect_daemon();
 +        // Check if daemon is available
 +        let daemon_available = Self::check_daemon();
          Ok(Self {
              window,
              should_quit: false,
              width,
              height,
 -            daemon_conn,
 +            daemon_available,
              last_refresh: Instant::now() - std::time::Duration::from_secs(10), // force immediate refresh
              status: None,
              cpu_stats: None,
          })
+     }
 -    /// Connect to the daemon, returns None if connection fails.
 -    fn connect_daemon() -> Option<UnixStream> {
 +    /// Check if daemon is available by attempting a connection.
 +    fn check_daemon() -> bool {
          let path = gartop_ipc::socket_path();
          match UnixStream::connect(&path) {
 -            Ok(stream) => {
 -                stream.set_nonblocking(false).ok()?;
 -                tracing::info!("Connected to daemon at {}", path.display());
 -                Some(stream)
 +            Ok(_) => {
 +                tracing::info!("Daemon available at {}", path.display());
 +                true
+             }
              Err(e) => {
 -                tracing::warn!("Failed to connect to daemon: {}", e);
 -                None
 +                tracing::warn!("Daemon not available: {}", e);
 +                false
+             }
+         }
+     }
      /// Send a command to the daemon and get response.
 -    fn send_command(&mut self, cmd: &Command) -> Option<Response> {
 -        let stream = self.daemon_conn.as_mut()?;
 +    /// Creates a fresh connection for each command since daemon closes after response.
 +    fn send_command(&self, cmd: &Command) -> Option<Response> {
 +        let path = gartop_ipc::socket_path();
 +        let mut stream = UnixStream::connect(&path).ok()?;
          // Send command
          let json = serde_json::to_string(cmd).ok()?;
          stream.flush().ok()?;
          // Read response
 -        let mut reader = BufReader::new(stream.try_clone().ok()?);
 +        let mut reader = BufReader::new(&stream);
          let mut line = String::new();
          reader.read_line(&mut line).ok()?;
      /// Refresh data from daemon.
      fn refresh_data(&mut self) {
 +        let mut any_success = false;
++
          // Get status
          if let Some(resp) = self.send_command(&Command::Status) {
 +            any_success = true;
              if resp.success {
                  self.status = resp.data.and_then(|d| serde_json::from_value(d).ok());
+             }
          // Get CPU stats
          if let Some(resp) = self.send_command(&Command::GetCpu) {
 +            any_success = true;
              if resp.success {
                  self.cpu_stats = resp.data.and_then(|d| serde_json::from_value(d).ok());
+             }
          // Get memory stats
          if let Some(resp) = self.send_command(&Command::GetMemory) {
 +            any_success = true;
              if resp.success {
                  self.memory_stats = resp.data.and_then(|d| serde_json::from_value(d).ok());
+             }
+         }
 +        // Update daemon availability based on whether any command succeeded
 +        self.daemon_available = any_success;
          self.last_refresh = Instant::now();
+     }
          let x = 20.0;
          let line_height = 24.0;
 -        if self.daemon_conn.is_none() {
 +        if !self.daemon_available {
              self.renderer.text(
                  "Not connected to daemon",
                  x,
                  InputEvent::Idle => {
                      // Periodic refresh
                      if self.last_refresh.elapsed().as_secs_f64() >= REFRESH_INTERVAL {
 -                        if self.daemon_conn.is_some() {
 +                        if self.daemon_available {
                              self.refresh_data();
                              self.update_header();
                              ev_loop.request_redraw();
                          } else {
                              // Try reconnecting
 -                            self.daemon_conn = Self::connect_daemon();
 -                            if self.daemon_conn.is_some() {
 +                            self.daemon_available = Self::check_daemon();
 +                            if self.daemon_available {
                                  ev_loop.request_redraw();
+                             }
                              self.last_refresh = Instant::now();

gartop/src/gui/header.rsmodified

              color: theme.text,
              ..Default::default()
          };
 -        renderer.text("gartop", 16.0, self.bounds.y as f64 + 20.0, &title_style)?;
 +        // Center text vertically (y is baseline, so add font_size + padding)
 +        let text_y = self.bounds.y as f64 + (self.bounds.height as f64 + title_style.font_size) / 2.0;
 +        renderer.text("gartop", 16.0, text_y, &title_style)?;
          // Stats summary on right side
          let stats_style = TextStyle {
          // Position from right side
          let right_margin = 16.0;
          let spacing = 20.0;
 -        let y = self.bounds.y as f64 + 20.0;
 +        let y = self.bounds.y as f64 + (self.bounds.height as f64 + stats_style.font_size) / 2.0;
          let uptime_width = renderer.measure_text(&uptime_text, &stats_style)?.width as f64;
          let mem_width = renderer.measure_text(&mem_text, &mem_style)?.width as f64;