bare-gtk 0.2.0 → 0.3.0

package/lib/text-view.h

@@ -0,0 +1,247 @@
+#ifndef BARE_GTK_TEXT_VIEW_H
+#define BARE_GTK_TEXT_VIEW_H
+
+#include <assert.h>
+#include <js.h>
+#include <utf.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+enum {
+  bare_gtk_text_view_event_has_focus = 1 << 0,
+  bare_gtk_text_view_event_is_focus = 1 << 1,
+};
+
+typedef struct {
+  GtkTextView handle;
+
+  bare_gtk_state_t *state;
+
+  uint32_t events;
+
+  gulong on_has_focus;
+  gulong on_is_focus;
+} BareTextView;
+
+typedef struct {
+  GtkTextViewClass parent;
+} BareTextViewClass;
+
+G_DEFINE_TYPE(BareTextView, bare_text_view, GTK_TYPE_TEXT_VIEW)
+
+static void
+bare_text_view_init(BareTextView *self) {}
+
+static void
+bare_text_view_class_init(BareTextViewClass *class) {}
+
+BareTextView *
+bare_text_view_new(void) {
+  return g_object_new(bare_text_view_get_type(), NULL);
+}
+
+static void
+bare_gtk_text_view__on_has_focus(GObject *object, GParamSpec *spec, gpointer data) {
+  BareTextView *self = (BareTextView *) 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, which is not the same as
+// having the keyboard.
+static void
+bare_gtk_text_view__on_is_focus(GObject *object, GParamSpec *spec, gpointer data) {
+  BareTextView *self = (BareTextView *) object;
+
+  bare_gtk__emit(self->state, object, "is-focus", 1, (const double[]) {gtk_widget_is_focus(GTK_WIDGET(object)) ? 1 : 0});
+}
+
+static js_value_t *
+bare_gtk_text_view_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);
+
+  BareTextView *view = bare_text_view_new();
+
+  view->state = state;
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, view), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_text_view_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);
+
+  BareTextView *view;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "textView", (gpointer *) &view);
+  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 = view->events ^ events;
+
+  view->events = events;
+
+#define V(bit, field, signal, callback) \
+  if ((changed & (bit)) != 0) { \
+    if ((events & (bit)) != 0) { \
+      view->field = g_signal_connect(view, signal, G_CALLBACK(callback), state); \
+    } else { \
+      g_signal_handler_disconnect(view, view->field); \
+    } \
+  }
+
+  V(bare_gtk_text_view_event_has_focus, on_has_focus, "notify::has-focus", bare_gtk_text_view__on_has_focus)
+  V(bare_gtk_text_view_event_is_focus, on_is_focus, "notify::is-focus", bare_gtk_text_view__on_is_focus)
+#undef V
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_text_view_buffer(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);
+
+  GtkTextView *view;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "textView", (gpointer *) &view);
+  if (err < 0) return NULL;
+
+  return bare_gtk__create_tag(env, state, gtk_text_view_get_buffer(view));
+}
+
+static js_value_t *
+bare_gtk_text_view_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);
+
+  GtkTextView *view;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "textView", (gpointer *) &view);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_get_boolean(env, gtk_text_view_get_editable(view), &result);
+    assert(err == 0);
+  } else {
+    bool editable;
+    err = bare_gtk__read_bool(env, argv[1], "editable", &editable);
+    if (err < 0) return NULL;
+
+    gtk_text_view_set_editable(view, editable);
+  }
+
+  return result;
+}
+
+#define BARE_GTK_TEXT_VIEW_ENUM(name, getter, setter, type) \
+  static js_value_t * \
+  bare_gtk_text_view_##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); \
+\
+    GtkTextView *view; \
+    err = bare_gobject_read_tag(env, state->registry, argv[0], "textView", (gpointer *) &view); \
+    if (err < 0) return NULL; \
+\
+    js_value_t *result = NULL; \
+\
+    if (argc == 1) { \
+      err = js_create_int32(env, (int32_t) getter(view), &result); \
+      assert(err == 0); \
+    } else { \
+      int32_t value; \
+      err = bare_gtk__read_int32(env, argv[1], #name, &value); \
+      if (err < 0) return NULL; \
+\
+      setter(view, (type) value); \
+    } \
+\
+    return result; \
+  }
+
+BARE_GTK_TEXT_VIEW_ENUM(wrap_mode, gtk_text_view_get_wrap_mode, gtk_text_view_set_wrap_mode, GtkWrapMode)
+BARE_GTK_TEXT_VIEW_ENUM(input_purpose, gtk_text_view_get_input_purpose, gtk_text_view_set_input_purpose, GtkInputPurpose)
+BARE_GTK_TEXT_VIEW_ENUM(input_hints, gtk_text_view_get_input_hints, gtk_text_view_set_input_hints, GtkInputHints)
+#undef BARE_GTK_TEXT_VIEW_ENUM
+
+
+static js_value_t *
+bare_gtk_text_view_justification(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);
+
+  GtkTextView *text_view;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "textView", (gpointer *) &text_view);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_create_int32(env, gtk_text_view_get_justification(text_view), &result);
+    assert(err == 0);
+  } else {
+    int32_t justification;
+    err = bare_gtk__read_int32(env, argv[1], "justification", &justification);
+    if (err < 0) return NULL;
+
+    gtk_text_view_set_justification(text_view, justification);
+  }
+
+  return result;
+}
+
+#endif // BARE_GTK_TEXT_VIEW_H

