animation: add geometry animation trigger

Signed-off-by: Yuxuan Shui <yshuiv7@gmail.com>

Author: yshui

man/picom.1.adoc

@@ -515,6 +515,10 @@ animations = ({
 
 	  _decrease-opacity_:: When the opacity of a window is decreased.
 
+	  _geometry_:: When the geometry of a window is changed. (EXPERIMENTAL)
++
+WARNING: The _geometry_ trigger is experimental. Using this means you accept the caveat that geometry animations will also trigger when you manually resize or move a window, like when you drag the window around with your mouse.
+
   _suppressions_:::
 	Which other animations should be suppressed when this animation is running. Normally, if another trigger is activated while an animation is already running, the animation in progress will be interrupted and the new animation will start. If you want to prevent this, you can set the `suppressions` option to a list of triggers that should be suppressed. This is optional, the default value for this is an empty list.
 
@@ -713,6 +717,8 @@ Currently, these context variables are defined: :::
 
   _window-width_, _window-height_:: The size of the window.
 
+  _window-x-before_, _window-y-before_, _window-width-before_, _window-height-before_:: The size and coordinates of the window before the animation is triggered. This is only meaningfully different from the normal window geometry variables for the _geometry_ trigger.
+
   _window-monitor-x_, _window-monitor-y_, _window-monitor-width_, _window-monitor-height_:: Defines the rectangle which reflects the monitor the window is on. If the window is not fully contained in any monitor, the rectangle will reflect the entire virtual screen.
 
   _window-raw-opacity-before_, _window-raw-opacity_:: Animation triggers are usually accompanied by a change in the window's opacity. For example, when a window is opened, its opacity changes from 0 to 1. These two variables reflect the opacity of the window before and after the animation is triggered. They are useful if you want to smoothly transition the window's opacity.

src/config.h

@@ -70,7 +70,6 @@ enum vblank_scheduler_type {
 };
 
 enum animation_trigger {
-	ANIMATION_TRIGGER_INVALID = -1,
 	/// When a hidden window is shown
 	ANIMATION_TRIGGER_SHOW = 0,
 	/// When a window is hidden
@@ -83,7 +82,11 @@ enum animation_trigger {
 	ANIMATION_TRIGGER_OPEN,
 	/// When a window is closed
 	ANIMATION_TRIGGER_CLOSE,
-	ANIMATION_TRIGGER_LAST = ANIMATION_TRIGGER_CLOSE,
+	/// When a window's geometry changes
+	ANIMATION_TRIGGER_GEOMETRY,
+
+	ANIMATION_TRIGGER_INVALID,
+	ANIMATION_TRIGGER_COUNT = ANIMATION_TRIGGER_INVALID,
 };
 
 static const char *animation_trigger_names[] attr_unused = {
@@ -93,6 +96,7 @@ static const char *animation_trigger_names[] attr_unused = {
     [ANIMATION_TRIGGER_DECREASE_OPACITY] = "decrease-opacity",
     [ANIMATION_TRIGGER_OPEN] = "open",
     [ANIMATION_TRIGGER_CLOSE] = "close",
+    [ANIMATION_TRIGGER_GEOMETRY] = "geometry",
 };
 
 struct script;
@@ -192,7 +196,7 @@ struct window_maybe_options {
 	enum tristate full_shadow;
 
 	/// Window specific animations
-	struct win_script animations[ANIMATION_TRIGGER_LAST + 1];
+	struct win_script animations[ANIMATION_TRIGGER_COUNT];
 };
 
 // Make sure `window_options` has no implicit padding.
@@ -214,7 +218,7 @@ struct window_options {
 	bool paint;
 	bool full_shadow;
 
-	struct win_script animations[ANIMATION_TRIGGER_LAST + 1];
+	struct win_script animations[ANIMATION_TRIGGER_COUNT];
 };
 #pragma GCC diagnostic pop
 
@@ -432,7 +436,7 @@ typedef struct options {
 
 	bool dithered_present;
 	// === Animation ===
-	struct win_script animations[ANIMATION_TRIGGER_LAST + 1];
+	struct win_script animations[ANIMATION_TRIGGER_COUNT];
 	/// Array of all the scripts used in `animations`. This is a dynarr.
 	struct script **all_scripts;
 

src/config_libconfig.c

@@ -224,8 +224,8 @@ static inline void parse_wintype_config(const config_t *cfg, const char *member_
 	}
 }
 
-static enum animation_trigger parse_animation_trigger(const char *trigger) {
-	for (int i = 0; i <= ANIMATION_TRIGGER_LAST; i++) {
+enum animation_trigger parse_animation_trigger(const char *trigger) {
+	for (unsigned i = 0; i < ANIMATION_TRIGGER_COUNT; i++) {
 		if (strcasecmp(trigger, animation_trigger_names[i]) == 0) {
 			return i;
 		}
@@ -297,7 +297,7 @@ static bool parse_animation_one(struct win_script *animations,
 	}
 	auto number_of_triggers =
 	    config_setting_get_string(triggers) == NULL ? config_setting_length(triggers) : 1;
-	if (number_of_triggers > ANIMATION_TRIGGER_LAST) {
+	if (number_of_triggers >= ANIMATION_TRIGGER_INVALID) {
 		log_error("Too many triggers in animation defined at line %d",
 		          config_setting_source_line(triggers));
 		return false;

src/dbus.c

@@ -555,9 +555,7 @@ cdbus_process_list_win(session_t *ps, DBusMessage *msg attr_unused, DBusMessage
 	return DBUS_HANDLER_RESULT_HANDLED;
 }
 
-/**
- * Process a win_get D-Bus request.
- */
+/// Process a property Get D-Bus request.
 static DBusHandlerResult
 cdbus_process_window_property_get(session_t *ps, DBusMessage *msg, cdbus_window_t wid,
                                   DBusMessage *reply, DBusError *e) {

src/inspect.c

@@ -218,7 +218,7 @@ void inspect_dump_window_maybe_options(struct window_maybe_options wopts) {
 	}
 
 	char **animation_triggers = dynarr_new(char *, 0);
-	for (int i = 0; i <= ANIMATION_TRIGGER_LAST; i++) {
+	for (int i = 0; i < ANIMATION_TRIGGER_COUNT; i++) {
 		if (wopts.animations[i].script != NULL) {
 			char *name = NULL;
 			casprintf(&name, "\"%s\"", animation_trigger_names[i]);

src/transition/generated/script_templates.c

@@ -81,11 +81,11 @@ static struct script *script_template__disappear(int *output_slots) {
 	    {.type = INST_STORE, .slot = 10},
 	    {.type = INST_BRANCH_ONCE, .rel = 15},
 	    {.type = INST_HALT},
-	    {.type = INST_LOAD_CTX, .ctx = 32},
+	    {.type = INST_LOAD_CTX, .ctx = 64},
 	    {.type = INST_STORE_OVER_NAN, .slot = 13},
 	    {.type = INST_LOAD_CTX, .ctx = 1073741824},
 	    {.type = INST_STORE, .slot = 15},
-	    {.type = INST_LOAD_CTX, .ctx = 40},
+	    {.type = INST_LOAD_CTX, .ctx = 72},
 	    {.type = INST_STORE, .slot = 14},
 	    {.type = INST_IMM, .imm = 0x1p+0},
 	    {.type = INST_STORE_OVER_NAN, .slot = 16},
@@ -299,11 +299,11 @@ static struct script *script_template__appear(int *output_slots) {
 	    {.type = INST_STORE, .slot = 10},
 	    {.type = INST_BRANCH_ONCE, .rel = 13},
 	    {.type = INST_HALT},
-	    {.type = INST_LOAD_CTX, .ctx = 32},
+	    {.type = INST_LOAD_CTX, .ctx = 64},
 	    {.type = INST_STORE_OVER_NAN, .slot = 13},
 	    {.type = INST_LOAD_CTX, .ctx = 1073741824},
 	    {.type = INST_STORE, .slot = 15},
-	    {.type = INST_LOAD_CTX, .ctx = 40},
+	    {.type = INST_LOAD_CTX, .ctx = 72},
 	    {.type = INST_STORE, .slot = 14},
 	    {.type = INST_LOAD_CTX, .ctx = 1073741828},
 	    {.type = INST_STORE_OVER_NAN, .slot = 16},

src/wm/win.c

@@ -397,6 +397,7 @@ void win_process_primary_flags(session_t *ps, struct win *w) {
 		}
 
 		// Update window geometry
+		w->previous.g = w->g;
 		w->g = w->pending_g;
 
 		// Whether a window is fullscreen changes based on its geometry
@@ -1732,6 +1733,10 @@ struct win_script_context win_script_context_prepare(struct session *ps, struct
 	    .width = w->widthb,
 	    .height = w->heightb,
 	    .opacity = w->opacity,
+	    .x_before = w->previous.g.x,
+	    .y_before = w->previous.g.y,
+	    .width_before = w->previous.g.width + w->previous.g.border_width * 2,
+	    .height_before = w->previous.g.height + w->previous.g.border_width * 2,
 	    .opacity_before = w->previous.opacity,
 	    .monitor_x = monitor.x1,
 	    .monitor_y = monitor.y1,
@@ -1817,10 +1822,9 @@ bool win_process_animation_and_state_change(struct session *ps, struct win *w, d
 
 	auto win_ctx = win_script_context_prepare(ps, w);
 	w->previous.opacity = w->opacity;
-	if (w->previous.state == w->state && win_ctx.opacity_before == win_ctx.opacity) {
-		// No state changes, if there's a animation running, we just continue it.
-		return win_advance_animation(w, delta_t, &win_ctx);
-	}
+
+	bool geometry_changed = !win_geometry_eq(w->previous.g, w->g);
+	w->previous.g = w->g;
 
 	// Try to determine the right animation trigger based on state changes. Note there
 	// is some complications here. X automatically unmaps windows before destroying
@@ -1831,13 +1835,10 @@ bool win_process_animation_and_state_change(struct session *ps, struct win *w, d
 	// gap between the UnmapNotify and DestroyNotify. There is no way on our end of
 	// fixing this without using hacks.
 	enum animation_trigger trigger = ANIMATION_TRIGGER_INVALID;
-	if (w->previous.state == w->state) {
-		// Only opacity changed
-		assert(w->state == WSTATE_MAPPED);
-		trigger = win_ctx.opacity > win_ctx.opacity_before
-		              ? ANIMATION_TRIGGER_INCREASE_OPACITY
-		              : ANIMATION_TRIGGER_DECREASE_OPACITY;
-	} else {
+
+	// Animation trigger priority:
+	//   state > geometry > opacity
+	if (w->previous.state != w->state) {
 		// Send D-Bus signal
 		if (ps->o.dbus) {
 			switch (w->state) {
@@ -1883,10 +1884,21 @@ bool win_process_animation_and_state_change(struct session *ps, struct win *w, d
 			assert(false);
 			return true;
 		}
+	} else if (geometry_changed) {
+		assert(w->state == WSTATE_MAPPED);
+		trigger = ANIMATION_TRIGGER_GEOMETRY;
+	} else if (win_ctx.opacity_before != win_ctx.opacity) {
+		assert(w->state == WSTATE_MAPPED);
+		trigger = win_ctx.opacity > win_ctx.opacity_before
+		              ? ANIMATION_TRIGGER_INCREASE_OPACITY
+		              : ANIMATION_TRIGGER_DECREASE_OPACITY;
 	}
 
-	if (trigger != ANIMATION_TRIGGER_INVALID && w->running_animation_instance &&
-	    (w->running_animation.suppressions & (1 << trigger)) != 0) {
+	if (trigger == ANIMATION_TRIGGER_INVALID) {
+		// No state changes, if there's a animation running, we just continue it.
+		return win_advance_animation(w, delta_t, &win_ctx);
+	} else if (w->running_animation_instance &&
+	           (w->running_animation.suppressions & (1 << trigger)) != 0) {
 		log_debug("Not starting animation %s for window %#010x (%s) because it "
 		          "is being suppressed.",
 		          animation_trigger_names[trigger], win_id(w), w->name);
@@ -1921,6 +1933,45 @@ bool win_process_animation_and_state_change(struct session *ps, struct win *w, d
 
 	auto new_animation = script_instance_new(wopts.animations[trigger].script);
 	if (w->running_animation_instance) {
+		if (geometry_changed) {
+			// If the window has moved, we need to adjust scripts
+			// outputs so that the window will stay in the same position and
+			// size after applying the animation. This way the window's size
+			// and position won't change discontinuously.
+			auto memory = w->running_animation_instance->memory;
+			auto output_indices = w->running_animation.output_indices;
+			struct {
+				int output;
+				double delta;
+			} adjustments[] = {
+			    {WIN_SCRIPT_OFFSET_X, win_ctx.x_before - win_ctx.x},
+			    {WIN_SCRIPT_OFFSET_Y, win_ctx.y_before - win_ctx.y},
+			    {WIN_SCRIPT_SHADOW_OFFSET_X, win_ctx.x_before - win_ctx.x},
+			    {WIN_SCRIPT_SHADOW_OFFSET_Y, win_ctx.y_before - win_ctx.y},
+			};
+			for (size_t i = 0; i < ARR_SIZE(adjustments); i++) {
+				if (output_indices[adjustments[i].output] >= 0) {
+					memory[output_indices[adjustments[i].output]] +=
+					    adjustments[i].delta;
+				}
+			}
+
+			struct {
+				int output;
+				double factor;
+			} factors[] = {
+			    {WIN_SCRIPT_SCALE_X, win_ctx.width_before / win_ctx.width},
+			    {WIN_SCRIPT_SCALE_Y, win_ctx.height_before / win_ctx.height},
+			    {WIN_SCRIPT_SHADOW_SCALE_X, win_ctx.width_before / win_ctx.width},
+			    {WIN_SCRIPT_SHADOW_SCALE_Y, win_ctx.height_before / win_ctx.height},
+			};
+			for (size_t i = 0; i < ARR_SIZE(factors); i++) {
+				if (output_indices[factors[i].output] >= 0) {
+					memory[output_indices[factors[i].output]] *=
+					    factors[i].factor;
+				}
+			}
+		}
 		script_instance_resume_from(w->running_animation_instance, new_animation);
 		free(w->running_animation_instance);
 	}

src/wm/win.h

@@ -90,9 +90,13 @@ struct win_geometry {
 
 /// These are changes of window state that might trigger an animation. We separate them
 /// out and delay their application so determining which animation to run is easier.
+///
+/// These values are only hold for an instant, and once the animation is started they are
+/// updated to reflect the latest state.
 struct win_state_change {
 	winstate_t state;
 	double opacity;
+	struct win_geometry g;
 };
 
 struct win {
@@ -261,6 +265,7 @@ struct win {
 
 struct win_script_context {
 	double x, y, width, height;
+	double x_before, y_before, width_before, height_before;
 	double opacity_before, opacity;
 	double monitor_x, monitor_y;
 	double monitor_width, monitor_height;
@@ -273,6 +278,10 @@ static const struct script_context_info win_script_context_info[] = {
     {"window-y", offsetof(struct win_script_context, y)},
     {"window-width", offsetof(struct win_script_context, width)},
     {"window-height", offsetof(struct win_script_context, height)},
+    {"window-x-before", offsetof(struct win_script_context, x_before)},
+    {"window-y-before", offsetof(struct win_script_context, y_before)},
+    {"window-width-before", offsetof(struct win_script_context, width_before)},
+    {"window-height-before", offsetof(struct win_script_context, height_before)},
     {"window-raw-opacity-before", offsetof(struct win_script_context, opacity_before)},
     {"window-raw-opacity", offsetof(struct win_script_context, opacity)},
     {"window-monitor-x", offsetof(struct win_script_context, monitor_x)},
@@ -317,7 +326,7 @@ static const struct window_maybe_options WIN_MAYBE_OPTIONS_DEFAULT = {
 
 static inline void win_script_fold(const struct win_script *upper,
                                    const struct win_script *lower, struct win_script *output) {
-	for (size_t i = 0; i <= ANIMATION_TRIGGER_LAST; i++) {
+	for (size_t i = 0; i < ANIMATION_TRIGGER_COUNT; i++) {
 		output[i] = upper[i].script ? upper[i] : lower[i];
 	}
 }
@@ -375,6 +384,12 @@ win_options(const struct win *w) {
 	    win_maybe_options_fold(w->options_override, w->options), *w->options_default);
 }
 
+/// Check if win_geometry `a` and `b` have the same sizes and positions. Border width is
+/// not considered.
+static inline bool win_geometry_eq(struct win_geometry a, struct win_geometry b) {
+	return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height;
+}
+
 /// Process pending updates/images flags on a window. Has to be called in X critical
 /// section. Returns true if the window had an animation running and it has just finished,
 /// or if the window's states just changed and there is no animation defined for this