diff options
Diffstat (limited to 'prototypes/connections/edit-window.c')
| -rw-r--r-- | prototypes/connections/edit-window.c | 638 |
1 files changed, 638 insertions, 0 deletions
diff --git a/prototypes/connections/edit-window.c b/prototypes/connections/edit-window.c new file mode 100644 index 0000000..303b2bf --- /dev/null +++ b/prototypes/connections/edit-window.c @@ -0,0 +1,638 @@ +#define _POSIX_C_SOURCE 200809L +/* Optional GTK document adapter for the same prepared edit program used by + * pure-edit and pure-connections. GTK text lives at the application boundary; + * Pure's execution core remains independent of the UI and document encoding. */ +#include "runtime.h" +#include "store-port.h" +#include "store.h" +#include <gtk/gtk.h> +#include <inttypes.h> +#include <stdint.h> +#include <stdio.h> +#include <string.h> + +typedef struct { + PureProgram program; + PureRuntime runtime; + PureWork work[1]; + const char *directory, *program_path; + char key[65]; + size_t prefix, baseline_size; + char *baseline; + char *definition_baseline; + size_t definition_baseline_size; + uint64_t definition_generation; + size_t last_output_bytes; + bool has_edit_output; + bool definition_needs_apply; + int64_t revision; + bool exists; + bool closing, asking_to_close; + GtkWidget *window, *text, *status, *version, *heading, *key_entry; + GtkWidget *source, *source_revealer, *source_status; +} Editor; + +static const char *result_name(PureResult result) { + switch (result) { + case PURE_OK: return "ok"; + case PURE_NOT_FOUND: return "not found"; + case PURE_CONFLICT: return "version conflict"; + case PURE_BUSY: return "busy"; + case PURE_BUDGET: return "request budget exceeded"; + case PURE_LIMIT: return "document limit or invalid range"; + case PURE_UNCERTAIN: return "durability unknown; inspect the stored revision before retrying"; + case PURE_DENIED: return "operation denied"; + case PURE_ALLOCATION: return "allocation failed"; + default: return "operation failed"; + } +} + +static bool valid_key(const char *key) { + size_t length = strlen(key); + if (!length || length > 64) return false; + for (size_t i = 0; i < length; ++i) { + char c = key[i]; + if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || + (c >= '0' && c <= '9') || c == '_' || c == '-')) return false; + } + return true; +} + +/* The window supplies the convenience layout accepted by pure-edit. The + * prepared program, not the window, determines the splice field locations. */ +static bool edit_layout(const PureProgram *p, size_t *prefix) { + if (!p->splice || !p->write.to_end || p->write_step || p->input_steps || + !p->splice_offset.from_u32le || !p->splice_remove.from_u32le || + p->read.offset || !p->read.to_end || p->read_required) return false; + size_t start = p->splice_offset.value, remove = p->splice_remove.value; + *prefix = p->write.offset; + if (*prefix > PURE_OBJECT_LIMIT || p->input_required > *prefix || start > *prefix || + remove > *prefix || *prefix - start < 4 || *prefix - remove < 4) return false; + return start < remove ? remove - start >= 4 : start - remove >= 4; +} + +static void put32(unsigned char *to, uint32_t value) { + for (unsigned i = 0; i < 4; ++i) to[i] = (unsigned char)(value >> (8 * i)); +} + +static void status(Editor *e, const char *text) { + gtk_label_set_text(GTK_LABEL(e->status), text); + char revision[64]; + snprintf(revision, sizeof(revision), "%s · revision %" PRId64, + e->exists ? "Stored" : "New", e->revision); + gtk_label_set_text(GTK_LABEL(e->version), revision); +} + +static void definition_status(Editor *e, const char *text) { + gtk_label_set_text(GTK_LABEL(e->source_status), text); +} + +static void definition_title(Editor *e) { + char title[128]; + if (e->has_edit_output) + snprintf(title, sizeof(title), "%s · Pure document · definition %" PRIu64 + " · output %zu B", e->key, e->definition_generation, e->last_output_bytes); + else snprintf(title, sizeof(title), "%s · Pure document · definition %" PRIu64, + e->key, e->definition_generation); + gtk_window_set_title(GTK_WINDOW(e->window), title); +} + +static void apply_definition(Editor *e) { + GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->source)); + GtkTextIter first, last; + gtk_text_buffer_get_bounds(buffer, &first, &last); + char *draft = gtk_text_buffer_get_text(buffer, &first, &last, FALSE); + size_t length = strlen(draft); + bool changed = length != e->definition_baseline_size || + memcmp(draft, e->definition_baseline, length) != 0; + if (!changed && !e->definition_needs_apply) { + gtk_text_buffer_set_modified(buffer, FALSE); + definition_status(e, "No definition changes to apply"); + g_free(draft); + return; + } + PureProgram candidate; + size_t prefix = 0; + char error[160] = {0}; + if (length > PURE_PROGRAM_LIMIT || + !pure_program_parse(draft, length, &candidate, error, sizeof(error)) || + !edit_layout(&candidate, &prefix)) { + char message[240]; + snprintf(message, sizeof(message), "Definition rejected: %s; draft preserved", + error[0] ? error : "document edit/read contract required"); + definition_status(e, message); + g_free(draft); + return; + } + char *on_disk = NULL; + gsize on_disk_size = 0; + GError *file_error = NULL; + bool read = g_file_get_contents(e->program_path, &on_disk, &on_disk_size, &file_error); + bool same = read && on_disk_size == e->definition_baseline_size && + !memcmp(on_disk, e->definition_baseline, on_disk_size); + g_free(on_disk); + if (file_error) g_error_free(file_error); + if (!same) { + definition_status(e, "Definition changed on disk; draft preserved. Reload or resolve it first"); + g_free(draft); + return; + } + if (e->runtime.active || e->runtime.running) { + definition_status(e, "A document operation is active; definition draft preserved"); + g_free(draft); + return; + } + if (changed && !g_file_set_contents_full(e->program_path, draft, (gssize)length, + G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_DURABLE, 0600, &file_error)) { + char message[240]; + snprintf(message, sizeof(message), "Could not save definition: %s; draft preserved", + file_error ? file_error->message : "unknown error"); + definition_status(e, message); + if (file_error) g_error_free(file_error); + g_free(draft); + return; + } + PureProgram previous = e->program; + size_t previous_prefix = e->prefix; + e->program = candidate; + e->prefix = prefix; + if (!pure_runtime_restart(&e->runtime, &e->program, + pure_store_host(e->directory), 4u * 1024u * 1024u)) { + e->program = previous; + e->prefix = previous_prefix; + bool restored = !changed || g_file_set_contents_full(e->program_path, e->definition_baseline, + (gssize)e->definition_baseline_size, + G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_DURABLE, 0600, NULL); + definition_status(e, restored ? "Could not install definition; previous source restored" : + "Definition installation failed; inspect source file before retrying"); + g_free(draft); + return; + } + g_free(e->definition_baseline); + e->definition_baseline = draft; + e->definition_baseline_size = length; + gtk_text_buffer_set_modified(buffer, FALSE); + e->definition_needs_apply = false; + ++e->definition_generation; + e->has_edit_output = false; + definition_title(e); + definition_status(e, "Applied locally & saved; other hosts load it after restart"); +} + +static void apply_definition_clicked(GtkButton *button, gpointer data) { + (void)button; + apply_definition(data); +} + +static void reload_definition(Editor *e) { + char *source = NULL; + gsize length = 0; + GError *error = NULL; + if (!g_file_get_contents(e->program_path, &source, &length, &error) || + length > PURE_PROGRAM_LIMIT || memchr(source, 0, length) || + !g_utf8_validate(source, (gssize)length, NULL)) { + definition_status(e, "Could not load a UTF-8 definition within 16 KiB; draft preserved"); + if (error) g_error_free(error); + g_free(source); + return; + } + g_free(e->definition_baseline); + e->definition_baseline = source; + e->definition_baseline_size = length; + GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->source)); + gtk_text_buffer_set_text(buffer, source, (int)length); + gtk_text_buffer_set_modified(buffer, FALSE); + e->definition_needs_apply = true; + definition_status(e, "Definition reloaded from disk; Apply to run it"); +} + +static void reload_definition_clicked(GtkButton *button, gpointer data) { + (void)button; + Editor *e = data; + if (gtk_text_buffer_get_modified(gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->source)))) { + definition_status(e, "Definition draft has changes; use Discard & reload"); + return; + } + reload_definition(e); +} + +static void discard_definition_clicked(GtkButton *button, gpointer data) { + (void)button; + reload_definition(data); +} + +static void toggle_definition(Editor *e) { + bool shown = gtk_revealer_get_reveal_child(GTK_REVEALER(e->source_revealer)); + gtk_revealer_set_reveal_child(GTK_REVEALER(e->source_revealer), !shown); + gtk_widget_grab_focus(shown ? e->text : e->source); +} + +static void toggle_definition_clicked(GtkButton *button, gpointer data) { + (void)button; + toggle_definition(data); +} + +static PureOutcome finish(Editor *e, PureTicket ticket) { + PureOutcome result; + while (!pure_runtime_result(ticket, &result)) + if (!pure_runtime_step(&e->runtime)) return (PureOutcome){.status = PURE_INVALID}; + return result; +} + +static bool open_document_key(Editor *e, const char *key) { + PureTicket ticket; + PureResult accepted = pure_runtime_accept(&e->runtime, PURE_INPUT_READ, + key, 0, 0, &ticket); + if (accepted != PURE_OK) { status(e, result_name(accepted)); return false; } + PureOutcome result = finish(e, ticket); + char *copy = NULL; + if (result.status == PURE_OK) { + if (result.body.size > G_MAXINT || + (result.body.size && (!result.body.data || + memchr(result.body.data, 0, result.body.size) || + !g_utf8_validate((const char *)result.body.data, result.body.size, NULL)))) { + pure_runtime_release(ticket); + status(e, "Stored bytes are not plain UTF-8 text; use pure-edit for binary data"); + return false; + } + copy = g_malloc(result.body.size + 1); + if (result.body.size) memcpy(copy, result.body.data, result.body.size); + copy[result.body.size] = 0; + } + pure_runtime_release(ticket); + if (result.status != PURE_OK && result.status != PURE_NOT_FOUND) { + status(e, result_name(result.status)); + return false; + } + if (strcmp(key, e->key) != 0) memcpy(e->key, key, strlen(key) + 1); + g_free(e->baseline); + e->baseline = copy ? copy : g_strdup(""); + e->baseline_size = result.status == PURE_OK ? result.body.size : 0; + e->revision = result.status == PURE_OK ? result.revision : 0; + e->exists = result.status == PURE_OK; + GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->text)); + gtk_text_buffer_set_text(buffer, e->baseline, (int)e->baseline_size); + gtk_text_buffer_set_modified(buffer, FALSE); + e->has_edit_output = false; + gtk_label_set_text(GTK_LABEL(e->heading), e->key); + definition_title(e); + char message[128]; + snprintf(message, sizeof(message), "%s · %zu bytes", e->exists ? "Loaded" : "New document", + e->baseline_size); + status(e, message); + return true; +} + +static void open_document(Editor *e) { + (void)open_document_key(e, e->key); +} + +static void open_key(Editor *e) { + GtkTextBuffer *document = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->text)); + GtkTextBuffer *definition = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->source)); + if (gtk_text_buffer_get_modified(document) || gtk_text_buffer_get_modified(definition)) { + status(e, "Save or discard the document and definition drafts before opening another key"); + return; + } + const char *key = gtk_editable_get_text(GTK_EDITABLE(e->key_entry)); + if (!valid_key(key)) { status(e, "Key must be 1–64 ASCII letters, digits, _ or -"); return; } + if (open_document_key(e, key)) gtk_widget_grab_focus(e->text); +} + +static void open_key_clicked(GtkButton *button, gpointer data) { + (void)button; + open_key(data); +} + +static void open_key_activated(GtkEntry *entry, gpointer data) { + (void)entry; + open_key(data); +} + +static void reload_clicked(GtkButton *button, gpointer data) { + (void)button; + Editor *e = data; + if (gtk_text_buffer_get_modified(gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->text)))) { + status(e, "Draft has changes; use Discard & reload to replace it"); + return; + } + open_document(e); +} + +static void discard_clicked(GtkButton *button, gpointer data) { + (void)button; + open_document(data); +} + +static bool continuation(unsigned char c) { return (c & 0xc0u) == 0x80u; } + +/* Find the smallest changed byte interval with valid UTF-8 boundaries. The + * storage effect still sees bytes; this only keeps the UI's edit interval + * meaningful when two code points happen to share leading/trailing bytes. */ +static void change_span(const char *old, size_t old_size, const char *draft, size_t draft_size, + size_t *start, size_t *remove, size_t *insert) { + size_t prefix = 0; + while (prefix < old_size && prefix < draft_size && old[prefix] == draft[prefix]) ++prefix; + while (prefix && prefix < old_size && continuation((unsigned char)old[prefix])) --prefix; + size_t suffix = 0; + while (suffix < old_size - prefix && suffix < draft_size - prefix && + old[old_size - suffix - 1] == draft[draft_size - suffix - 1]) ++suffix; + while (suffix && (continuation((unsigned char)old[old_size - suffix]) || + continuation((unsigned char)draft[draft_size - suffix]))) --suffix; + *start = prefix; + *remove = old_size - prefix - suffix; + *insert = draft_size - prefix - suffix; +} + +static void save_document(Editor *e) { + GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->text)); + GtkTextIter first, last; + gtk_text_buffer_get_bounds(buffer, &first, &last); + char *draft = gtk_text_buffer_get_text(buffer, &first, &last, FALSE); + size_t draft_size = strlen(draft); + size_t offset, remove, insert; + change_span(e->baseline, e->baseline_size, draft, draft_size, &offset, &remove, &insert); + if (e->exists && !remove && !insert) { + gtk_text_buffer_set_modified(buffer, FALSE); + status(e, "No changes to save"); + g_free(draft); + return; + } + if (draft_size > PURE_OBJECT_LIMIT || offset > UINT32_MAX || remove > UINT32_MAX || + insert > PURE_OBJECT_LIMIT - e->prefix) { + status(e, "Document or edit exceeds the selected byte limit"); + g_free(draft); + return; + } + PureTicket ticket; + PureResult accepted = pure_runtime_accept(&e->runtime, PURE_INPUT_WRITE, e->key, + e->revision, e->prefix + insert, &ticket); + if (accepted != PURE_OK) { + status(e, result_name(accepted)); + g_free(draft); + return; + } + unsigned char *input = pure_runtime_ingress(ticket, NULL); + memset(input, 0, e->prefix); + put32(input + e->program.splice_offset.value, (uint32_t)offset); + put32(input + e->program.splice_remove.value, (uint32_t)remove); + if (insert) memcpy(input + e->prefix, draft + offset, insert); + if (!pure_runtime_ready(ticket)) { + pure_runtime_release(ticket); + status(e, "Could not publish edit"); + g_free(draft); + return; + } + PureOutcome result = finish(e, ticket); + size_t reply_size = result.body.size; + pure_runtime_release(ticket); + if (result.status != PURE_OK) { + char message[160]; + if (result.status == PURE_CONFLICT) + snprintf(message, sizeof(message), "Version conflict: stored revision %" PRId64 + "; draft preserved", result.revision); + else snprintf(message, sizeof(message), "%s; draft preserved", result_name(result.status)); + status(e, message); + g_free(draft); + return; + } + g_free(e->baseline); + e->baseline = draft; + e->baseline_size = draft_size; + e->revision = result.revision; + e->exists = true; + e->last_output_bytes = reply_size; + e->has_edit_output = true; + definition_title(e); + gtk_text_buffer_set_modified(buffer, FALSE); + char message[128]; + snprintf(message, sizeof(message), "Saved %zu-byte edit at byte %zu · output %zu bytes", + insert, offset, reply_size); + status(e, message); +} + +static void save_clicked(GtkButton *button, gpointer data) { + (void)button; + save_document(data); +} + +static gboolean key_pressed(GtkEventControllerKey *controller, guint keyval, guint keycode, + GdkModifierType modifiers, gpointer data) { + (void)controller; (void)keycode; + Editor *e = data; + if ((modifiers & GDK_CONTROL_MASK) && (modifiers & GDK_SHIFT_MASK) && + (keyval == GDK_KEY_d || keyval == GDK_KEY_D)) { + toggle_definition(e); + return TRUE; + } + if ((modifiers & GDK_CONTROL_MASK) && + (keyval == GDK_KEY_o || keyval == GDK_KEY_O)) { + gtk_widget_grab_focus(e->key_entry); + return TRUE; + } + if ((modifiers & GDK_CONTROL_MASK) && + (keyval == GDK_KEY_s || keyval == GDK_KEY_S)) { + if ((modifiers & GDK_SHIFT_MASK) || + gtk_window_get_focus(GTK_WINDOW(e->window)) == e->source) + apply_definition(e); + else save_document(e); + return TRUE; + } + if ((modifiers & GDK_CONTROL_MASK) && + (keyval == GDK_KEY_w || keyval == GDK_KEY_W)) { + gtk_window_close(GTK_WINDOW(e->window)); + return TRUE; + } + return FALSE; +} + +static void close_decision(GObject *source, GAsyncResult *response, gpointer data) { + Editor *e = data; + GError *error = NULL; + int selected = gtk_alert_dialog_choose_finish(GTK_ALERT_DIALOG(source), response, &error); + if (error) g_error_free(error); + e->asking_to_close = false; + if (selected == 1) { + e->closing = true; + gtk_window_destroy(GTK_WINDOW(e->window)); + } +} + +static gboolean close_requested(GtkWindow *window, gpointer data) { + Editor *e = data; + bool document_changed = gtk_text_buffer_get_modified(gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->text))); + bool definition_changed = gtk_text_buffer_get_modified(gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->source))); + if (e->closing || (!document_changed && !definition_changed)) + return FALSE; + if (e->asking_to_close) return TRUE; + e->asking_to_close = true; + GtkAlertDialog *dialog = gtk_alert_dialog_new("Discard unsaved document or definition changes?"); + gtk_alert_dialog_set_detail(dialog, "The current draft has not been saved or applied."); + const char *buttons[] = {"Keep editing", "Discard changes", NULL}; + gtk_alert_dialog_set_buttons(dialog, buttons); + gtk_alert_dialog_set_cancel_button(dialog, 0); + gtk_alert_dialog_set_default_button(dialog, 0); + gtk_alert_dialog_choose(dialog, window, NULL, close_decision, e); + g_object_unref(dialog); + return TRUE; +} + +static void activate(GtkApplication *application, gpointer data) { + Editor *e = data; + if (e->window) { gtk_window_present(GTK_WINDOW(e->window)); return; } + e->window = gtk_application_window_new(application); + g_signal_connect(e->window, "close-request", G_CALLBACK(close_requested), e); + gtk_window_set_default_size(GTK_WINDOW(e->window), 960, 680); + definition_title(e); + GtkWidget *column = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); + gtk_window_set_child(GTK_WINDOW(e->window), column); + GtkWidget *bar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10); + gtk_widget_set_margin_start(bar, 14); + gtk_widget_set_margin_end(bar, 14); + gtk_widget_set_margin_top(bar, 12); + gtk_widget_set_margin_bottom(bar, 12); + gtk_box_append(GTK_BOX(column), bar); + e->heading = gtk_label_new(e->key); + gtk_widget_add_css_class(e->heading, "title-3"); + gtk_box_append(GTK_BOX(bar), e->heading); + e->version = gtk_label_new(""); + gtk_widget_add_css_class(e->version, "dim-label"); + gtk_box_append(GTK_BOX(bar), e->version); + GtkWidget *spacer = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); + gtk_widget_set_hexpand(spacer, TRUE); + gtk_box_append(GTK_BOX(bar), spacer); + GtkWidget *definition = gtk_button_new_with_label("Definition · Ctrl+Shift+D"); + g_signal_connect(definition, "clicked", G_CALLBACK(toggle_definition_clicked), e); + gtk_box_append(GTK_BOX(bar), definition); + GtkWidget *reload = gtk_button_new_with_label("Reload"); + g_signal_connect(reload, "clicked", G_CALLBACK(reload_clicked), e); + gtk_box_append(GTK_BOX(bar), reload); + GtkWidget *discard = gtk_button_new_with_label("Discard & reload"); + g_signal_connect(discard, "clicked", G_CALLBACK(discard_clicked), e); + gtk_box_append(GTK_BOX(bar), discard); + GtkWidget *save = gtk_button_new_with_label("Save · Ctrl+S"); + gtk_widget_add_css_class(save, "suggested-action"); + g_signal_connect(save, "clicked", G_CALLBACK(save_clicked), e); + gtk_box_append(GTK_BOX(bar), save); + GtkWidget *scroll = gtk_scrolled_window_new(); + gtk_widget_set_vexpand(scroll, TRUE); + gtk_box_append(GTK_BOX(column), scroll); + e->text = gtk_text_view_new(); + gtk_accessible_update_property(GTK_ACCESSIBLE(e->text), + GTK_ACCESSIBLE_PROPERTY_LABEL, "Document text", -1); + gtk_text_view_set_monospace(GTK_TEXT_VIEW(e->text), TRUE); + gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(e->text), GTK_WRAP_WORD_CHAR); + gtk_widget_set_margin_start(e->text, 18); + gtk_widget_set_margin_end(e->text, 18); + gtk_widget_set_margin_top(e->text, 12); + gtk_widget_set_margin_bottom(e->text, 12); + gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(scroll), e->text); + e->source_revealer = gtk_revealer_new(); + gtk_box_append(GTK_BOX(column), e->source_revealer); + GtkWidget *source_panel = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8); + gtk_widget_set_margin_start(source_panel, 14); + gtk_widget_set_margin_end(source_panel, 14); + gtk_widget_set_margin_bottom(source_panel, 8); + gtk_revealer_set_child(GTK_REVEALER(e->source_revealer), source_panel); + GtkWidget *source_bar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8); + gtk_box_append(GTK_BOX(source_panel), source_bar); + GtkWidget *source_heading = gtk_label_new("Application definition · editor.pure"); + gtk_widget_add_css_class(source_heading, "title-4"); + gtk_box_append(GTK_BOX(source_bar), source_heading); + GtkWidget *source_spacer = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); + gtk_widget_set_hexpand(source_spacer, TRUE); + gtk_box_append(GTK_BOX(source_bar), source_spacer); + GtkWidget *source_reload = gtk_button_new_with_label("Reload definition"); + g_signal_connect(source_reload, "clicked", G_CALLBACK(reload_definition_clicked), e); + gtk_box_append(GTK_BOX(source_bar), source_reload); + GtkWidget *source_discard = gtk_button_new_with_label("Discard & reload"); + g_signal_connect(source_discard, "clicked", G_CALLBACK(discard_definition_clicked), e); + gtk_box_append(GTK_BOX(source_bar), source_discard); + GtkWidget *source_apply = gtk_button_new_with_label("Apply & save · Ctrl+S"); + gtk_widget_add_css_class(source_apply, "suggested-action"); + g_signal_connect(source_apply, "clicked", G_CALLBACK(apply_definition_clicked), e); + gtk_box_append(GTK_BOX(source_bar), source_apply); + GtkWidget *source_scroll = gtk_scrolled_window_new(); + gtk_widget_set_size_request(source_scroll, -1, 260); + gtk_box_append(GTK_BOX(source_panel), source_scroll); + e->source = gtk_text_view_new(); + gtk_accessible_update_property(GTK_ACCESSIBLE(e->source), + GTK_ACCESSIBLE_PROPERTY_LABEL, "Application definition source", -1); + gtk_text_view_set_monospace(GTK_TEXT_VIEW(e->source), TRUE); + gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(source_scroll), e->source); + GtkTextBuffer *source_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->source)); + gtk_text_buffer_set_text(source_buffer, e->definition_baseline, + (int)e->definition_baseline_size); + gtk_text_buffer_set_modified(source_buffer, FALSE); + e->source_status = gtk_label_new("Definition is active; edit and apply to change it"); + gtk_label_set_xalign(GTK_LABEL(e->source_status), 0); + gtk_box_append(GTK_BOX(source_panel), e->source_status); + GtkWidget *footer = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8); + gtk_widget_set_margin_start(footer, 14); + gtk_widget_set_margin_end(footer, 14); + gtk_widget_set_margin_top(footer, 9); + gtk_widget_set_margin_bottom(footer, 11); + gtk_box_append(GTK_BOX(column), footer); + e->status = gtk_label_new(""); + gtk_label_set_xalign(GTK_LABEL(e->status), 0); + gtk_widget_set_hexpand(e->status, TRUE); + gtk_box_append(GTK_BOX(footer), e->status); + e->key_entry = gtk_entry_new(); + gtk_entry_set_max_length(GTK_ENTRY(e->key_entry), 64); + gtk_editable_set_text(GTK_EDITABLE(e->key_entry), e->key); + gtk_entry_set_placeholder_text(GTK_ENTRY(e->key_entry), "Document key"); + gtk_editable_set_width_chars(GTK_EDITABLE(e->key_entry), 15); + gtk_accessible_update_property(GTK_ACCESSIBLE(e->key_entry), + GTK_ACCESSIBLE_PROPERTY_LABEL, "Document key", -1); + g_signal_connect(e->key_entry, "activate", G_CALLBACK(open_key_activated), e); + gtk_box_append(GTK_BOX(footer), e->key_entry); + GtkWidget *open = gtk_button_new_with_label("Open · Ctrl+O"); + g_signal_connect(open, "clicked", G_CALLBACK(open_key_clicked), e); + gtk_box_append(GTK_BOX(footer), open); + GtkEventController *keys = gtk_event_controller_key_new(); + g_signal_connect(keys, "key-pressed", G_CALLBACK(key_pressed), e); + gtk_widget_add_controller(e->window, keys); + open_document(e); + gtk_window_present(GTK_WINDOW(e->window)); +} + +int main(int argc, char **argv) { + if (argc != 6 || strcmp(argv[1], "--program") || strcmp(argv[3], "--store") || + !valid_key(argv[5])) { + fputs("pure-edit-window --program FILE --store DIRECTORY KEY\n", stderr); + return 2; + } + Editor e = {.directory = argv[4], .program_path = argv[2], .definition_generation = 1}; + memcpy(e.key, argv[5], strlen(argv[5]) + 1); + char error[160] = {0}; + gsize source_size = 0; + GError *source_error = NULL; + if (!g_file_get_contents(e.program_path, &e.definition_baseline, &source_size, &source_error) || + source_size > PURE_PROGRAM_LIMIT || + memchr(e.definition_baseline, 0, source_size) || + !g_utf8_validate(e.definition_baseline, (gssize)source_size, NULL) || + !pure_program_parse(e.definition_baseline, source_size, &e.program, error, sizeof(error)) || + !edit_layout(&e.program, &e.prefix)) { + fprintf(stderr, "Program must define the simple splice edit layout: %s\n", + error[0] ? error : source_error ? source_error->message : "unsupported layout"); + if (source_error) g_error_free(source_error); + g_free(e.definition_baseline); + return 2; + } + e.definition_baseline_size = source_size; + if (pure_store_init(e.directory) != PURE_OK || + !pure_runtime_init(&e.runtime, e.work, 1, &e.program, + pure_store_host(e.directory), 4u * 1024u * 1024u)) { + fputs("Cannot initialize document store or execution domain\n", stderr); + return 2; + } + e.baseline = g_strdup(""); + GtkApplication *application = gtk_application_new("org.pure.DocumentEditor", G_APPLICATION_NON_UNIQUE); + g_signal_connect(application, "activate", G_CALLBACK(activate), &e); + char *app_argv[] = {argv[0], NULL}; + int result = g_application_run(G_APPLICATION(application), 1, app_argv); + g_object_unref(application); + g_free(e.baseline); + g_free(e.definition_baseline); + return result; +} |