chroma

#ifndef CHROMA_H

#define CHROMA_H

#include "wlr-layer-shell-unstable-v1.h"

#include "xdg-shell.h"

#include <EGL/egl.h>

#include <GL/gl.h>

#include <signal.h>

#include <stdbool.h>

#include <stdint.h>

#include <sys/types.h>

#include <wayland-client.h>

#include <wayland-egl.h>

#define CHROMA_VERSION "1.0.0"

#define MAX_OUTPUTS 16

#define MAX_PATH_LEN 4096

#define CONFIG_FILE_NAME "chroma.conf"

// Error codes

typedef enum {

  CHROMA_OK = 0,

  CHROMA_ERROR_INIT = -1,

  CHROMA_ERROR_WAYLAND = -2,

  CHROMA_ERROR_EGL = -3,

  CHROMA_ERROR_IMAGE = -4,

  CHROMA_ERROR_CONFIG = -5,

  CHROMA_ERROR_MEMORY = -6

} chroma_error_t;

// Image data structure

typedef struct {

  unsigned char *data; // RGBA pixel data

  int width;

  int height;

  int channels;

  char path[MAX_PATH_LEN];

  bool loaded;

} chroma_image_t;

// Wayland output information

typedef struct {

  struct wl_output *wl_output;

  uint32_t id;

  int32_t x, y;

  int32_t width, height;

  int32_t scale;

  enum wl_output_transform transform;

  char *name;

  char *description;

  bool active;

  // Back reference to state

  struct chroma_state *state;

  // Rendering context

  struct wl_surface *surface;

  struct zwlr_layer_surface_v1 *layer_surface;

  struct wl_egl_window *egl_window;

  EGLSurface egl_surface;

  uint32_t configure_serial;

  // Associated wallpaper

  chroma_image_t *image;

  // OpenGL resource cache

  GLuint texture_id;

  GLuint shader_program;

  GLuint vbo;

  GLuint ebo;

  bool gl_resources_initialized;

  bool texture_uploaded;

} chroma_output_t;

// Config mapping structure

typedef struct {

  char output_name[256];

  char image_path[MAX_PATH_LEN];

} chroma_config_mapping_t;

// Application configuration

typedef struct {

  chroma_config_mapping_t mappings[MAX_OUTPUTS];

  int mapping_count;

  char default_image[MAX_PATH_LEN];

  bool daemon_mode;

} chroma_config_t;

// Main application state

typedef struct chroma_state {

  // Wayland globals

  struct wl_display *display;

  struct wl_registry *registry;

  struct wl_compositor *compositor;

  struct zwlr_layer_shell_v1 *layer_shell;

  // EGL context

  EGLDisplay egl_display;

  EGLContext egl_context;

  EGLConfig egl_config;

  // Outputs

  chroma_output_t outputs[MAX_OUTPUTS];

  int output_count;

  // Images

  chroma_image_t images[MAX_OUTPUTS];

  int image_count;

  // Configuration

  chroma_config_t config;

  // State flags

  bool running;

  bool initialized;

} chroma_state_t;

// Function declarations

// Initialization and cleanup

int chroma_init(chroma_state_t *state);

void chroma_cleanup(chroma_state_t *state);

// Wayland management

int chroma_wayland_connect(chroma_state_t *state);

void chroma_wayland_disconnect(chroma_state_t *state);

void chroma_registry_listener(void *data, struct wl_registry *registry,

                              uint32_t id, const char *interface,

                              uint32_t version);

void chroma_registry_remove(void *data, struct wl_registry *registry,

                            uint32_t id);

// Output management

int chroma_output_add(chroma_state_t *state, uint32_t id,

                      struct wl_output *output);

void chroma_output_remove(chroma_state_t *state, uint32_t id);

chroma_output_t *chroma_output_find_by_id(chroma_state_t *state, uint32_t id);

chroma_output_t *chroma_output_find_by_name(chroma_state_t *state,

                                            const char *name);

// Output event handlers

