bare-gtk 0.2.0 → 0.3.0

package/lib/gesture.h

@@ -0,0 +1,73 @@
+#ifndef BARE_GTK_GESTURE_H
+#define BARE_GTK_GESTURE_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_gesture_set_state(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);
+
+  GtkGesture *gesture;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "gesture", (gpointer *) &gesture);
+  if (err < 0) return NULL;
+
+  uint32_t sequence_state;
+  err = bare_gtk__read_uint32(env, argv[1], "state", &sequence_state);
+  if (err < 0) return NULL;
+
+  js_value_t *result;
+  err = js_get_boolean(env, gtk_gesture_set_state(gesture, sequence_state), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_gesture_single_button(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);
+
+  GtkGestureSingle *gesture;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "gesture", (gpointer *) &gesture);
+  if (err < 0) return NULL;
+
+  if (argc == 1) {
+    js_value_t *result;
+    err = js_create_uint32(env, gtk_gesture_single_get_button(gesture), &result);
+    assert(err == 0);
+
+    return result;
+  }
+
+  uint32_t button;
+  err = bare_gtk__read_uint32(env, argv[1], "button", &button);
+  if (err < 0) return NULL;
+
+  gtk_gesture_single_set_button(gesture, button);
+
+  return NULL;
+}
+
+#endif // BARE_GTK_GESTURE_H

package/lib/gesture.js

@@ -0,0 +1,8 @@
+const binding = require('../binding')
+const GTKEventController = require('./event-controller')
+
+module.exports = exports = class GTKGesture extends GTKEventController {
+  setState(state) {
+    return binding.gestureSetState(this._tag, state)
+  }
+}

package/lib/handle.d.ts

@@ -0,0 +1,5 @@
+import { Wrapper } from 'bare-gobject-registry'
+
+/** Return the tag of `object` in this addon, adopting it from another addon first if needed. */
+export function adopt(object: Wrapper): number
+export function adopt(object: null | undefined): null

package/lib/handle.js

@@ -0,0 +1,6 @@
+const binding = require('../binding')
+const registry = require('bare-gobject-registry')
+
+exports.adopt = function adopt(object) {
+  return registry.adopt(binding, object)
+}

package/lib/label.d.ts

@@ -0,0 +1,36 @@
+import GTKWidget = require('./widget')
+
+/** A widget that shows text, as a `GtkLabel`. */
+interface GTKLabel extends GTKWidget {
+  text: string
+
+  /** Show Pango markup, such as `'<b>bold</b>'`. */
+  setMarkup(markup: string): this
+
+  /** Whether long lines wrap. */
+  wrap: boolean
+
+  /** How lines wrap, as a `WRAP_*` constant. */
+  wrapMode: number
+
+  /** Where the text sits horizontally, from 0 (left) to 1 (right). */
+  xalign: number
+
+  /** Where the text sits vertically, from 0 (top) to 1 (bottom). */
+  yalign: number
+
+  /** How lines line up with each other, as a `JUSTIFY_*` constant. */
+  justify: number
+
+  /** The most lines to show when `ellipsize` is set. -1 means no limit. */
+  lines: number
+
+  /** Where text that does not fit is cut off with "...", as an `ELLIPSIZE_*` constant. */
+  ellipsize: number
+}
+
+declare class GTKLabel {
+  constructor()
+}
+
+export = GTKLabel

package/lib/label.h

