bare-gtk 0.2.1 → 0.3.0

package/lib/display.h

@@ -0,0 +1,86 @@
+#ifndef BARE_GTK_DISPLAY_H
+#define BARE_GTK_DISPLAY_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_display_get_default(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);
+
+  return bare_gtk__create_tag(env, state, gdk_display_get_default());
+}
+
+static js_value_t *
+bare_gtk_display_get_clipboard(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);
+
+  GdkDisplay *display;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "display", (gpointer *) &display);
+  if (err < 0) return NULL;
+
+  return bare_gtk__create_tag(env, state, gdk_display_get_clipboard(display));
+}
+
+static js_value_t *
+bare_gtk_display_get_primary_clipboard(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);
+
+  GdkDisplay *display;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "display", (gpointer *) &display);
+  if (err < 0) return NULL;
+
+  return bare_gtk__create_tag(env, state, gdk_display_get_primary_clipboard(display));
+}
+
+static js_value_t *
+bare_gtk_display_get_monitor_at_surface(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;
+
+  GdkSurface *surface;
+  err = bare_gobject_read_tag(env, state->registry, argv[1], "surface", (gpointer *) &surface);
+  if (err < 0) return NULL;
+
+  return bare_gtk__create_tag(env, state, gdk_display_get_monitor_at_surface(display, surface));
+}
+
+#endif // BARE_GTK_DISPLAY_H

package/lib/display.js

@@ -0,0 +1,23 @@
+const binding = require('../binding')
+const GObject = require('./object')
+const GDKMonitor = require('./monitor')
+const GDKClipboard = require('./clipboard')
+const wrap = require('./wrap')
+
+module.exports = exports = class GDKDisplay extends GObject {
+  static getDefault() {
+    return wrap(GDKDisplay, binding.displayGetDefault())
+  }
+
+  getMonitorAtSurface(surface) {
+    return wrap(GDKMonitor, binding.displayGetMonitorAtSurface(this._tag, surface._tag))
+  }
+
+  getClipboard() {
+    return wrap(GDKClipboard, binding.displayGetClipboard(this._tag))
+  }
+
+  getPrimaryClipboard() {
+    return wrap(GDKClipboard, binding.displayGetPrimaryClipboard(this._tag))
+  }
+}

package/lib/editable.h

@@ -0,0 +1,160 @@
+#ifndef BARE_GTK_EDITABLE_H
+#define BARE_GTK_EDITABLE_H
+
+#include <assert.h>
+#include <js.h>
+#include <utf.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+// `GtkEditable` is an interface that an entry implements and a text view does
+// not.
+static js_value_t *
+bare_gtk_editable_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);
+
+  GtkEditable *editable;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "editable", (gpointer *) &editable);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    const char *text = gtk_editable_get_text(editable);
+
+    err = js_create_string_utf8(env, (const utf8_t *) (text == NULL ? "" : text), (size_t) -1, &result);
+    assert(err == 0);
+  } else {
+    char *text;
+    err = bare_gtk__read_string(env, argv[1], "text", &text);
+    if (err < 0) return NULL;
+
+    gtk_editable_set_text(editable, text);
+
+    g_free(text);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_editable_editable(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);
+
+  GtkEditable *editable;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "editable", (gpointer *) &editable);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_get_boolean(env, gtk_editable_get_editable(editable), &result);
+    assert(err == 0);
+  } else {
+    bool value;
+    err = bare_gtk__read_bool(env, argv[1], "editable", &value);
+    if (err < 0) return NULL;
+
+    gtk_editable_set_editable(editable, value);
+  }
+
+  return result;
+}
+
+// With nothing selected, both ends are at the caret.
+static js_value_t *
+bare_gtk_editable_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);
+
+  GtkEditable *editable;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "editable", (gpointer *) &editable);
+  if (err < 0) return NULL;
+
+  int start = 0;
+  int end = 0;
+
+  if (!gtk_editable_get_selection_bounds(editable, &start, &end)) {
+    start = end = gtk_editable_get_position(editable);
+  }
+
+  js_value_t *result;
+  err = js_create_object(env, &result);
+  assert(err == 0);
+
+  js_value_t *value;
+
+  err = js_create_int32(env, start, &value);
+  assert(err == 0);
+
+  err = js_set_named_property(env, result, "start", value);
+  assert(err == 0);
+
+  err = js_create_int32(env, 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_editable_select_region(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);
+
+  GtkEditable *editable;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "editable", (gpointer *) &editable);
+  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;
+
+  gtk_editable_select_region(editable, start, end);
+
+  return NULL;
+}
+
+#endif // BARE_GTK_EDITABLE_H

