bare-gtk 0.2.1 → 0.3.0

package/lib/style-context.h

@@ -0,0 +1,67 @@
+#ifndef BARE_GTK_STYLE_CONTEXT_H
+#define BARE_GTK_STYLE_CONTEXT_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_style_context_add_provider_for_display(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 3);
+
+  GdkDisplay *display;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "display", (gpointer *) &display);
+  if (err < 0) return NULL;
+
+  GtkStyleProvider *provider;
+  err = bare_gobject_read_tag(env, state->registry, argv[1], "provider", (gpointer *) &provider);
+  if (err < 0) return NULL;
+
+  int32_t priority;
+  err = bare_gtk__read_int32(env, argv[2], "priority", &priority);
+  if (err < 0) return NULL;
+
+  gtk_style_context_add_provider_for_display(display, provider, priority);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_style_context_remove_provider_for_display(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);
+
+  GdkDisplay *display;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "display", (gpointer *) &display);
+  if (err < 0) return NULL;
+
+  GtkStyleProvider *provider;
+  err = bare_gobject_read_tag(env, state->registry, argv[1], "provider", (gpointer *) &provider);
+  if (err < 0) return NULL;
+
+  gtk_style_context_remove_provider_for_display(display, provider);
+
+  return NULL;
+}
+
+#endif // BARE_GTK_STYLE_CONTEXT_H

package/lib/style-context.js

@@ -0,0 +1,9 @@
+const binding = require('../binding')
+
+exports.addProviderForDisplay = function addProviderForDisplay(display, provider, priority) {
+  binding.styleContextAddProviderForDisplay(display._tag, provider._tag, priority)
+}
+
+exports.removeProviderForDisplay = function removeProviderForDisplay(display, provider) {
+  binding.styleContextRemoveProviderForDisplay(display._tag, provider._tag)
+}

package/lib/surface.d.ts

@@ -0,0 +1,19 @@
+import GObject = require('./object')
+import GDKDisplay = require('./display')
+
+/** What a window draws on, as a `GdkSurface`. */
+interface GDKSurface extends GObject {
+  readonly width: number
+
+  readonly height: number
+
+  readonly scaleFactor: number
+
+  readonly display: GDKDisplay | null
+}
+
+declare class GDKSurface {
+  protected constructor()
+}
+
+export = GDKSurface

package/lib/surface.h

@@ -0,0 +1,61 @@
+#ifndef BARE_GTK_SURFACE_H
+#define BARE_GTK_SURFACE_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+#define V(name, fn) \
+  static js_value_t * \
+  name(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); \
+\
+    GdkSurface *surface; \
+    err = bare_gobject_read_tag(env, state->registry, argv[0], "surface", (gpointer *) &surface); \
+    if (err < 0) return NULL; \
+\
+    js_value_t *result; \
+    err = js_create_int32(env, fn(surface), &result); \
+    assert(err == 0); \
+\
+    return result; \
+  }
+
+V(bare_gtk_surface_width, gdk_surface_get_width)
+V(bare_gtk_surface_height, gdk_surface_get_height)
+V(bare_gtk_surface_scale_factor, gdk_surface_get_scale_factor)
+#undef V
+
+static js_value_t *
+bare_gtk_surface_display(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);
+
+  GdkSurface *surface;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "surface", (gpointer *) &surface);
+  if (err < 0) return NULL;
+
+  return bare_gtk__create_tag(env, state, gdk_surface_get_display(surface));
+}
+
+#endif // BARE_GTK_SURFACE_H

package/lib/surface.js

@@ -0,0 +1,22 @@
+const binding = require('../binding')
+const wrap = require('./wrap')
+const GObject = require('./object')
+const GDKDisplay = require('./display')
+
+module.exports = exports = class GDKSurface extends GObject {
+  get width() {
+    return binding.surfaceWidth(this._tag)
+  }
+
+  get height() {
+    return binding.surfaceHeight(this._tag)
+  }
+
+  get scaleFactor() {
+    return binding.surfaceScaleFactor(this._tag)
+  }
+
+  get display() {
+    return wrap(GDKDisplay, binding.surfaceDisplay(this._tag))
+  }
+}

package/lib/switch.d.ts

@@ -0,0 +1,19 @@
+import GTKWidget = require('./widget')
+
+/** An on and off switch, as a `GtkSwitch`. */
+interface GTKSwitch extends GTKWidget<GTKSwitch.Events> {
+  active: boolean
+}
+
+declare class GTKSwitch {
+  constructor()
+}
+
+declare namespace GTKSwitch {
+  export interface Events {
+    /** `active` changed, whether the user or the program changed it. */
+    active: []
+  }
+}
+
+export = GTKSwitch

