bare-gtk 0.2.0 → 0.3.0

package/lib/message-dialog.h

@@ -0,0 +1,190 @@
+#ifndef BARE_GTK_MESSAGE_DIALOG_H
+#define BARE_GTK_MESSAGE_DIALOG_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+enum {
+  bare_gtk_dialog_event_response = 1 << 0,
+};
+
+static void
+bare_gtk_dialog__on_response(GtkDialog *dialog, gint response, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, dialog) & bare_gtk_dialog_event_response) == 0) return;
+
+  bare_gtk__emit(state, dialog, "response", 1, (double[]){(double) response});
+}
+
+// No buttons yet, because adding them one at a time is the only way to choose
+// their labels.
+static js_value_t *
+bare_gtk_message_dialog_new(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);
+
+  GtkWindow *parent = NULL;
+
+  js_value_type_t type;
+  err = js_typeof(env, argv[0], &type);
+  assert(err == 0);
+
+  if (type != js_null && type != js_undefined) {
+    err = bare_gobject_read_tag(env, state->registry, argv[0], "parent", (gpointer *) &parent);
+    if (err < 0) return NULL;
+  }
+
+  int32_t message_type;
+  err = bare_gtk__read_int32(env, argv[1], "message_type", &message_type);
+  if (err < 0) return NULL;
+
+  char *text;
+  err = bare_gtk__read_string(env, argv[2], "text", &text);
+  if (err < 0) return NULL;
+
+  GtkWidget *dialog = gtk_message_dialog_new(
+    parent,
+    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+    (GtkMessageType) message_type,
+    GTK_BUTTONS_NONE,
+    "%s",
+    text
+  );
+
+  free(text);
+
+  g_signal_connect(dialog, "response", G_CALLBACK(bare_gtk_dialog__on_response), state);
+
+  return bare_gtk__create_tag(env, state, dialog);
+}
+
+static js_value_t *
+bare_gtk_message_dialog_secondary_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);
+
+  GtkMessageDialog *dialog;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "dialog", (gpointer *) &dialog);
+  if (err < 0) return NULL;
+
+  char *text;
+  err = bare_gtk__read_string(env, argv[1], "text", &text);
+  if (err < 0) return NULL;
+
+  gtk_message_dialog_format_secondary_text(dialog, "%s", text);
+
+  free(text);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_dialog_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);
+
+  GtkDialog *dialog;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "dialog", (gpointer *) &dialog);
+  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, dialog, events);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_dialog_add_button(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);
+
+  GtkDialog *dialog;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "dialog", (gpointer *) &dialog);
+  if (err < 0) return NULL;
+
+  char *label;
+  err = bare_gtk__read_string(env, argv[1], "label", &label);
+  if (err < 0) return NULL;
+
+  int32_t response;
+  err = bare_gtk__read_int32(env, argv[2], "response", &response);
+  if (err < 0) {
+    free(label);
+
+    return NULL;
+  }
+
+  GtkWidget *button = gtk_dialog_add_button(dialog, label, response);
+
+  free(label);
+
+  return bare_gtk__create_tag(env, state, button);
+}
+
+static js_value_t *
+bare_gtk_dialog_response(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);
+
+  GtkDialog *dialog;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "dialog", (gpointer *) &dialog);
+  if (err < 0) return NULL;
+
+  int32_t response;
+  err = bare_gtk__read_int32(env, argv[1], "response", &response);
+  if (err < 0) return NULL;
+
+  gtk_dialog_response(dialog, response);
+
+  return NULL;
+}
+
+#endif // BARE_GTK_MESSAGE_DIALOG_H

package/lib/message-dialog.js

@@ -0,0 +1,22 @@
+const binding = require('../binding')
+const GTKDialog = require('./dialog')
+
+module.exports = exports = class GTKMessageDialog extends GTKDialog {
+  _init(opts) {
+    const { parent = null, messageType = exports.MESSAGE_TYPE.OTHER, text = '' } = opts
+
+    return binding.messageDialogNew(parent === null ? null : parent._tag, messageType, text)
+  }
+
+  set secondaryText(text) {
+    binding.messageDialogSecondaryText(this._tag, text)
+  }
+}
+
+exports.MESSAGE_TYPE = {
+  INFO: binding.MESSAGE_DIALOG_MESSAGE_TYPE_INFO,
+  WARNING: binding.MESSAGE_DIALOG_MESSAGE_TYPE_WARNING,
+  QUESTION: binding.MESSAGE_DIALOG_MESSAGE_TYPE_QUESTION,
+  ERROR: binding.MESSAGE_DIALOG_MESSAGE_TYPE_ERROR,
+  OTHER: binding.MESSAGE_DIALOG_MESSAGE_TYPE_OTHER
+}

package/lib/monitor.d.ts

