diff options
Diffstat (limited to 'include/ecex.h')
| -rw-r--r-- | include/ecex.h | 219 |
1 files changed, 219 insertions, 0 deletions
diff --git a/include/ecex.h b/include/ecex.h index cefee9b..efcbe5a 100644 --- a/include/ecex.h +++ b/include/ecex.h @@ -4,10 +4,93 @@ #include "types.h" #include "buffers.h" #include "eval.h" +#include "path.h" +#include "media.h" + + +typedef struct ecex_config_command { + const char *name; + ecex_command_fn fn; +} ecex_config_command_t; + +typedef struct ecex_config_keybind { + const char *key; + const char *command; +} ecex_config_keybind_t; + +typedef struct ecex_config_mode_keybind { + const char *mode; + const char *key; + const char *command; +} ecex_config_mode_keybind_t; ecex_t *ecex_new(void); void ecex_free(ecex_t *ed); +/* Small runtime services exported to JIT configs/plugins. Prefer these over + * calling libc directly from config code; the tiny JIT resolver is intentionally + * conservative and host-exported wrappers are more reliable. */ +void *ecex_config_alloc(size_t size); +void *ecex_config_calloc(size_t count, size_t size); +void ecex_config_free(void *ptr); +double ecex_time_seconds(void); +void ecex_log(const char *message); +void ecex_log_int(const char *message, int value); +void ecex_log_double(const char *message, double value); +void ecex_log_ptr(const char *message, const void *ptr); +void ecex_mem_zero(void *ptr, size_t size); +int ecex_i32_get(const int *items, size_t index); +void ecex_i32_set(int *items, size_t index, int value); +int ecex_prng_next_bounded(unsigned int *state, int bound); +int ecex_random_bounded(int bound); +int ecex_tetris_shape_cell(int piece, int rot, int col, int row); + +/* Host-owned variable registry for JIT plugins. Plugins can keep persistent + * scalar values, dynamic arrays, or static host buffers behind a stable owner + * pointer and a name instead of relying on fragile JIT struct/array storage. */ +void *ecex_var_get(ecex_t *ed, void *owner, const char *name); +void *ecex_var_get_or_alloc(ecex_t *ed, void *owner, const char *name, size_t count, size_t elem_size); +int ecex_var_bind_static(ecex_t *ed, void *owner, const char *name, void *data, size_t count, size_t elem_size); +int ecex_var_free(ecex_t *ed, void *owner, const char *name); +int ecex_var_free_owner(ecex_t *ed, void *owner); +int ecex_var_i32_get(ecex_t *ed, void *owner, const char *name, size_t index, int fallback); +int ecex_var_i32_set(ecex_t *ed, void *owner, const char *name, size_t index, int value); +int ecex_var_i32(ecex_t *ed, void *owner, const char *name, int fallback); +int ecex_var_i32_set_scalar(ecex_t *ed, void *owner, const char *name, int value); + +/* Host-owned object allocator for plugin state. Returned pointers are tracked + * by the editor and can be freed through the API. Prefer this for callback + * userdata over plugin/local allocations when the object has callback lifetime. + */ +void *ecex_object_alloc(ecex_t *ed, size_t size); +void *ecex_object_calloc(ecex_t *ed, size_t count, size_t size); +int ecex_object_free(ecex_t *ed, void *object); +int ecex_object_valid(ecex_t *ed, void *object); +int ecex_object_i32_get(ecex_t *ed, void *object, size_t byte_offset, int fallback); +int ecex_object_i32_set(ecex_t *ed, void *object, size_t byte_offset, int value); +void *ecex_object_ptr_get(ecex_t *ed, void *object, size_t byte_offset); +int ecex_object_ptr_set(ecex_t *ed, void *object, size_t byte_offset, void *value); + +/* Host-owned text registry for plugins that need to render arbitrary text. + * Plugins copy text into host storage, then draw by owner/id. This avoids + * passing JIT-owned literals or stack strings into the normal text renderer. */ +int ecex_text_set(ecex_t *ed, void *owner, int id, const char *text, int len); +int ecex_text_set_buffer_title(ecex_t *ed, void *owner, int id, buffer_t *buffer); +int ecex_text_free(ecex_t *ed, void *owner, int id); +int ecex_text_free_owner(ecex_t *ed, void *owner); + +int ecex_buffer_text_len(buffer_t *buffer); +int ecex_buffer_scroll_line(buffer_t *buffer); +int ecex_buffer_line_count_i(buffer_t *buffer); +int ecex_buffer_line_copy(buffer_t *buffer, int line, char *out, int out_cap); +int ecex_markdown_draw_line_from_buffer_i(ecex_draw_context_t *ctx, void *owner, buffer_t *buffer, int line, int y, int in_code); +int ecex_markdown_body_y_i(ecex_draw_context_t *ctx); +int ecex_draw_context_height_i(ecex_draw_context_t *ctx); +int ecex_draw_context_line_height_i(ecex_draw_context_t *ctx); + +int ecex_register_file_handler(ecex_t *ed, const char *extension, ecex_file_handler_fn fn); +int ecex_run_file_handlers(ecex_t *ed, buffer_t *buffer); + int ecex_reserve_buffers(ecex_t *ed, size_t needed); int ecex_add_buffer(ecex_t *ed, buffer_t *buffer); @@ -20,6 +103,7 @@ buffer_t *ecex_find_buffer(ecex_t *ed, const char *name); int ecex_switch_buffer(ecex_t *ed, const char *name); buffer_t *ecex_current_buffer(ecex_t *ed); +buffer_t *ecex_other_buffer(ecex_t *ed); ecex_window_t *ecex_current_window(ecex_t *ed); size_t ecex_window_count(ecex_t *ed); int ecex_sync_current_buffer(ecex_t *ed); @@ -35,6 +119,9 @@ int ecex_balance_windows(ecex_t *ed); int ecex_next_buffer(ecex_t *ed); int ecex_previous_buffer(ecex_t *ed); int ecex_kill_buffer(ecex_t *ed, const char *name); +int ecex_kill_buffer_force(ecex_t *ed, const char *name); +int ecex_has_modified_buffers(ecex_t *ed); +int ecex_validate_bindings(ecex_t *ed); int ecex_keep_jit_module(ecex_t *ed, void *module); @@ -42,6 +129,12 @@ int ecex_set_config_path(ecex_t *ed, const char *path); const char *ecex_config_path(ecex_t *ed); int ecex_reload_config(ecex_t *ed); +int ecex_config_register_commands(ecex_t *ed, const ecex_config_command_t *commands, size_t count); +int ecex_config_bind_keys(ecex_t *ed, const ecex_config_keybind_t *bindings, size_t count); +int ecex_config_bind_mode_keys(ecex_t *ed, const ecex_config_mode_keybind_t *bindings, size_t count); +int ecex_config_define_modes(ecex_t *ed, const char *const *modes, size_t count); +int ecex_apply_theme(ecex_t *ed, const ecex_theme_t *theme); + int ecex_register_command(ecex_t *ed, const char *name, ecex_command_fn fn); int ecex_execute_command(ecex_t *ed, const char *name); void ecex_set_clipboard_callbacks(ecex_t *ed, @@ -77,6 +170,100 @@ int ecex_interactive_append_line(ecex_t *ed, void *userdata); int ecex_interactive_activate_current_line(ecex_t *ed); +/* + * Attach an immediate-mode renderer to a buffer. The callback runs while the + * buffer's window is being drawn and may call ecex_draw_* functions with + * coordinates local to that window. Pass ECEX_RENDER_REPLACE_CONTENT to draw a + * fully custom buffer; pass ECEX_RENDER_OVERLAY to draw on top of normal text. + */ +int ecex_buffer_set_renderer(buffer_t *buffer, + ecex_buffer_render_fn fn, + void *userdata, + ecex_buffer_userdata_free_fn free_fn, + int flags); +int ecex_buffer_clear_renderer(buffer_t *buffer); +int ecex_buffer_has_renderer(buffer_t *buffer); +void *ecex_buffer_renderer_userdata(buffer_t *buffer); + +/* + * Optional mouse/pointer input for rendered buffers. Coordinates are integer + * pixels local to the buffer window. Return nonzero from the callback when the + * event changes state and should trigger a redraw. Prefer this host-dispatched + * path over reading windowing-system globals from a plugin. + */ +int ecex_buffer_set_mouse_handler(buffer_t *buffer, + ecex_buffer_mouse_fn fn, + void *userdata, + ecex_buffer_userdata_free_fn free_fn); +int ecex_buffer_clear_mouse_handler(buffer_t *buffer); +int ecex_buffer_has_mouse_handler(buffer_t *buffer); +void *ecex_buffer_mouse_userdata(buffer_t *buffer); + +/* + * Host-driven animation for rendered buffers. The editor calls tick_fn at up to + * fps while the main loop is alive; returning nonzero marks the frame dirty and + * triggers a redraw. Use this instead of timers, sleep, clock calls, or threads + * in CCDJIT plugins. fps <= 0 defaults to 60; values above 240 are clamped. + */ +int ecex_buffer_set_animation(buffer_t *buffer, + ecex_buffer_tick_fn fn, + void *userdata, + ecex_buffer_userdata_free_fn free_fn, + double fps); +int ecex_buffer_set_animation_ms(buffer_t *buffer, + ecex_buffer_tick_ms_fn fn, + void *userdata, + ecex_buffer_userdata_free_fn free_fn, + int fps); +int ecex_buffer_clear_animation(buffer_t *buffer); +int ecex_buffer_is_animating(buffer_t *buffer); +void *ecex_buffer_animation_userdata(buffer_t *buffer); +int ecex_tick_animations(ecex_t *ed, double now_seconds); + +int ecex_buffer_replace_text(buffer_t *buffer, const char *text); +void ecex_buffer_set_modified(buffer_t *buffer, int modified); + +/* Drawing helpers. x/y are local to the buffer window; ecex_draw_text uses + * top-left coordinates. ecex_draw_rgba expects tightly packed RGBA8 pixels. */ +void ecex_draw_set_color(ecex_draw_context_t *ctx, float r, float g, float b, float a); +void ecex_draw_rect(ecex_draw_context_t *ctx, float x, float y, float w, float h); +void ecex_draw_rect_outline(ecex_draw_context_t *ctx, float x, float y, float w, float h, float thickness); +void ecex_draw_line(ecex_draw_context_t *ctx, float x1, float y1, float x2, float y2, float thickness); +void ecex_draw_text(ecex_draw_context_t *ctx, float x, float y, const char *text); +void ecex_draw_text_aligned(ecex_draw_context_t *ctx, float x, float y, float w, const char *text, int align); +float ecex_draw_text_width(ecex_draw_context_t *ctx, const char *text); +void ecex_draw_rgba(ecex_draw_context_t *ctx, + float x, + float y, + float w, + float h, + const unsigned char *rgba, + int image_w, + int image_h); + +/* CCDJIT-safe integer drawing wrappers. Prefer these from plugins when the + * JIT ABI is known to be fragile with float/double arguments. Colors are + * 0..255 RGBA and coordinates are integer pixels local to the buffer window. */ +void ecex_draw_color_rgba8(ecex_draw_context_t *ctx, int r, int g, int b, int a); +void ecex_draw_rect_i(ecex_draw_context_t *ctx, int x, int y, int w, int h); +void ecex_draw_rect_outline_i(ecex_draw_context_t *ctx, int x, int y, int w, int h, int thickness); +void ecex_draw_line_i(ecex_draw_context_t *ctx, int x1, int y1, int x2, int y2, int thickness); +void ecex_draw_text_i(ecex_draw_context_t *ctx, int x, int y, const char *text); +void ecex_draw_text_id_i(ecex_draw_context_t *ctx, void *owner, int id, int x, int y); + +void ecex_draw_markdown_canvas_i(ecex_draw_context_t *ctx, void *owner, int title_id, int x, int y, int w, int line_h); +void ecex_draw_markdown_text_i(ecex_draw_context_t *ctx, void *owner, int text_id, int x, int y, int w, int line_h, int style); +/* Lower-arity Markdown helpers preferred by CCDJIT plugins. Some JIT call + * paths are fragile with 7+ arguments, so these derive layout from ctx. */ +void ecex_draw_markdown_canvas_auto_i(ecex_draw_context_t *ctx, void *owner, int title_id); +void ecex_draw_markdown_line_auto_i(ecex_draw_context_t *ctx, void *owner, int text_id, int y, int style); + +/* CCDJIT-safe host-owned text helpers. Plugins pass integer ids instead of + * pointers to JIT-owned string literals/stack buffers. */ +void ecex_draw_label_i(ecex_draw_context_t *ctx, int x, int y, int label_id); +void ecex_draw_stat_i(ecex_draw_context_t *ctx, int x, int y, int label_id, int value); +void ecex_draw_tetris_preview_i(ecex_draw_context_t *ctx, int piece, int x, int y, int cell, int alpha); + int ecex_find_file(ecex_t *ed, const char *path); int ecex_save_current_buffer(ecex_t *ed); int ecex_write_current_buffer(ecex_t *ed, const char *path); @@ -121,4 +308,36 @@ void ecex_set_search_bg_color(ecex_t *ed, float r, float g, float b); void ecex_set_line_numbers_enabled(ecex_t *ed, int enabled); void ecex_set_current_line_enabled(ecex_t *ed, int enabled); + +/* + * Small config/plugin convenience layer. + * + * Config files are still plain C and must export ecex_config_init(ecex_t *ed), + * but these macros make them safer to write: every registration/bind operation + * is checked and failures abort config loading instead of being ignored. + */ +#define ECEX_ARRAY_COUNT(a) (sizeof(a) / sizeof((a)[0])) +#define ECEX_RGB8(r, g, b) ((float)(r) / 255.0f), ((float)(g) / 255.0f), ((float)(b) / 255.0f) +#define ECEX_CONFIG_BEGIN int ecex_config_init(ecex_t *ed) { +#define ECEX_CONFIG_END return 0; } +#define ECEX_PLUGIN_BEGIN(name) int name(ecex_t *ed) { +#define ECEX_PLUGIN_END return 0; } +#define ECEX_CONFIG_TRY(expr) \ + do { \ + if ((expr) != 0) return -1; \ + } while (0) +#define ECEX_CONFIG_COMMAND(name, fn) ECEX_CONFIG_TRY(ecex_register_command(ed, (name), (fn))) +#define ECEX_CONFIG_BIND(key, command) ECEX_CONFIG_TRY(ecex_bind_key(ed, (key), (command))) +#define ECEX_CONFIG_MODE(name) \ + do { \ + if (ecex_define_major_mode(ed, (name)) == 0) return -1; \ + } while (0) +#define ECEX_CONFIG_MODE_BIND(mode, key, command) ECEX_CONFIG_TRY(ecex_bind_mode_key(ed, (mode), (key), (command))) +#define ECEX_CONFIG_COMMANDS(commands) ECEX_CONFIG_TRY(ecex_config_register_commands(ed, (commands), ECEX_ARRAY_COUNT(commands))) +#define ECEX_CONFIG_BINDS(bindings) ECEX_CONFIG_TRY(ecex_config_bind_keys(ed, (bindings), ECEX_ARRAY_COUNT(bindings))) +#define ECEX_CONFIG_MODE_BINDS(bindings) ECEX_CONFIG_TRY(ecex_config_bind_mode_keys(ed, (bindings), ECEX_ARRAY_COUNT(bindings))) +#define ECEX_CONFIG_MODES(modes) ECEX_CONFIG_TRY(ecex_config_define_modes(ed, (modes), ECEX_ARRAY_COUNT(modes))) +#define ECEX_CONFIG_THEME(theme_ptr) ECEX_CONFIG_TRY(ecex_apply_theme(ed, (theme_ptr))) +#define ECEX_CONFIG_INCLUDE(plugin_init_fn) ECEX_CONFIG_TRY((plugin_init_fn)(ed)) + #endif |