package/lib/switch.h

@@ -0,0 +1,114 @@
+#ifndef BARE_GTK_SWITCH_H
+#define BARE_GTK_SWITCH_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+enum {
+  bare_gtk_switch_event_active = 1 << 0,
+};
+
+// `GtkSwitch` cannot be subclassed, so the handler is kept in the data table of
+// the object and the signal carries the state.
+#define BARE_GTK_SWITCH_ACTIVE "bare.switch.active"
+
+// This fires whoever changed the property, including the program itself. A
+// controlled switch has to tell those apart in the layers above.
+static void
+bare_gtk_switch__on_active(GObject *object, GParamSpec *spec, gpointer data) {
+  bare_gtk__emit(data, object, "active", 0, NULL);
+}
+
+static js_value_t *
+bare_gtk_switch_init(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, NULL, NULL, NULL, (void **) &state);
+  assert(err == 0);
+
+  GtkWidget *handle = gtk_switch_new();
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, handle), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_switch_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);
+
+  GtkSwitch *handle;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "switch", (gpointer *) &handle);
+  if (err < 0) return NULL;
+
+  uint32_t events;
+  err = bare_gtk__read_uint32(env, argv[1], "events", &events);
+  if (err < 0) return NULL;
+
+  gulong id = (gulong) (uintptr_t) g_object_get_data(G_OBJECT(handle), BARE_GTK_SWITCH_ACTIVE);
+
+  if ((events & bare_gtk_switch_event_active) != 0) {
+    if (id == 0) {
+      id = g_signal_connect(handle, "notify::active", G_CALLBACK(bare_gtk_switch__on_active), state);
+
+      g_object_set_data(G_OBJECT(handle), BARE_GTK_SWITCH_ACTIVE, (gpointer) (uintptr_t) id);
+    }
+  } else if (id != 0) {
+    g_signal_handler_disconnect(handle, id);
+
+    g_object_set_data(G_OBJECT(handle), BARE_GTK_SWITCH_ACTIVE, NULL);
+  }
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_switch_active(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);
+
+  GtkSwitch *handle;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "switch", (gpointer *) &handle);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_get_boolean(env, gtk_switch_get_active(handle), &result);
+    assert(err == 0);
+  } else {
+    bool active;
+    err = bare_gtk__read_bool(env, argv[1], "active", &active);
+    if (err < 0) return NULL;
+
+    gtk_switch_set_active(handle, active);
+  }
+
+  return result;
+}
+
+#endif // BARE_GTK_SWITCH_H

package/lib/switch.js

@@ -0,0 +1,30 @@
+const binding = require('../binding')
+const GTKWidget = require('./widget')
+
+module.exports = exports = class GTKSwitch extends GTKWidget {
+  static _events = {
+    active: binding.SWITCH_EVENT_ACTIVE
+  }
+
+  _init() {
+    return binding.switchInit()
+  }
+
+  _eventMask(mask) {
+    binding.switchEventMask(this._tag, mask)
+  }
+
+  get active() {
+    return binding.switchActive(this._tag)
+  }
+
+  set active(value) {
+    binding.switchActive(this._tag, value)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: GTKSwitch }
+    }
+  }
+}

package/lib/text-buffer.d.ts

@@ -0,0 +1,31 @@
+import GObject = require('./object')
+
+/** The text of a `GTKTextView`, as a `GtkTextBuffer`. Positions are character offsets. */
+interface GTKTextBuffer extends GObject<GTKTextBuffer.Events> {
+  text: string
+
+  /** The selected range. With nothing selected, both are at the caret. */
+  readonly selectionBounds: { start: number; end: number }
+
+  /** Select the characters from `start` to `end`. */
+  selectRange(start: number, end: number): this
+}
+
+declare class GTKTextBuffer {
+  protected constructor()
+}
+
+declare namespace GTKTextBuffer {
+  export interface Events {
+    changed: []
+    'cursor-position': []
+
+    /** Text is about to be inserted at `start`. `end` is the same as `start`. */
+    'insert-text': [text: string, start: number, end: number]
+
+    /** The text from `start` to `end` is about to be deleted. `text` is empty. */
+    'delete-range': [text: string, start: number, end: number]
+  }
+}
+
+export = GTKTextBuffer

package/lib/text-buffer.h

