`b44d141`

add compositor selection and focus_follows_mouse

- Add compositor config option: picom, garchomp, or none
- Add focus_follows_mouse setting (default: true)
- Add start_compositor() and stop_compositor() methods
- Generate picom config only when using picom

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

SHA: b44d1414dcf1627ddd01793f526df91a031c76be
Parents: bb18f1e
Tree: 00020d9

3 changed files

Status	File	+	-
M	`gar/src/config/lua.rs`	18	0
M	`gar/src/config/mod.rs`	70	1
M	`gar/src/core/mod.rs`	2	4

gar/src/config/lua.rsmodified

                          state.config.mouse_follows_focus = v;
+                     }
+                 }
++                "focus_follows_mouse" => {
++                    if let Value::Boolean(v) = value {
++                        state.config.focus_follows_mouse = v;
++                    }
++                }
                  "bar_height" => {
                      if let Value::Integer(v) = value {
                          state.config.bar_height = v as u32;
+                     }
+                 }
++                // Compositor selection: "picom", "garchomp", or "none"
++                "compositor" => {
++                    if let Value::String(s) = value {
++                        if let Ok(str_val) = s.to_str() {
++                            let comp = str_val.to_lowercase();
++                            if comp == "picom" || comp == "garchomp" || comp == "none" {
++                                state.config.compositor = comp;
++                            } else {
++                                tracing::warn!("Unknown compositor '{}', using 'picom'", str_val);
++                            }
++                        }
++                    }
++                }
                  // Compositor visual settings (picom)
                  "corner_radius" => {
                      if let Value::Integer(v) = value {

gar/src/config/mod.rsmodified

      // Behavior settings
      pub follow_window_on_move: bool,
      pub mouse_follows_focus: bool,
++    pub focus_follows_mouse: bool,
      // Manual bar/panel reserved space (overrides struts)
      pub bar_height: u32,
      // garbar integration: spawn garbar automatically if gar.bar is configured
      // Screen timeout/DPMS settings
      pub screen_timeout_enabled: bool,
      pub screen_timeout_seconds: u32,
++    // Compositor selection: "picom" (default), "garchomp", or "none"
++    pub compositor: String,
      // Compositor visual settings (picom)
      // These are stored for reference and potential dynamic picom config generation
      pub corner_radius: u32,
+         )
+     }
--    /// Write picom config to ~/.config/gar/picom.conf and signal picom to reload.
++    /// Write picom config to ~/.config/gar/picom.conf and optionally restart picom.
++    /// Only writes/restarts if compositor is set to "picom".
      pub fn write_picom_config(&self) -> std::io::Result<()> {
++        // Only generate picom config if using picom
++        if self.compositor != "picom" {
++            tracing::debug!("Skipping picom config (compositor={})", self.compositor);
++            return Ok(());
++        }
++
          let config_dir = dirs::config_dir()
              .ok_or_else(|| std::io::Error::new(
                  std::io::ErrorKind::NotFound,
          Ok(())
+     }
++    /// Start the configured compositor.
++    /// Called on gar startup to launch the appropriate compositor.
++    pub fn start_compositor(&self) {
++        use std::process::Command;
++
++        match self.compositor.as_str() {
++            "picom" => {
++                // Generate picom config first
++                if let Err(e) = self.write_picom_config() {
++                    tracing::warn!("Failed to write picom config: {}", e);
++                }
++                // picom will be started by write_picom_config -> reload_picom
++            }
++            "garchomp" => {
++                // Kill any existing compositor first
++                let _ = Command::new("pkill").arg("picom").status();
++                let _ = Command::new("pkill").arg("garchomp").status();
++
++                std::thread::sleep(std::time::Duration::from_millis(100));
++
++                // Start garchomp
++                match Command::new("garchomp").spawn() {
++                    Ok(_) => {
++                        tracing::info!("Started garchomp compositor");
++                    }
++                    Err(e) => {
++                        tracing::error!("Failed to start garchomp: {}", e);
++                        // Fall back to picom
++                        tracing::info!("Falling back to picom");
++                        Self::reload_picom();
++                    }
++                }
++            }
++            "none" => {
++                tracing::info!("Compositor disabled (compositor=none)");
++                // Kill any running compositor
++                let _ = Command::new("pkill").arg("picom").status();
++                let _ = Command::new("pkill").arg("garchomp").status();
++            }
++            _ => {
++                tracing::warn!("Unknown compositor '{}', defaulting to picom", self.compositor);
++                if let Err(e) = self.write_picom_config() {
++                    tracing::warn!("Failed to write picom config: {}", e);
++                }
++            }
++        }
++    }
++
++    /// Stop any running compositor.
++    pub fn stop_compositor() {
++        use std::process::Command;
++        let _ = Command::new("pkill").arg("picom").status();
++        let _ = Command::new("pkill").arg("garchomp").status();
++    }
++
      /// Apply screen timeout/DPMS settings using xset
      pub fn apply_screen_timeout(&self) {
          use std::process::Command;
              follow_window_on_move: false,
              // Behavior: warp mouse pointer to center of focused window
              mouse_follows_focus: false,
++            // Behavior: focus window when mouse enters it
++            focus_follows_mouse: true,
              // Manual bar height (0 = use struts from dock windows)
              bar_height: 0,
              // garbar not enabled by default (enabled when gar.bar table is set)
              // Screen timeout: enabled by default with 10 minute timeout
              screen_timeout_enabled: true,
              screen_timeout_seconds: 600,
++            // Compositor selection: "picom" (default), "garchomp", or "none"
++            compositor: "picom".to_string(),
              // Compositor settings (picom) - matching picom.conf defaults
              corner_radius: 12,
              blur_enabled: true,

gar/src/core/mod.rsmodified

          // Get config values from Lua state
          let config = lua_state.lock().unwrap().config.clone();
--        // Generate picom config from settings
++        // Start the configured compositor (picom, garchomp, or none)
--        if let Err(e) = config.write_picom_config() {
++        config.start_compositor();
--            tracing::warn!("Failed to generate picom config: {}", e);
--        }
          // Apply screen timeout/DPMS settings
          config.apply_screen_timeout();