bare-gtk 0.2.1 → 0.3.0

package/lib/constants.d.ts

@@ -0,0 +1,40 @@
+export const ORIENTATION_HORIZONTAL: number
+export const ORIENTATION_VERTICAL: number
+export const OVERFLOW_VISIBLE: number
+export const OVERFLOW_HIDDEN: number
+export const WRAP_WORD: number
+export const WRAP_CHAR: number
+export const WRAP_WORD_CHAR: number
+export const ELLIPSIZE_NONE: number
+export const ELLIPSIZE_START: number
+export const ELLIPSIZE_MIDDLE: number
+export const ELLIPSIZE_END: number
+export const JUSTIFY_LEFT: number
+export const JUSTIFY_RIGHT: number
+export const JUSTIFY_CENTER: number
+export const JUSTIFY_FILL: number
+export const STYLE_PROVIDER_PRIORITY_FALLBACK: number
+export const STYLE_PROVIDER_PRIORITY_THEME: number
+export const STYLE_PROVIDER_PRIORITY_SETTINGS: number
+export const STYLE_PROVIDER_PRIORITY_APPLICATION: number
+export const STYLE_PROVIDER_PRIORITY_USER: number
+export const PROPAGATION_PHASE_NONE: number
+export const PROPAGATION_PHASE_CAPTURE: number
+export const PROPAGATION_PHASE_BUBBLE: number
+export const PROPAGATION_PHASE_TARGET: number
+export const EVENT_SEQUENCE_STATE_NONE: number
+export const EVENT_SEQUENCE_STATE_CLAIMED: number
+export const EVENT_SEQUENCE_STATE_DENIED: number
+export const INPUT_SOURCE_MOUSE: number
+export const INPUT_SOURCE_PEN: number
+export const INPUT_SOURCE_KEYBOARD: number
+export const INPUT_SOURCE_TOUCHSCREEN: number
+export const INPUT_SOURCE_TOUCHPAD: number
+export const INPUT_SOURCE_TRACKPOINT: number
+export const INPUT_SOURCE_TABLET_PAD: number
+export const POLICY_ALWAYS: number
+export const POLICY_AUTOMATIC: number
+export const POLICY_NEVER: number
+export const POLICY_EXTERNAL: number
+export const SCROLL_MINIMUM: number
+export const SCROLL_NATURAL: number

package/lib/constants.js