package/lib/text-view.js

@@ -0,0 +1,63 @@
+const binding = require('../binding')
+const wrap = require('./wrap')
+const GTKTextBuffer = require('./text-buffer')
+const GTKWidget = require('./widget')
+
+module.exports = exports = class GTKTextView extends GTKWidget {
+  static _events = {
+    'has-focus': binding.TEXT_VIEW_EVENT_HAS_FOCUS,
+    'is-focus': binding.TEXT_VIEW_EVENT_IS_FOCUS
+  }
+
+  _init(opts) {
+    return binding.textViewInit()
+  }
+
+  _eventMask(mask) {
+    binding.textViewEventMask(this._tag, mask)
+  }
+
+  get buffer() {
+    return wrap(GTKTextBuffer, binding.textViewBuffer(this._tag))
+  }
+
+  get editable() {
+    return binding.textViewEditable(this._tag)
+  }
+
+  set editable(value) {
+    binding.textViewEditable(this._tag, value)
+  }
+
+  get wrapMode() {
+    return binding.textViewWrapMode(this._tag)
+  }
+
+  set wrapMode(value) {
+    binding.textViewWrapMode(this._tag, value)
+  }
+
+  get inputPurpose() {
+    return binding.textViewInputPurpose(this._tag)
+  }
+
+  set inputPurpose(value) {
+    binding.textViewInputPurpose(this._tag, value)
+  }
+
+  get inputHints() {
+    return binding.textViewInputHints(this._tag)
+  }
+
+  set inputHints(value) {
+    binding.textViewInputHints(this._tag, value)
+  }
+
+  get justification() {
+    return binding.textViewJustification(this._tag)
+  }
+
+  set justification(value) {
+    binding.textViewJustification(this._tag, value)
+  }
+}

package/lib/text.d.ts

@@ -0,0 +1,18 @@
+export interface Measurement {
+  width: number
+  height: number
+  lines: number
+}
+
+/**
+ * Measure `text` as a label would show it, wrapped at `width` pixels, which defaults to
+ * `Infinity`. `style.size` is in pixels, and 0 means the default size. Results are cached.
+ */
+export function measure(
+  text: string,
+  style?: { family?: string | null; size?: number },
+  width?: number
+): Measurement
+
+/** Measure Pango markup as a label would show it, wrapped at `width` pixels. */
+export function measureMarkup(markup: string, width?: number): Measurement

package/lib/text.h