@@ -0,0 +1,246 @@
+#ifndef BARE_GTK_TEXT_BUFFER_H
+#define BARE_GTK_TEXT_BUFFER_H
+
+#include <assert.h>
+#include <js.h>
+#include <utf.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+enum {
+  bare_gtk_text_buffer_event_changed = 1 << 0,
+  bare_gtk_text_buffer_event_cursor_position = 1 << 1,
+  bare_gtk_text_buffer_event_insert_text = 1 << 2,
+  bare_gtk_text_buffer_event_delete_range = 1 << 3,
+};
+
+// A text view makes its own buffer, so there is no subclass to keep the mask
+// on. It is kept beside the buffer instead.
+typedef struct {
+  uint32_t events;
+
+  gulong on_changed;
+  gulong on_cursor_position;
+  gulong on_insert_text;
+  gulong on_delete_range;
+} bare_gtk_text_buffer_t;
+
+static void
+bare_gtk_text_buffer__free(gpointer data, GClosure *closure) {
+  g_free(data);
+}
+
+static bare_gtk_text_buffer_t *
+bare_gtk_text_buffer__signals(GtkTextBuffer *buffer) {
+  bare_gtk_text_buffer_t *signals = g_object_get_data(G_OBJECT(buffer), "bare");
+
+  if (signals == NULL) {
+    signals = g_new0(bare_gtk_text_buffer_t, 1);
+
+    g_object_set_data_full(G_OBJECT(buffer), "bare", signals, g_free);
+  }
+
+  return signals;
+}
+
+static void
+bare_gtk_text_buffer__on_changed(GtkTextBuffer *buffer, gpointer data) {
+  bare_gtk__emit(data, buffer, "changed", 0, NULL);
+}
+
+static void
+bare_gtk_text_buffer__on_cursor_position(GObject *object, GParamSpec *spec, gpointer data) {
+  bare_gtk__emit(data, object, "cursor-position", 0, NULL);
+}
+
+static void
+bare_gtk_text_buffer__on_insert_text(GtkTextBuffer *buffer, GtkTextIter *position, const char *text, int length, gpointer data) {
+  int offset = gtk_text_iter_get_offset(position);
+
+  bare_gtk__emit_replacement(data, buffer, "insert-text", text, offset, offset);
+}
+
+static void
+bare_gtk_text_buffer__on_delete_range(GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end, gpointer data) {
+  bare_gtk__emit_replacement(
+    data,
+    buffer,
+    "delete-range",
+    "",
+    gtk_text_iter_get_offset(start),
+    gtk_text_iter_get_offset(end)
+  );
+}
+
+static js_value_t *
+bare_gtk_text_buffer_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);
+
+  GtkTextBuffer *buffer;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "buffer", (gpointer *) &buffer);
+  if (err < 0) return NULL;
+
+  uint32_t events;
+  err = bare_gtk__read_uint32(env, argv[1], "events", &events);
+  if (err < 0) return NULL;
+
+  bare_gtk_text_buffer_t *signals = bare_gtk_text_buffer__signals(buffer);
+
+  uint32_t changed = signals->events ^ events;
+
+  signals->events = events;
+
+#define V(bit, field, signal, callback) \
+  if ((changed & (bit)) != 0) { \
+    if ((events & (bit)) != 0) { \
+      signals->field = g_signal_connect(buffer, signal, G_CALLBACK(callback), state); \
+    } else { \
+      g_signal_handler_disconnect(buffer, signals->field); \
+    } \
+  }
+
+  V(bare_gtk_text_buffer_event_changed, on_changed, "changed", bare_gtk_text_buffer__on_changed)
+  V(bare_gtk_text_buffer_event_cursor_position, on_cursor_position, "notify::cursor-position", bare_gtk_text_buffer__on_cursor_position)
+  V(bare_gtk_text_buffer_event_insert_text, on_insert_text, "insert-text", bare_gtk_text_buffer__on_insert_text)
+  V(bare_gtk_text_buffer_event_delete_range, on_delete_range, "delete-range", bare_gtk_text_buffer__on_delete_range)
+#undef V
+
+  return NULL;
+}
+
+// A `GtkTextIter` has no identity, so it crosses as its offset.
+static js_value_t *
+bare_gtk_text_buffer_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 == 1 || argc == 2);
+
+  GtkTextBuffer *buffer;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "buffer", (gpointer *) &buffer);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    GtkTextIter start;
+    GtkTextIter end;
+
+    gtk_text_buffer_get_bounds(buffer, &start, &end);
+
+    char *text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
+
+    err = js_create_string_utf8(env, (const utf8_t *) text, (size_t) -1, &result);
+    assert(err == 0);
+
+    g_free(text);
+  } else {
+    char *text;
+    err = bare_gtk__read_string(env, argv[1], "text", &text);
+    if (err < 0) return NULL;
+
+    gtk_text_buffer_set_text(buffer, text, -1);
+
+    g_free(text);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_text_buffer_selection_bounds(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);
+
+  GtkTextBuffer *buffer;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "buffer", (gpointer *) &buffer);
+  if (err < 0) return NULL;
+
+  GtkTextIter start;
+  GtkTextIter end;
+
+  gtk_text_buffer_get_selection_bounds(buffer, &start, &end);
+
+  js_value_t *result;
+  err = js_create_object(env, &result);
+  assert(err == 0);
+
+  js_value_t *value;
+
+  err = js_create_int32(env, gtk_text_iter_get_offset(&start), &value);
+  assert(err == 0);
+
+  err = js_set_named_property(env, result, "start", value);
+  assert(err == 0);
+
+  err = js_create_int32(env, gtk_text_iter_get_offset(&end), &value);
+  assert(err == 0);
+
+  err = js_set_named_property(env, result, "end", value);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_text_buffer_select_range(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 3);
+
+  GtkTextBuffer *buffer;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "buffer", (gpointer *) &buffer);
+  if (err < 0) return NULL;
+
+  int32_t start;
+  err = bare_gtk__read_int32(env, argv[1], "start", &start);
+  if (err < 0) return NULL;
+
+  int32_t end;
+  err = bare_gtk__read_int32(env, argv[2], "end", &end);
+  if (err < 0) return NULL;
+
+  GtkTextIter from;
+  GtkTextIter to;
+
+  gtk_text_buffer_get_iter_at_offset(buffer, &from, start);
+  gtk_text_buffer_get_iter_at_offset(buffer, &to, end);
+
+  gtk_text_buffer_select_range(buffer, &to, &from);
+
+  return NULL;
+}
+
+#endif // BARE_GTK_TEXT_BUFFER_H