package/lib/entry.d.ts

@@ -0,0 +1,93 @@
+import GTKWidget = require('./widget')
+
+/** A single line of editable text, as a `GtkEntry`. */
+interface GTKEntry extends GTKWidget<GTKEntry.Events> {
+  text: string
+
+  /** Whether the user can change the text. */
+  editable: boolean
+
+  /** The selected range, as character offsets. With nothing selected, both are at the caret. */
+  readonly selectionBounds: { start: number; end: number }
+
+  /** Select the characters from `start` to `end`. -1 means the end of the text. */
+  selectRegion(start: number, end: number): this
+
+  /** Take the keyboard focus without selecting all the text, as `grabFocus()` does. */
+  grabFocusWithoutSelecting(): boolean
+
+  /** Text shown while the entry is empty, or `null`. */
+  placeholderText: string | null
+
+  /** Whether the text is shown. Set it to `false` for a password. */
+  visibility: boolean
+
+  /** What the text is for, as an `INPUT_PURPOSE` constant. */
+  inputPurpose: number
+
+  /** Hints for input methods, as `INPUT_HINTS` flags combined with `|`. */
+  inputHints: number
+
+  /** Where the text sits when it is shorter than the entry, from 0 (start) to 1 (end). */
+  alignment: number
+}
+
+declare class GTKEntry {
+  constructor()
+
+  static readonly INPUT_PURPOSE: {
+    readonly FREE_FORM: 0
+    readonly ALPHA: 1
+    readonly DIGITS: 2
+    readonly NUMBER: 3
+    readonly PHONE: 4
+    readonly URL: 5
+    readonly EMAIL: 6
+    readonly NAME: 7
+    readonly PASSWORD: 8
+    readonly PIN: 9
+    readonly TERMINAL: 10
+  }
+
+  static readonly INPUT_HINTS: {
+    readonly NONE: number
+    readonly SPELLCHECK: number
+    readonly NO_SPELLCHECK: number
+    readonly WORD_COMPLETION: number
+    readonly LOWERCASE: number
+    readonly UPPERCASE_CHARS: number
+    readonly UPPERCASE_WORDS: number
+    readonly UPPERCASE_SENTENCES: number
+    readonly INHIBIT_OSK: number
+  }
+}
+
+declare namespace GTKEntry {
+  export interface Events {
+    /** The text changed. */
+    changed: []
+
+    /** The user pressed Enter. */
+    activate: []
+
+    /** The caret moved. */
+    '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-text': [text: string, start: number, end: number]
+
+    /** The entry got or lost the keyboard. `focused` is 1 or 0. */
+    'has-focus': [focused: number]
+
+    /**
+     * The entry became or stopped being the focus widget of its window. `focused` is 1 or 0.
+     * A window that is not active still has a focus widget.
+     */
+    'is-focus': [focused: number]
+  }
+}
+
+export = GTKEntry

package/lib/entry.h

