`e0f66b3`

fixes

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

SHA: e0f66b34e861915965c0534f6736f8f73065be82
Parents: 83272c3
Tree: 01d20b4

5 changed files

Status	File	+	-
M	`gar-session.sh`	2	2
M	`gar/src/config/lua.rs`	35	2
M	`gar/src/config/mod.rs`	4	0
M	`gar/src/core/mod.rs`	3	0
M	`gar/src/x11/events.rs`	148	0

gar-session.shmodified

  # Set log level
  export GAR_LOG=info
 -# Launch polybar after gar starts (needs i3 IPC socket)
 -(sleep 0.5 && ~/.config/polybar/launch.sh) &
 +# garbar is now launched natively by gar when gar.bar is configured in init.lua
 +# (Legacy polybar launch removed - use gar.bar config instead)
  # Start gar
  exec /home/mfwolffe/GithubOrgs/tenseleyFlow/gar/target/release/gar

gar/src/config/lua.rsmodified

          self.lua.load(&source).exec()?;
 +        // Check if gar.bar table exists - enables garbar integration
 +        self.check_bar_config()?;
++
          let state = self.state.lock().unwrap();
          tracing::info!(
 -            "Config loaded: {} keybinds registered",
 -            state.keybinds.len()
 +            "Config loaded: {} keybinds registered, bar_enabled={}",
 +            state.keybinds.len(),
 +            state.config.bar_enabled
          );
          Ok(())
+     }
 +    /// Check if gar.bar table is configured, enabling garbar integration
 +    fn check_bar_config(&self) -> LuaResult<()> {
 +        let globals = self.lua.globals();
 +        let gar: Table = globals.get("gar")?;
++
 +        // Check if gar.bar exists and is a table
 +        match gar.get::<Table>("bar") {
 +            Ok(bar_table) => {
 +                // gar.bar exists! Enable garbar integration
 +                let mut state = self.state.lock().unwrap();
 +                state.config.bar_enabled = true;
++
 +                // Optionally read bar height from config for reserved space
 +                if let Ok(height) = bar_table.get::<u32>("height") {
 +                    state.config.bar_height = height;
 +                    tracing::info!("garbar integration enabled (height={})", height);
 +                } else {
 +                    tracing::info!("garbar integration enabled (default height)");
 +                }
 +            }
 +            Err(_) => {
 +                // gar.bar not set, garbar won't be spawned
 +                tracing::debug!("gar.bar not configured, garbar integration disabled");
 +            }
 +        }
++
 +        Ok(())
 +    }
++
      /// Reload configuration (clears existing keybinds and rules)
      pub fn reload(&self) -> LuaResult<()> {
+         {

gar/src/config/mod.rsmodified

      pub mouse_follows_focus: bool,
      // Manual bar/panel reserved space (overrides struts)
      pub bar_height: u32,
 +    // garbar integration: spawn garbar automatically if gar.bar is configured
 +    pub bar_enabled: bool,
      // Compositor visual settings (picom)
      // These are stored for reference and potential dynamic picom config generation
      pub corner_radius: u32,
              mouse_follows_focus: false,
              // Manual bar height (0 = use struts from dock windows)
              bar_height: 0,
 +            // garbar not enabled by default (enabled when gar.bar table is set)
 +            bar_enabled: false,
              // Compositor settings (picom) - matching picom.conf defaults
              corner_radius: 12,
              blur_enabled: true,

gar/src/core/mod.rsmodified

      pub dock_struts: HashMap<XWindow, Strut>,
      /// Current edge being displayed (for cursor changes on floating window edges)
      pub current_edge_cursor: Option<(XWindow, crate::x11::events::ResizeEdge)>,
 +    /// garbar child process (managed automatically when gar.bar is configured)
 +    pub garbar_process: Option<std::process::Child>,
+ }
  impl WindowManager {
              focus_history: Vec::new(),
              dock_struts: HashMap::new(),
              current_edge_cursor: None,
 +            garbar_process: None,
          })
+     }

gar/src/x11/events.rsmodified

+         }
+     }
+ }
++
 +/// Spawn garbar as a child process.
 +/// Returns the child process handle if successful.
 +fn spawn_garbar() -> Option<std::process::Child> {
 +    tracing::info!("Spawning garbar...");
++
 +    // Try to find garbar in PATH or common locations
 +    let garbar_cmd = which_garbar().unwrap_or_else(|| "garbar".to_string());
++
 +    // Determine i3 IPC socket path (same as gar's i3_server.rs)
 +    let i3sock = std::env::var("XDG_RUNTIME_DIR")
 +        .map(|dir| format!("{}/gar-i3.sock", dir))
 +        .unwrap_or_else(|_| "/tmp/gar-i3.sock".to_string());
++
 +    match Command::new(&garbar_cmd)
 +        .arg("daemon")
 +        .env("I3SOCK", &i3sock)
 +        .spawn()
 +    {
 +        Ok(child) => {
 +            tracing::info!("garbar started (PID {}), I3SOCK={}", child.id(), i3sock);
 +            Some(child)
 +        }
 +        Err(e) => {
 +            tracing::error!("Failed to spawn garbar: {}", e);
 +            tracing::info!("Hint: Ensure garbar is installed and in PATH, or use 'cargo install --path garbar'");
 +            None
 +        }
 +    }
 +}