@@ -0,0 +1,51 @@
+const binding = require('../binding')
+
+exports.ORIENTATION_HORIZONTAL = binding.ORIENTATION_HORIZONTAL
+exports.ORIENTATION_VERTICAL = binding.ORIENTATION_VERTICAL
+
+exports.OVERFLOW_VISIBLE = binding.OVERFLOW_VISIBLE
+exports.OVERFLOW_HIDDEN = binding.OVERFLOW_HIDDEN
+
+exports.WRAP_WORD = binding.WRAP_WORD
+exports.WRAP_CHAR = binding.WRAP_CHAR
+exports.WRAP_WORD_CHAR = binding.WRAP_WORD_CHAR
+
+exports.ELLIPSIZE_NONE = binding.ELLIPSIZE_NONE
+exports.ELLIPSIZE_START = binding.ELLIPSIZE_START
+exports.ELLIPSIZE_MIDDLE = binding.ELLIPSIZE_MIDDLE
+exports.ELLIPSIZE_END = binding.ELLIPSIZE_END
+exports.JUSTIFY_LEFT = binding.JUSTIFY_LEFT
+exports.JUSTIFY_RIGHT = binding.JUSTIFY_RIGHT
+exports.JUSTIFY_CENTER = binding.JUSTIFY_CENTER
+exports.JUSTIFY_FILL = binding.JUSTIFY_FILL
+
+exports.STYLE_PROVIDER_PRIORITY_FALLBACK = binding.STYLE_PROVIDER_PRIORITY_FALLBACK
+exports.STYLE_PROVIDER_PRIORITY_THEME = binding.STYLE_PROVIDER_PRIORITY_THEME
+exports.STYLE_PROVIDER_PRIORITY_SETTINGS = binding.STYLE_PROVIDER_PRIORITY_SETTINGS
+exports.STYLE_PROVIDER_PRIORITY_APPLICATION = binding.STYLE_PROVIDER_PRIORITY_APPLICATION
+exports.STYLE_PROVIDER_PRIORITY_USER = binding.STYLE_PROVIDER_PRIORITY_USER
+
+exports.PROPAGATION_PHASE_NONE = binding.PROPAGATION_PHASE_NONE
+exports.PROPAGATION_PHASE_CAPTURE = binding.PROPAGATION_PHASE_CAPTURE
+exports.PROPAGATION_PHASE_BUBBLE = binding.PROPAGATION_PHASE_BUBBLE
+exports.PROPAGATION_PHASE_TARGET = binding.PROPAGATION_PHASE_TARGET
+
+exports.EVENT_SEQUENCE_STATE_NONE = binding.EVENT_SEQUENCE_STATE_NONE
+exports.EVENT_SEQUENCE_STATE_CLAIMED = binding.EVENT_SEQUENCE_STATE_CLAIMED
+exports.EVENT_SEQUENCE_STATE_DENIED = binding.EVENT_SEQUENCE_STATE_DENIED
+
+exports.INPUT_SOURCE_MOUSE = binding.INPUT_SOURCE_MOUSE
+exports.INPUT_SOURCE_PEN = binding.INPUT_SOURCE_PEN
+exports.INPUT_SOURCE_KEYBOARD = binding.INPUT_SOURCE_KEYBOARD
+exports.INPUT_SOURCE_TOUCHSCREEN = binding.INPUT_SOURCE_TOUCHSCREEN
+exports.INPUT_SOURCE_TOUCHPAD = binding.INPUT_SOURCE_TOUCHPAD
+exports.INPUT_SOURCE_TRACKPOINT = binding.INPUT_SOURCE_TRACKPOINT
+exports.INPUT_SOURCE_TABLET_PAD = binding.INPUT_SOURCE_TABLET_PAD
+
+exports.POLICY_ALWAYS = binding.POLICY_ALWAYS
+exports.POLICY_AUTOMATIC = binding.POLICY_AUTOMATIC
+exports.POLICY_NEVER = binding.POLICY_NEVER
+exports.POLICY_EXTERNAL = binding.POLICY_EXTERNAL
+
+exports.SCROLL_MINIMUM = binding.SCROLL_MINIMUM
+exports.SCROLL_NATURAL = binding.SCROLL_NATURAL

package/lib/css-provider.d.ts

@@ -0,0 +1,13 @@
+import GObject = require('./object')
+
+/** A style sheet, as a `GtkCssProvider`. Apply it with `StyleContext.addProviderForDisplay()`. */
+interface GTKCssProvider extends GObject {
+  /** Load the style sheet from CSS source. */
+  loadFromData(data: string): this
+}
+
+declare class GTKCssProvider {
+  constructor()
+}
+
+export = GTKCssProvider

package/lib/css-provider.h

@@ -0,0 +1,56 @@
+#ifndef BARE_GTK_CSS_PROVIDER_H
+#define BARE_GTK_CSS_PROVIDER_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_css_provider_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);
+
+  GtkCssProvider *provider = gtk_css_provider_new();
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, provider), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_css_provider_load_from_data(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);
+
+  GtkCssProvider *provider;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "cssProvider", (gpointer *) &provider);
+  if (err < 0) return NULL;
+
+  char *data;
+  err = bare_gtk__read_string(env, argv[1], "data", &data);
+  if (err < 0) return NULL;
+
+  gtk_css_provider_load_from_data(provider, data, -1);
+
+  g_free(data);
+
+  return NULL;
+}
+
+#endif // BARE_GTK_CSS_PROVIDER_H

