build: add -ldl linker flag, recursive source discovery, and API test targets to Makefile

include/core/wm_client.h

@@ -0,0 +1,523 @@
+/*
+ * DWN - Desktop Window Manager
+ * Abstract Client Interface
+ */
+
+#ifndef WM_CLIENT_H
+#define WM_CLIENT_H
+
+#include "core/wm_types.h"
+#include "core/wm_string.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+typedef struct Client Client;  /* Legacy client structure */
+
+/*==============================================================================
+ * Abstract Client Type
+ *============================================================================*/
+
+typedef struct AbstractClient AbstractClient;
+
+/*==============================================================================
+ * Client State Flags
+ *============================================================================*/
+
+typedef enum {
+    WM_CLIENT_STATE_NORMAL     = 0,
+    WM_CLIENT_STATE_FLOATING   = (1 << 0),
+    WM_CLIENT_STATE_FULLSCREEN = (1 << 1),
+    WM_CLIENT_STATE_MAXIMIZED  = (1 << 2),
+    WM_CLIENT_STATE_MINIMIZED  = (1 << 3),
+    WM_CLIENT_STATE_URGENT     = (1 << 4),
+    WM_CLIENT_STATE_STICKY     = (1 << 5),
+    WM_CLIENT_STATE_HIDDEN     = (1 << 6),
+    WM_CLIENT_STATE_FOCUS      = (1 << 7),
+    WM_CLIENT_STATE_MAPPED     = (1 << 8),
+    WM_CLIENT_STATE_MANAGED    = (1 << 9),
+    WM_CLIENT_STATE_DESTROYING = (1 << 10)
+} WmClientState;
+
+/*==============================================================================
+ * Client Window Type
+ *============================================================================*/
+
+typedef enum {
+    WM_CLIENT_TYPE_UNKNOWN = 0,
+    WM_CLIENT_TYPE_NORMAL,
+    WM_CLIENT_TYPE_DIALOG,
+    WM_CLIENT_TYPE_DOCK,
+    WM_CLIENT_TYPE_DESKTOP,
+    WM_CLIENT_TYPE_TOOLBAR,
+    WM_CLIENT_TYPE_MENU,
+    WM_CLIENT_TYPE_UTILITY,
+    WM_CLIENT_TYPE_SPLASH,
+    WM_CLIENT_TYPE_NOTIFICATION
+} WmClientType;
+
+/*==============================================================================
+ * Client Lifecycle
+ *============================================================================*/
+
+/**
+ * Create an abstract client from a native window handle.
+ * This takes ownership of the native window.
+ */
+AbstractClient* wm_client_create(WmWindowHandle window, WmClientType type);
+
+/**
+ * Destroy a client and release all associated resources.
+ */
+void wm_client_destroy(AbstractClient *client);
+
+/**
+ * Check if a client is valid (not NULL and not being destroyed).
+ */
+bool wm_client_is_valid(const AbstractClient *client);
+
+/*==============================================================================
+ * Native Access (for compatibility during migration)
+ *============================================================================*/
+
+/**
+ * Get the native window handle.
+ * Note: This should be avoided in backend-agnostic code.
+ */
+WmWindowHandle wm_client_get_window(const AbstractClient *client);
+
+/**
+ * Get the native frame window handle (if reparented).
+ */
+WmWindowHandle wm_client_get_frame(const AbstractClient *client);
+
+/**
+ * Get the legacy Client structure.
+ * Note: This is for gradual migration only.
+ */
+Client* wm_client_get_legacy(const AbstractClient *client);
+
+/**
+ * Create an abstract client wrapper around an existing legacy Client.
+ * Note: The abstract client does NOT own the legacy client.
+ */
+AbstractClient* wm_client_from_legacy(Client *client);
+
+/*==============================================================================
+ * Client Identification
+ *============================================================================*/
+
+/**
+ * Get the unique client ID.
+ */
+WmClientId wm_client_get_id(const AbstractClient *client);
+
+/**
+ * Get the client window type.
+ */
+WmClientType wm_client_get_type(const AbstractClient *client);
+
+/**
+ * Set the client window type.
+ */
+void wm_client_set_type(AbstractClient *client, WmClientType type);
+
+/*==============================================================================
+ * Client State
+ *============================================================================*/
+
+/**
+ * Get the current state flags.
+ */
+WmClientState wm_client_get_state(const AbstractClient *client);
+
+/**
+ * Set state flags.
+ */
+void wm_client_set_state(AbstractClient *client, WmClientState state);
+
+/**
+ * Add state flags.
+ */
+void wm_client_add_state(AbstractClient *client, WmClientState state);
+
+/**
+ * Remove state flags.
+ */
+void wm_client_remove_state(AbstractClient *client, WmClientState state);
+
+/**
+ * Toggle state flags.
+ */
+void wm_client_toggle_state(AbstractClient *client, WmClientState state);
+
+/**
+ * Check if a specific state is set.
+ */
+bool wm_client_has_state(const AbstractClient *client, WmClientState state);
+
+/* Convenience state checks */
+static inline bool wm_client_is_floating(const AbstractClient *c) {
+    return c && wm_client_has_state(c, WM_CLIENT_STATE_FLOATING);
+}
+static inline bool wm_client_is_fullscreen(const AbstractClient *c) {
+    return c && wm_client_has_state(c, WM_CLIENT_STATE_FULLSCREEN);
+}
+static inline bool wm_client_is_maximized(const AbstractClient *c) {
+    return c && wm_client_has_state(c, WM_CLIENT_STATE_MAXIMIZED);
+}
+static inline bool wm_client_is_minimized(const AbstractClient *c) {
+    return c && wm_client_has_state(c, WM_CLIENT_STATE_MINIMIZED);
+}
+static inline bool wm_client_is_urgent(const AbstractClient *c) {
+    return c && wm_client_has_state(c, WM_CLIENT_STATE_URGENT);
+}
+static inline bool wm_client_is_sticky(const AbstractClient *c) {
+    return c && wm_client_has_state(c, WM_CLIENT_STATE_STICKY);
+}
+static inline bool wm_client_is_focused(const AbstractClient *c) {
+    return c && wm_client_has_state(c, WM_CLIENT_STATE_FOCUS);
+}
+static inline bool wm_client_is_mapped(const AbstractClient *c) {
+    return c && wm_client_has_state(c, WM_CLIENT_STATE_MAPPED);
+}
+
+/*==============================================================================
+ * Client Geometry
+ *============================================================================*/
+
+/**
+ * Get the client geometry (position and size).
+ */
+WmRect wm_client_get_geometry(const AbstractClient *client);
+
+/**
+ * Set the client geometry.
+ */
+void wm_client_set_geometry(AbstractClient *client, const WmRect *geometry);
+
+/**
+ * Get the client position.
+ */
+WmPoint wm_client_get_position(const AbstractClient *client);
+
+/**
+ * Set the client position.
+ */
+void wm_client_set_position(AbstractClient *client, int x, int y);
+
+/**
+ * Get the client size.
+ */
+WmSize wm_client_get_size(const AbstractClient *client);
+
+/**
+ * Set the client size.
+ */
+void wm_client_set_size(AbstractClient *client, int width, int height);
+
+/**
+ * Get the border width.
+ */
+int wm_client_get_border_width(const AbstractClient *client);
+
+/**
+ * Set the border width.
+ */
+void wm_client_set_border_width(AbstractClient *client, int width);
+
+/**
+ * Store previous geometry (for restore after maximize/fullscreen).
+ */
+void wm_client_save_geometry(AbstractClient *client);
+
+/**
+ * Restore previous geometry.
+ */
+void wm_client_restore_geometry(AbstractClient *client);
+
+/*==============================================================================
+ * Client Workspace
+ *============================================================================*/
+
+/**
+ * Get the client's workspace ID.
+ */
+WmWorkspaceId wm_client_get_workspace(const AbstractClient *client);
+
+/**
+ * Set the client's workspace ID.
+ */
+void wm_client_set_workspace(AbstractClient *client, WmWorkspaceId workspace);
+
+/**
+ * Check if the client is on a specific workspace.
+ */
+bool wm_client_is_on_workspace(const AbstractClient *client, WmWorkspaceId workspace);
+
+/**
+ * Check if the client is visible on the current workspace.
+ */
+bool wm_client_is_visible_on_current(const AbstractClient *client);
+
+/*==============================================================================
+ * Client Properties
+ *============================================================================*/
+
+/**
+ * Get the client title.
+ * Returns a reference to the internal string (do not free).
+ */
+const char* wm_client_get_title(const AbstractClient *client);
+
+/**
+ * Set the client title.
+ */
+void wm_client_set_title(AbstractClient *client, const char *title);
+
+/**
+ * Get the client class (application class).
+ */
+const char* wm_client_get_class(const AbstractClient *client);
+
+/**
+ * Set the client class.
+ */
+void wm_client_set_class(AbstractClient *client, const char *class_name);
+
+/**
+ * Get the client instance name.
+ */
+const char* wm_client_get_instance(const AbstractClient *client);
+
+/**
+ * Set the client instance name.
+ */
+void wm_client_set_instance(AbstractClient *client, const char *instance);
+
+/**
+ * Get the client's taskbar color.
+ */
+WmColor wm_client_get_color(const AbstractClient *client);
+
+/**
+ * Set the client's taskbar color.
+ */
+void wm_client_set_color(AbstractClient *client, WmColor color);
+
+/*==============================================================================
+ * Client Actions
+ *============================================================================*/
+
+/**
+ * Focus the client.
+ */
+void wm_client_focus(AbstractClient *client);
+
+/**
+ * Unfocus the client.
+ */
+void wm_client_unfocus(AbstractClient *client);
+
+/**
+ * Raise the client to the top of the stack.
+ */
+void wm_client_raise(AbstractClient *client);
+
+/**
+ * Lower the client to the bottom of the stack.
+ */
+void wm_client_lower(AbstractClient *client);
+
+/**
+ * Show/map the client window.
+ */
+void wm_client_show(AbstractClient *client);
+
+/**
+ * Hide/unmap the client window.
+ */
+void wm_client_hide(AbstractClient *client);
+
+/**
+ * Minimize the client.
+ */
+void wm_client_minimize(AbstractClient *client);
+
+/**
+ * Restore the client from minimized state.
+ */
+void wm_client_restore(AbstractClient *client);
+
+/**
+ * Close the client (politely request close).
+ */
+void wm_client_close(AbstractClient *client);
+
+/**
+ * Kill the client (forcefully terminate).
+ */
+void wm_client_kill(AbstractClient *client);
+
+/*==============================================================================
+ * Client Management
+ *============================================================================*/
+
+/**
+ * Reparent the client into a frame window.
+ */
+void wm_client_reparent(AbstractClient *client, WmWindowHandle frame);
+
+/**
+ * Unreparent the client from its frame.
+ */
+void wm_client_unreparent(AbstractClient *client);
+
+/**
+ * Configure the client (apply size hints, constraints).
+ */
+void wm_client_configure(AbstractClient *client);
+
+/**
+ * Apply size hints to constrain width/height.
+ */
+void wm_client_apply_size_hints(AbstractClient *client, int *width, int *height);
+
+/**
+ * Move and resize a client.
+ */
+void wm_client_move_resize(AbstractClient *client, int x, int y, int width, int height);
+
+/*==============================================================================
+ * Client List Management
+ *============================================================================*/
+
+/**
+ * Get the next client in the global list.
+ */
+AbstractClient* wm_client_get_next(const AbstractClient *client);
+
+/**
+ * Get the previous client in the global list.
+ */
+AbstractClient* wm_client_get_prev(const AbstractClient *client);
+
+/**
+ * Get the first client in the global list.
+ */
+AbstractClient* wm_client_get_first(void);
+
+/**
+ * Get the last client in the global list.
+ */
+AbstractClient* wm_client_get_last(void);
+
+/**
+ * Get the next client in MRU (Most Recently Used) order.
+ */
+AbstractClient* wm_client_get_next_mru(const AbstractClient *client);
+
+/**
+ * Get the previous client in MRU order.
+ */
+AbstractClient* wm_client_get_prev_mru(const AbstractClient *client);
+
+/*==============================================================================
+ * Client Lookup
+ *============================================================================*/
+
+/**
+ * Find a client by its window handle.
+ */
+AbstractClient* wm_client_find_by_window(WmWindowHandle window);
+
+/**
+ * Find a client by its frame handle.
+ */
+AbstractClient* wm_client_find_by_frame(WmWindowHandle frame);
+
+/**
+ * Find a client by its ID.
+ */
+AbstractClient* wm_client_find_by_id(WmClientId id);
+
+/*==============================================================================
+ * Client Iteration
+ *============================================================================*/
+
+typedef bool (*WmClientForeachFunc)(AbstractClient *client, void *user_data);
+
+/**
+ * Iterate over all clients.
+ */
+void wm_client_foreach(WmClientForeachFunc func, void *user_data);
+
+/**
+ * Iterate over clients on a specific workspace.
+ */
+void wm_client_foreach_on_workspace(WmWorkspaceId workspace, 
+                                     WmClientForeachFunc func, void *user_data);
+
+/**
+ * Count total clients.
+ */
+int wm_client_count(void);
+
+/**
+ * Count clients on a specific workspace.
+ */
+int wm_client_count_on_workspace(WmWorkspaceId workspace);
+
+/*==============================================================================
+ * Client Manager
+ *============================================================================*/
+
+typedef struct WmClientManager WmClientManager;
+
+/**
+ * Get the global client manager.
+ */
+WmClientManager* wm_client_manager_get(void);
+
+/**
+ * Initialize the client manager.
+ */
+bool wm_client_manager_init(void);
+
+/**
+ * Shutdown the client manager.
+ */
+void wm_client_manager_shutdown(void);
+
+/**
+ * Register a client with the manager.
+ */
+void wm_client_manager_add(WmClientManager *mgr, AbstractClient *client);
+
+/**
+ * Unregister a client from the manager.
+ */
+void wm_client_manager_remove(WmClientManager *mgr, AbstractClient *client);
+
+/**
+ * Move a client to the front of the MRU list.
+ */
+void wm_client_manager_touch(WmClientManager *mgr, AbstractClient *client);
+
+/**
+ * Get the focused client.
+ */
+AbstractClient* wm_client_manager_get_focused(const WmClientManager *mgr);
+
+/**
+ * Set the focused client.
+ */
+void wm_client_manager_set_focused(WmClientManager *mgr, AbstractClient *client);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WM_CLIENT_H */

