bare-gtk 0.2.0 → 0.3.0

package/lib/entry.js

@@ -0,0 +1,118 @@
+const binding = require('../binding')
+const GTKWidget = require('./widget')
+
+module.exports = exports = class GTKEntry extends GTKWidget {
+  static _events = {
+    changed: binding.ENTRY_EVENT_CHANGED,
+    activate: binding.ENTRY_EVENT_ACTIVATE,
+    'cursor-position': binding.ENTRY_EVENT_CURSOR_POSITION,
+    'insert-text': binding.ENTRY_EVENT_INSERT_TEXT,
+    'delete-text': binding.ENTRY_EVENT_DELETE_TEXT,
+    'has-focus': binding.ENTRY_EVENT_HAS_FOCUS,
+    'is-focus': binding.ENTRY_EVENT_IS_FOCUS
+  }
+
+  _init(opts) {
+    return binding.entryInit()
+  }
+
+  _eventMask(mask) {
+    binding.entryEventMask(this._tag, mask)
+  }
+
+  get text() {
+    return binding.editableText(this._tag)
+  }
+
+  set text(value) {
+    binding.editableText(this._tag, value)
+  }
+
+  get editable() {
+    return binding.editableEditable(this._tag)
+  }
+
+  set editable(value) {
+    binding.editableEditable(this._tag, value)
+  }
+
+  get selectionBounds() {
+    return binding.editableSelectionBounds(this._tag)
+  }
+
+  selectRegion(start, end) {
+    binding.editableSelectRegion(this._tag, start, end)
+
+    return this
+  }
+
+  grabFocusWithoutSelecting() {
+    return binding.entryGrabFocusWithoutSelecting(this._tag)
+  }
+
+  get placeholderText() {
+    return binding.entryPlaceholderText(this._tag)
+  }
+
+  set placeholderText(value) {
+    binding.entryPlaceholderText(this._tag, value)
+  }
+
+  get visibility() {
+    return binding.entryVisibility(this._tag)
+  }
+
+  set visibility(value) {
+    binding.entryVisibility(this._tag, value)
+  }
+
+  get inputPurpose() {
+    return binding.entryInputPurpose(this._tag)
+  }
+
+  set inputPurpose(value) {
+    binding.entryInputPurpose(this._tag, value)
+  }
+
+  get inputHints() {
+    return binding.entryInputHints(this._tag)
+  }
+
+  set inputHints(value) {
+    binding.entryInputHints(this._tag, value)
+  }
+
+  get alignment() {
+    return binding.entryAlignment(this._tag)
+  }
+
+  set alignment(value) {
+    binding.entryAlignment(this._tag, value)
+  }
+}
+
+exports.INPUT_PURPOSE = {
+  FREE_FORM: 0,
+  ALPHA: 1,
+  DIGITS: 2,
+  NUMBER: 3,
+  PHONE: 4,
+  URL: 5,
+  EMAIL: 6,
+  NAME: 7,
+  PASSWORD: 8,
+  PIN: 9,
+  TERMINAL: 10
+}
+
+exports.INPUT_HINTS = {
+  NONE: 0,
+  SPELLCHECK: 1 << 0,
+  NO_SPELLCHECK: 1 << 1,
+  WORD_COMPLETION: 1 << 2,
+  LOWERCASE: 1 << 3,
+  UPPERCASE_CHARS: 1 << 4,
+  UPPERCASE_WORDS: 1 << 5,
+  UPPERCASE_SENTENCES: 1 << 6,
+  INHIBIT_OSK: 1 << 7
+}

package/lib/event-controller-focus.d.ts

@@ -0,0 +1,17 @@
+import GTKEventController = require('./event-controller')
+
+/** Reports when a widget gets and loses the keyboard focus, as a `GtkEventControllerFocus`. */
+interface GTKEventControllerFocus extends GTKEventController<GTKEventControllerFocus.Events> {}
+
+declare class GTKEventControllerFocus {
+  constructor()
+}
+
+declare namespace GTKEventControllerFocus {
+  export interface Events {
+    enter: []
+    leave: []
+  }
+}
+
+export = GTKEventControllerFocus

package/lib/event-controller-focus.h

