bare-gtk 0.2.0 → 0.3.0

package/lib/adjustment.h

@@ -0,0 +1,112 @@
+#ifndef BARE_GTK_ADJUSTMENT_H
+#define BARE_GTK_ADJUSTMENT_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+enum {
+  bare_gtk_adjustment_event_value_changed = 1 << 0,
+};
+
+static void
+bare_gtk_adjustment__on_value_changed(GtkAdjustment *adjustment, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, adjustment) & bare_gtk_adjustment_event_value_changed) == 0) return;
+
+  bare_gtk__emit(state, adjustment, "value-changed", 1, (const double[]) {gtk_adjustment_get_value(adjustment)});
+}
+
+static js_value_t *
+bare_gtk_adjustment_event_mask(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 2);
+
+  GtkAdjustment *adjustment;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "adjustment", (gpointer *) &adjustment);
+  if (err < 0) return NULL;
+
+  uint32_t events;
+  err = bare_gtk__read_uint32(env, argv[1], "events", &events);
+  if (err < 0) return NULL;
+
+  // Connected once and left connected. The mask decides whether anything is
+  // sent.
+  if (bare_gtk__observe(state, adjustment, events)) {
+    g_signal_connect(adjustment, "value-changed", G_CALLBACK(bare_gtk_adjustment__on_value_changed), state);
+  }
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_adjustment_value(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1 || argc == 2);
+
+  GtkAdjustment *adjustment;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "adjustment", (gpointer *) &adjustment);
+  if (err < 0) return NULL;
+
+  if (argc == 1) {
+    js_value_t *result;
+    err = js_create_double(env, gtk_adjustment_get_value(adjustment), &result);
+    assert(err == 0);
+
+    return result;
+  }
+
+  double value;
+  err = js_get_value_double(env, argv[1], &value);
+  assert(err == 0);
+
+  gtk_adjustment_set_value(adjustment, value);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_adjustment_upper(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  GtkAdjustment *adjustment;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "adjustment", (gpointer *) &adjustment);
+  if (err < 0) return NULL;
+
+  js_value_t *result;
+  err = js_create_double(env, gtk_adjustment_get_upper(adjustment), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+#endif // BARE_GTK_ADJUSTMENT_H

package/lib/adjustment.js

@@ -0,0 +1,24 @@
+const binding = require('../binding')
+const GObject = require('./object')
+
+module.exports = exports = class GTKAdjustment extends GObject {
+  static _events = {
+    'value-changed': binding.ADJUSTMENT_EVENT_VALUE_CHANGED
+  }
+
+  _eventMask(mask) {
+    binding.adjustmentEventMask(this._tag, mask)
+  }
+
+  get value() {
+    return binding.adjustmentValue(this._tag)
+  }
+
+  set value(value) {
+    binding.adjustmentValue(this._tag, value)
+  }
+
+  get upper() {
+    return binding.adjustmentUpper(this._tag)
+  }
+}

package/lib/bridging.h

@@ -0,0 +1,347 @@
+#ifndef BARE_GTK_BRIDGING_H
+#define BARE_GTK_BRIDGING_H
+
+#include <assert.h>
+#include <glib.h>
+#include <js.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <utf.h>
+
+#include <gtk/gtk.h>
+
+#include "registry.h"
+
+// What the addon keeps between calls. It belongs to one instantiation, because
+// an addon can be loaded more than once in a process. Bindings reach it through
+// their data pointer, and signal handlers through the object they are connected
+// to.
+typedef struct {
+  bare_gobject_registry_t *registry;
+  js_env_t *env;
+
+  GHashTable *events;
+
+  // A label that is never shown, used to measure text in the font a real label
+  // draws with. A standalone Pango context would pick a different font. A theme
+  // may pad a label, so its inset is measured too.
+  GtkWidget *text_probe;
+  int text_inset_width;
+  int text_inset_height;
+} bare_gtk_state_t;
+
+static void
+bare_gtk__on_observed_gone(gpointer data, GObject *object);
+
+static void
+bare_gtk__on_state_release(js_env_t *env, void *data, void *finalize_hint) {
+  bare_gtk_state_t *state = data;
+
+  GHashTableIter iter;
+  gpointer object;
+
+  g_hash_table_iter_init(&iter, state->events);
+
+  while (g_hash_table_iter_next(&iter, &object, NULL)) {
+    g_object_weak_unref(G_OBJECT(object), bare_gtk__on_observed_gone, state);
+  }
+
+  g_hash_table_destroy(state->events);
+
+  if (state->text_probe) g_object_unref(state->text_probe);
+
+  bare_gobject_registry_release(state->registry);
+
+  g_free(state);
+}
+
+static bare_gtk_state_t *
+bare_gtk_state_create(js_env_t *env, js_value_t *exports) {
+  int err;
+
+  bare_gtk_state_t *state = g_new0(bare_gtk_state_t, 1);
+
+  state->registry = bare_gobject_registry_create(env, exports);
+  state->env = env;
+
+  state->events = g_hash_table_new(NULL, NULL);
+
+  err = js_add_finalizer(env, exports, state, bare_gtk__on_state_release, NULL, NULL);
+  assert(err == 0);
+
+  return state;
+}
+
+static int
+bare_gtk__read_bool(js_env_t *env, js_value_t *value, const char *name, bool *result) {
+  int err;
+
+  bool is;
+  err = js_is_boolean(env, value, &is);
+  assert(err == 0);
+
+  if (!is) {
+    err = js_throw_type_errorf(env, NULL, "Expected '%s' to be a boolean", name);
+    assert(err == 0);
+
+    return -1;
+  }
+
+  err = js_get_value_bool(env, value, result);
+  assert(err == 0);
+
+  return 0;
+}
+
+static int
+bare_gtk__read_number(js_env_t *env, js_value_t *value, const char *name) {
+  int err;
+
+  bool is;
+  err = js_is_number(env, value, &is);
+  assert(err == 0);
+
+  if (!is) {
+    err = js_throw_type_errorf(env, NULL, "Expected '%s' to be a number", name);
+    assert(err == 0);
+
+    return -1;
+  }
+
+  return 0;
+}
+
+static int
+bare_gtk__read_int32(js_env_t *env, js_value_t *value, const char *name, int32_t *result) {
+  int err;
+
+  err = bare_gtk__read_number(env, value, name);
+  if (err < 0) return err;
+
+  err = js_get_value_int32(env, value, result);
+  assert(err == 0);
+
+  return 0;
+}
+
+static int
+bare_gtk__read_uint32(js_env_t *env, js_value_t *value, const char *name, uint32_t *result) {
+  int err;
+
+  err = bare_gtk__read_number(env, value, name);
+  if (err < 0) return err;
+
+  err = js_get_value_uint32(env, value, result);
+  assert(err == 0);
+
+  return 0;
+}
+
+static int
+bare_gtk__read_double(js_env_t *env, js_value_t *value, const char *name, double *result) {
+  int err;
+
+  err = bare_gtk__read_number(env, value, name);
+  if (err < 0) return err;
+
+  err = js_get_value_double(env, value, result);
+  assert(err == 0);
+
+  return 0;
+}
+
+static int
+bare_gtk__read_string(js_env_t *env, js_value_t *value, const char *name, char **result) {
+  int err;
+
+  bool is;
+  err = js_is_string(env, value, &is);
+  assert(err == 0);
+
+  if (!is) {
+    err = js_throw_type_errorf(env, NULL, "Expected '%s' to be a string", name);
+    assert(err == 0);
+
+    return -1;
+  }
+
+  size_t len;
+  err = js_get_value_string_utf8(env, value, NULL, 0, &len);
+  assert(err == 0);
+
+  char *str = g_malloc(len + 1);
+
+  err = js_get_value_string_utf8(env, value, (utf8_t *) str, len + 1, NULL);
+  assert(err == 0);
+
+  *result = str;
+
+  return 0;
+}
+
+static int
+bare_gtk__read_string_or_null(js_env_t *env, js_value_t *value, const char *name, char **result) {
+  int err;
+
+  bool is;
+  err = js_is_null(env, value, &is);
+  assert(err == 0);
+
+  if (is) {
+    *result = NULL;
+
+    return 0;
+  }
+
+  return bare_gtk__read_string(env, value, name, result);
+}
+
+// A GTK call that fails sets a `GError`. Here that becomes a thrown error.
+static int
+bare_gtk__throw(js_env_t *env, GError *error) {
+  int err = js_throw_error(env, NULL, error->message);
+  assert(err == 0);
+
+  g_error_free(error);
+
+  return -1;
+}
+
+static int
+bare_gtk__read_tag_or_null(js_env_t *env, bare_gobject_registry_t *registry, js_value_t *value, const char *name, gpointer *result) {
+  int err;
+
+  bool is;
+  err = js_is_null(env, value, &is);
+  assert(err == 0);
+
+  if (is) {
+    *result = NULL;
+
+    return 0;
+  }
+
+  return bare_gobject_read_tag(env, registry, value, name, result);
+}
+
+static js_value_t *
+bare_gtk__create_tag(js_env_t *env, bare_gtk_state_t *state, gpointer object) {
+  int err;
+
+  js_value_t *result;
+
+  if (object) {
+    err = js_create_uint32(env, bare_gobject_tag(state->registry, object), &result);
+  } else {
+    err = js_get_null(env, &result);
+  }
+
+  assert(err == 0);
+
+  return result;
+}
+
+// Each instantiation keeps its own event mask for an object, because objects
+// such as `GtkSettings` are shared by the whole process. The weak reference
+// removes the entry when the object goes away.
+static void
+bare_gtk__on_observed_gone(gpointer data, GObject *object) {
+  bare_gtk_state_t *state = data;
+
+  g_hash_table_remove(state->events, object);
+}
+
+static uint32_t
+bare_gtk__observed(bare_gtk_state_t *state, gpointer object) {
+  return GPOINTER_TO_UINT(g_hash_table_lookup(state->events, object));
+}
+
+// Returns true the first time this state sees the object, which is when it
+// still has to connect its signals.
+static bool
+bare_gtk__observe(bare_gtk_state_t *state, gpointer object, uint32_t events) {
+  if (!g_hash_table_insert(state->events, object, GUINT_TO_POINTER(events))) return false;
+
+  g_object_weak_ref(G_OBJECT(object), bare_gtk__on_observed_gone, state);
+
+  return true;
+}
+
+// Emit an edit before it happens, as the range it replaces and the new text.
+static void
+bare_gtk__emit_replacement(bare_gtk_state_t *state, gpointer object, const char *event, const char *text, int start, int end) {
+  int err;
+
+  js_env_t *env = state->env;
+
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
+
+  js_value_t *wrapper = bare_gobject_lookup(env, state->registry, object);
+
+  if (wrapper) {
+    js_value_t *emit;
+    err = js_get_named_property(env, wrapper, "emit", &emit);
+    assert(err == 0);
+
+    js_value_t *argv[4];
+
+    err = js_create_string_utf8(env, (const utf8_t *) event, (size_t) -1, &argv[0]);
+    assert(err == 0);
+
+    err = js_create_string_utf8(env, (const utf8_t *) (text == NULL ? "" : text), (size_t) -1, &argv[1]);
+    assert(err == 0);
+
+    err = js_create_int32(env, start, &argv[2]);
+    assert(err == 0);
+
+    err = js_create_int32(env, end, &argv[3]);
+    assert(err == 0);
+
+    err = js_call_function(env, wrapper, emit, 4, argv, NULL);
+    assert(err == 0 || err == js_pending_exception);
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
+}
+
+static void
+bare_gtk__emit(bare_gtk_state_t *state, gpointer object, const char *event, size_t argc, const double args[]) {
+  int err;
+
+  js_env_t *env = state->env;
+
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
+
+  js_value_t *wrapper = bare_gobject_lookup(env, state->registry, object);
+
+  if (wrapper) {
+    js_value_t *emit;
+    err = js_get_named_property(env, wrapper, "emit", &emit);
+    assert(err == 0);
+
+    js_value_t *argv[8];
+
+    assert(argc + 1 <= 8);
+
+    err = js_create_string_utf8(env, (const utf8_t *) event, (size_t) -1, &argv[0]);
+    assert(err == 0);
+
+    for (size_t i = 0; i < argc; i++) {
+      err = js_create_double(env, args[i], &argv[i + 1]);
+      assert(err == 0);
+    }
+
+    err = js_call_function(env, wrapper, emit, argc + 1, argv, NULL);
+    assert(err == 0 || err == js_pending_exception);
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
+}
+
+#endif // BARE_GTK_BRIDGING_H

package/lib/clipboard.d.ts

@@ -0,0 +1,22 @@
+import GObject = require('./object')
+
+/** A clipboard, as a `GdkClipboard`. Get one from a `GDKDisplay`. */
+interface GDKClipboard extends GObject {
+  /**
+   * Read the text on the clipboard. `callback` is called with an error message, or with `null`
+   * and the text, which is `null` if there is none.
+   */
+  readTextAsync(callback: (error: string | null, text: string | null) => void): void
+
+  /** Put `text` on the clipboard. */
+  setText(text: string): this
+
+  /** The mime types of what the clipboard holds. */
+  readonly formats: string[]
+}
+
+declare class GDKClipboard {
+  protected constructor()
+}
+
+export = GDKClipboard

package/lib/clipboard.h

@@ -0,0 +1,176 @@
+#ifndef BARE_GTK_CLIPBOARD_H
+#define BARE_GTK_CLIPBOARD_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+// GDK reads a clipboard through a callback, so the caller passes one in.
+typedef struct {
+  bare_gtk_state_t *state;
+  js_ref_t *callback;
+} bare_gtk_clipboard_read_t;
+
+static void
+bare_gtk_clipboard__on_read_text(GObject *source, GAsyncResult *result, gpointer data) {
+  int err;
+
+  bare_gtk_clipboard_read_t *read = data;
+
+  js_env_t *env = read->state->env;
+
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
+
+  js_value_t *callback;
+  err = js_get_reference_value(env, read->callback, &callback);
+  assert(err == 0);
+
+  GError *error = NULL;
+
+  char *text = gdk_clipboard_read_text_finish(GDK_CLIPBOARD(source), result, &error);
+
+  js_value_t *argv[2];
+
+  if (error == NULL) {
+    err = js_get_null(env, &argv[0]);
+    assert(err == 0);
+
+    if (text == NULL) {
+      err = js_get_null(env, &argv[1]);
+    } else {
+      err = js_create_string_utf8(env, (const utf8_t *) text, (size_t) -1, &argv[1]);
+    }
+
+    assert(err == 0);
+  } else {
+    err = js_create_string_utf8(env, (const utf8_t *) error->message, (size_t) -1, &argv[0]);
+    assert(err == 0);
+
+    err = js_get_null(env, &argv[1]);
+    assert(err == 0);
+
+    g_error_free(error);
+  }
+
+  g_free(text);
+
+  js_value_t *receiver;
+  err = js_get_null(env, &receiver);
+  assert(err == 0);
+
+  err = js_call_function(env, receiver, callback, 2, argv, NULL);
+  (void) err;
+
+  err = js_delete_reference(env, read->callback);
+  assert(err == 0);
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
+
+  free(read);
+}
+
+static js_value_t *
+bare_gtk_clipboard_read_text_async(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 2);
+
+  GdkClipboard *clipboard;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "clipboard", (gpointer *) &clipboard);
+  if (err < 0) return NULL;
+
+  bare_gtk_clipboard_read_t *read = malloc(sizeof(bare_gtk_clipboard_read_t));
+
+  read->state = state;
+
+  err = js_create_reference(env, argv[1], 1, &read->callback);
+  assert(err == 0);
+
+  gdk_clipboard_read_text_async(clipboard, NULL, bare_gtk_clipboard__on_read_text, read);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_clipboard_set_text(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 2);
+
+  GdkClipboard *clipboard;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "clipboard", (gpointer *) &clipboard);
+  if (err < 0) return NULL;
+
+  char *text;
+  err = bare_gtk__read_string(env, argv[1], "text", &text);
+  if (err < 0) return NULL;
+
+  gdk_clipboard_set_text(clipboard, text);
+
+  free(text);
+
+  return NULL;
+}
+
+// A `GdkContentFormats` is not a `GObject`, so it crosses as the list of mime
+// types it holds.
+static js_value_t *
+bare_gtk_clipboard_formats(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  GdkClipboard *clipboard;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "clipboard", (gpointer *) &clipboard);
+  if (err < 0) return NULL;
+
+  GdkContentFormats *formats = gdk_clipboard_get_formats(clipboard);
+
+  gsize len = 0;
+
+  const char *const *mime_types = gdk_content_formats_get_mime_types(formats, &len);
+
+  js_value_t *result;
+  err = js_create_array_with_length(env, len, &result);
+  assert(err == 0);
+
+  for (gsize i = 0; i < len; i++) {
+    js_value_t *value;
+    err = js_create_string_utf8(env, (const utf8_t *) mime_types[i], (size_t) -1, &value);
+    assert(err == 0);
+
+    err = js_set_element(env, result, i, value);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+#endif // BARE_GTK_CLIPBOARD_H

package/lib/clipboard.js

@@ -0,0 +1,18 @@
+const binding = require('../binding')
+const GObject = require('./object')
+
+module.exports = exports = class GDKClipboard extends GObject {
+  readTextAsync(callback) {
+    binding.clipboardReadTextAsync(this._tag, callback)
+  }
+
+  setText(text) {
+    binding.clipboardSetText(this._tag, text)
+
+    return this
+  }
+
+  get formats() {
+    return binding.clipboardFormats(this._tag)
+  }
+}