feat: Gesture configuration in shortcuts config

This commit adds a Gesture abstraction, which can define gestures by the
number of fingers used, and the direction the gesture is performed in.

The abstraction is modeled after the Binding type, and the resulting
Gestures type is similar to the Shortcuts type.

This is the first step in implementing configurable touchpad gestures
(pop-os/cosmic-comp#396)

Signed-off-by: Ryan Brue <[email protected]>

Author: ryanabx

config/src/shortcuts/action.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MPL-2.0
 #![allow(deprecated)] // Derives on deprecated variants produce warnings...
 
+use std::str::FromStr;
+
 use serde::{Deserialize, Serialize};
 
 /// An operation which may be bound to a keyboard shortcut.
@@ -198,8 +200,39 @@ pub enum System {
     WorkspaceOverview,
 }
 
+/// Defines the number of fingers used for a gesture
+#[derive(Copy, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize, Hash)]
+pub enum FingerCount {
+    Three,
+    Four,
+    Five,
+}
+
+impl From<FingerCount> for &'static str {
+    fn from(count: FingerCount) -> Self {
+        match count {
+            FingerCount::Three => "3",
+            FingerCount::Four => "4",
+            FingerCount::Five => "5",
+        }
+    }
+}
+
+impl FromStr for FingerCount {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "3" => Ok(Self::Three),
+            "4" => Ok(Self::Four),
+            "5" => Ok(Self::Five),
+            _ => return Err(format!("String {} cannot be converted to finger count.", s)),
+        }
+    }
+}
+
 /// Defines the direction of an operation
-#[derive(Copy, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
+#[derive(Copy, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize, Hash)]
 pub enum Direction {
     Left,
     Right,
@@ -219,6 +252,31 @@ impl std::ops::Not for Direction {
     }
 }
 