include/core/wm_container.h

@@ -0,0 +1,220 @@
+/*
+ * DWN - Desktop Window Manager
+ * Generic Container Interface
+ */
+
+#ifndef WM_CONTAINER_H
+#define WM_CONTAINER_H
+
+#include "wm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*==============================================================================
+ * Container Lifecycle
+ *============================================================================*/
+
+WmContainer* wm_container_create(WmContainerType type, WmDestroyFunc destroy_fn);
+void wm_container_destroy(WmContainer *container);
+void wm_container_clear(WmContainer *container);
+
+WmContainer* wm_container_clone(const WmContainer *container, WmCloneFunc clone_fn);
+
+/*==============================================================================
+ * Container Properties
+ *============================================================================*/
+
+WmContainerType wm_container_get_type(const WmContainer *container);
+size_t wm_container_size(const WmContainer *container);
+bool wm_container_is_empty(const WmContainer *container);
+
+/*==============================================================================
+ * List Operations
+ *============================================================================*/
+
+/* These work for LIST and QUEUE */
+void wm_list_append(WmContainer *list, void *data);
+void wm_list_prepend(WmContainer *list, void *data);
+void wm_list_insert(WmContainer *list, size_t index, void *data);
+
+bool wm_list_remove(WmContainer *list, void *data);
+void* wm_list_remove_at(WmContainer *list, size_t index);
+
+void* wm_list_get(const WmContainer *list, size_t index);
+void* wm_list_get_first(const WmContainer *list);
+void* wm_list_get_last(const WmContainer *list);
+
+size_t wm_list_index_of(const WmContainer *list, void *data);
+bool wm_list_contains(const WmContainer *list, void *data);
+
+void* wm_list_find(const WmContainer *list, WmCompareFunc cmp, const void *key);
+void* wm_list_find_custom(const WmContainer *list, 
+                          bool (*predicate)(const void *item, const void *user_data),
+                          const void *user_data);
+
+void wm_list_sort(WmContainer *list, WmCompareFunc cmp);
+void wm_list_reverse(WmContainer *list);
+
+/*==============================================================================
+ * Array Operations
+ *============================================================================*/
+
+void wm_array_append(WmContainer *array, void *data);
+void wm_array_insert(WmContainer *array, size_t index, void *data);
+void wm_array_set(WmContainer *array, size_t index, void *data);
+
+void* wm_array_get(const WmContainer *array, size_t index);
+void* wm_array_remove_at(WmContainer *array, size_t index);
+
+void wm_array_resize(WmContainer *array, size_t new_size);
+void wm_array_reserve(WmContainer *array, size_t capacity);
+size_t wm_array_capacity(const WmContainer *array);
+
+void wm_array_compact(WmContainer *array);
+void wm_array_sort(WmContainer *array, WmCompareFunc cmp);
+
+/*==============================================================================
+ * HashMap Operations
+ *============================================================================*/
+
+/* Key types supported */
+typedef enum {
+    WM_HASH_KEY_STRING,
+    WM_HASH_KEY_INT,
+    WM_HASH_KEY_POINTER
+} WmHashKeyType;
+
+WmContainer* wm_hashmap_create(WmHashKeyType key_type, WmDestroyFunc destroy_fn);
+
+void wm_hashmap_insert(WmContainer *map, const void *key, void *value);
+void* wm_hashmap_get(const WmContainer *map, const void *key);
+bool wm_hashmap_contains(const WmContainer *map, const void *key);
+bool wm_hashmap_remove(WmContainer *map, const void *key);
+
+void* wm_hashmap_lookup(const WmContainer *map, WmCompareFunc cmp, const void *key);
+
+WmContainer* wm_hashmap_get_keys(const WmContainer *map);
+WmContainer* wm_hashmap_get_values(const WmContainer *map);
+
+void wm_hashmap_rehash(WmContainer *map, size_t new_capacity);
+float wm_hashmap_load_factor(const WmContainer *map);
+
+/* Convenience functions for string keys */
+void wm_hashmap_insert_string(WmContainer *map, const char *key, void *value);
+void* wm_hashmap_get_string(const WmContainer *map, const char *key);
+bool wm_hashmap_contains_string(const WmContainer *map, const char *key);
+bool wm_hashmap_remove_string(WmContainer *map, const char *key);
+
+/* Convenience functions for int keys */
+void wm_hashmap_insert_int(WmContainer *map, int key, void *value);
+void* wm_hashmap_get_int(const WmContainer *map, int key);
+bool wm_hashmap_contains_int(const WmContainer *map, int key);
+bool wm_hashmap_remove_int(WmContainer *map, int key);
+
+/*==============================================================================
+ * Stack Operations
+ *============================================================================*/
+
+void wm_stack_push(WmContainer *stack, void *data);
+void* wm_stack_pop(WmContainer *stack);
+void* wm_stack_peek(const WmContainer *stack);
+
+/*==============================================================================
+ * Queue Operations
+ *============================================================================*/
+
+void wm_queue_enqueue(WmContainer *queue, void *data);
+void* wm_queue_dequeue(WmContainer *queue);
+void* wm_queue_peek(const WmContainer *queue);
+void* wm_queue_peek_tail(const WmContainer *queue);
+
+/*==============================================================================
+ * Tree Operations (if type is TREE)
+ *============================================================================*/
+
+typedef struct WmTreeNode WmTreeNode;
+
+WmTreeNode* wm_tree_get_root(const WmContainer *tree);
+WmTreeNode* wm_tree_node_get_left(const WmTreeNode *node);
+WmTreeNode* wm_tree_node_get_right(const WmTreeNode *node);
+WmTreeNode* wm_tree_node_get_parent(const WmTreeNode *node);
+void* wm_tree_node_get_data(const WmTreeNode *node);
+
+/*==============================================================================
+ * Iteration
+ *============================================================================*/
+
+WmIterator* wm_container_iterator(const WmContainer *container);
+WmIterator* wm_container_iterator_reverse(const WmContainer *container);
+
+void wm_iterator_destroy(WmIterator *it);
+bool wm_iterator_has_next(const WmIterator *it);
+void* wm_iterator_next(WmIterator *it);
+const void* wm_iterator_peek(const WmIterator *it);
+
+/* HashMap iteration - returns key-value pairs */
+typedef struct {
+    const void *key;
+    void *value;
+} WmHashEntry;
+
+WmIterator* wm_hashmap_iterator(const WmContainer *map);
+WmHashEntry* wm_hashmap_iterator_next(WmIterator *it);
+
+/*==============================================================================
+ * Functional Operations
+ *============================================================================*/
+
+typedef void (*WmForeachFunc)(void *item, void *user_data);
+typedef void* (*WmMapFunc)(const void *item, void *user_data);
+typedef bool (*WmFilterFunc)(const void *item, void *user_data);
+typedef void* (*WmReduceFunc)(void *accumulator, const void *item, void *user_data);
+
+void wm_container_foreach(const WmContainer *container, WmForeachFunc func, void *user_data);
+
+WmContainer* wm_container_map(const WmContainer *container, WmContainerType new_type,
+                               WmMapFunc func, WmDestroyFunc destroy_fn, void *user_data);
+
+WmContainer* wm_container_filter(const WmContainer *container, 
+                                  WmFilterFunc predicate, void *user_data);
+
+void* wm_container_reduce(const WmContainer *container, 
+                          WmReduceFunc func, void *initial, void *user_data);
+
+bool wm_container_all_match(const WmContainer *container, 
+                            WmFilterFunc predicate, void *user_data);
+
+bool wm_container_any_match(const WmContainer *container,
+                            WmFilterFunc predicate, void *user_data);
+
+/*==============================================================================
+ * Convenience Constructors
+ *============================================================================*/
+
+static inline WmContainer* wm_list_create(WmDestroyFunc destroy_fn) {
+    return wm_container_create(WM_CONTAINER_LIST, destroy_fn);
+}
+
+static inline WmContainer* wm_array_create(WmDestroyFunc destroy_fn) {
+    return wm_container_create(WM_CONTAINER_ARRAY, destroy_fn);
+}
+
+static inline WmContainer* wm_hashmap_create_string(WmDestroyFunc destroy_fn) {
+    return wm_hashmap_create(WM_HASH_KEY_STRING, destroy_fn);
+}
+
+static inline WmContainer* wm_queue_create(WmDestroyFunc destroy_fn) {
+    return wm_container_create(WM_CONTAINER_QUEUE, destroy_fn);
+}
+
+static inline WmContainer* wm_stack_create(WmDestroyFunc destroy_fn) {
+    return wm_container_create(WM_CONTAINER_STACK, destroy_fn);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WM_CONTAINER_H */

include/core/wm_event.h

@@ -0,0 +1,265 @@
+/*
+ * DWN - Desktop Window Manager
+ * Event Bus System
+ */
+
+#ifndef WM_EVENT_H
+#define WM_EVENT_H
+
+#include "wm_types.h"
+#include "wm_client.h"
+#include "wm_string.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*==============================================================================
+ * Event Data Structures
+ *============================================================================*/
+
+typedef struct {
+    WmEventType type;
+    WmTime timestamp;
+    WmId source_id;
+} WmEventHeader;
+
+/* Window Events */
+typedef struct {
+    WmEventHeader header;
+    AbstractClient *client;
+} WmEventWindowBase;
+
+typedef struct {
+    WmEventHeader header;
+    AbstractClient *client;
+} WmEventWindowCreated;
+
+typedef struct {
+    WmEventHeader header;
+    AbstractClient *client;
+    WmString *old_title;
+    WmString *new_title;
+} WmEventWindowTitleChanged;
+
+typedef struct {
+    WmEventHeader header;
+    AbstractClient *client;
+    WmRect old_geometry;
+    WmRect new_geometry;
+} WmEventWindowMoved;
+
+typedef struct {
+    WmEventHeader header;
+    AbstractClient *client;
+    WmRect old_geometry;
+    WmRect new_geometry;
+} WmEventWindowResized;
+
+typedef struct {
+    WmEventHeader header;
+    AbstractClient *client;
+    WmClientFlags old_flags;
+    WmClientFlags new_flags;
+} WmEventWindowStateChanged;
+
+/* Workspace Events */
+typedef struct {
+    WmEventHeader header;
+    WmWorkspaceId workspace;
+} WmEventWorkspaceBase;
+
+typedef struct {
+    WmEventHeader header;
+    WmWorkspaceId old_workspace;
+    WmWorkspaceId new_workspace;
+} WmEventWorkspaceSwitched;
+
+typedef struct {
+    WmEventHeader header;
+    WmWorkspaceId workspace;
+    WmLayoutType old_layout;
+    WmLayoutType new_layout;
+} WmEventWorkspaceLayoutChanged;
+
+typedef struct {
+    WmEventHeader header;
+    WmWorkspaceId workspace;
+    AbstractClient *client;
+} WmEventClientWorkspaceChanged;
+
+/* Input Events */
+typedef struct {
+    WmEventHeader header;
+    unsigned int keycode;
+    unsigned int keysym;
+    unsigned int modifiers;
+    const char *key_name;
+} WmEventKey;
+
+typedef struct {
+    WmEventHeader header;
+    unsigned int button;
+    int x;
+    int y;
+    unsigned int modifiers;
+} WmEventButton;
+
+typedef struct {
+    WmEventHeader header;
+    int x;
+    int y;
+    int delta_x;
+    int delta_y;
+    unsigned int modifiers;
+} WmEventMotion;
+
+typedef struct {
+    WmEventHeader header;
+    int delta;
+    int x;
+    int y;
+} WmEventScroll;
+
+/* Monitor Events */
+typedef struct {
+    WmEventHeader header;
+    int monitor_index;
+    WmRect geometry;
+    bool primary;
+} WmEventMonitorAdded;
+
+typedef struct {
+    WmEventHeader header;
+    int monitor_index;
+} WmEventMonitorRemoved;
+
+/* Configuration Events */
+typedef struct {
+    WmEventHeader header;
+    WmString *config_path;
+    bool success;
+    WmString *error_message;
+} WmEventConfigReloaded;
+
+/* Command Events */
+typedef struct {
+    WmEventHeader header;
+    WmCommandType command;
+    bool success;
+    WmString *error_message;
+} WmEventCommandExecuted;
+
+/* Custom Event */
+typedef struct {
+    WmEventHeader header;
+    WmString *event_name;
+    void *custom_data;
+    WmDestroyFunc destroy_func;
+} WmEventCustom;
+
+/*==============================================================================
+ * Event Bus Lifecycle
+ *============================================================================*/
+
+WmEventBus* wm_event_bus_create(void);
+void wm_event_bus_destroy(WmEventBus *bus);
+
+WmEventBus* wm_event_bus_get_default(void);
+void wm_event_bus_set_default(WmEventBus *bus);
+
+/*==============================================================================
+ * Event Subscription
+ *============================================================================*/
+
+WmEventSubscription* wm_event_subscribe(WmEventBus *bus, 
+                                        WmEventType type,
+                                        WmEventHandler handler, 
+                                        void *user_data);
+
+WmEventSubscription* wm_event_subscribe_pattern(WmEventBus *bus,
+                                                WmEventType type_min,
+                                                WmEventType type_max,
+                                                WmEventHandler handler,
+                                                void *user_data);
+
+WmEventSubscription* wm_event_subscribe_all(WmEventBus *bus,
+                                            WmEventHandler handler,
+                                            void *user_data);
+
+void wm_event_unsubscribe(WmEventBus *bus, WmEventSubscription *subscription);
+void wm_event_unsubscribe_all(WmEventBus *bus, void *user_data);
+
+/*==============================================================================
+ * Event Emission
+ *============================================================================*/
+
+void wm_event_emit(WmEventBus *bus, WmEventType type, const void *event_data);
+void wm_event_emit_async(WmEventBus *bus, WmEventType type, const void *event_data);
+
+/* Convenience emitters */
+void wm_event_emit_window_created(WmEventBus *bus, AbstractClient *client);
+void wm_event_emit_window_destroyed(WmEventBus *bus, AbstractClient *client);
+void wm_event_emit_window_focused(WmEventBus *bus, AbstractClient *client, AbstractClient *prev_focus);
+void wm_event_emit_window_moved(WmEventBus *bus, AbstractClient *client, const WmRect *old_geom);
+void wm_event_emit_window_resized(WmEventBus *bus, AbstractClient *client, const WmRect *old_geom);
+void wm_event_emit_window_state_changed(WmEventBus *bus, AbstractClient *client, 
+                                        WmClientFlags old_flags, WmClientFlags new_flags);
+
+void wm_event_emit_workspace_switched(WmEventBus *bus, WmWorkspaceId old_ws, WmWorkspaceId new_ws);
+void wm_event_emit_workspace_layout_changed(WmEventBus *bus, WmWorkspaceId ws, 
+                                            WmLayoutType old_layout, WmLayoutType new_layout);
+
+/*==============================================================================
+ * Event Processing
+ *============================================================================*/
+
+void wm_event_process(WmEventBus *bus);
+void wm_event_process_all(WmEventBus *bus);
+bool wm_event_process_one(WmEventBus *bus);
+
+void wm_event_dispatch_pending(WmEventBus *bus);
+int wm_event_get_pending_count(const WmEventBus *bus);
+
+/*==============================================================================
+ * Event Data Helpers
+ *============================================================================*/
+
+WmEventHeader* wm_event_get_header(void *event_data);
+WmTime wm_event_get_timestamp(const void *event_data);
+const char* wm_event_type_to_string(WmEventType type);
+WmEventType wm_event_type_from_string(const char *str);
+
+/*==============================================================================
+ * Event Blocking/Filtering
+ *============================================================================*/
+
+void wm_event_begin_block(WmEventBus *bus, WmEventType type);
+void wm_event_end_block(WmEventBus *bus, WmEventType type);
+bool wm_event_is_blocked(const WmEventBus *bus, WmEventType type);
+
+void wm_event_suppress(WmEventBus *bus, WmEventType type);
+void wm_event_unsuppress(WmEventBus *bus, WmEventType type);
+bool wm_event_is_suppressed(const WmEventBus *bus, WmEventType type);
+
+/*==============================================================================
+ * Custom Events
+ *============================================================================*/
+
+void wm_event_emit_custom(WmEventBus *bus, const char *event_name, void *data, WmDestroyFunc destroy_fn);
+WmEventSubscription* wm_event_subscribe_custom(WmEventBus *bus, const char *event_name,
+                                               WmEventHandler handler, void *user_data);
+
+/*==============================================================================
+ * Event Statistics
+ *============================================================================*/
+
+uint64_t wm_event_get_emit_count(const WmEventBus *bus, WmEventType type);
+uint64_t wm_event_get_total_emit_count(const WmEventBus *bus);
+void wm_event_reset_statistics(WmEventBus *bus);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WM_EVENT_H */

include/core/wm_hashmap.h

@@ -0,0 +1,107 @@
+/*
+ * DWN - Desktop Window Manager
+ * Abstract Hash Map Container
+ */
+
+#ifndef WM_HASHMAP_H
+#define WM_HASHMAP_H
+
+#include "core/wm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*==============================================================================
+ * Opaque Types
+ *============================================================================*/
+
+typedef struct WmHashMap WmHashMap;
+
+/*==============================================================================
+ * Function Types
+ *============================================================================*/
+
+typedef uint32_t (*WmHashFunc)(const void *key);
+typedef bool (*WmKeyEqualFunc)(const void *a, const void *b);
+typedef void (*WmHashForeachFunc)(void *key, void *value, void *user_data);
+
+/*==============================================================================
+ * Hash Functions
+ *============================================================================*/
+
+static inline uint32_t wm_hash_ptr(const void *ptr) {
+    uintptr_t p = (uintptr_t)ptr;
+    return (uint32_t)(p ^ (p >> 32));
+}
+
+static inline uint32_t wm_hash_int(int key) {
+    return (uint32_t)key;
+}
+
+/*==============================================================================
+ * Lifecycle
+ *============================================================================*/
+
+WmHashMap* wm_hashmap_new(void);
+WmHashMap* wm_hashmap_new_full(WmHashFunc hash_func, WmKeyEqualFunc key_equal,
+                                WmFreeFunc key_free, WmFreeFunc value_free);
+WmHashMap* wm_hashmap_new_string_key(void);
+void wm_hashmap_destroy(WmHashMap *map);
+WmHashMap* wm_hashmap_clone(const WmHashMap *map);
+
+/*==============================================================================
+ * Capacity
+ *============================================================================*/
+
+size_t wm_hashmap_size(const WmHashMap *map);
+bool wm_hashmap_is_empty(const WmHashMap *map);
+void wm_hashmap_clear(WmHashMap *map);
+
+/*==============================================================================
+ * Element Access
+ *============================================================================*/
+
+void* wm_hashmap_get(const WmHashMap *map, const void *key);
+void* wm_hashmap_get_or_default(const WmHashMap *map, const void *key, void *default_val);
+bool wm_hashmap_contains(const WmHashMap *map, const void *key);
+
+/*==============================================================================
+ * Modifiers
+ *============================================================================*/
+
+bool wm_hashmap_insert(WmHashMap *map, void *key, void *value);
+bool wm_hashmap_insert_no_replace(WmHashMap *map, void *key, void *value);
+void* wm_hashmap_set(WmHashMap *map, void *key, void *value);
+void* wm_hashmap_remove(WmHashMap *map, const void *key);
+bool wm_hashmap_steal(WmHashMap *map, const void *key);
+
+/*==============================================================================
+ * Iteration
+ *============================================================================*/
+
+typedef struct {
+    void *map;          /* Opaque pointer to hashmap */
+    size_t bucket;
+    void *entry;        /* Opaque pointer to current entry */
+    void *next_entry;   /* Opaque pointer to next entry */
+} WmHashMapIter;
+
+void wm_hashmap_iter_init(WmHashMapIter *iter, WmHashMap *map);
+bool wm_hashmap_iter_next(WmHashMapIter *iter, void **key, void **value);
+void wm_hashmap_foreach(const WmHashMap *map, WmHashForeachFunc func, void *user_data);
+
+/*==============================================================================
+ * String Helpers
+ *============================================================================*/
+
+bool wm_hashmap_insert_string(WmHashMap *map, const char *key, void *value);
+void* wm_hashmap_get_string(const WmHashMap *map, const char *key);
+bool wm_hashmap_contains_string(const WmHashMap *map, const char *key);
+void* wm_hashmap_remove_string(WmHashMap *map, const char *key);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WM_HASHMAP_H */

include/core/wm_list.h

@@ -0,0 +1,123 @@
+/*
+ * DWN - Desktop Window Manager
+ * Abstract List Container
+ */
+
+#ifndef WM_LIST_H
+#define WM_LIST_H
+
+#include "core/wm_types.h"
+
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*==============================================================================
+ * Opaque Types
+ *============================================================================*/
+
+typedef struct WmList WmList;
+
+/*==============================================================================
+ * Function Types
+ *============================================================================*/
+
+typedef void (*WmFreeFunc)(void *item);
+typedef int (*WmCompareFunc)(const void *a, const void *b);
+typedef bool (*WmForeachFunc)(void *item, size_t index, void *user_data);
+typedef void* (*WmCloneFunc)(const void *item);
+
+/*==============================================================================
+ * Lifecycle
+ *============================================================================*/
+
+WmList* wm_list_new(void);
+WmList* wm_list_new_sized(size_t initial_capacity);
+void wm_list_destroy(WmList *list);
+void wm_list_destroy_no_free(WmList *list);
+WmList* wm_list_clone(const WmList *list);
+void wm_list_set_free_func(WmList *list, WmFreeFunc func);
+
+/*==============================================================================
+ * Capacity
+ *============================================================================*/
+
+size_t wm_list_size(const WmList *list);
+size_t wm_list_capacity(const WmList *list);
+bool wm_list_is_empty(const WmList *list);
+void wm_list_reserve(WmList *list, size_t capacity);
+void wm_list_compact(WmList *list);
+void wm_list_clear(WmList *list);
+
+/*==============================================================================
+ * Modifiers
+ *============================================================================*/
+
+void wm_list_append(WmList *list, void *item);
+void wm_list_prepend(WmList *list, void *item);
+void wm_list_insert(WmList *list, size_t index, void *item);
+void wm_list_insert_sorted(WmList *list, void *item, WmCompareFunc compare);
+void wm_list_remove(WmList *list, void *item);
+void wm_list_remove_at(WmList *list, size_t index);
+void* wm_list_take_at(WmList *list, size_t index);
+bool wm_list_remove_one(WmList *list, void *item);
+bool wm_list_remove_all(WmList *list, void *item);
+void* wm_list_pop_back(WmList *list);
+void* wm_list_pop_front(WmList *list);
+
+/*==============================================================================
+ * Accessors
+ *============================================================================*/
+
+void* wm_list_get(const WmList *list, size_t index);
+void* wm_list_first(const WmList *list);
+void* wm_list_last(const WmList *list);
+void* wm_list_front(const WmList *list);
+void* wm_list_back(const WmList *list);
+void wm_list_set(WmList *list, size_t index, void *item);
+
+/*==============================================================================
+ * Iteration
+ *============================================================================*/
+
+void wm_list_foreach(const WmList *list, WmForeachFunc func, void *user_data);
+void wm_list_foreach_reverse(const WmList *list, WmForeachFunc func, void *user_data);
+
+/*==============================================================================
+ * Search
+ *============================================================================*/
+
+ssize_t wm_list_index_of(const WmList *list, void *item);
+bool wm_list_contains(const WmList *list, void *item);
+void* wm_list_find(const WmList *list, WmCompareFunc compare, const void *key);
+ssize_t wm_list_find_index(const WmList *list, WmCompareFunc compare, const void *key);
+
+/*==============================================================================
+ * Sorting
+ *============================================================================*/
+
+void wm_list_sort(WmList *list, WmCompareFunc compare);
+
+/*==============================================================================
+ * Data Operations
+ *============================================================================*/
+
+void** wm_list_data(WmList *list);
+void* wm_list_steal(WmList *list, size_t index);
+WmList* wm_list_slice(const WmList *list, size_t start, size_t end);
+void wm_list_move(WmList *list, size_t from, size_t to);
+void wm_list_swap(WmList *list, size_t i, size_t j);
+
+/*==============================================================================
+ * Comparison
+ *============================================================================*/
+
+bool wm_list_equals(const WmList *list1, const WmList *list2);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WM_LIST_H */

include/core/wm_string.h

@@ -0,0 +1,222 @@
+/*
+ * DWN - Desktop Window Manager
+ * Abstract String Type
+ */
+
+#ifndef WM_STRING_H
+#define WM_STRING_H
+
+#include "wm_types.h"
+
+#include <stdarg.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*==============================================================================
+ * String Lifecycle
+ *============================================================================*/
+
+WmString* wm_string_new(const char *str);
+WmString* wm_string_new_empty(void);
+WmString* wm_string_new_sized(size_t capacity);
+WmString* wm_string_new_printf(const char *fmt, ...);
+WmString* wm_string_new_vprintf(const char *fmt, va_list args);
+WmString* wm_string_new_n(const char *str, size_t n);
+
+void wm_string_destroy(WmString *str);
+WmString* wm_string_clone(const WmString *str);
+
+/*==============================================================================
+ * String Operations
+ *============================================================================*/
+
+void wm_string_append(WmString *str, const char *suffix);
+void wm_string_append_char(WmString *str, char c);
+void wm_string_append_n(WmString *str, const char *suffix, size_t n);
+void wm_string_append_printf(WmString *str, const char *fmt, ...);
+void wm_string_append_vprintf(WmString *str, const char *fmt, va_list args);
+void wm_string_append_string(WmString *str, const WmString *suffix);
+
+void wm_string_prepend(WmString *str, const char *prefix);
+void wm_string_prepend_char(WmString *str, char c);
+
+void wm_string_insert(WmString *str, size_t pos, const char *insert);
+void wm_string_insert_char(WmString *str, size_t pos, char c);
+void wm_string_insert_string(WmString *str, size_t pos, const WmString *insert);
+
+void wm_string_erase(WmString *str, size_t pos, size_t len);
+void wm_string_clear(WmString *str);
+
+/*==============================================================================
+ * String Queries
+ *============================================================================*/
+
+const char* wm_string_cstr(const WmString *str);
+char* wm_string_detach(WmString *str);
+
+size_t wm_string_length(const WmString *str);
+size_t wm_string_capacity(const WmString *str);
+size_t wm_string_bytes(const WmString *str);
+
+bool wm_string_is_empty(const WmString *str);
+bool wm_string_is_null(const WmString *str);
+
+char wm_string_char_at(const WmString *str, size_t pos);
+
+/*==============================================================================
+ * String Comparison
+ *============================================================================*/
+
+bool wm_string_equals(const WmString *str1, const WmString *str2);
+bool wm_string_equals_cstr(const WmString *str, const char *cstr);
+
+int wm_string_compare(const WmString *str1, const WmString *str2);
+int wm_string_compare_cstr(const WmString *str, const char *cstr);
+int wm_string_case_compare(const WmString *str1, const WmString *str2);
+int wm_string_case_compare_cstr(const WmString *str, const char *cstr);
+
+/*==============================================================================
+ * String Searching
+ *============================================================================*/
+
+bool wm_string_contains(const WmString *str, const char *needle);
+bool wm_string_contains_char(const WmString *str, char c);
+
+size_t wm_string_find(const WmString *str, const char *needle, size_t start);
+size_t wm_string_find_char(const WmString *str, char c, size_t start);
+size_t wm_string_find_last(const WmString *str, const char *needle);
+size_t wm_string_find_last_char(const WmString *str, char c);
+
+bool wm_string_starts_with(const WmString *str, const char *prefix);
+bool wm_string_starts_with_char(const WmString *str, char c);
+bool wm_string_ends_with(const WmString *str, const char *suffix);
+bool wm_string_ends_with_char(const WmString *str, char c);
+
+/*==============================================================================
+ * String Modification
+ *============================================================================*/
+
+void wm_string_trim(WmString *str);
+void wm_string_trim_left(WmString *str);
+void wm_string_trim_right(WmString *str);
+
+void wm_string_replace(WmString *str, const char *search, const char *replace);
+void wm_string_replace_char(WmString *str, char search, char replace);
+size_t wm_string_replace_all(WmString *str, const char *search, const char *replace);
+
+void wm_string_to_lower(WmString *str);
+void wm_string_to_upper(WmString *str);
+
+void wm_string_reverse(WmString *str);
+
+/*==============================================================================
+ * String Substrings
+ *============================================================================*/
+
+WmString* wm_string_substring(const WmString *str, size_t start, size_t len);
+WmString* wm_string_left(const WmString *str, size_t n);
+WmString* wm_string_right(const WmString *str, size_t n);
+
+/*==============================================================================
+ * String Splitting and Joining
+ *============================================================================*/
+
+WmContainer* wm_string_split(const WmString *str, const char *delimiter);
+WmContainer* wm_string_split_chars(const WmString *str, const char *delimiters);
+WmContainer* wm_string_split_lines(const WmString *str);
+
+WmString* wm_string_join(const WmContainer *strings, const char *separator);
+WmString* wm_string_join_cstr(const char **strings, size_t count, const char *separator);
+
+/*==============================================================================
+ * String Formatting
+ *============================================================================*/
+
+void wm_string_printf(WmString *str, const char *fmt, ...);
+void wm_string_vprintf(WmString *str, const char *fmt, va_list args);
+
+/*==============================================================================
+ * String Validation
+ *============================================================================*/
+
+bool wm_string_is_valid_utf8(const WmString *str);
+bool wm_string_is_ascii(const WmString *str);
+bool wm_string_is_numeric(const WmString *str);
+bool wm_string_is_integer(const WmString *str);
+bool wm_string_is_float(const WmString *str);
+
+/*==============================================================================
+ * String Conversion
+ *============================================================================*/
+
+int wm_string_to_int(const WmString *str, int default_val);
+long wm_string_to_long(const WmString *str, long default_val);
+float wm_string_to_float(const WmString *str, float default_val);
+double wm_string_to_double(const WmString *str, double default_val);
+bool wm_string_to_bool(const WmString *str, bool default_val);
+
+WmString* wm_string_from_int(int val);
+WmString* wm_string_from_long(long val);
+WmString* wm_string_from_float(float val, int precision);
+WmString* wm_string_from_double(double val, int precision);
+WmString* wm_string_from_bool(bool val);
+
+/*==============================================================================
+ * String Hash
+ *============================================================================*/
+
+uint32_t wm_string_hash(const WmString *str);
+uint32_t wm_string_hash_cstr(const char *str);
+
+/*==============================================================================
+ * String Escaping
+ *============================================================================*/
+
+WmString* wm_string_escape_json(const WmString *str);
+WmString* wm_string_escape_xml(const WmString *str);
+WmString* wm_string_escape_html(const WmString *str);
+WmString* wm_string_escape_shell(const WmString *str);
+WmString* wm_string_escape_regex(const WmString *str);
+
+WmString* wm_string_unescape_json(const WmString *str);
+WmString* wm_string_unescape_xml(const WmString *str);
+WmString* wm_string_unescape_html(const WmString *str);
+
+/*==============================================================================
+ * Static String Helpers
+ *============================================================================*/
+
+static inline bool wm_cstr_is_empty(const char *str) {
+    return str == NULL || str[0] == '\0';
+}
+
+static inline size_t wm_cstr_length(const char *str) {
+    return str == NULL ? 0 : strlen(str);
+}
+
+static inline bool wm_cstr_equals(const char *a, const char *b) {
+    if (a == b) return true;
+    if (a == NULL || b == NULL) return false;
+    return strcmp(a, b) == 0;
+}
+
+static inline bool wm_cstr_case_equals(const char *a, const char *b) {
+    if (a == b) return true;
+    if (a == NULL || b == NULL) return false;
+    return strcasecmp(a, b) == 0;
+}
+
+static inline void wm_cstr_copy(char *dest, const char *src, size_t size) {
+    if (size == 0) return;
+    strncpy(dest, src, size - 1);
+    dest[size - 1] = '\0';
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WM_STRING_H */

include/core/wm_types.h

@@ -0,0 +1,490 @@
+/*
+ * DWN - Desktop Window Manager
+ * Core Abstract Types
+ * Extreme Abstraction Architecture
+ */
+
+#ifndef WM_TYPES_H
+#define WM_TYPES_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*==============================================================================
+ * Version and API Information
+ *============================================================================*/
+
+#define WM_CORE_VERSION_MAJOR 2
+#define WM_CORE_VERSION_MINOR 0
+#define WM_CORE_VERSION_PATCH 0
+
+#define WM_PLUGIN_API_VERSION 1
+
+/*==============================================================================
+ * Opaque Type Declarations
+ *============================================================================*/
+
+typedef struct WmCore WmCore;
+typedef struct WmBackend WmBackend;
+typedef struct WmPlugin WmPlugin;
+typedef struct WmPluginManager WmPluginManager;
+typedef struct WmEventBus WmEventBus;
+typedef struct WmEventSubscription WmEventSubscription;
+typedef struct WmContainer WmContainer;
+typedef struct WmIterator WmIterator;
+typedef struct WmString WmString;
+typedef struct WmRenderer WmRenderer;
+typedef struct WmSurface WmSurface;
+typedef struct WmFont WmFont;
+typedef struct WmImage WmImage;
+typedef struct WmCommand WmCommand;
+typedef struct WmCommandBuilder WmCommandBuilder;
+typedef struct WmConfigSchema WmConfigSchema;
+typedef struct WmConfigInstance WmConfigInstance;
+typedef struct WmLayoutEngine WmLayoutEngine;
+typedef struct WmPanelSystem WmPanelSystem;
+typedef struct WmAnimation WmAnimation;
+typedef struct WmTimer WmTimer;
+typedef struct WmMutex WmMutex;
+typedef struct WmCondition WmCondition;
+typedef struct WmThread WmThread;
+
+/*==============================================================================
+ * Basic Type Definitions
+ *============================================================================*/
+
+typedef uint32_t WmColor;
+typedef uint64_t WmTime;
+typedef uint32_t WmHandle;
+typedef uint32_t WmId;
+typedef WmId WmClientId;
+typedef int WmWorkspaceId;
+typedef void* WmWindowHandle;
+typedef void* WmNativeHandle;
+
+/*==============================================================================
+ * Window Types
+ *============================================================================*/
+
+typedef enum {
+    WM_WINDOW_TYPE_UNKNOWN = 0,
+    WM_WINDOW_TYPE_NORMAL,
+    WM_WINDOW_TYPE_DIALOG,
+    WM_WINDOW_TYPE_DOCK,
+    WM_WINDOW_TYPE_DESKTOP,
+    WM_WINDOW_TYPE_TOOLBAR,
+    WM_WINDOW_TYPE_MENU,
+    WM_WINDOW_TYPE_UTILITY,
+    WM_WINDOW_TYPE_SPLASH,
+    WM_WINDOW_TYPE_NOTIFICATION,
+    WM_WINDOW_TYPE_COMBO,
+    WM_WINDOW_TYPE_DND,
+    WM_WINDOW_TYPE_POPUP_MENU,
+    WM_WINDOW_TYPE_TOOLTIP
+} WmWindowType;
+
+/*==============================================================================
+ * Geometry Types
+ *============================================================================*/
+
+typedef struct {
+    int x;
+    int y;
+} WmPoint;
+
+typedef struct {
+    int width;
+    int height;
+} WmSize;
+
+typedef struct {
+    int x;
+    int y;
+    int width;
+    int height;
+} WmRect;
+
+typedef struct {
+    WmPoint location;
+    WmSize size;
+} WmGeometry;
+
+typedef struct {
+    int top;
+    int bottom;
+    int left;
+    int right;
+} WmInsets;
+
+typedef struct {
+    float x;
+    float y;
+} WmPointF;
+
+typedef struct {
+    float width;
+    float height;
+} WmSizeF;
+
+typedef struct {
+    WmPointF location;
+    WmSizeF size;
+} WmGeometryF;
+
+/*==============================================================================
+ * Rectangle Operations (Inline)
+ *============================================================================*/
+
+static inline WmRect wm_rect_make(int x, int y, int width, int height) {
+    WmRect r = { x, y, width, height };
+    return r;
+}
+
+static inline bool wm_rect_is_empty(const WmRect *r) {
+    return r == NULL || r->width <= 0 || r->height <= 0;
+}
+
+static inline bool wm_rect_contains_point(const WmRect *r, int x, int y) {
+    return r != NULL && 
+           x >= r->x && x < r->x + r->width &&
+           y >= r->y && y < r->y + r->height;
+}
+
+static inline bool wm_rect_intersects(const WmRect *a, const WmRect *b) {
+    if (a == NULL || b == NULL) return false;
+    return !(a->x + a->width <= b->x ||
+             b->x + b->width <= a->x ||
+             a->y + a->height <= b->y ||
+             b->y + b->height <= a->y);
+}
+
+static inline WmRect wm_rect_intersection(const WmRect *a, const WmRect *b) {
+    WmRect r = { 0, 0, 0, 0 };
+    if (a == NULL || b == NULL) return r;
+    
+    int x1 = a->x > b->x ? a->x : b->x;
+    int y1 = a->y > b->y ? a->y : b->y;
+    int x2 = (a->x + a->width) < (b->x + b->width) ? (a->x + a->width) : (b->x + b->width);
+    int y2 = (a->y + a->height) < (b->y + b->height) ? (a->y + a->height) : (b->y + b->height);
+    
+    if (x2 > x1 && y2 > y1) {
+        r.x = x1;
+        r.y = y1;
+        r.width = x2 - x1;
+        r.height = y2 - y1;
+    }
+    return r;
+}
+
+static inline WmRect wm_rect_union(const WmRect *a, const WmRect *b) {
+    WmRect r = { 0, 0, 0, 0 };
+    if (a == NULL && b == NULL) return r;
+    if (a == NULL) return *b;
+    if (b == NULL) return *a;
+    
+    int x1 = a->x < b->x ? a->x : b->x;
+    int y1 = a->y < b->y ? a->y : b->y;
+    int x2 = (a->x + a->width) > (b->x + b->width) ? (a->x + a->width) : (b->x + b->width);
+    int y2 = (a->y + a->height) > (b->y + b->height) ? (a->y + a->height) : (b->y + b->height);
+    
+    r.x = x1;
+    r.y = y1;
+    r.width = x2 - x1;
+    r.height = y2 - y1;
+    return r;
+}
+
+/*==============================================================================
+ * Color Operations (Inline)
+ *============================================================================*/
+
+static inline WmColor wm_color_rgb(uint8_t r, uint8_t g, uint8_t b) {
+    return (0xFF << 24) | (r << 16) | (g << 8) | b;
+}
+
+static inline WmColor wm_color_rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+    return (a << 24) | (r << 16) | (g << 8) | b;
+}
+
+static inline uint8_t wm_color_get_red(WmColor c) {
+    return (c >> 16) & 0xFF;
+}
+
+static inline uint8_t wm_color_get_green(WmColor c) {
+    return (c >> 8) & 0xFF;
+}
+
+static inline uint8_t wm_color_get_blue(WmColor c) {
+    return c & 0xFF;
+}
+
+static inline uint8_t wm_color_get_alpha(WmColor c) {
+    return (c >> 24) & 0xFF;
+}
+
+/*==============================================================================
+ * Client State Flags
+ *============================================================================*/
+
+typedef enum {
+    WM_CLIENT_FLAG_NONE        = 0,
+    WM_CLIENT_FLAG_FLOATING    = (1 << 0),
+    WM_CLIENT_FLAG_FULLSCREEN  = (1 << 1),
+    WM_CLIENT_FLAG_URGENT      = (1 << 2),
+    WM_CLIENT_FLAG_MINIMIZED   = (1 << 3),
+    WM_CLIENT_FLAG_STICKY      = (1 << 4),
+    WM_CLIENT_FLAG_MAXIMIZED   = (1 << 5),
+    WM_CLIENT_FLAG_UNMANAGING  = (1 << 6),
+    WM_CLIENT_FLAG_FOCUSED     = (1 << 7),
+    WM_CLIENT_FLAG_MAPPED      = (1 << 8),
+    WM_CLIENT_FLAG_DECORATED   = (1 << 9),
+    WM_CLIENT_FLAG_DIALOG      = (1 << 10),
+    WM_CLIENT_FLAG_DOCK        = (1 << 11),
+    WM_CLIENT_FLAG_UTILITY     = (1 << 12),
+    WM_CLIENT_FLAG_SPLASH      = (1 << 13),
+    WM_CLIENT_FLAG_MENU        = (1 << 14),
+    WM_CLIENT_FLAG_TOOLBAR     = (1 << 15)
+} WmClientFlags;
+
+/*==============================================================================
+ * Layout Types
+ *============================================================================*/
+
+typedef enum {
+    WM_LAYOUT_TYPE_TILING,
+    WM_LAYOUT_TYPE_FLOATING,
+    WM_LAYOUT_TYPE_MONOCLE,
+    WM_LAYOUT_TYPE_GRID,
+    WM_LAYOUT_TYPE_SPIRAL,
+    WM_LAYOUT_TYPE_DWINDLE,
+    WM_LAYOUT_TYPE_MAX
+} WmLayoutType;
+
+/*==============================================================================
+ * Panel Positions
+ *============================================================================*/
+
+typedef enum {
+    WM_PANEL_POSITION_TOP,
+    WM_PANEL_POSITION_BOTTOM,
+    WM_PANEL_POSITION_LEFT,
+    WM_PANEL_POSITION_RIGHT
+} WmPanelPosition;
+
+/*==============================================================================
+ * Event Types
+ *============================================================================*/
+
+typedef enum {
+    /* Window events */
+    WM_EVENT_NONE = 0,
+    WM_EVENT_WINDOW_CREATED,
+    WM_EVENT_WINDOW_DESTROYED,
+    WM_EVENT_WINDOW_MAPPED,
+    WM_EVENT_WINDOW_UNMAPPED,
+    WM_EVENT_WINDOW_CONFIGURED,
+    WM_EVENT_WINDOW_FOCUSED,
+    WM_EVENT_WINDOW_UNFOCUSED,
+    WM_EVENT_WINDOW_RAISED,
+    WM_EVENT_WINDOW_LOWERED,
+    WM_EVENT_WINDOW_MINIMIZED,
+    WM_EVENT_WINDOW_RESTORED,
+    WM_EVENT_WINDOW_MAXIMIZED,
+    WM_EVENT_WINDOW_UNMAXIMIZED,
+    WM_EVENT_WINDOW_FULLSCREENED,
+    WM_EVENT_WINDOW_UNFULLSCREENED,
+    WM_EVENT_WINDOW_FLOATING_CHANGED,
+    WM_EVENT_WINDOW_PROPERTY_CHANGED,
+    WM_EVENT_WINDOW_STATE_CHANGED,
+    WM_EVENT_WINDOW_TITLE_CHANGED,
+    WM_EVENT_WINDOW_CLASS_CHANGED,
+    WM_EVENT_WINDOW_ROLE_CHANGED,
+    WM_EVENT_WINDOW_URGENCY_CHANGED,
+    WM_EVENT_WINDOW_MOVED,
+    WM_EVENT_WINDOW_RESIZED,
+    
+    /* Workspace events */
+    WM_EVENT_WORKSPACE_CREATED,
+    WM_EVENT_WORKSPACE_DESTROYED,
+    WM_EVENT_WORKSPACE_SWITCHED,
+    WM_EVENT_WORKSPACE_RENAMED,
+    WM_EVENT_WORKSPACE_LAYOUT_CHANGED,
+    WM_EVENT_WORKSPACE_MASTER_RATIO_CHANGED,
+    WM_EVENT_WORKSPACE_MASTER_COUNT_CHANGED,
+    
+    /* Client/workspace relationship */
+    WM_EVENT_CLIENT_ADDED_TO_WORKSPACE,
+    WM_EVENT_CLIENT_REMOVED_FROM_WORKSPACE,
+    
+    /* Input events */
+    WM_EVENT_KEY_PRESSED,
+    WM_EVENT_KEY_RELEASED,
+    WM_EVENT_BUTTON_PRESSED,
+    WM_EVENT_BUTTON_RELEASED,
+    WM_EVENT_MOTION,
+    WM_EVENT_ENTER,
+    WM_EVENT_LEAVE,
+    WM_EVENT_SCROLL,
+    
+    /* System events */
+    WM_EVENT_MONITOR_ADDED,
+    WM_EVENT_MONITOR_REMOVED,
+    WM_EVENT_MONITOR_CONFIGURED,
+    WM_EVENT_SCREEN_RESIZED,
+    
+    /* Configuration events */
+    WM_EVENT_CONFIG_RELOADED,
+    WM_EVENT_CONFIG_CHANGED,
+    
+    /* Lifecycle events */
+    WM_EVENT_WM_STARTED,
+    WM_EVENT_WM_SHUTDOWN,
+    WM_EVENT_WM_READY,
+    
+    /* Plugin events */
+    WM_EVENT_PLUGIN_LOADED,
+    WM_EVENT_PLUGIN_UNLOADED,
+    WM_EVENT_PLUGIN_ERROR,
+    
+    /* Custom events for plugins */
+    WM_EVENT_CUSTOM = 1000
+} WmEventType;
+
+/*==============================================================================
+ * Container Types
+ *============================================================================*/
+
+typedef enum {
+    WM_CONTAINER_LIST,
+    WM_CONTAINER_ARRAY,
+    WM_CONTAINER_HASHMAP,
+    WM_CONTAINER_QUEUE,
+    WM_CONTAINER_STACK,
+    WM_CONTAINER_TREE
+} WmContainerType;
+
+/*==============================================================================
+ * Command Types
+ *============================================================================*/
+
+typedef enum {
+    WM_COMMAND_NONE = 0,
+    
+    /* Window commands */
+    WM_COMMAND_WINDOW_FOCUS,
+    WM_COMMAND_WINDOW_MOVE,
+    WM_COMMAND_WINDOW_RESIZE,
+    WM_COMMAND_WINDOW_MOVE_RESIZE,
+    WM_COMMAND_WINDOW_CLOSE,
+    WM_COMMAND_WINDOW_KILL,
+    WM_COMMAND_WINDOW_MINIMIZE,
+    WM_COMMAND_WINDOW_RESTORE,
+    WM_COMMAND_WINDOW_MAXIMIZE,
+    WM_COMMAND_WINDOW_UNMAXIMIZE,
+    WM_COMMAND_WINDOW_FULLSCREEN,
+    WM_COMMAND_WINDOW_UNFULLSCREEN,
+    WM_COMMAND_WINDOW_FLOAT,
+    WM_COMMAND_WINDOW_UNFLOAT,
+    WM_COMMAND_WINDOW_RAISE,
+    WM_COMMAND_WINDOW_LOWER,
+    WM_COMMAND_WINDOW_SET_WORKSPACE,
+    
+    /* Workspace commands */
+    WM_COMMAND_WORKSPACE_SWITCH,
+    WM_COMMAND_WORKSPACE_CREATE,
+    WM_COMMAND_WORKSPACE_DESTROY,
+    WM_COMMAND_WORKSPACE_RENAME,
+    WM_COMMAND_WORKSPACE_SET_LAYOUT,
+    WM_COMMAND_WORKSPACE_ADJUST_MASTER_RATIO,
+    WM_COMMAND_WORKSPACE_ADJUST_MASTER_COUNT,
+    WM_COMMAND_WORKSPACE_SWAP,
+    
+    /* Client manipulation */
+    WM_COMMAND_CLIENT_SWAP,
+    WM_COMMAND_CLIENT_SWAP_MASTER,
+    WM_COMMAND_CLIENT_CYCLE,
+    WM_COMMAND_CLIENT_CYCLE_REVERSE,
+    
+    /* System commands */
+    WM_COMMAND_RELOAD_CONFIG,
+    WM_COMMAND_QUIT,
+    WM_COMMAND_RESTART,
+    
+    /* Plugin commands */
+    WM_COMMAND_PLUGIN_LOAD,
+    WM_COMMAND_PLUGIN_UNLOAD,
+    WM_COMMAND_PLUGIN_ENABLE,
+    WM_COMMAND_PLUGIN_DISABLE
+} WmCommandType;
+
+/*==============================================================================
+ * Result/Error Types
+ *============================================================================*/
+
+typedef enum {
+    WM_RESULT_OK = 0,
+    WM_RESULT_ERROR_GENERIC = -1,
+    WM_RESULT_ERROR_INVALID_ARG = -2,
+    WM_RESULT_ERROR_NO_MEMORY = -3,
+    WM_RESULT_ERROR_NOT_FOUND = -4,
+    WM_RESULT_ERROR_EXISTS = -5,
+    WM_RESULT_ERROR_PERMISSION = -6,
+    WM_RESULT_ERROR_NOT_SUPPORTED = -7,
+    WM_RESULT_ERROR_NOT_IMPLEMENTED = -8,
+    WM_RESULT_ERROR_BACKEND = -9,
+    WM_RESULT_ERROR_PLUGIN = -10,
+    WM_RESULT_ERROR_TIMEOUT = -11,
+    WM_RESULT_ERROR_CANCELED = -12
+} WmResult;
+
+/*==============================================================================
+ * Callback Types
+ *============================================================================*/
+
+typedef void (*WmDestroyFunc)(void *data);
+typedef int (*WmCompareFunc)(const void *a, const void *b);
+typedef uint32_t (*WmHashFunc)(const void *key);
+typedef void* (*WmCloneFunc)(const void *data);
+typedef void (*WmEventHandler)(WmEventType type, const void *event_data, void *user_data);
+typedef void (*WmTimerCallback)(WmTimer *timer, void *user_data);
+typedef void* (*WmThreadFunc)(void *arg);
+
+/*==============================================================================
+ * Memory Management Types
+ *============================================================================*/
+
+typedef void* (*WmAllocFunc)(size_t size);
+typedef void* (*WmReallocFunc)(void *ptr, size_t old_size, size_t new_size);
+typedef void (*WmFreeFunc)(void *ptr);
+
+typedef struct {
+    WmAllocFunc alloc;
+    WmReallocFunc realloc;
+    WmFreeFunc free;
+} WmAllocator;
+
+/*==============================================================================
+ * Logging Types
+ *============================================================================*/
+
+typedef enum {
+    WM_LOG_LEVEL_DEBUG,
+    WM_LOG_LEVEL_INFO,
+    WM_LOG_LEVEL_WARN,
+    WM_LOG_LEVEL_ERROR,
+    WM_LOG_LEVEL_FATAL
+} WmLogLevel;
+
+typedef void (*WmLogHandler)(WmLogLevel level, const char *file, int line, 
+                              const char *func, const char *message);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WM_TYPES_H */

include/core/wm_workspace.h

@@ -0,0 +1,161 @@
+/*
+ * DWN - Desktop Window Manager
+ * Abstract Workspace Interface
+ */
+
+#ifndef WM_WORKSPACE_H
+#define WM_WORKSPACE_H
+
+#include "wm_types.h"
+#include "wm_client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*==============================================================================
+ * Workspace Configuration
+ *============================================================================*/
+
+#define WM_MAX_WORKSPACES 32
+
+typedef struct {
+    WmLayoutType layout_type;
+    float master_ratio;
+    int master_count;
+    char name[64];
+    bool persistent;
+    WmString *custom_data;
+} WmWorkspaceConfig;
+
+/*==============================================================================
+ * Workspace Lifecycle
+ *============================================================================*/
+
+bool wm_workspace_exists(WmCore *core, WmWorkspaceId id);
+WmWorkspaceId wm_workspace_create(WmCore *core, const char *name);
+void wm_workspace_destroy(WmCore *core, WmWorkspaceId id);
+
+void wm_workspace_init_all(WmCore *core);
+void wm_workspace_cleanup_all(WmCore *core);
+
+/*==============================================================================
+ * Workspace Properties
+ *============================================================================*/
+
+const char* wm_workspace_get_name(WmCore *core, WmWorkspaceId id);
+void wm_workspace_set_name(WmCore *core, WmWorkspaceId id, const char *name);
+
+bool wm_workspace_is_empty(WmCore *core, WmWorkspaceId id);
+size_t wm_workspace_get_client_count(WmCore *core, WmWorkspaceId id);
+
+/*==============================================================================
+ * Current Workspace
+ *============================================================================*/
+
+WmWorkspaceId wm_workspace_get_current(WmCore *core);
+void wm_workspace_set_current(WmCore *core, WmWorkspaceId id);
+void wm_workspace_switch(WmCore *core, WmWorkspaceId id);
+
+void wm_workspace_switch_next(WmCore *core);
+void wm_workspace_switch_prev(WmCore *core);
+
+/*==============================================================================
+ * Client Management
+ *============================================================================*/
+
+void wm_workspace_add_client(WmCore *core, WmWorkspaceId id, AbstractClient *client);
+void wm_workspace_remove_client(WmCore *core, WmWorkspaceId id, AbstractClient *client);
+void wm_workspace_move_client(WmCore *core, AbstractClient *client, WmWorkspaceId to_workspace);
+
+WmContainer* wm_workspace_get_clients(WmCore *core, WmWorkspaceId id);
+
+AbstractClient* wm_workspace_get_focused_client(WmCore *core, WmWorkspaceId id);
+void wm_workspace_set_focused_client(WmCore *core, WmWorkspaceId id, AbstractClient *client);
+
+AbstractClient* wm_workspace_get_first_client(WmCore *core, WmWorkspaceId id);
+AbstractClient* wm_workspace_get_last_client(WmCore *core, WmWorkspaceId id);
+
+/*==============================================================================
+ * Layout Management
+ *============================================================================*/
+
+WmLayoutType wm_workspace_get_layout(WmCore *core, WmWorkspaceId id);
+void wm_workspace_set_layout(WmCore *core, WmWorkspaceId id, WmLayoutType layout);
+void wm_workspace_cycle_layout(WmCore *core, WmWorkspaceId id);
+void wm_workspace_cycle_layout_reverse(WmCore *core, WmWorkspaceId id);
+
+float wm_workspace_get_master_ratio(WmCore *core, WmWorkspaceId id);
+void wm_workspace_set_master_ratio(WmCore *core, WmWorkspaceId id, float ratio);
+void wm_workspace_adjust_master_ratio(WmCore *core, WmWorkspaceId id, float delta);
+
+int wm_workspace_get_master_count(WmCore *core, WmWorkspaceId id);
+void wm_workspace_set_master_count(WmCore *core, WmWorkspaceId id, int count);
+void wm_workspace_adjust_master_count(WmCore *core, WmWorkspaceId id, int delta);
+
+/*==============================================================================
+ * Workspace Arrangement
+ *============================================================================*/
+
+void wm_workspace_arrange(WmCore *core, WmWorkspaceId id);
+void wm_workspace_arrange_all(WmCore *core);
+void wm_workspace_arrange_current(WmCore *core);
+
+WmRect wm_workspace_get_arrange_area(WmCore *core, WmWorkspaceId id);
+
+/*==============================================================================
+ * Workspace Visibility
+ *============================================================================*/
+
+void wm_workspace_show(WmCore *core, WmWorkspaceId id);
+void wm_workspace_hide(WmCore *core, WmWorkspaceId id);
+bool wm_workspace_is_visible(WmCore *core, WmWorkspaceId id);
+
+/*==============================================================================
+ * Focus Management
+ *============================================================================*/
+
+void wm_workspace_focus_next(WmCore *core, WmWorkspaceId id);
+void wm_workspace_focus_prev(WmCore *core, WmWorkspaceId id);
+void wm_workspace_focus_master(WmCore *core, WmWorkspaceId id);
+
+/*==============================================================================
+ * MRU (Most Recently Used) Stack
+ *============================================================================*/
+
+void wm_workspace_mru_push(WmCore *core, WmWorkspaceId id, AbstractClient *client);
+void wm_workspace_mru_remove(WmCore *core, WmWorkspaceId id, AbstractClient *client);
+AbstractClient* wm_workspace_mru_get_next(WmCore *core, WmWorkspaceId id, AbstractClient *current);
+AbstractClient* wm_workspace_mru_get_prev(WmCore *core, WmWorkspaceId id, AbstractClient *current);
+
+/*==============================================================================
+ * Alt-Tab Navigation
+ *============================================================================*/
+
+void wm_workspace_alt_tab_start(WmCore *core, WmWorkspaceId id);
+void wm_workspace_alt_tab_next(WmCore *core, WmWorkspaceId id);
+void wm_workspace_alt_tab_prev(WmCore *core, WmWorkspaceId id);
+void wm_workspace_alt_tab_end(WmCore *core, WmWorkspaceId id);
+bool wm_workspace_alt_tab_is_active(WmCore *core, WmWorkspaceId id);
+
+/*==============================================================================
+ * Workspace Iteration
+ *============================================================================*/
+
+WmWorkspaceId wm_workspace_get_first(WmCore *core);
+WmWorkspaceId wm_workspace_get_last(WmCore *core);
+WmWorkspaceId wm_workspace_get_next(WmCore *core, WmWorkspaceId id);
+WmWorkspaceId wm_workspace_get_prev(WmCore *core, WmWorkspaceId id);
+
+/*==============================================================================
+ * Configuration
+ *============================================================================*/
+
+void wm_workspace_save_config(WmCore *core, WmWorkspaceId id, const WmWorkspaceConfig *config);
+bool wm_workspace_load_config(WmCore *core, WmWorkspaceId id, WmWorkspaceConfig *config);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WM_WORKSPACE_H */