void chroma_output_geometry(void *data, struct wl_output *output, int32_t x,

                            int32_t y, int32_t physical_width,

                            int32_t physical_height, int32_t subpixel,

                            const char *make, const char *model,

                            int32_t transform);

void chroma_output_mode(void *data, struct wl_output *output, uint32_t flags,

                        int32_t width, int32_t height, int32_t refresh);

void chroma_output_scale(void *data, struct wl_output *output, int32_t scale);

void chroma_output_name(void *data, struct wl_output *output, const char *name);

void chroma_output_description(void *data, struct wl_output *output,

                               const char *description);

void chroma_output_done(void *data, struct wl_output *output);

// EGL and rendering

int chroma_egl_init(chroma_state_t *state);

void chroma_egl_cleanup(chroma_state_t *state);

int chroma_surface_create(chroma_state_t *state, chroma_output_t *output);

void chroma_surface_destroy(chroma_output_t *output);

int chroma_render_wallpaper(chroma_state_t *state, chroma_output_t *output);

void chroma_output_invalidate_texture(chroma_output_t *output);

// Layer shell functions

void chroma_layer_surface_configure(void *data,

                                    struct zwlr_layer_surface_v1 *layer_surface,

                                    uint32_t serial, uint32_t width,

                                    uint32_t height);

void chroma_layer_surface_closed(void *data,

                                 struct zwlr_layer_surface_v1 *layer_surface);

// Image loading

void chroma_image_init_stb(void);

int chroma_image_load(chroma_image_t *image, const char *path);

void chroma_image_free(chroma_image_t *image);

chroma_image_t *chroma_image_find_by_path(chroma_state_t *state,

                                          const char *path);

chroma_image_t *chroma_image_get_or_load(chroma_state_t *state,

                                         const char *path);

int chroma_image_validate(const char *path);

int chroma_image_get_info(const char *path, int *width, int *height,

                          int *channels);

void chroma_images_cleanup(chroma_state_t *state);

// Configuration

int chroma_config_load(chroma_config_t *config, const char *config_file);

void chroma_config_free(chroma_config_t *config);

const char *chroma_config_get_image_for_output(chroma_config_t *config,

                                               const char *output_name);

// Main loop and events

int chroma_run(chroma_state_t *state);

void chroma_handle_signals(void);

int chroma_reload_config(chroma_state_t *state, const char *config_file);

int chroma_update_outputs(chroma_state_t *state);

void chroma_get_stats(chroma_state_t *state, int *active_outputs,

                      int *loaded_images);

void handle_output_done(chroma_state_t *state, chroma_output_t *output);

// Utilities

void chroma_log(const char *level, const char *format, ...);

const char *chroma_error_string(chroma_error_t error);

void chroma_set_log_level(int level);

int chroma_get_log_level(void);

void chroma_set_signal_state(chroma_state_t *state, const char *config_file);

void chroma_cleanup_signals(void);

char *chroma_expand_path(const char *path);

int chroma_mkdir_recursive(const char *path, mode_t mode);

char *chroma_get_config_dir(void);

bool chroma_path_exists(const char *path);

bool chroma_is_regular_file(const char *path);

bool chroma_is_directory(const char *path);

long chroma_get_file_size(const char *path);

const char *chroma_get_file_extension(const char *path);

int chroma_strcasecmp(const char *s1, const char *s2);

size_t chroma_strlcpy(char *dst, const char *src, size_t size);

size_t chroma_strlcat(char *dst, const char *src, size_t size);

long long chroma_get_time_ms(void);

void chroma_sleep_ms(long ms);

void chroma_format_memory_size(size_t bytes, char *buffer, size_t buffer_size);

void chroma_utils_cleanup(void);

// Listener structures

extern const struct wl_registry_listener chroma_registry_listener_impl;

extern const struct wl_output_listener chroma_output_listener_impl;

extern const struct zwlr_layer_surface_v1_listener

    chroma_layer_surface_listener_impl;

// Global state for signal handling

extern volatile sig_atomic_t chroma_should_quit;

#endif // CHROMA_H