@@ -0,0 +1,189 @@
+#ifndef BARE_GTK_TEXT_H
+#define BARE_GTK_TEXT_H
+
+#include <assert.h>
+#include <js.h>
+#include <math.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static PangoContext *
+bare_gtk_text__context(bare_gtk_state_t *state) {
+  if (state->text_probe) return gtk_widget_get_pango_context(state->text_probe);
+
+  state->text_probe = g_object_ref_sink(gtk_label_new("Mg"));
+
+  PangoContext *context = gtk_widget_get_pango_context(state->text_probe);
+
+  PangoLayout *layout = pango_layout_new(context);
+  pango_layout_set_text(layout, "Mg", -1);
+
+  int width, height;
+  pango_layout_get_pixel_size(layout, &width, &height);
+
+  g_object_unref(layout);
+
+  int minimum, natural;
+
+  gtk_widget_measure(state->text_probe, GTK_ORIENTATION_HORIZONTAL, -1, &minimum, &natural, NULL, NULL);
+  state->text_inset_width = natural - width;
+
+  gtk_widget_measure(state->text_probe, GTK_ORIENTATION_VERTICAL, -1, &minimum, &natural, NULL, NULL);
+  state->text_inset_height = natural - height;
+
+  return context;
+}
+
+static js_value_t *
+bare_gtk_text_measure(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);
+
+  g_autofree char *text = NULL;
+  err = bare_gtk__read_string(env, argv[0], "text", &text);
+  if (err < 0) return NULL;
+
+  g_autofree char *family = NULL;
+  err = bare_gtk__read_string_or_null(env, argv[1], "family", &family);
+  if (err < 0) return NULL;
+
+  double size;
+  err = bare_gtk__read_double(env, argv[2], "size", &size);
+  if (err < 0) return NULL;
+
+  double available;
+  err = bare_gtk__read_double(env, argv[3], "width", &available);
+  if (err < 0) return NULL;
+
+  PangoContext *context = bare_gtk_text__context(state);
+
+  PangoLayout *layout = pango_layout_new(context);
+
+  pango_layout_set_text(layout, text, -1);
+
+  if (family || size > 0) {
+    PangoFontDescription *font = pango_font_description_copy(pango_context_get_font_description(context));
+
+    if (family) pango_font_description_set_family(font, family);
+
+    // Absolute, so the size is in device pixels and not scaled by the context
+    // resolution. A label matches this with a CSS font size in px.
+    if (size > 0) pango_font_description_set_absolute_size(font, size * PANGO_SCALE);
+
+    pango_layout_set_font_description(layout, font);
+
+    pango_font_description_free(font);
+  }
+
+  pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
+
+  pango_layout_set_width(
+    layout,
+    isfinite(available) && available >= 0 && available < (double) (G_MAXINT / PANGO_SCALE)
+      ? (int) (available * PANGO_SCALE)
+      : -1
+  );
+
+  int width, height;
+  pango_layout_get_pixel_size(layout, &width, &height);
+
+  int lines = pango_layout_get_line_count(layout);
+
+  g_object_unref(layout);
+
+  js_value_t *result;
+  err = js_create_array_with_length(env, 3, &result);
+  assert(err == 0);
+
+#define V(i, d) \
+  { \
+    js_value_t *val; \
+    err = js_create_double(env, d, &val); \
+    assert(err == 0); \
+    err = js_set_element(env, result, i, val); \
+    assert(err == 0); \
+  }
+  V(0, width + state->text_inset_width)
+  V(1, height + state->text_inset_height)
+  V(2, lines)
+#undef V
+
+  return result;
+}
+
+// Measured from the same markup a label is given, so both use one font
+// description.
+static js_value_t *
+bare_gtk_text_measure_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);
+
+  g_autofree char *markup = NULL;
+  err = bare_gtk__read_string(env, argv[0], "markup", &markup);
+  if (err < 0) return NULL;
+
+  double available;
+  err = bare_gtk__read_double(env, argv[1], "width", &available);
+  if (err < 0) return NULL;
+
+  PangoContext *context = bare_gtk_text__context(state);
+
+  PangoLayout *layout = pango_layout_new(context);
+
+  pango_layout_set_markup(layout, markup, -1);
+
+  pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
+
+  pango_layout_set_width(
+    layout,
+    isfinite(available) && available >= 0 && available < (double) (G_MAXINT / PANGO_SCALE)
+      ? (int) (available * PANGO_SCALE)
+      : -1
+  );
+
+  int width, height;
+  pango_layout_get_pixel_size(layout, &width, &height);
+
+  int lines = pango_layout_get_line_count(layout);
+
+  g_object_unref(layout);
+
+  js_value_t *result;
+  err = js_create_array_with_length(env, 3, &result);
+  assert(err == 0);
+
+#define V(i, d) \
+  { \
+    js_value_t *val; \
+    err = js_create_double(env, d, &val); \
+    assert(err == 0); \
+    err = js_set_element(env, result, i, val); \
+    assert(err == 0); \
+  }
+  V(0, width + state->text_inset_width)
+  V(1, height + state->text_inset_height)
+  V(2, lines)
+#undef V
+
+  return result;
+}
+
+#endif // BARE_GTK_TEXT_H