@@ -0,0 +1,340 @@
+#ifndef BARE_GTK_ENTRY_H
+#define BARE_GTK_ENTRY_H
+
+#include <assert.h>
+#include <js.h>
+#include <utf.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+enum {
+  bare_gtk_entry_event_changed = 1 << 0,
+  bare_gtk_entry_event_activate = 1 << 1,
+  bare_gtk_entry_event_cursor_position = 1 << 2,
+  bare_gtk_entry_event_insert_text = 1 << 3,
+  bare_gtk_entry_event_delete_text = 1 << 4,
+  bare_gtk_entry_event_has_focus = 1 << 5,
+  bare_gtk_entry_event_is_focus = 1 << 6,
+};
+
+typedef struct {
+  GtkEntry handle;
+
+  bare_gtk_state_t *state;
+
+  uint32_t events;
+
+  gulong on_changed;
+  gulong on_activate;
+  gulong on_cursor_position;
+  gulong on_insert_text;
+  gulong on_delete_text;
+  gulong on_has_focus;
+  gulong on_is_focus;
+} BareEntry;
+
+typedef struct {
+  GtkEntryClass parent;
+} BareEntryClass;
+
+G_DEFINE_TYPE(BareEntry, bare_entry, GTK_TYPE_ENTRY)
+
+static void
+bare_entry_init(BareEntry *self) {}
+
+static void
+bare_entry_class_init(BareEntryClass *class) {}
+
+BareEntry *
+bare_entry_new(void) {
+  return g_object_new(bare_entry_get_type(), NULL);
+}
+
+static void
+bare_gtk_entry__on_changed(GtkEditable *editable, gpointer data) {
+  BareEntry *self = (BareEntry *) editable;
+
+  bare_gtk__emit(self->state, editable, "changed", 0, NULL);
+}
+
+static void
+bare_gtk_entry__on_activate(GtkEntry *entry, gpointer data) {
+  BareEntry *self = (BareEntry *) entry;
+
+  bare_gtk__emit(self->state, entry, "activate", 0, NULL);
+}
+
+static void
+bare_gtk_entry__on_cursor_position(GObject *object, GParamSpec *spec, gpointer data) {
+  BareEntry *self = (BareEntry *) object;
+
+  bare_gtk__emit(self->state, object, "cursor-position", 0, NULL);
+}
+
+static void
+bare_gtk_entry__on_has_focus(GObject *object, GParamSpec *spec, gpointer data) {
+  BareEntry *self = (BareEntry *) object;
+
+  bare_gtk__emit(self->state, object, "has-focus", 1, (const double[]) {gtk_widget_has_focus(GTK_WIDGET(object)) ? 1 : 0});
+}
+
+// Whether this is the focus widget of its window. That is not the same as
+// having the keyboard: a window that is not active still has a focus widget.
+static void
+bare_gtk_entry__on_is_focus(GObject *object, GParamSpec *spec, gpointer data) {
+  BareEntry *self = (BareEntry *) object;
+
+  bare_gtk__emit(self->state, object, "is-focus", 1, (const double[]) {gtk_widget_is_focus(GTK_WIDGET(object)) ? 1 : 0});
+}
+
+// GTK reports an insertion and a deletion separately, where other toolkits
+// report one replacement, so both are sent as a replacement.
+static void
+bare_gtk_entry__on_insert_text(GtkEditable *editable, const char *text, int length, int *position, gpointer data) {
+  BareEntry *self = (BareEntry *) editable;
+
+  bare_gtk__emit_replacement(self->state, editable, "insert-text", text, *position, *position);
+}
+
+static void
+bare_gtk_entry__on_delete_text(GtkEditable *editable, int start, int end, gpointer data) {
+  BareEntry *self = (BareEntry *) editable;
+
+  bare_gtk__emit_replacement(self->state, editable, "delete-text", "", start, end);
+}
+
+static js_value_t *
+bare_gtk_entry_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);
+
+  BareEntry *entry = bare_entry_new();
+
+  entry->state = state;
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, entry), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_entry_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);
+
+  BareEntry *entry;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "entry", (gpointer *) &entry);
+  if (err < 0) return NULL;
+
+  uint32_t events;
+  err = bare_gtk__read_uint32(env, argv[1], "events", &events);
+  if (err < 0) return NULL;
+
+  uint32_t changed = entry->events ^ events;
+
+  entry->events = events;
+
+#define V(bit, field, signal, callback) \
+  if ((changed & (bit)) != 0) { \
+    if ((events & (bit)) != 0) { \
+      entry->field = g_signal_connect(entry, signal, G_CALLBACK(callback), state); \
+    } else { \
+      g_signal_handler_disconnect(entry, entry->field); \
+    } \
+  }
+
+  V(bare_gtk_entry_event_changed, on_changed, "changed", bare_gtk_entry__on_changed)
+  V(bare_gtk_entry_event_activate, on_activate, "activate", bare_gtk_entry__on_activate)
+  V(bare_gtk_entry_event_cursor_position, on_cursor_position, "notify::cursor-position", bare_gtk_entry__on_cursor_position)
+  V(bare_gtk_entry_event_insert_text, on_insert_text, "insert-text", bare_gtk_entry__on_insert_text)
+  V(bare_gtk_entry_event_delete_text, on_delete_text, "delete-text", bare_gtk_entry__on_delete_text)
+  V(bare_gtk_entry_event_has_focus, on_has_focus, "notify::has-focus", bare_gtk_entry__on_has_focus)
+  V(bare_gtk_entry_event_is_focus, on_is_focus, "notify::is-focus", bare_gtk_entry__on_is_focus)
+#undef V
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_entry_placeholder_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);
+
+  GtkEntry *entry;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "entry", (gpointer *) &entry);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    const char *text = gtk_entry_get_placeholder_text(entry);
+
+    err = js_create_string_utf8(env, (const utf8_t *) (text == NULL ? "" : text), (size_t) -1, &result);
+    assert(err == 0);
+  } else {
+    char *text;
+    err = bare_gtk__read_string(env, argv[1], "text", &text);
+    if (err < 0) return NULL;
+
+    gtk_entry_set_placeholder_text(entry, text);
+
+    g_free(text);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_entry_visibility(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);
+
+  GtkEntry *entry;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "entry", (gpointer *) &entry);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_get_boolean(env, gtk_entry_get_visibility(entry), &result);
+    assert(err == 0);
+  } else {
+    bool visibility;
+    err = bare_gtk__read_bool(env, argv[1], "visibility", &visibility);
+    if (err < 0) return NULL;
+
+    gtk_entry_set_visibility(entry, visibility);
+  }
+
+  return result;
+}
+
+#define BARE_GTK_ENTRY_ENUM(name, getter, setter, type) \
+  static js_value_t * \
+  bare_gtk_entry_##name(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); \
+\
+    GtkEntry *entry; \
+    err = bare_gobject_read_tag(env, state->registry, argv[0], "entry", (gpointer *) &entry); \
+    if (err < 0) return NULL; \
+\
+    js_value_t *result = NULL; \
+\
+    if (argc == 1) { \
+      err = js_create_int32(env, (int32_t) getter(entry), &result); \
+      assert(err == 0); \
+    } else { \
+      int32_t value; \
+      err = bare_gtk__read_int32(env, argv[1], #name, &value); \
+      if (err < 0) return NULL; \
+\
+      setter(entry, (type) value); \
+    } \
+\
+    return result; \
+  }
+
+BARE_GTK_ENTRY_ENUM(input_purpose, gtk_entry_get_input_purpose, gtk_entry_set_input_purpose, GtkInputPurpose)
+BARE_GTK_ENTRY_ENUM(input_hints, gtk_entry_get_input_hints, gtk_entry_set_input_hints, GtkInputHints)
+#undef BARE_GTK_ENTRY_ENUM
+
+// An entry selects all its text when it gets focus, which would undo a
+// selection the caller made. This grab does not.
+static js_value_t *
+bare_gtk_entry_grab_focus_without_selecting(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);
+
+  GtkEntry *entry;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "entry", (gpointer *) &entry);
+  if (err < 0) return NULL;
+
+  js_value_t *result;
+  err = js_get_boolean(env, gtk_entry_grab_focus_without_selecting(entry), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_entry_alignment(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);
+
+  GtkEntry *entry;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "entry", (gpointer *) &entry);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_create_double(env, gtk_entry_get_alignment(entry), &result);
+    assert(err == 0);
+  } else {
+    double alignment;
+    err = bare_gtk__read_double(env, argv[1], "alignment", &alignment);
+    if (err < 0) return NULL;
+
+    gtk_entry_set_alignment(entry, (float) alignment);
+  }
+
+  return result;
+}
+
+#endif // BARE_GTK_ENTRY_H