core: 添加窗口规则 (rules) 数据结构和配置接口

src/config/runtime_config.c

@@ -1,6 +1,7 @@
 #include "config/runtime_config.h"
 
 #include <dlfcn.h>
+#include <stddef.h>
 #include <zdwm/config.h>
 
 #include "base/array.h"
@@ -8,11 +9,14 @@
 #include "config/defaults.h"
 #include "config/loader.h"
 #include "core/layout.h"
+#include "core/rules.h"
 #include "core/runtime.h"
+#include "core/types.h"
 #include "core/wm_desc.h"
 
 struct zdwm_config_builder_t {
   layout_registry_t layouts;
+  rules_t rules;
   workspace_desc_t *workspaces;
   size_t workspace_count;
   size_t workspace_capacity;
@@ -89,6 +93,46 @@ static workspace_id_t runtime_config_define_workspace(
   return workspace_id;
 }
 
+static bool rule_match_valid(const rule_match_t *match) {
+  if (!match) return false;
+
+  return match->app_id || match->role || match->class_name ||
+         match->instance_name;
+}
+
+static bool rule_action_valid(const rule_action_t *action,
+                              size_t workspace_count) {
+  if (!action) return false;
+
+  bool flag_valid = action->switch_to_workspace || action->fullscreen ||
+                    action->maximize || action->floating;
+
+  if (action->workspace == ZDWM_WORKSPACE_ID_INVALID) {
+    return flag_valid;
+  } else {
+    return action->workspace < workspace_count && flag_valid;
+  }
+}
+
+static bool runtime_config_add_rule(zdwm_config_builder_t *builder,
+                                    const zdwm_rule_match_t *match,
+                                    const zdwm_rule_action_t *action) {
+  if (!builder) return false;
+  if (!rule_match_valid(match)) return false;
+  if (!rule_action_valid(action, builder->workspace_count)) return false;
+
+  rules_t *rules = &builder->rules;
+  rule_item_t *rule = array_push(rules->items, rules->count, rules->capacity);
+
+  rule->match.app_id = p_strdup_nullable(match->app_id);
+  rule->match.role = p_strdup_nullable(match->role);
+  rule->match.class_name = p_strdup_nullable(match->class_name);
+  rule->match.instance_name = p_strdup_nullable(match->instance_name);
+  rule->action = *action;
+
+  return true;
+}
+
 static bool config_builder_finish(zdwm_config_builder_t *builder,
                                   runtime_init_desc_t *out) {
   if (!builder || !out) return false;
@@ -96,6 +140,7 @@ static bool config_builder_finish(zdwm_config_builder_t *builder,
   if (!builder->layouts.slot_count || !builder->workspace_count) return false;
 
   if (!layout_registry_move(&builder->layouts, &out->layouts)) return false;
+  if (!rules_move(&builder->rules, &out->rules)) return false;
   out->workspaces = builder->workspaces;
   out->workspace_count = builder->workspace_count;
   builder->workspaces = nullptr;
@@ -122,6 +167,7 @@ static bool runtime_config_build(zdwm_config_setup_fn *setup,
       },
     .register_layout = runtime_config_register_layout,
     .define_workspace = runtime_config_define_workspace,
+    .add_rule = runtime_config_add_rule,
   };
   bool ok = setup(&api, &builder, outputs, output_count) &&
             config_builder_finish(&builder, out);

src/core/rules.c

@@ -0,0 +1,37 @@
+#include "core/rules.h"
+
+#include "base/memory.h"
+#include "core/types.h"
+
+bool rules_move(rules_t *src, rules_t *dest) {
+  if (!dest || !src) return false;
+
+  dest->items = src->items;
+  dest->count = src->count;
+  dest->capacity = src->capacity;
+
+  src->items = nullptr;
+  src->count = 0;
+  src->capacity = 0;
+
+  return true;
+}
+
+void rules_cleanup(rules_t *rules) {
+  for (size_t i = 0; i < rules->count; ++i) {
+    rule_match_t *match = &rules->items[i].match;
+    rule_action_t *action = &rules->items[i].action;
+
+    p_delete(&match->app_id);
+    p_delete(&match->role);
+    p_delete(&match->class_name);
+    p_delete(&match->instance_name);
+
+    p_clear(action, 1);
+    action->workspace = ZDWM_WORKSPACE_ID_INVALID;
+  }
+
+  p_delete(&rules->items);
+  rules->capacity = 0;
+  rules->count = 0;
+}

src/core/rules.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <stddef.h>
+
+#include "core/types.h"
+
+typedef struct rule_item_t {
+  rule_match_t match;
+  rule_action_t action;
+} rule_item_t;
+
+typedef struct rules_t {
+  rule_item_t *items;
+  size_t count;
+  size_t capacity;
+} rules_t;
+
+bool rules_move(rules_t *dest, rules_t *src);
+void rules_cleanup(rules_t *rules);

src/core/runtime.c

@@ -5,6 +5,8 @@
 #include "base/memory.h"
 #include "core/backend.h"
 #include "core/event.h"
+#include "core/layout.h"
+#include "core/rules.h"
 #include "core/state.h"
 #include "core/wm_desc.h"
 
@@ -42,11 +44,10 @@ bool runtime_init(runtime_t *runtime, runtime_init_desc_t *desc) {
 
   p_clear(runtime, 1);
   runtime->backend = desc->backend;
-  runtime->layouts = desc->layouts;
+  layout_registry_move(&desc->layouts, &runtime->layouts);
+  rules_move(&desc->rules, &runtime->rules);
   runtime->config_module_handle = desc->config_module_handle;
-
   desc->backend = nullptr;
-  p_clear(&desc->layouts, 1);
   desc->config_module_handle = nullptr;
 
   state_init(&runtime->state, desc->outputs, desc->output_count,
@@ -81,10 +82,8 @@ void runtime_init_desc_cleanup(runtime_init_desc_t *desc) {
 
 void runtime_shutdown(runtime_t *runtime) {
   runtime->running = false;
-  if (runtime->layouts.slots || runtime->layouts.slot_count ||
-      runtime->layouts.slot_capacity) {
-    layout_registry_cleanup(&runtime->layouts);
-  }
+  layout_registry_cleanup(&runtime->layouts);
+  rules_cleanup(&runtime->rules);
   state_cleanup(&runtime->state);
   backend_destroy(runtime->backend);
   runtime->backend = nullptr;

src/core/runtime.h

@@ -4,6 +4,7 @@
 
 #include "core/backend.h"
 #include "core/layout.h"
+#include "core/rules.h"
 #include "core/state.h"
 
 typedef struct runtime_init_desc_t {
@@ -12,6 +13,7 @@ typedef struct runtime_init_desc_t {
   size_t output_count;
 
   layout_registry_t layouts;
+  rules_t rules;
   workspace_desc_t *workspaces;
   size_t workspace_count;
   void *config_module_handle;
@@ -23,6 +25,7 @@ typedef struct runtime_t {
 
   state_t state;
   layout_registry_t layouts;
+  rules_t rules;
   backend_t *backend;
   void *config_module_handle;
 } runtime_t;

src/core/types.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <stdint.h>
+#include <zdwm/rules.h>
 #include <zdwm/types.h>
 
 /* clang-format off */
@@ -11,6 +12,9 @@ typedef uint32_t                output_id_t;
 
 typedef zdwm_rect_t             rect_t;
 typedef zdwm_output_info_t      output_info_t;
+
+typedef zdwm_rule_match_t       rule_match_t;
+typedef zdwm_rule_action_t      rule_action_t;
 /* clang-format on */
 
 #define ZDWM_OUTPUT_ID_INVALID ((output_id_t)UINT32_MAX)