package/lib/css-provider.js

@@ -0,0 +1,14 @@
+const binding = require('../binding')
+const GObject = require('./object')
+
+module.exports = exports = class GTKCssProvider extends GObject {
+  _init(opts) {
+    return binding.cssProviderInit()
+  }
+
+  loadFromData(data) {
+    binding.cssProviderLoadFromData(this._tag, data)
+
+    return this
+  }
+}

package/lib/cursor.d.ts

@@ -0,0 +1,35 @@
+import GObject = require('./object')
+import GDKTexture = require('./texture')
+
+/** A mouse cursor, as a `GdkCursor`. */
+interface GDKCursor extends GObject {
+  readonly name: string | null
+
+  readonly fallback: GDKCursor | null
+
+  readonly texture: GDKTexture | null
+
+  readonly hotspotX: number
+
+  readonly hotspotY: number
+}
+
+declare class GDKCursor {
+  protected constructor()
+
+  /**
+   * Create the cursor called `name`, such as `'pointer'`. `fallback` is shown where that cursor
+   * does not exist.
+   */
+  static newFromName(name: string, fallback?: GDKCursor | null): GDKCursor | null
+
+  /** Create a cursor from a texture, with its hotspot at `hotspotX`, `hotspotY`. */
+  static newFromTexture(
+    texture: GDKTexture,
+    hotspotX: number,
+    hotspotY: number,
+    fallback?: GDKCursor | null
+  ): GDKCursor | null
+}
+
+export = GDKCursor

package/lib/cursor.h