@@ -0,0 +1,32 @@
+import GObject = require('./object')
+
+/** A monitor, as a `GdkMonitor`. */
+interface GDKMonitor extends GObject {
+  /** Where the monitor is and how big it is, in logical pixels. */
+  readonly geometry: { x: number; y: number; width: number; height: number }
+
+  readonly scaleFactor: number
+
+  readonly widthMm: number
+
+  readonly heightMm: number
+
+  /** The refresh rate in millihertz, or 0 if it is not known. */
+  readonly refreshRate: number
+
+  /** The name of the connector, such as `'HDMI-1'`, or `null`. */
+  readonly connector: string | null
+
+  readonly manufacturer: string | null
+
+  readonly model: string | null
+
+  /** Whether the monitor is still connected. */
+  readonly valid: boolean
+}
+
+declare class GDKMonitor {
+  protected constructor()
+}
+
+export = GDKMonitor

package/lib/monitor.h

@@ -0,0 +1,143 @@
+#ifndef BARE_GTK_MONITOR_H
+#define BARE_GTK_MONITOR_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_monitor_geometry(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);
+
+  GdkMonitor *monitor;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "monitor", (gpointer *) &monitor);
+  if (err < 0) return NULL;
+
+  GdkRectangle geometry;
+  gdk_monitor_get_geometry(monitor, &geometry);
+
+  js_value_t *result;
+  err = js_create_object(env, &result);
+  assert(err == 0);
+
+  const char *names[] = {"x", "y", "width", "height"};
+  int values[] = {geometry.x, geometry.y, geometry.width, geometry.height};
+
+  for (size_t i = 0; i < 4; i++) {
+    js_value_t *value;
+    err = js_create_int32(env, values[i], &value);
+    assert(err == 0);
+
+    err = js_set_named_property(env, result, names[i], value);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+#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); \
+\
+    GdkMonitor *monitor; \
+    err = bare_gobject_read_tag(env, state->registry, argv[0], "monitor", (gpointer *) &monitor); \
+    if (err < 0) return NULL; \
+\
+    js_value_t *result; \
+    err = js_create_int32(env, fn(monitor), &result); \
+    assert(err == 0); \
+\
+    return result; \
+  }
+
+V(bare_gtk_monitor_scale_factor, gdk_monitor_get_scale_factor)
+V(bare_gtk_monitor_width_mm, gdk_monitor_get_width_mm)
+V(bare_gtk_monitor_height_mm, gdk_monitor_get_height_mm)
+V(bare_gtk_monitor_refresh_rate, gdk_monitor_get_refresh_rate)
+#undef V
+
+#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); \
+\
+    GdkMonitor *monitor; \
+    err = bare_gobject_read_tag(env, state->registry, argv[0], "monitor", (gpointer *) &monitor); \
+    if (err < 0) return NULL; \
+\
+    const char *value = fn(monitor); \
+\
+    js_value_t *result; \
+\
+    if (value == NULL) { \
+      err = js_get_null(env, &result); \
+    } else { \
+      err = js_create_string_utf8(env, (const utf8_t *) value, -1, &result); \
+    } \
+\
+    assert(err == 0); \
+\
+    return result; \
+  }
+
+V(bare_gtk_monitor_connector, gdk_monitor_get_connector)
+V(bare_gtk_monitor_manufacturer, gdk_monitor_get_manufacturer)
+V(bare_gtk_monitor_model, gdk_monitor_get_model)
+#undef V
+
+static js_value_t *
+bare_gtk_monitor_valid(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);
+
+  GdkMonitor *monitor;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "monitor", (gpointer *) &monitor);
+  if (err < 0) return NULL;
+
+  js_value_t *result;
+  err = js_get_boolean(env, gdk_monitor_is_valid(monitor), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+#endif // BARE_GTK_MONITOR_H

package/lib/monitor.js

@@ -0,0 +1,40 @@
+const binding = require('../binding')
+const GObject = require('./object')
+
+module.exports = exports = class GDKMonitor extends GObject {
+  get geometry() {
+    return binding.monitorGeometry(this._tag)
+  }
+
+  get scaleFactor() {
+    return binding.monitorScaleFactor(this._tag)
+  }
+
+  get widthMm() {
+    return binding.monitorWidthMm(this._tag)
+  }
+
+  get heightMm() {
+    return binding.monitorHeightMm(this._tag)
+  }
+
+  get refreshRate() {
+    return binding.monitorRefreshRate(this._tag)
+  }
+
+  get connector() {
+    return binding.monitorConnector(this._tag)
+  }
+
+  get manufacturer() {
+    return binding.monitorManufacturer(this._tag)
+  }
+
+  get model() {
+    return binding.monitorModel(this._tag)
+  }
+
+  get valid() {
+    return binding.monitorValid(this._tag)
+  }
+}

package/lib/native.h

@@ -0,0 +1,31 @@
+#ifndef BARE_GTK_NATIVE_H
+#define BARE_GTK_NATIVE_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_native_surface(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);
+
+  GtkNative *native;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "native", (gpointer *) &native);
+  if (err < 0) return NULL;
+
+  return bare_gtk__create_tag(env, state, gtk_native_get_surface(native));
+}
+
+#endif // BARE_GTK_NATIVE_H