@@ -0,0 +1,55 @@
+#ifndef BARE_GTK_EVENT_CONTROLLER_FOCUS_H
+#define BARE_GTK_EVENT_CONTROLLER_FOCUS_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+#include "event-controller.h"
+
+enum {
+  bare_gtk_event_controller_focus_event_enter = 1 << 0,
+  bare_gtk_event_controller_focus_event_leave = 1 << 1,
+};
+
+static void
+bare_gtk_event_controller_focus__on_enter(GtkEventControllerFocus *focus, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, focus) & bare_gtk_event_controller_focus_event_enter) == 0) return;
+
+  bare_gtk__emit(state, focus, "enter", 0, NULL);
+}
+
+static void
+bare_gtk_event_controller_focus__on_leave(GtkEventControllerFocus *focus, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, focus) & bare_gtk_event_controller_focus_event_leave) == 0) return;
+
+  bare_gtk__emit(state, focus, "leave", 0, NULL);
+}
+
+static js_value_t *
+bare_gtk_event_controller_focus_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);
+
+  GtkEventController *focus = gtk_event_controller_focus_new();
+
+  g_signal_connect(focus, "enter", G_CALLBACK(bare_gtk_event_controller_focus__on_enter), state);
+  g_signal_connect(focus, "leave", G_CALLBACK(bare_gtk_event_controller_focus__on_leave), state);
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, focus), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+#endif // BARE_GTK_EVENT_CONTROLLER_FOCUS_H

package/lib/event-controller-focus.js

@@ -0,0 +1,13 @@
+const binding = require('../binding')
+const GTKEventController = require('./event-controller')
+
+module.exports = exports = class GTKEventControllerFocus extends GTKEventController {
+  static _events = {
+    enter: binding.EVENT_CONTROLLER_FOCUS_EVENT_ENTER,
+    leave: binding.EVENT_CONTROLLER_FOCUS_EVENT_LEAVE
+  }
+
+  _init() {
+    return binding.eventControllerFocusInit()
+  }
+}

package/lib/event-controller-motion.d.ts

@@ -0,0 +1,18 @@
+import GTKEventController = require('./event-controller')
+
+/** Reports pointer movement over a widget, as a `GtkEventControllerMotion`. */
+interface GTKEventControllerMotion extends GTKEventController<GTKEventControllerMotion.Events> {}
+
+declare class GTKEventControllerMotion {
+  constructor()
+}
+
+declare namespace GTKEventControllerMotion {
+  export interface Events {
+    motion: [x: number, y: number]
+    enter: [x: number, y: number]
+    leave: []
+  }
+}
+
+export = GTKEventControllerMotion

package/lib/event-controller-motion.h

@@ -0,0 +1,66 @@
+#ifndef BARE_GTK_EVENT_CONTROLLER_MOTION_H
+#define BARE_GTK_EVENT_CONTROLLER_MOTION_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+#include "event-controller.h"
+
+enum {
+  bare_gtk_event_controller_motion_event_motion = 1 << 0,
+  bare_gtk_event_controller_motion_event_enter = 1 << 1,
+  bare_gtk_event_controller_motion_event_leave = 1 << 2,
+};
+
+static void
+bare_gtk_event_controller_motion__on_motion(GtkEventControllerMotion *motion, double x, double y, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, motion) & bare_gtk_event_controller_motion_event_motion) == 0) return;
+
+  bare_gtk__emit(state, motion, "motion", 2, (const double[]) {x, y});
+}
+
+static void
+bare_gtk_event_controller_motion__on_enter(GtkEventControllerMotion *motion, double x, double y, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, motion) & bare_gtk_event_controller_motion_event_enter) == 0) return;
+
+  bare_gtk__emit(state, motion, "enter", 2, (const double[]) {x, y});
+}
+
+static void
+bare_gtk_event_controller_motion__on_leave(GtkEventControllerMotion *motion, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, motion) & bare_gtk_event_controller_motion_event_leave) == 0) return;
+
+  bare_gtk__emit(state, motion, "leave", 0, NULL);
+}
+
+static js_value_t *
+bare_gtk_event_controller_motion_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);
+
+  GtkEventController *motion = gtk_event_controller_motion_new();
+
+  g_signal_connect(motion, "motion", G_CALLBACK(bare_gtk_event_controller_motion__on_motion), state);
+  g_signal_connect(motion, "enter", G_CALLBACK(bare_gtk_event_controller_motion__on_enter), state);
+  g_signal_connect(motion, "leave", G_CALLBACK(bare_gtk_event_controller_motion__on_leave), state);
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, motion), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+#endif // BARE_GTK_EVENT_CONTROLLER_MOTION_H