+impl From<Direction> for &'static str {
+    fn from(direction: Direction) -> Self {
+        match direction {
+            Direction::Left => "Left",
+            Direction::Right => "Right",
+            Direction::Up => "Up",
+            Direction::Down => "Down",
+        }
+    }
+}
+
+impl FromStr for Direction {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "Down" => Ok(Self::Down),
+            "Up" => Ok(Self::Up),
+            "Left" => Ok(Self::Left),
+            "Right" => Ok(Self::Right),
+            _ => return Err(format!("String {} cannot be converted to direction.", s)),
+        }
+    }
+}
+
 /// Defines the direction to focus towards
 #[derive(Copy, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
 pub enum FocusDirection {

config/src/shortcuts/gesture.rs

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MPL-2.0
+use std::{fmt::Display, str::FromStr};
+
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use super::action::{Direction, FingerCount};
+
+/// Description of a gesture that can be handled by the compositor
+#[serde_with::serde_as]
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize, Hash, Ord, PartialOrd)]
+#[serde(deny_unknown_fields)]
+pub struct Gesture {
+    /// How many fingers are held down
+    pub fingers: FingerCount,
+    pub direction: Direction,
+    // A custom description for a custom binding
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+
+impl Gesture {
+    /// Creates a new gesture from a number of fingers and a direction
+    pub fn new(fingers: FingerCount, direction: Direction) -> Gesture {
+        Gesture {
+            fingers,
+            direction,
+            description: None,
+        }
+    }
+}
+
+impl Display for Gesture {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{} Finger {}",
+            <&'static str>::from(self.fingers),
+            <&'static str>::from(self.direction)
+        )
+    }
+}
+
+#[derive(Error, Debug, PartialEq)]
+pub enum GestureParseError {
+    #[error("Expected value for the number of fingers")]
+    NoFingerValue,
+    #[error("Invalid finger value `{0}`")]
+    InvalidFingerValue(String),
+    #[error("Expected value for the direction")]
+    NoDirectionValue,
+    #[error("Invalid direction value `{0}`")]
+    InvalidDirectionValue(String),
+    #[error("Received unknown extra data `{0}`")]
+    ExtraData(String),
+}
+
+impl FromStr for Gesture {
+    type Err = GestureParseError;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        let mut value_iter = value.split("+");
+
+        let Some(n) = value_iter.next() else {
+            return Err(GestureParseError::NoFingerValue);
+        };
+        let Ok(fingers) = FingerCount::from_str(n) else {
+            return Err(GestureParseError::InvalidFingerValue(n.to_string()));
+        };
+
+        let Some(n2) = value_iter.next() else {
+            return Err(GestureParseError::NoDirectionValue);
+        };
+
+        let Ok(direction) = Direction::from_str(n2) else {
+            return Err(GestureParseError::InvalidDirectionValue(n2.to_string()));
+        };
+
+        if let Some(n3) = value_iter.next() {
+            return Err(GestureParseError::ExtraData(n3.to_string()));
+        }
+
+        return Ok(Self {
+            fingers,
+            direction,
+            description: None,
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::shortcuts::action::{Direction, FingerCount};
+
+    use super::Gesture;
+    use std::str::FromStr;
+
+    #[test]
+    fn binding_from_str() {
+        assert_eq!(
+            Gesture::from_str("3+Left"),
+            Ok(Gesture::new(FingerCount::Three, Direction::Left))
+        );
+
+        assert_eq!(
+            Gesture::from_str("5+Up"),
+            Ok(Gesture::new(FingerCount::Five, Direction::Up))
+        );
+
+        assert_ne!(
+            Gesture::from_str("4+Left+More+Info"),
+            Ok(Gesture::new(FingerCount::Four, Direction::Left))
+        );
+    }
+}

config/src/shortcuts/mod.rs

@@ -5,10 +5,13 @@ pub use action::Action;
 
 pub mod modifier;
 
+use action::{Direction, FingerCount};
 pub use modifier::{Modifier, Modifiers, ModifiersDef};
 
 mod binding;
+mod gesture;
 pub use binding::Binding;
+pub use gesture::Gesture;
 
 pub mod sym;
 
@@ -49,6 +52,33 @@ pub fn shortcuts(context: &cosmic_config::Config) -> Shortcuts {
     shortcuts
 }
 
+/// Get the current system gesture configuration
+///
+/// Merges user-defined custom gestures to the system default config
+pub fn gestures(context: &cosmic_config::Config) -> Gestures {
+    // Load gestures defined by the system.
+    let mut gestures = context
+        .get::<Gestures>("default_gestures")
+        .unwrap_or_else(|why| {
+            if why.is_err() {
+                tracing::error!("shortcuts defaults config error: {why:?}");
+            }
+            Gestures::default()
+        });
+
+    // Load custom gestures defined by the user.
+    let custom_gestures = context
+        .get::<Gestures>("custom_gestures")
+        .unwrap_or_else(|why| {
+            tracing::error!("shortcuts custom config error: {why:?}");
+            Gestures::default()
+        });
+
+    // Combine while overriding system gestures.
+    gestures.0.extend(custom_gestures.0);
+    gestures
+}
+
 /// Get a map of system actions and their configured commands
 pub fn system_actions(context: &cosmic_config::Config) -> SystemActions {
     let mut config = SystemActions::default();
@@ -80,6 +110,8 @@ pub fn system_actions(context: &cosmic_config::Config) -> SystemActions {
 pub struct Config {
     pub defaults: Shortcuts,
     pub custom: Shortcuts,
+    pub default_gestures: Gestures,
+    pub custom_gestures: Gestures,
     pub system_actions: SystemActions,
 }
 
@@ -97,6 +129,18 @@ impl Config {
             .shortcut_for_action(action)
             .or_else(|| self.defaults.shortcut_for_action(action))
     }
+
+    pub fn gestures(&self) -> impl Iterator<Item = (&Gesture, &Action)> {
+        self.custom_gestures
+            .iter()
+            .chain(self.default_gestures.iter())
+    }
+
+    pub fn gesture_for_action(&self, action: &Action) -> Option<String> {
+        self.custom_gestures
+            .gesture_for_action(action)
+            .or_else(|| self.default_gestures.gesture_for_action(action))
+    }
 }
 
 /// A map of defined key [Binding]s and their triggerable [Action]s
@@ -261,3 +305,49 @@ impl<'de> Deserialize<'de> for SystemActionsImpl {
         deserializer.deserialize_map(SystemActionsMapVisitor)
     }
 }
+
+/// A map of defined [Gesture]s and their triggerable [Action]s
+#[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
+#[serde(transparent)]
+pub struct Gestures(pub BTreeMap<Gesture, Action>);
+
+impl Gestures {
+    pub fn insert_default_gesture(
+        &mut self,
+        fingers: FingerCount,
+        direction: Direction,
+        action: Action,
+    ) {
+        if !self.0.values().any(|a| a == &action) {
+            let pattern = Gesture {
+                description: None,
+                fingers,
+                direction,
+            };
+            if !self.0.contains_key(&pattern) {
+                self.0.insert(pattern, action.clone());
+            }
+        }
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (&Gesture, &Action)> {
+        self.0.iter()
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&Gesture, &mut Action)> {
+        self.0.iter_mut()
+    }
+
+    pub fn gesture_for_action(&self, action: &Action) -> Option<String> {
+        self.gestures(action)
+            .next() // take the first one
+            .map(|gesture| gesture.to_string())
+    }
+
+    pub fn gestures<'a>(&'a self, action: &'a Action) -> impl Iterator<Item = &'a Gesture> {
+        self.0
+            .iter()
+            .filter(move |(_, a)| *a == action)
+            .map(|(b, _)| b)
+    }
+}