fix,feat: keep corner masks updated during animations, tiled resize fixes, multi rule matching

Author: dy-tea

TODO.md

@@ -1,8 +1,8 @@
 # Animations
 - Per-window animation overrides
-- Ensure animations and blur work together without visual artifacts (corner masks missing during animations)
+- Ensure animations and blur work together without visual artifacts
 - Custom animation shaders for windows (e.g. open/close animations)
-- Resize animations are imperfect (tiled resize)
+- Tiled resize does not have stable position (edge(s) that should not move does not have stable position)
 
 # Effects
 - Effects per window state (e.g. unfocused, focused, ...)
@@ -15,7 +15,6 @@
 # Misc
 - Rework the docs to be easier to use
 - Minimum sizes are currently always respected, clipping may be preferred in most cases
-- Let more than 1 rule match a given client
 - Improve the README (include video, images, better info)
 
 # Potential

src/animation.c

@@ -753,6 +753,13 @@ bool animation_apply_geometry_from(node_t *node, struct wlr_scene_tree *scene_tr
 	if (!node || !scene_tree)
 		return false;
 
+	// if the size changes, delegate to the resize animation system
+	if ((from.width != target.width || from.height != target.height) && node->client &&
+			node->client->toplevel && from.width > 0 && from.height > 0) {
+		if (animation_start_resize(node->client->toplevel, from, target))
+			return true;
+	}
+
 	output_t *output = node->output;
 	if (!animate || !enable_animations || !output || !output->enabled || !node->client ||
 			!node->client->shown) {
@@ -970,8 +977,16 @@ bool animation_update_output(output_t *output, struct timespec now) {
 			int y = (int)(entry->from.y + (entry->to.y - entry->from.y) * entry->eased);
 			wlr_scene_node_set_position(&entry->scene_tree->node, x, y);
 
-			if (entry->workspace_switch)
+			if (entry->workspace_switch) {
 				update_blur_for_slide_animation(output, entry);
+				if (entry->node && entry->node->client && entry->node->client->toplevel) {
+					toplevel_t *tl = entry->node->client->toplevel;
+					if (tl->rounded && tl->rounded->corner_mask_node) {
+						tl->rounded->corner_mask_dirty = true;
+						tl->rounded->border_dirty = true;
+					}
+				}
+			}
 
 			if (is_entry_done(entry)) {
 				if (entry->from_opacity != entry->to_opacity) {

src/effects.c

@@ -1221,6 +1221,9 @@ static struct wlr_box get_animated_client_rect(toplevel_t *tl) {
 			r.width = 1;
 		if (r.height < 1)
 			r.height = 1;
+	} else if (tl->node && tl->node->output && animation_workspace_switch_active(tl->node->output)) {
+		r.x = tl->scene_tree->node.x;
+		r.y = tl->scene_tree->node.y;
 	}
 	return r;
 }

src/rule.c

@@ -206,28 +206,45 @@ static bool match_string(const char *pattern, const char *value) {
 }
 
 rule_consequence_t *find_matching_rule(const char *app_id, const char *title, const char *tag) {
-	rule_t *r = rule_head;
-	rule_t *matched = NULL;
+	static rule_consequence_t merged;
+	memset(&merged, 0, sizeof(merged));
 
+	rule_t *r = rule_head;
 	while (r != NULL) {
+		rule_t *next = r->next;
+
 		bool app_id_matches = match_string(r->match.app_id, app_id);
 		bool title_matches = match_string(r->match.title, title);
 		bool tag_matches = match_string(r->match.tag, tag);
 
 		if (app_id_matches && title_matches && tag_matches) {
-			matched = r;
-			break;
+			rule_type_t bits = r->consequence.has;
+			merged.has |= bits;
+			merged.flags = (merged.flags & ~bits) | (r->consequence.flags & bits);
+
+			if (bits & RULE_TYPE_DESKTOP)
+				strncpy(merged.desktop, r->consequence.desktop, SMALEN);
+			if (bits & RULE_TYPE_MONITOR)
+				strncpy(merged.monitor, r->consequence.monitor, SMALEN);
+			if (bits & RULE_TYPE_STATE)
+				merged.state = r->consequence.state;
+			if (bits & RULE_TYPE_SCROLLER_PROPORTION)
+				merged.scroller_proportion = r->consequence.scroller_proportion;
+			if (bits & RULE_TYPE_SCROLLER_PROPORTION_SINGLE)
+				merged.scroller_proportion_single = r->consequence.scroller_proportion_single;
+			if (bits & RULE_TYPE_BORDER_RADIUS)
+				merged.border_radius = r->consequence.border_radius;
+			if (bits & RULE_TYPE_OPACITY)
+				merged.opacity = r->consequence.opacity;
+
+			if (r->match.one_shot)
+				remove_rule(r);
 		}
-		r = r->next;
-	}
-
-	if (matched == NULL)
-		return NULL;
 
-	if (matched->match.one_shot)
-		remove_rule(matched);
+		r = next;
+	}
 
-	return &matched->consequence;
+	return merged.has ? &merged : NULL;
 }
 
 void rule_apply_consequence(node_t *node, client_t *client, const rule_consequence_t *rule) {