@@ -0,0 +1,220 @@
+#ifndef BARE_GTK_CURSOR_H
+#define BARE_GTK_CURSOR_H
+
+#include <assert.h>
+#include <js.h>
+#include <utf.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+// A new cursor is not floating, so the registry takes its own reference and the
+// one from this call is dropped.
+static js_value_t *
+bare_gtk_cursor_new_from_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 == 2);
+
+  char *name;
+  err = bare_gtk__read_string(env, argv[0], "name", &name);
+  if (err < 0) return NULL;
+
+  GdkCursor *fallback;
+  err = bare_gtk__read_tag_or_null(env, state->registry, argv[1], "fallback", (gpointer *) &fallback);
+  if (err < 0) {
+    g_free(name);
+
+    return NULL;
+  }
+
+  GdkCursor *cursor = gdk_cursor_new_from_name(name, fallback);
+
+  g_free(name);
+
+  js_value_t *result;
+
+  if (cursor == NULL) {
+    err = js_get_null(env, &result);
+    assert(err == 0);
+
+    return result;
+  }
+
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, cursor), &result);
+  assert(err == 0);
+
+  g_object_unref(cursor);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_cursor_new_from_texture(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 4;
+  js_value_t *argv[4];
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 4);
+
+  GdkTexture *texture;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "texture", (gpointer *) &texture);
+  if (err < 0) return NULL;
+
+  int32_t hotspot_x;
+  err = bare_gtk__read_int32(env, argv[1], "hotspot_x", &hotspot_x);
+  if (err < 0) return NULL;
+
+  int32_t hotspot_y;
+  err = bare_gtk__read_int32(env, argv[2], "hotspot_y", &hotspot_y);
+  if (err < 0) return NULL;
+
+  GdkCursor *fallback;
+  err = bare_gtk__read_tag_or_null(env, state->registry, argv[3], "fallback", (gpointer *) &fallback);
+  if (err < 0) return NULL;
+
+  GdkCursor *cursor = gdk_cursor_new_from_texture(texture, hotspot_x, hotspot_y, fallback);
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, cursor), &result);
+  assert(err == 0);
+
+  g_object_unref(cursor);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_cursor_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);
+
+  GdkCursor *cursor;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "cursor", (gpointer *) &cursor);
+  if (err < 0) return NULL;
+
+  const char *name = gdk_cursor_get_name(cursor);
+
+  js_value_t *result;
+
+  if (name == NULL) {
+    err = js_get_null(env, &result);
+    assert(err == 0);
+  } else {
+    err = js_create_string_utf8(env, (const utf8_t *) name, (size_t) -1, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_cursor_fallback(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);
+
+  GdkCursor *cursor;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "cursor", (gpointer *) &cursor);
+  if (err < 0) return NULL;
+
+  return bare_gtk__create_tag(env, state, gdk_cursor_get_fallback(cursor));
+}
+
+static js_value_t *
+bare_gtk_cursor_texture(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);
+
+  GdkCursor *cursor;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "cursor", (gpointer *) &cursor);
+  if (err < 0) return NULL;
+
+  return bare_gtk__create_tag(env, state, gdk_cursor_get_texture(cursor));
+}
+
+static js_value_t *
+bare_gtk_cursor_hotspot_x(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);
+
+  GdkCursor *cursor;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "cursor", (gpointer *) &cursor);
+  if (err < 0) return NULL;
+
+  js_value_t *result;
+  err = js_create_int32(env, gdk_cursor_get_hotspot_x(cursor), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_cursor_hotspot_y(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);
+
+  GdkCursor *cursor;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "cursor", (gpointer *) &cursor);
+  if (err < 0) return NULL;
+
+  js_value_t *result;
+  err = js_create_int32(env, gdk_cursor_get_hotspot_y(cursor), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+#endif // BARE_GTK_CURSOR_H

package/lib/cursor.js

@@ -0,0 +1,45 @@
+const binding = require('../binding')
+const wrap = require('./wrap')
+const GObject = require('./object')
+const GDKTexture = require('./texture')
+
+module.exports = exports = class GDKCursor extends GObject {
+  static newFromName(name, fallback = null) {
+    return wrap(
+      GDKCursor,
+      binding.cursorNewFromName(name, fallback === null ? null : fallback._tag)
+    )
+  }
+
+  static newFromTexture(texture, hotspotX, hotspotY, fallback = null) {
+    return wrap(
+      GDKCursor,
+      binding.cursorNewFromTexture(
+        texture._tag,
+        hotspotX,
+        hotspotY,
+        fallback === null ? null : fallback._tag
+      )
+    )
+  }
+
+  get name() {
+    return binding.cursorName(this._tag)
+  }
+
+  get fallback() {
+    return wrap(GDKCursor, binding.cursorFallback(this._tag))
+  }
+
+  get texture() {
+    return wrap(GDKTexture, binding.cursorTexture(this._tag))
+  }
+
+  get hotspotX() {
+    return binding.cursorHotspotX(this._tag)
+  }
+
+  get hotspotY() {
+    return binding.cursorHotspotY(this._tag)
+  }
+}

package/lib/device.d.ts

@@ -0,0 +1,13 @@
+import GObject = require('./object')
+
+/** An input device, as a `GdkDevice`. */
+interface GTKDevice extends GObject {
+  /** What kind of device it is, as an `INPUT_SOURCE_*` constant. */
+  readonly source: number
+}
+
+declare class GTKDevice {
+  protected constructor()
+}
+
+export = GTKDevice

package/lib/device.h

@@ -0,0 +1,35 @@
+#ifndef BARE_GTK_DEVICE_H
+#define BARE_GTK_DEVICE_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_device_source(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);
+
+  GdkDevice *device;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "device", (gpointer *) &device);
+  if (err < 0) return NULL;
+
+  js_value_t *result;
+  err = js_create_uint32(env, gdk_device_get_source(device), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+#endif // BARE_GTK_DEVICE_H

package/lib/device.js

@@ -0,0 +1,8 @@
+const binding = require('../binding')
+const GObject = require('./object')
+
+module.exports = exports = class GTKDevice extends GObject {
+  get source() {
+    return binding.deviceSource(this._tag)
+  }
+}

package/lib/dialog.d.ts

@@ -0,0 +1,41 @@
+import GTKWidget = require('./widget')
+
+/** A dialog window, as a `GtkDialog`. */
+interface GTKDialog<M extends Record<keyof M, unknown[]> = GTKDialog.Events> extends GTKWidget<M> {
+  /**
+   * Add a button that closes the dialog with `response`. Use 0 and up for your own buttons; the
+   * negative values are the `RESPONSE` constants. Returns the button.
+   */
+  addButton(label: string, response: number): GTKWidget
+
+  /** Close the dialog with `response`, as if a button with that response was pressed. */
+  response(response: number): this
+}
+
+declare class GTKDialog<M extends Record<keyof M, unknown[]> = GTKDialog.Events> {
+  protected constructor()
+
+  /** The responses GTK defines. They are all negative. */
+  static readonly RESPONSE: {
+    readonly NONE: number
+    readonly REJECT: number
+    readonly ACCEPT: number
+    readonly DELETE_EVENT: number
+    readonly OK: number
+    readonly CANCEL: number
+    readonly CLOSE: number
+    readonly YES: number
+    readonly NO: number
+    readonly APPLY: number
+    readonly HELP: number
+  }
+}
+
+declare namespace GTKDialog {
+  export interface Events {
+    /** A button was pressed or the dialog was closed. */
+    response: [response: number]
+  }
+}
+
+export = GTKDialog

package/lib/dialog.js

@@ -0,0 +1,37 @@
+const binding = require('../binding')
+const wrap = require('./wrap')
+const GTKWidget = require('./widget')
+
+module.exports = exports = class GTKDialog extends GTKWidget {
+  static _events = {
+    response: binding.DIALOG_EVENT_RESPONSE
+  }
+
+  _eventMask(mask) {
+    binding.dialogEventMask(this._tag, mask)
+  }
+
+  addButton(label, response) {
+    return wrap(GTKWidget, binding.dialogAddButton(this._tag, label, response))
+  }
+
+  response(response) {
+    binding.dialogResponse(this._tag, response)
+
+    return this
+  }
+}
+
+exports.RESPONSE = {
+  NONE: binding.DIALOG_RESPONSE_NONE,
+  REJECT: binding.DIALOG_RESPONSE_REJECT,
+  ACCEPT: binding.DIALOG_RESPONSE_ACCEPT,
+  DELETE_EVENT: binding.DIALOG_RESPONSE_DELETE_EVENT,
+  OK: binding.DIALOG_RESPONSE_OK,
+  CANCEL: binding.DIALOG_RESPONSE_CANCEL,
+  CLOSE: binding.DIALOG_RESPONSE_CLOSE,
+  YES: binding.DIALOG_RESPONSE_YES,
+  NO: binding.DIALOG_RESPONSE_NO,
+  APPLY: binding.DIALOG_RESPONSE_APPLY,
+  HELP: binding.DIALOG_RESPONSE_HELP
+}

package/lib/display.d.ts

@@ -0,0 +1,25 @@
+import GObject = require('./object')
+import GDKClipboard = require('./clipboard')
+import GDKMonitor = require('./monitor')
+import GDKSurface = require('./surface')
+
+/** A connection to the display server, as a `GdkDisplay`. */
+interface GDKDisplay extends GObject {
+  /** The monitor that most of `surface` is on, or `null`. */
+  getMonitorAtSurface(surface: GDKSurface): GDKMonitor | null
+
+  /** The clipboard used for copy and paste. */
+  getClipboard(): GDKClipboard
+
+  /** The selection that middle click pastes. */
+  getPrimaryClipboard(): GDKClipboard
+}
+
+declare class GDKDisplay {
+  protected constructor()
+
+  /** The display the app opened, or `null` before GTK is initialised. */
+  static getDefault(): GDKDisplay | null
+}
+
+export = GDKDisplay