package/lib/object.d.ts

@@ -0,0 +1,18 @@
+import EventEmitter from 'bare-events'
+import { tag, handle, Handle } from 'bare-gobject-registry'
+
+/**
+ * The base of every GTK and GDK object in this module. Objects that have events emit them as
+ * ordinary events, and GTK is only asked to report an event while something listens to it.
+ */
+interface GObject<M extends Record<keyof M, unknown[]> = {}> extends EventEmitter<M> {
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class GObject<M extends Record<keyof M, unknown[]> = {}> {
+  protected constructor()
+}
+
+export = GObject

package/lib/object.js

@@ -0,0 +1,38 @@
+const EventEmitter = require('bare-events')
+const binding = require('../binding')
+const registry = require('bare-gobject-registry')
+const observe = require('./events')
+
+module.exports = exports = class GObject extends EventEmitter {
+  constructor(opts = {}) {
+    super()
+
+    const { tag = null } = opts
+
+    this._retained = new Set()
+
+    const created = tag === null ? this._init(opts) : tag
+
+    this._tag = typeof created === 'number' ? created : binding.adopt(created)
+
+    this._token = binding.claim(this._tag, this)
+
+    observe(this)
+  }
+
+  get [registry.tag]() {
+    return this._tag
+  }
+
+  get [registry.handle]() {
+    return binding.handle(this._tag)
+  }
+
+  _init(opts) {
+    throw new TypeError(`${this.constructor.name} cannot be constructed directly`)
+  }
+
+  _eventMask(mask) {
+    throw new Error(`${this.constructor.name} does not implement _eventMask`)
+  }
+}

package/lib/paintable.d.ts

@@ -0,0 +1,10 @@
+import GObject = require('./object')
+
+/** Anything a `GTKPicture` can show, as a `GdkPaintable`. A `GDKTexture` is one. */
+interface GDKPaintable extends GObject {}
+
+declare class GDKPaintable {
+  protected constructor()
+}
+
+export = GDKPaintable

package/lib/paintable.js

@@ -0,0 +1,3 @@
+const GObject = require('./object')
+
+module.exports = exports = class GDKPaintable extends GObject {}

package/lib/picture.d.ts

@@ -0,0 +1,22 @@
+import { Wrapper } from 'bare-gobject-registry'
+import GTKWidget = require('./widget')
+import GDKPaintable = require('./paintable')
+
+/** A widget that shows an image, as a `GtkPicture`. */
+interface GTKPicture extends GTKWidget {
+  /** What the picture shows, or `null`. It can come from another addon. */
+  get paintable(): GDKPaintable | null
+  set paintable(paintable: Wrapper | null)
+
+  /** Whether the image keeps its aspect ratio when it is scaled. */
+  keepAspectRatio: boolean
+
+  /** Whether the picture can be made smaller than the image. */
+  canShrink: boolean
+}
+
+declare class GTKPicture {
+  constructor()
+}
+
+export = GTKPicture

package/lib/picture.h

@@ -0,0 +1,127 @@
+#ifndef BARE_GTK_PICTURE_H
+#define BARE_GTK_PICTURE_H
+
+#include <assert.h>
+#include <js.h>
+#include <utf.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_picture_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 *picture = gtk_picture_new();
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, picture), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_picture_paintable(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);
+
+  GtkPicture *picture;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "picture", (gpointer *) &picture);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    result = bare_gtk__create_tag(env, state, gtk_picture_get_paintable(picture));
+  } else {
+    GdkPaintable *paintable;
+    err = bare_gtk__read_tag_or_null(env, state->registry, argv[1], "paintable", (gpointer *) &paintable);
+    if (err < 0) return NULL;
+
+    gtk_picture_set_paintable(picture, paintable);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_picture_keep_aspect_ratio(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);
+
+  GtkPicture *picture;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "picture", (gpointer *) &picture);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_get_boolean(env, gtk_picture_get_keep_aspect_ratio(picture), &result);
+    assert(err == 0);
+  } else {
+    bool keep;
+    err = bare_gtk__read_bool(env, argv[1], "keepAspectRatio", &keep);
+    if (err < 0) return NULL;
+
+    gtk_picture_set_keep_aspect_ratio(picture, keep);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_picture_can_shrink(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);
+
+  GtkPicture *picture;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "picture", (gpointer *) &picture);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_get_boolean(env, gtk_picture_get_can_shrink(picture), &result);
+    assert(err == 0);
+  } else {
+    bool shrink;
+    err = bare_gtk__read_bool(env, argv[1], "canShrink", &shrink);
+    if (err < 0) return NULL;
+
+    gtk_picture_set_can_shrink(picture, shrink);
+  }
+
+  return result;
+}
+
+#endif // BARE_GTK_PICTURE_H