package/lib/event-controller-motion.js

@@ -0,0 +1,14 @@
+const binding = require('../binding')
+const GTKEventController = require('./event-controller')
+
+module.exports = exports = class GTKEventControllerMotion extends GTKEventController {
+  static _events = {
+    motion: binding.EVENT_CONTROLLER_MOTION_EVENT_MOTION,
+    enter: binding.EVENT_CONTROLLER_MOTION_EVENT_ENTER,
+    leave: binding.EVENT_CONTROLLER_MOTION_EVENT_LEAVE
+  }
+
+  _init() {
+    return binding.eventControllerMotionInit()
+  }
+}

package/lib/event-controller.d.ts

@@ -0,0 +1,17 @@
+import GObject = require('./object')
+import GTKDevice = require('./device')
+
+/** The base of the objects that report input on a widget, as a `GtkEventController`. */
+interface GTKEventController<M extends Record<keyof M, unknown[]> = {}> extends GObject<M> {
+  /** When the controller sees an event, as a `PROPAGATION_PHASE_*` constant. */
+  propagationPhase: number
+
+  /** The device of the event being handled, or `null` outside an event. */
+  readonly currentEventDevice: GTKDevice | null
+}
+
+declare class GTKEventController<M extends Record<keyof M, unknown[]> = {}> {
+  protected constructor()
+}
+
+export = GTKEventController

package/lib/event-controller.h