@@ -0,0 +1,269 @@
+#ifndef BARE_GTK_LABEL_H
+#define BARE_GTK_LABEL_H
+
+#include <assert.h>
+#include <js.h>
+#include <utf.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_label_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 *label = gtk_label_new(NULL);
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, label), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_label_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);
+
+  GtkLabel *label;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "label", (gpointer *) &label);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    const char *text = gtk_label_get_text(label);
+
+    err = js_create_string_utf8(env, (const utf8_t *) 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_label_set_text(label, text);
+
+    g_free(text);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_label_wrap(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);
+
+  GtkLabel *label;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "label", (gpointer *) &label);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_get_boolean(env, gtk_label_get_wrap(label), &result);
+    assert(err == 0);
+  } else {
+    bool wrap;
+    err = bare_gtk__read_bool(env, argv[1], "wrap", &wrap);
+    if (err < 0) return NULL;
+
+    gtk_label_set_wrap(label, wrap);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_label_wrap_mode(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);
+
+  GtkLabel *label;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "label", (gpointer *) &label);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_create_int32(env, gtk_label_get_wrap_mode(label), &result);
+    assert(err == 0);
+  } else {
+    int32_t mode;
+    err = bare_gtk__read_int32(env, argv[1], "wrapMode", &mode);
+    if (err < 0) return NULL;
+
+    gtk_label_set_wrap_mode(label, mode);
+  }
+
+  return result;
+}
+
+#define V(name, get, set) \
+  static js_value_t * \
+  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); \
+\
+    GtkLabel *label; \
+    err = bare_gobject_read_tag(env, state->registry, argv[0], "label", (gpointer *) &label); \
+    if (err < 0) return NULL; \
+\
+    js_value_t *result = NULL; \
+\
+    if (argc == 1) { \
+      err = js_create_double(env, get(label), &result); \
+      assert(err == 0); \
+    } else { \
+      double align; \
+      err = bare_gtk__read_double(env, argv[1], "align", &align); \
+      if (err < 0) return NULL; \
+\
+      set(label, (float) align); \
+    } \
+\
+    return result; \
+  }
+
+V(bare_gtk_label_xalign, gtk_label_get_xalign, gtk_label_set_xalign)
+V(bare_gtk_label_yalign, gtk_label_get_yalign, gtk_label_set_yalign)
+#undef V
+
+static js_value_t *
+bare_gtk_label_justify(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);
+
+  GtkLabel *label;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "label", (gpointer *) &label);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_create_int32(env, gtk_label_get_justify(label), &result);
+    assert(err == 0);
+  } else {
+    int32_t justify;
+    err = bare_gtk__read_int32(env, argv[1], "justify", &justify);
+    if (err < 0) return NULL;
+
+    gtk_label_set_justify(label, justify);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_label_set_markup(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);
+
+  GtkLabel *label;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "label", (gpointer *) &label);
+  if (err < 0) return NULL;
+
+  char *markup;
+  err = bare_gtk__read_string(env, argv[1], "markup", &markup);
+  if (err < 0) return NULL;
+
+  gtk_label_set_markup(label, markup);
+
+  g_free(markup);
+
+  return NULL;
+}
+
+#define V(name, get, set, type) \
+  static js_value_t * \
+  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); \
+\
+    GtkLabel *label; \
+    err = bare_gobject_read_tag(env, state->registry, argv[0], "label", (gpointer *) &label); \
+    if (err < 0) return NULL; \
+\
+    js_value_t *result = NULL; \
+\
+    if (argc == 1) { \
+      err = js_create_int32(env, get(label), &result); \
+      assert(err == 0); \
+    } else { \
+      int32_t value; \
+      err = bare_gtk__read_int32(env, argv[1], #name, &value); \
+      if (err < 0) return NULL; \
+\
+      set(label, (type) value); \
+    } \
+\
+    return result; \
+  }
+
+V(bare_gtk_label_lines, gtk_label_get_lines, gtk_label_set_lines, int)
+V(bare_gtk_label_ellipsize, gtk_label_get_ellipsize, gtk_label_set_ellipsize, PangoEllipsizeMode)
+#undef V
+
+#endif // BARE_GTK_LABEL_H

package/lib/label.js

@@ -0,0 +1,78 @@
+const binding = require('../binding')
+const GTKWidget = require('./widget')
+
+module.exports = exports = class GTKLabel extends GTKWidget {
+  _init(opts) {
+    return binding.labelInit()
+  }
+
+  get text() {
+    return binding.labelText(this._tag)
+  }
+
+  set text(value) {
+    binding.labelText(this._tag, value)
+  }
+
+  setMarkup(markup) {
+    binding.labelSetMarkup(this._tag, markup)
+
+    return this
+  }
+
+  get wrap() {
+    return binding.labelWrap(this._tag)
+  }
+
+  set wrap(value) {
+    binding.labelWrap(this._tag, value)
+  }
+
+  get wrapMode() {
+    return binding.labelWrapMode(this._tag)
+  }
+
+  set wrapMode(value) {
+    binding.labelWrapMode(this._tag, value)
+  }
+
+  get xalign() {
+    return binding.labelXalign(this._tag)
+  }
+
+  set xalign(value) {
+    binding.labelXalign(this._tag, value)
+  }
+
+  get yalign() {
+    return binding.labelYalign(this._tag)
+  }
+
+  set yalign(value) {
+    binding.labelYalign(this._tag, value)
+  }
+
+  get justify() {
+    return binding.labelJustify(this._tag)
+  }
+
+  set justify(value) {
+    binding.labelJustify(this._tag, value)
+  }
+
+  get lines() {
+    return binding.labelLines(this._tag)
+  }
+
+  set lines(value) {
+    binding.labelLines(this._tag, value)
+  }
+
+  get ellipsize() {
+    return binding.labelEllipsize(this._tag)
+  }
+
+  set ellipsize(value) {
+    binding.labelEllipsize(this._tag, value)
+  }
+}