package/lib/text.js

@@ -0,0 +1,31 @@
+const binding = require('../binding')
+
+const cache = new Map()
+
+const CACHE_LIMIT = 4096
+
+exports.measure = function measure(text, style = {}, width = Infinity) {
+  const { family = null, size = 0 } = style
+
+  const key = `${family}\u0000${size}\u0000${width}\u0000${text}`
+
+  let result = cache.get(key)
+
+  if (result === undefined) {
+    const [w, h, lines] = binding.textMeasure(text, family, size, width)
+
+    if (cache.size === CACHE_LIMIT) cache.delete(cache.keys().next().value)
+
+    cache.set(key, (result = { width: w, height: h, lines }))
+  }
+
+  return result
+}
+
+// Not cached, because the markup carries its own style and there is nothing to
+// share a cache on.
+exports.measureMarkup = function measureMarkup(markup, width = Infinity) {
+  const [w, h, lines] = binding.textMeasureMarkup(markup, width)
+
+  return { width: w, height: h, lines }
+}

package/lib/texture.d.ts

@@ -0,0 +1,20 @@
+import GDKPaintable = require('./paintable')
+
+/** An image in memory, as a `GdkTexture`. */
+interface GDKTexture extends GDKPaintable {
+  readonly width: number
+
+  readonly height: number
+}
+
+declare class GDKTexture {
+  protected constructor()
+
+  /**
+   * Load an image file.
+   * @throws When the file cannot be read or is not an image.
+   */
+  static newFromFilename(path: string): GDKTexture
+}
+
+export = GDKTexture

package/lib/texture.h

@@ -0,0 +1,100 @@
+#ifndef BARE_GTK_TEXTURE_H
+#define BARE_GTK_TEXTURE_H
+
+#include <assert.h>
+#include <js.h>
+#include <utf.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+// A new texture is not floating, so the registry takes its own reference and
+// the one from this call is dropped.
+static js_value_t *
+bare_gtk_texture_new_from_filename(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);
+
+  char *path;
+  err = bare_gtk__read_string(env, argv[0], "path", &path);
+  if (err < 0) return NULL;
+
+  GError *error = NULL;
+
+  GdkTexture *texture = gdk_texture_new_from_filename(path, &error);
+
+  g_free(path);
+
+  if (texture == NULL) {
+    bare_gtk__throw(env, error);
+
+    return NULL;
+  }
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, texture), &result);
+  assert(err == 0);
+
+  g_object_unref(texture);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_texture_width(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);
+
+  GdkTexture *texture;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "texture", (gpointer *) &texture);
+  if (err < 0) return NULL;
+
+  js_value_t *result;
+  err = js_create_int32(env, gdk_texture_get_width(texture), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_texture_height(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);
+
+  GdkTexture *texture;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "texture", (gpointer *) &texture);
+  if (err < 0) return NULL;
+
+  js_value_t *result;
+  err = js_create_int32(env, gdk_texture_get_height(texture), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+#endif // BARE_GTK_TEXTURE_H

package/lib/texture.js

@@ -0,0 +1,17 @@
+const binding = require('../binding')
+const wrap = require('./wrap')
+const GDKPaintable = require('./paintable')
+
+module.exports = exports = class GDKTexture extends GDKPaintable {
+  static newFromFilename(path) {
+    return wrap(GDKTexture, binding.textureNewFromFilename(path))
+  }
+
+  get width() {
+    return binding.textureWidth(this._tag)
+  }
+
+  get height() {
+    return binding.textureHeight(this._tag)
+  }
+}

package/lib/viewport.d.ts

@@ -0,0 +1,22 @@
+import GTKWidget = require('./widget')
+
+/** Lets a widget that cannot scroll by itself be put in a `GTKScrolledWindow`, as a `GtkViewport`. */
+interface GTKViewport extends GTKWidget {
+  child: GTKWidget | null
+
+  /**
+   * Whether the child gets its minimum width or the width it asks for, as a `SCROLL_*` constant.
+   */
+  hscrollPolicy: number
+
+  /**
+   * Whether the child gets its minimum height or the height it asks for, as a `SCROLL_*` constant.
+   */
+  vscrollPolicy: number
+}
+
+declare class GTKViewport {
+  constructor()
+}
+
+export = GTKViewport