@@ -0,0 +1,103 @@
+#ifndef BARE_GTK_EVENT_CONTROLLER_H
+#define BARE_GTK_EVENT_CONTROLLER_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_event_controller_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);
+
+  GtkEventController *controller;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "controller", (gpointer *) &controller);
+  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__observe(state, controller, events);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_event_controller_propagation_phase(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);
+
+  GtkEventController *controller;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "controller", (gpointer *) &controller);
+  if (err < 0) return NULL;
+
+  if (argc == 1) {
+    js_value_t *result;
+    err = js_create_uint32(env, gtk_event_controller_get_propagation_phase(controller), &result);
+    assert(err == 0);
+
+    return result;
+  }
+
+  uint32_t phase;
+  err = bare_gtk__read_uint32(env, argv[1], "phase", &phase);
+  if (err < 0) return NULL;
+
+  gtk_event_controller_set_propagation_phase(controller, phase);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_event_controller_current_event_device(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);
+
+  GtkEventController *controller;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "controller", (gpointer *) &controller);
+  if (err < 0) return NULL;
+
+  GdkDevice *device = gtk_event_controller_get_current_event_device(controller);
+
+  js_value_t *result;
+
+  if (device == NULL) {
+    err = js_get_null(env, &result);
+    assert(err == 0);
+  } else {
+    err = js_create_uint32(env, bare_gobject_tag(state->registry, device), &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+#endif // BARE_GTK_EVENT_CONTROLLER_H

package/lib/event-controller.js

@@ -0,0 +1,22 @@
+const binding = require('../binding')
+const GObject = require('./object')
+const wrap = require('./wrap')
+const GTKDevice = require('./device')
+
+module.exports = exports = class GTKEventController extends GObject {
+  _eventMask(mask) {
+    binding.eventControllerEventMask(this._tag, mask)
+  }
+
+  get propagationPhase() {
+    return binding.eventControllerPropagationPhase(this._tag)
+  }
+
+  set propagationPhase(phase) {
+    binding.eventControllerPropagationPhase(this._tag, phase)
+  }
+
+  get currentEventDevice() {
+    return wrap(GTKDevice, binding.eventControllerCurrentEventDevice(this._tag))
+  }
+}

package/lib/events.js

@@ -0,0 +1,23 @@
+module.exports = exports = function observe(target) {
+  const events = target.constructor._events
+
+  if (events === undefined) return
+
+  let mask = 0
+
+  target
+    .on('newListener', (name) => {
+      const bit = events[name]
+
+      if (bit === undefined || target.listenerCount(name) !== 0) return
+
+      target._eventMask((mask |= bit))
+    })
+    .on('removeListener', (name) => {
+      const bit = events[name]
+
+      if (bit === undefined || target.listenerCount(name) !== 0) return
+
+      target._eventMask((mask &= ~bit))
+    })
+}

package/lib/fixed.d.ts

@@ -0,0 +1,10 @@
+import GTKWidget = require('./widget')
+
+/** A container that places children at fixed positions, as a `GtkFixed`. */
+interface GTKFixed extends GTKWidget {}
+
+declare class GTKFixed {
+  constructor()
+}
+
+export = GTKFixed

package/lib/fixed.h

@@ -0,0 +1,28 @@
+#ifndef BARE_GTK_FIXED_H
+#define BARE_GTK_FIXED_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_fixed_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 *fixed = gtk_fixed_new();
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, fixed), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+#endif // BARE_GTK_FIXED_H

package/lib/fixed.js

@@ -0,0 +1,8 @@
+const binding = require('../binding')
+const GTKWidget = require('./widget')
+
+module.exports = exports = class GTKFixed extends GTKWidget {
+  _init(opts) {
+    return binding.fixedInit()
+  }
+}

package/lib/frame-fixed.d.ts

@@ -0,0 +1,10 @@
+import GTKFixed = require('./fixed')
+
+/** A `GTKFixed` that places each child at an exact frame, using a `BareFrameLayout`. */
+interface BareFrameFixed extends GTKFixed {}
+
+declare class BareFrameFixed {
+  constructor()
+}
+
+export = BareFrameFixed

package/lib/frame-fixed.js

@@ -0,0 +1,12 @@
+const BareFrameLayout = require('./frame-layout')
+const GTKFixed = require('./fixed')
+
+module.exports = exports = class BareFrameFixed extends GTKFixed {
+  constructor(opts = {}) {
+    super(opts)
+
+    const { tag = null } = opts
+
+    if (tag === null) this.layoutManager = new BareFrameLayout()
+  }
+}

package/lib/frame-layout-child.d.ts

@@ -0,0 +1,17 @@
+import GTKLayoutChild = require('./layout-child')
+
+/** The frame of one child of a `BareFrameLayout`. */
+interface BareFrameLayoutChild extends GTKLayoutChild {
+  /** Where the child is placed, as `[x, y, width, height]`. */
+  get frame(): [x: number, y: number, width: number, height: number]
+  set frame(frame: [x: number, y: number, width: number, height: number])
+
+  /** A 3D transform for the child, as sixteen numbers in the order CSS uses for `matrix3d()`. */
+  set transform(transform: number[])
+}
+
+declare class BareFrameLayoutChild {
+  protected constructor()
+}
+
+export = BareFrameLayoutChild

package/lib/frame-layout-child.js

@@ -0,0 +1,16 @@
+const binding = require('../binding')
+const GTKLayoutChild = require('./layout-child')
+
+module.exports = exports = class BareFrameLayoutChild extends GTKLayoutChild {
+  get frame() {
+    return binding.frameLayoutChildFrame(this._tag)
+  }
+
+  set frame([x, y, width, height]) {
+    binding.frameLayoutChildFrame(this._tag, x, y, width, height)
+  }
+
+  set transform(value) {
+    binding.frameLayoutChildTransform(this._tag, value)
+  }
+}

package/lib/frame-layout.d.ts

@@ -0,0 +1,27 @@
+import GTKLayoutManager = require('./layout-manager')
+import BareFrameLayoutChild = require('./frame-layout-child')
+import GTKWidget = require('./widget')
+
+/**
+ * A layout manager that gives each child an exact frame. GTK's own managers size a child from
+ * what it prefers. Set a frame through the `BareFrameLayoutChild` of each child.
+ */
+interface BareFrameLayout extends GTKLayoutManager<BareFrameLayout.Events> {
+  getLayoutChild(widget: GTKWidget): BareFrameLayoutChild | null
+}
+
+declare class BareFrameLayout {
+  constructor()
+}
+
+declare namespace BareFrameLayout {
+  export interface Events {
+    /**
+     * The widget is being laid out at `width` by `height`. Frames set from a listener apply in
+     * this layout. A listener must not change the widget tree.
+     */
+    resize: [width: number, height: number]
+  }
+}
+
+export = BareFrameLayout