--cycle-accordions flag

HolbyFPV · HolbyFPV · commit 44b911996112 · 2025-03-10T00:07:16.000-04:00
diff --git a/packages/wm-common/src/app_command.rs b/packages/wm-common/src/app_command.rs
@@ -159,6 +159,7 @@ pub enum InvokeCommand {
   AdjustBorders(InvokeAdjustBordersCommand),
   Close,
   Focus(InvokeFocusCommand),
+  FocusAccordion(InvokeFocusCommand),
   Ignore,
   Move(InvokeMoveCommand),
   MoveWorkspace {
@@ -327,6 +328,10 @@ pub struct InvokeFocusCommand {
 
   #[clap(long)]
   pub recent_workspace: bool,
+
+  // #[clap(long, default_value_t = false)]
+  #[clap(long, default_value_t = true)]
+  pub cycle_accordions: bool,
 }
 
 #[derive(Args, Clone, Debug, PartialEq, Serialize)]
diff --git a/packages/wm/src/commands/container/focus_in_accordion.rs b/packages/wm/src/commands/container/focus_in_accordion.rs
@@ -0,0 +1,62 @@
+use wm_common::{Direction, TilingDirection};
+
+use super::set_focused_descendant;
+use crate::{
+  models::Container,
+  traits::{CommonGetters, TilingDirectionGetters},
+  wm_state::WmState,
+};
+
+pub fn focus_in_accordion(
+  origin_container: &Container,
+  direction: &Direction,
+  state: &mut WmState,
+) -> anyhow::Result<()> {
+  let origin_or_ancestor = origin_container.clone();
+
+  // Check if we're in an accordion container
+  if let Some(parent) = origin_or_ancestor.parent() {
+    if let Ok(direction_parent) = parent.as_direction_container() {
+      if matches!(
+        direction_parent.tiling_direction(),
+        TilingDirection::HorizontalAccordion
+          | TilingDirection::VerticalAccordion
+      ) {
+        // For horizontal accordion, only respond to Up/Down
+        // For vertical accordion, only respond to Left/Right
+        let is_valid_direction = match direction_parent.tiling_direction()
+        {
+          TilingDirection::HorizontalAccordion => {
+            matches!(direction, Direction::Up | Direction::Down)
+          }
+          TilingDirection::VerticalAccordion => {
+            matches!(direction, Direction::Left | Direction::Right)
+          }
+          _ => false,
+        };
+
+        if is_valid_direction {
+          // Get the next/prev sibling depending on the direction
+          let focus_target = match direction {
+            Direction::Up | Direction::Left => origin_or_ancestor
+              .prev_siblings()
+              .find_map(|c| c.as_tiling_container().ok()),
+            _ => origin_or_ancestor
+              .next_siblings()
+              .find_map(|c| c.as_tiling_container().ok()),
+          };
+
+          if let Some(target) = focus_target {
+            // Set focus to the target container
+            set_focused_descendant(&target.into(), None);
+            state.pending_sync.queue_focus_change().queue_cursor_jump();
+            return Ok(());
+          }
+        }
+      }
+    }
+  }
+
+  // If not in an accordion or no target found, do nothing
+  Ok(())
+}
diff --git a/packages/wm/src/commands/container/focus_in_direction.rs b/packages/wm/src/commands/container/focus_in_direction.rs
@@ -12,7 +12,55 @@ pub fn focus_in_direction(
   origin_container: &Container,
   direction: &Direction,
   state: &mut WmState,
+  cycle_accordions: bool, // New parameter
 ) -> anyhow::Result<()> {
+  // First, check if we're in an accordion and shouldn't cycle
+  if !cycle_accordions {
+    let is_in_accordion = if let Some(parent) = origin_container.parent() {
+      if let Ok(direction_parent) = parent.as_direction_container() {
+        matches!(
+          direction_parent.tiling_direction(),
+          TilingDirection::HorizontalAccordion
+            | TilingDirection::VerticalAccordion
+        )
+      } else {
+        false
+      }
+    } else {
+      false
+    };
+
+    // If in accordion but not cycling, treat the whole accordion as one
+    // unit
+    if is_in_accordion {
+      // Find the accordion container
+      let accordion_parent = origin_container
+        .parent()
+        .and_then(|p| p.as_direction_container().ok())
+        .context("No direction container")?;
+
+      // We'll convert it to container once and use that
+      let accordion_container = accordion_parent.clone().into();
+
+      // Try to move from the accordion to the next container
+      // Use the accordion parent as the origin instead of the window
+      let workspace_target =
+        workspace_focus_target(&accordion_container, direction, state)
+          .ok()
+          .flatten();
+      let tiling_target =
+        tiling_focus_target(&accordion_container, direction)?;
+      let focus_target = tiling_target.or(workspace_target);
+
+      if let Some(focus_target) = focus_target {
+        set_focused_descendant(&focus_target, None);
+        state.pending_sync.queue_focus_change().queue_cursor_jump();
+      }
+
+      return Ok(());
+    }
+  }
+
   let focus_target = match origin_container {
     Container::TilingWindow(_) => {
       // If a suitable focus target isn't found in the current workspace,
@@ -85,67 +133,41 @@ fn tiling_focus_target(
   let tiling_direction = TilingDirection::from_direction(direction);
   let mut origin_or_ancestor = origin_container.clone();
 
-  // First check if we're in an accordion container
-  if let Some(parent) = origin_or_ancestor.parent() {
+  // Check if origin is in an accordion and if direction is valid for that
+  // accordion
+  let in_accordion = if let Some(parent) = origin_or_ancestor.parent() {
     if let Ok(direction_parent) = parent.as_direction_container() {
       match direction_parent.tiling_direction() {
         TilingDirection::HorizontalAccordion => {
-          match direction {
-            Direction::Up => {
-              // Try to focus previous sibling in accordion
-              if let Some(prev) = origin_or_ancestor
-                .prev_siblings()
-                .find_map(|c| c.as_tiling_container().ok())
-              {
-                return Ok(Some(prev.into()));
-              }
-              // If no previous sibling, allow falling through to normal
-              // navigation
-            }
-            Direction::Down => {
-              // Try to focus next sibling in accordion
-              if let Some(next) = origin_or_ancestor
-                .next_siblings()
-                .find_map(|c| c.as_tiling_container().ok())
-              {
-                return Ok(Some(next.into()));
-              }
-              // If no next sibling, allow falling through to normal
-              // navigation
-            }
-            // For Left/Right, immediately pass through to normal
-            // navigation
-            _ => {}
-          }
+          matches!(direction, Direction::Up | Direction::Down)
         }
         TilingDirection::VerticalAccordion => {
-          match direction {
-            Direction::Left => {
-              if let Some(prev) = origin_or_ancestor
-                .prev_siblings()
-                .find_map(|c| c.as_tiling_container().ok())
-              {
-                return Ok(Some(prev.into()));
-              }
-              // If no previous sibling, allow falling through to normal
-              // navigation
-            }
-            Direction::Right => {
-              if let Some(next) = origin_or_ancestor
-                .next_siblings()
-                .find_map(|c| c.as_tiling_container().ok())
-              {
-                return Ok(Some(next.into()));
-              }
-              // If no next sibling, allow falling through to normal
-              // navigation
-            }
-            // For Up/Down, immediately pass through to normal navigation
-            _ => {}
-          }
+          matches!(direction, Direction::Left | Direction::Right)
         }
-        _ => {}
+        _ => false,
       }
+    } else {
+      false
+    }
+  } else {
+    false
+  };
+
+  // If we're in an accordion and moving in its main direction,
+  // handle accordion navigation directly
+  if in_accordion {
+    // Get the next/prev sibling depending on the direction
+    let focus_target = match direction {
+      Direction::Up | Direction::Left => origin_or_ancestor
+        .prev_siblings()
+        .find_map(|c| c.as_tiling_container().ok()),
+      _ => origin_or_ancestor
+        .next_siblings()
+        .find_map(|c| c.as_tiling_container().ok()),
+    };
+
+    if let Some(target) = focus_target {
+      return Ok(Some(target.into()));
     }
   }
 
diff --git a/packages/wm/src/commands/container/mod.rs b/packages/wm/src/commands/container/mod.rs
@@ -2,6 +2,7 @@ mod attach_container;
 mod detach_container;
 mod flatten_child_split_containers;
 mod flatten_split_container;
+mod focus_in_accordion;
 mod focus_in_direction;
 mod move_container_within_tree;
 mod replace_container;
@@ -14,6 +15,7 @@ pub use attach_container::*;
 pub use detach_container::*;
 pub use flatten_child_split_containers::*;
 pub use flatten_split_container::*;
+pub use focus_in_accordion::*;
 pub use focus_in_direction::*;
 pub use move_container_within_tree::*;
 pub use replace_container::*;
diff --git a/packages/wm/src/wm.rs b/packages/wm/src/wm.rs
@@ -11,7 +11,8 @@ use wm_platform::PlatformEvent;
 use crate::{
   commands::{
     container::{
-      focus_in_direction, set_tiling_direction, toggle_tiling_direction,
+      focus_in_accordion, focus_in_direction, set_tiling_direction,
+      toggle_tiling_direction,
     },
     general::{
       cycle_focus, disable_binding_mode, enable_binding_mode,
@@ -235,9 +236,54 @@ impl WindowManager {
       }
       InvokeCommand::Focus(args) => {
         if let Some(direction) = &args.direction {
-          focus_in_direction(&subject_container, direction, state)?;
+          focus_in_direction(
+            &subject_container,
+            direction,
+            state,
+            args.cycle_accordions,
+          )?;
+        }
+
+        if let Some(name) = &args.workspace {
+          focus_workspace(
+            WorkspaceTarget::Name(name.to_string()),
+            state,
+            config,
+          )?;
+        }
+
+        if let Some(monitor_index) = &args.monitor {
+          focus_monitor(*monitor_index, state, config)?;
+        }
+
+        if args.next_active_workspace {
+          focus_workspace(WorkspaceTarget::NextActive, state, config)?;
+        }
+
+        if args.prev_active_workspace {
+          focus_workspace(WorkspaceTarget::PreviousActive, state, config)?;
+        }
+
+        if args.next_workspace {
+          focus_workspace(WorkspaceTarget::Next, state, config)?;
+        }
+
+        if args.prev_workspace {
+          focus_workspace(WorkspaceTarget::Previous, state, config)?;
+        }
+
+        if args.recent_workspace {
+          focus_workspace(WorkspaceTarget::Recent, state, config)?;
+        }
+
+        Ok(())
+      }
+      InvokeCommand::FocusAccordion(args) => {
+        if let Some(direction) = &args.direction {
+          focus_in_accordion(&subject_container, direction, state)?;
         }
 
+        // TODO - temp C+P
         if let Some(name) = &args.workspace {
           focus_workspace(
             WorkspaceTarget::Name(name.to_string()),