++
 +/// Find garbar executable
 +fn which_garbar() -> Option<String> {
 +    // Check if garbar is in PATH
 +    if Command::new("which")
 +        .arg("garbar")
 +        .output()
 +        .map(|o| o.status.success())
 +        .unwrap_or(false)
 +    {
 +        return Some("garbar".to_string());
 +    }
++
 +    // Check common cargo install location
 +    if let Ok(home) = std::env::var("HOME") {
 +        let cargo_bin = format!("{}/.cargo/bin/garbar", home);
 +        if std::path::Path::new(&cargo_bin).exists() {
 +            return Some(cargo_bin);
 +        }
 +    }
++
 +    // Check /usr/local/bin
 +    if std::path::Path::new("/usr/local/bin/garbar").exists() {
 +        return Some("/usr/local/bin/garbar".to_string());
 +    }
++
 +    None
 +}
++
 +/// Stop garbar gracefully by sending SIGTERM.
 +fn stop_garbar(child: &mut std::process::Child) {
 +    tracing::info!("Stopping garbar (PID {})...", child.id());
++
 +    // Send SIGTERM for graceful shutdown
 +    unsafe {
 +        libc::kill(child.id() as i32, libc::SIGTERM);
 +    }
++
 +    // Wait briefly for it to exit
 +    match child.try_wait() {
 +        Ok(Some(status)) => {
 +            tracing::info!("garbar exited with status: {}", status);
 +        }
 +        Ok(None) => {
 +            // Give it a moment to shut down
 +            std::thread::sleep(std::time::Duration::from_millis(100));
 +            match child.try_wait() {
 +                Ok(Some(status)) => {
 +                    tracing::info!("garbar exited with status: {}", status);
 +                }
 +                Ok(None) => {
 +                    // Force kill if still running
 +                    tracing::warn!("garbar did not exit gracefully, sending SIGKILL");
 +                    let _ = child.kill();
 +                }
 +                Err(e) => {
 +                    tracing::warn!("Error waiting for garbar: {}", e);
 +                }
 +            }
 +        }
 +        Err(e) => {
 +            tracing::warn!("Error checking garbar status: {}", e);
 +        }
 +    }
 +}
++
 +/// Signal garbar to reload its configuration (SIGHUP).
 +fn reload_garbar(child: &std::process::Child) {
 +    tracing::info!("Signaling garbar to reload (PID {})...", child.id());
 +    unsafe {
 +        libc::kill(child.id() as i32, libc::SIGHUP);
 +    }
 +}
  use x11rb::protocol::xproto::{
      ButtonPressEvent, ButtonReleaseEvent, ClientMessageEvent, ConfigureRequestEvent,
      ConfigureWindowAux, ConnectionExt, DestroyNotifyEvent, EnterNotifyEvent, EventMask,
          // Re-apply layout with new settings
          self.apply_layout()?;
 +        // Handle garbar lifecycle based on new config
 +        if self.config.bar_enabled {
 +            // Check if garbar is still running
 +            let garbar_alive = if let Some(ref mut child) = self.garbar_process {
 +                match child.try_wait() {
 +                    Ok(None) => true,  // Still running
 +                    Ok(Some(status)) => {
 +                        tracing::info!("garbar exited with status {}, will respawn", status);
 +                        false
 +                    }
 +                    Err(e) => {
 +                        tracing::warn!("Failed to check garbar status: {}", e);
 +                        false
 +                    }
 +                }
 +            } else {
 +                false
 +            };
++
 +            if garbar_alive {
 +                // garbar running, signal it to reload
 +                if let Some(ref child) = self.garbar_process {
 +                    reload_garbar(child);
 +                }
 +            } else {
 +                // garbar not running, spawn it
 +                self.garbar_process = spawn_garbar();
 +            }
 +        } else if let Some(ref mut child) = self.garbar_process {
 +            // bar_enabled is now false, stop garbar
 +            stop_garbar(child);
 +            self.garbar_process = None;
 +        }
++
          tracing::info!("Configuration reloaded");
          Ok(())
+     }
          // This allows user services (like garbg) bound to graphical-session.target to start
          start_graphical_session();
 +        // Spawn garbar if gar.bar is configured
 +        if self.config.bar_enabled {
 +            self.garbar_process = spawn_garbar();
 +        }
++
          while self.running {
              // Handle X11 events (non-blocking poll)
              while let Some(event) = self.conn.conn.poll_for_event()? {
              std::thread::sleep(std::time::Duration::from_millis(10));
+         }
 +        // Stop garbar if it was spawned
 +        if let Some(ref mut child) = self.garbar_process {
 +            stop_garbar(child);
 +        }
 +        self.garbar_process = None;
++
          // Signal systemd that graphical session has ended
          // This stops user services bound to graphical-session.target (like garbg)
          stop_graphical_session();