package/lib/text-buffer.js

@@ -0,0 +1,33 @@
+const binding = require('../binding')
+const GObject = require('./object')
+
+module.exports = exports = class GTKTextBuffer extends GObject {
+  static _events = {
+    changed: binding.TEXT_BUFFER_EVENT_CHANGED,
+    'cursor-position': binding.TEXT_BUFFER_EVENT_CURSOR_POSITION,
+    'insert-text': binding.TEXT_BUFFER_EVENT_INSERT_TEXT,
+    'delete-range': binding.TEXT_BUFFER_EVENT_DELETE_RANGE
+  }
+
+  _eventMask(mask) {
+    binding.textBufferEventMask(this._tag, mask)
+  }
+
+  get text() {
+    return binding.textBufferText(this._tag)
+  }
+
+  set text(value) {
+    binding.textBufferText(this._tag, value)
+  }
+
+  get selectionBounds() {
+    return binding.textBufferSelectionBounds(this._tag)
+  }
+
+  selectRange(start, end) {
+    binding.textBufferSelectRange(this._tag, start, end)
+
+    return this
+  }
+}

package/lib/text-view.d.ts

@@ -0,0 +1,39 @@
+import GTKWidget = require('./widget')
+import GTKTextBuffer = require('./text-buffer')
+
+/** Several lines of editable text, as a `GtkTextView`. */
+interface GTKTextView extends GTKWidget<GTKTextView.Events> {
+  /** The text the view shows. */
+  readonly buffer: GTKTextBuffer
+
+  /** Whether the user can change the text. */
+  editable: boolean
+
+  /** How lines wrap, as a `WRAP_*` constant. */
+  wrapMode: number
+
+  /** What the text is for, as a `GTKEntry.INPUT_PURPOSE` constant. */
+  inputPurpose: number
+
+  /** Hints for input methods, as `GTKEntry.INPUT_HINTS` flags combined with `|`. */
+  inputHints: number
+
+  /** How lines line up with each other, as a `JUSTIFY_*` constant. */
+  justification: number
+}
+
+declare class GTKTextView {
+  constructor()
+}
+
+declare namespace GTKTextView {
+  export interface Events {
+    /** The view got or lost the keyboard. `focused` is 1 or 0. */
+    'has-focus': [focused: number]
+
+    /** The view became or stopped being the focus widget of its window. `focused` is 1 or 0. */
+    'is-focus': [focused: number]
+  }
+}
+
+export = GTKTextView