Add linear tiled window animations

toml-config/src/config/parsers.rs

@@ -8,6 +8,7 @@ use {
 
 pub mod action;
 mod actions;
+mod animations;
 mod capabilities;
 mod clean_logs_older_than;
 mod client_match;

toml-config/src/config/parsers/animations.rs

@@ -0,0 +1,50 @@
+use {
+    crate::{
+        config::{
+            Animations,
+            context::Context,
+            extractor::{Extractor, ExtractorError, bol, n32, opt, recover, str},
+            parser::{DataType, ParseResult, Parser, UnexpectedDataType},
+        },
+        toml::{
+            toml_span::{DespanExt, Span, Spanned},
+            toml_value::Value,
+        },
+    },
+    indexmap::IndexMap,
+    thiserror::Error,
+};
+
+#[derive(Debug, Error)]
+pub enum AnimationsParserError {
+    #[error(transparent)]
+    Expected(#[from] UnexpectedDataType),
+    #[error(transparent)]
+    Extract(#[from] ExtractorError),
+}
+
+pub struct AnimationsParser<'a>(pub &'a Context<'a>);
+
+impl Parser for AnimationsParser<'_> {
+    type Value = Animations;
+    type Error = AnimationsParserError;
+    const EXPECTED: &'static [DataType] = &[DataType::Table];
+
+    fn parse_table(
+        &mut self,
+        span: Span,
+        table: &IndexMap<Spanned<String>, Spanned<Value>>,
+    ) -> ParseResult<Self> {
+        let mut ext = Extractor::new(self.0, span, table);
+        let (enabled, duration_ms, curve) = ext.extract((
+            recover(opt(bol("enabled"))),
+            recover(opt(n32("duration-ms"))),
+            recover(opt(str("curve"))),
+        ))?;
+        Ok(Animations {
+            enabled: enabled.despan(),
+            duration_ms: duration_ms.despan(),
+            curve: curve.despan().map(|s| s.to_string()),
+        })
+    }
+}

toml-config/src/config/parsers/config.rs

@@ -1,13 +1,14 @@
 use {
     crate::{
         config::{
-            Action, Config, Libei, Theme, UiDrag,
+            Action, Animations, Config, Libei, Theme, UiDrag,
             context::Context,
             extractor::{Extractor, ExtractorError, arr, bol, int, opt, recover, str, val},
             parser::{DataType, ParseResult, Parser, UnexpectedDataType},
             parsers::{
                 action::ActionParser,
                 actions::ActionsParser,
+                animations::AnimationsParser,
                 clean_logs_older_than::CleanLogsOlderThanParser,
                 client_rule::ClientRulesParser,
                 color_management::ColorManagementParser,
@@ -153,6 +154,7 @@ impl Parser for ConfigParser<'_> {
                 fallback_output_mode_val,
                 clean_logs_older_than_val,
                 mouse_follows_focus,
+                animations_val,
             ),
         ) = ext.extract((
             (
@@ -213,6 +215,7 @@ impl Parser for ConfigParser<'_> {
                 opt(val("fallback-output-mode")),
                 opt(val("clean-logs-older-than")),
                 recover(opt(bol("unstable-mouse-follows-focus"))),
+                opt(val("animations")),
             ),
         ))?;
         let mut keymap = None;
@@ -429,6 +432,15 @@ impl Parser for ConfigParser<'_> {
                 }
             }
         }
+        let mut animations = Animations::default();
+        if let Some(value) = animations_val {
+            match value.parse(&mut AnimationsParser(self.0)) {
+                Ok(v) => animations = v,
+                Err(e) => {
+                    log::warn!("Could not parse animations setting: {}", self.0.error(e));
+                }
+            }
+        }
         let mut xwayland = None;
         if let Some(value) = xwayland_val {
             match value.parse(&mut XwaylandParser(self.0)) {
@@ -587,6 +599,7 @@ impl Parser for ConfigParser<'_> {
             tearing,
             libei,
             ui_drag,
+            animations,
             xwayland,
             color_management,
             float,