package/lib/layout-child.d.ts

@@ -0,0 +1,13 @@
+import GObject = require('./object')
+import GTKWidget = require('./widget')
+
+/** What a layout manager keeps about one child, as a `GtkLayoutChild`. */
+interface GTKLayoutChild extends GObject {
+  readonly childWidget: GTKWidget | null
+}
+
+declare class GTKLayoutChild {
+  protected constructor()
+}
+
+export = GTKLayoutChild

package/lib/layout-child.h

@@ -0,0 +1,35 @@
+#ifndef BARE_GTK_LAYOUT_CHILD_H
+#define BARE_GTK_LAYOUT_CHILD_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); \
+\
+    GtkLayoutChild *layout_child; \
+    err = bare_gobject_read_tag(env, state->registry, argv[0], "layoutChild", (gpointer *) &layout_child); \
+    if (err < 0) return NULL; \
+\
+    return bare_gtk__create_tag(env, state, fn(layout_child)); \
+  }
+
+V(bare_gtk_layout_child_child_widget, gtk_layout_child_get_child_widget)
+#undef V
+
+#endif // BARE_GTK_LAYOUT_CHILD_H

package/lib/layout-child.js

@@ -0,0 +1,10 @@
+const binding = require('../binding')
+const GObject = require('./object')
+const GTKWidget = require('./widget')
+const wrap = require('./wrap')
+
+module.exports = exports = class GTKLayoutChild extends GObject {
+  get childWidget() {
+    return wrap(GTKWidget, binding.layoutChildChildWidget(this._tag))
+  }
+}

package/lib/layout-manager.d.ts

@@ -0,0 +1,15 @@
+import GObject = require('./object')
+import GTKLayoutChild = require('./layout-child')
+import GTKWidget = require('./widget')
+
+/** Places the children of a widget, as a `GtkLayoutManager`. */
+interface GTKLayoutManager<M extends Record<keyof M, unknown[]> = {}> extends GObject<M> {
+  /** What the manager keeps about `widget`, which must be a child of its widget. */
+  getLayoutChild(widget: GTKWidget): GTKLayoutChild | null
+}
+
+declare class GTKLayoutManager<M extends Record<keyof M, unknown[]> = {}> {
+  protected constructor()
+}
+
+export = GTKLayoutManager

package/lib/layout-manager.h

@@ -0,0 +1,42 @@
+#ifndef BARE_GTK_LAYOUT_MANAGER_H
+#define BARE_GTK_LAYOUT_MANAGER_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_layout_manager_layout_child(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);
+
+  GtkLayoutManager *manager;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "layoutManager", (gpointer *) &manager);
+  if (err < 0) return NULL;
+
+  GtkWidget *child;
+  err = bare_gobject_read_tag(env, state->registry, argv[1], "child", (gpointer *) &child);
+  if (err < 0) return NULL;
+
+  if (gtk_widget_get_parent(child) == NULL) {
+    err = js_throw_error(env, NULL, "Widget has no parent");
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  return bare_gtk__create_tag(env, state, gtk_layout_manager_get_layout_child(manager, child));
+}
+
+#endif // BARE_GTK_LAYOUT_MANAGER_H

package/lib/layout-manager.js

@@ -0,0 +1,15 @@
+const binding = require('../binding')
+const GObject = require('./object')
+const GTKLayoutChild = require('./layout-child')
+const wrap = require('./wrap')
+
+module.exports = exports = class GTKLayoutManager extends GObject {
+  static layoutChild = GTKLayoutChild
+
+  getLayoutChild(widget) {
+    return wrap(
+      this.constructor.layoutChild,
+      binding.layoutManagerLayoutChild(this._tag, widget._tag)
+    )
+  }
+}

package/lib/message-dialog.d.ts

@@ -0,0 +1,26 @@
+import GTKDialog = require('./dialog')
+import GTKWindow = require('./window')
+
+/** A dialog that shows a message, as a `GtkMessageDialog`. Add its buttons with `addButton()`. */
+interface GTKMessageDialog extends GTKDialog {
+  /** Text shown below the main message. */
+  set secondaryText(text: string)
+}
+
+declare class GTKMessageDialog {
+  /**
+   * Create a message dialog. `messageType` is a `MESSAGE_TYPE` constant and defaults to
+   * `MESSAGE_TYPE.OTHER`.
+   */
+  constructor(opts?: { parent?: GTKWindow | null; messageType?: number; text?: string })
+
+  static readonly MESSAGE_TYPE: {
+    readonly INFO: number
+    readonly WARNING: number
+    readonly QUESTION: number
+    readonly ERROR: number
+    readonly OTHER: number
+  }
+}
+
+export = GTKMessageDialog