bare-gtk 0.2.0 → 0.3.0

package/lib/picture.js

@@ -0,0 +1,35 @@
+const binding = require('../binding')
+const { adopt } = require('./handle')
+const wrap = require('./wrap')
+const GDKPaintable = require('./paintable')
+const GTKWidget = require('./widget')
+
+module.exports = exports = class GTKPicture extends GTKWidget {
+  _init(opts) {
+    return binding.pictureInit()
+  }
+
+  get paintable() {
+    return wrap(GDKPaintable, binding.picturePaintable(this._tag))
+  }
+
+  set paintable(value) {
+    binding.picturePaintable(this._tag, value === null ? null : adopt(value))
+  }
+
+  get keepAspectRatio() {
+    return binding.pictureKeepAspectRatio(this._tag)
+  }
+
+  set keepAspectRatio(value) {
+    binding.pictureKeepAspectRatio(this._tag, value)
+  }
+
+  get canShrink() {
+    return binding.pictureCanShrink(this._tag)
+  }
+
+  set canShrink(value) {
+    binding.pictureCanShrink(this._tag, value)
+  }
+}

package/lib/reachable.js

@@ -0,0 +1,11 @@
+exports.hold = function hold(owner, wrapper) {
+  if (wrapper !== null) owner._retained.add(wrapper)
+
+  return wrapper
+}
+
+exports.drop = function drop(owner, wrapper) {
+  if (wrapper !== null) owner._retained.delete(wrapper)
+
+  return wrapper
+}

package/lib/runtime.c

@@ -4,6 +4,7 @@
 #include <path.h>
 #include <rlimit.h>
 #include <signal.h>
+#include <stdbool.h>
 #include <unistd.h>
 #include <uv.h>
 
@@ -22,6 +23,8 @@ static GIOChannel *bare__channel;
 static guint bare__poll;
 static guint bare__timer;
 
+static bool bare__exited;
+
 GtkApplication *bare_gtk_app;
 
 extern char __bare_identifier[] __attribute__((weak));
@@ -92,6 +95,8 @@ bare__run(void) {
   err = bare_run(bare, UV_RUN_NOWAIT);
   assert(err >= 0);
 
+  if (bare__exited) return;
+
   int timeout = uv_backend_timeout(bare__loop);
 
   if (timeout == 0) {
@@ -101,6 +106,13 @@ bare__run(void) {
   }
 }
 
+static void
+bare__on_exit(bare_t *bare, void *data) {
+  bare__exited = true;
+
+  g_application_quit(G_APPLICATION(bare_gtk_app));
+}
+
 static void
 bare__on_activate(GtkApplication *app, gpointer data) {}
 
@@ -219,6 +231,9 @@ main(int argc, char *argv[]) {
   err = bare_setup(bare__loop, bare__platform, NULL, argc, (const char **) argv, NULL, &bare);
   assert(err == 0);
 
+  err = bare_on_exit(bare, bare__on_exit, NULL);
+  assert(err == 0);
+
   GtkApplication *app = bare_gtk_app = gtk_application_new(__bare_identifier, 0);
 
   g_signal_connect(app, "activate", G_CALLBACK(bare__on_activate), NULL);
@@ -236,11 +251,13 @@ main(int argc, char *argv[]) {
   err = uv_async_send(&bare__shutdown);
   assert(err == 0);
 
-  err = bare_terminate(bare);
-  assert(err == 0);
+  if (!bare__exited) {
+    err = bare_terminate(bare);
+    assert(err == 0);
 
-  err = bare_run(bare, UV_RUN_DEFAULT);
-  assert(err == 0);
+    err = bare_run(bare, UV_RUN_DEFAULT);
+    assert(err == 0);
+  }
 
   int exit_code;
   err = bare_teardown(bare, UV_RUN_DEFAULT, &exit_code);

package/lib/scrolled-window.d.ts

@@ -0,0 +1,22 @@
+import GTKWidget = require('./widget')
+import GTKAdjustment = require('./adjustment')
+
+/** A widget that scrolls its child, as a `GtkScrolledWindow`. */
+interface GTKScrolledWindow extends GTKWidget {
+  child: GTKWidget | null
+
+  /** What horizontal scrolling moves. Read and set its `value` to scroll. */
+  readonly hadjustment: GTKAdjustment
+
+  /** What vertical scrolling moves. Read and set its `value` to scroll. */
+  readonly vadjustment: GTKAdjustment
+
+  /** When each scroll bar is shown, as `POLICY_*` constants. */
+  setPolicy(horizontal: number, vertical: number): this
+}
+
+declare class GTKScrolledWindow {
+  constructor()
+}
+
+export = GTKScrolledWindow

package/lib/scrolled-window.h

@@ -0,0 +1,142 @@
+#ifndef BARE_GTK_SCROLLED_WINDOW_H
+#define BARE_GTK_SCROLLED_WINDOW_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_scrolled_window_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 *window = gtk_scrolled_window_new();
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, window), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_scrolled_window_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 == 1 || argc == 2);
+
+  GtkScrolledWindow *window;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "window", (gpointer *) &window);
+  if (err < 0) return NULL;
+
+  if (argc == 1) {
+    GtkWidget *child = gtk_scrolled_window_get_child(window);
+
+    js_value_t *result;
+
+    if (child == NULL) {
+      err = js_get_null(env, &result);
+      assert(err == 0);
+    } else {
+      err = js_create_uint32(env, bare_gobject_tag(state->registry, child), &result);
+      assert(err == 0);
+    }
+
+    return result;
+  }
+
+  js_value_type_t type;
+  err = js_typeof(env, argv[1], &type);
+  assert(err == 0);
+
+  if (type == js_null) {
+    gtk_scrolled_window_set_child(window, NULL);
+
+    return NULL;
+  }
+
+  GtkWidget *child;
+  err = bare_gobject_read_tag(env, state->registry, argv[1], "child", (gpointer *) &child);
+  if (err < 0) return NULL;
+
+  gtk_scrolled_window_set_child(window, child);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_scrolled_window_policy(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);
+
+  GtkScrolledWindow *window;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "window", (gpointer *) &window);
+  if (err < 0) return NULL;
+
+  uint32_t horizontal, vertical;
+
+  err = bare_gtk__read_uint32(env, argv[1], "horizontal", &horizontal);
+  if (err < 0) return NULL;
+
+  err = bare_gtk__read_uint32(env, argv[2], "vertical", &vertical);
+  if (err < 0) return NULL;
+
+  gtk_scrolled_window_set_policy(window, horizontal, vertical);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_scrolled_window_adjustment(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);
+
+  GtkScrolledWindow *window;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "window", (gpointer *) &window);
+  if (err < 0) return NULL;
+
+  bool horizontal;
+  err = bare_gtk__read_bool(env, argv[1], "horizontal", &horizontal);
+  if (err < 0) return NULL;
+
+  GtkAdjustment *adjustment = horizontal
+    ? gtk_scrolled_window_get_hadjustment(window)
+    : gtk_scrolled_window_get_vadjustment(window);
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, adjustment), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+#endif // BARE_GTK_SCROLLED_WINDOW_H

package/lib/scrolled-window.js

@@ -0,0 +1,37 @@
+const binding = require('../binding')
+const GTKWidget = require('./widget')
+const GTKAdjustment = require('./adjustment')
+const wrap = require('./wrap')
+const { hold, drop } = require('./reachable')
+
+module.exports = exports = class GTKScrolledWindow extends GTKWidget {
+  _init() {
+    return binding.scrolledWindowInit()
+  }
+
+  get child() {
+    return wrap(GTKWidget, binding.scrolledWindowChild(this._tag))
+  }
+
+  set child(child) {
+    drop(this, this.child)
+
+    binding.scrolledWindowChild(this._tag, child === null ? null : child._tag)
+
+    hold(this, child)
+  }
+
+  get hadjustment() {
+    return wrap(GTKAdjustment, binding.scrolledWindowAdjustment(this._tag, true))
+  }
+
+  get vadjustment() {
+    return wrap(GTKAdjustment, binding.scrolledWindowAdjustment(this._tag, false))
+  }
+
+  setPolicy(horizontal, vertical) {
+    binding.scrolledWindowPolicy(this._tag, horizontal, vertical)
+
+    return this
+  }
+}

package/lib/settings.d.ts

@@ -0,0 +1,25 @@
+import GObject = require('./object')
+
+/** The settings of the desktop, as a `GtkSettings`. */
+interface GTKSettings extends GObject<GTKSettings.Events> {
+  /** Whether the dark variant of the theme is used. */
+  preferDarkTheme: boolean
+
+  /** The font resolution, in 1024ths of a dot per inch. -1 means the default. */
+  xftDpi: number
+}
+
+declare class GTKSettings {
+  protected constructor()
+
+  static getDefault(): GTKSettings | null
+}
+
+declare namespace GTKSettings {
+  export interface Events {
+    'prefer-dark-theme': []
+    'xft-dpi': []
+  }
+}
+
+export = GTKSettings

package/lib/settings.h

@@ -0,0 +1,163 @@
+#ifndef BARE_GTK_SETTINGS_H
+#define BARE_GTK_SETTINGS_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+enum {
+  bare_gtk_settings_event_prefer_dark_theme = 1 << 0,
+  bare_gtk_settings_event_xft_dpi = 1 << 1,
+};
+
+static void
+bare_gtk_settings__on_prefer_dark_theme(GObject *object, GParamSpec *spec, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, object) & bare_gtk_settings_event_prefer_dark_theme) == 0) return;
+
+  bare_gtk__emit(state, object, "prefer-dark-theme", 0, NULL);
+}
+
+static void
+bare_gtk_settings__on_xft_dpi(GObject *object, GParamSpec *spec, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, object) & bare_gtk_settings_event_xft_dpi) == 0) return;
+
+  bare_gtk__emit(state, object, "xft-dpi", 0, NULL);
+}
+
+static js_value_t *
+bare_gtk_settings_get_default(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);
+
+  GtkSettings *settings = gtk_settings_get_default();
+
+  return bare_gtk__create_tag(env, state, settings);
+}
+
+// Connected once and left connected, so the mask alone decides whether anything
+// is sent. Settings belong to the display and outlive every wrapper.
+static js_value_t *
+bare_gtk_settings_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);
+
+  GtkSettings *settings;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "settings", (gpointer *) &settings);
+  if (err < 0) return NULL;
+
+  uint32_t events;
+  err = bare_gtk__read_uint32(env, argv[1], "events", &events);
+  if (err < 0) return NULL;
+
+  if (bare_gtk__observe(state, settings, events)) {
+    g_signal_connect(
+      settings,
+      "notify::gtk-application-prefer-dark-theme",
+      G_CALLBACK(bare_gtk_settings__on_prefer_dark_theme),
+      state
+    );
+
+    g_signal_connect(
+      settings,
+      "notify::gtk-xft-dpi",
+      G_CALLBACK(bare_gtk_settings__on_xft_dpi),
+      state
+    );
+  }
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_settings_prefer_dark_theme(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);
+
+  GtkSettings *settings;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "settings", (gpointer *) &settings);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    gboolean prefer_dark;
+
+    g_object_get(settings, "gtk-application-prefer-dark-theme", &prefer_dark, NULL);
+
+    err = js_get_boolean(env, prefer_dark, &result);
+    assert(err == 0);
+  } else {
+    bool prefer_dark;
+    err = bare_gtk__read_bool(env, argv[1], "prefer_dark_theme", &prefer_dark);
+    if (err < 0) return NULL;
+
+    g_object_set(settings, "gtk-application-prefer-dark-theme", (gboolean) prefer_dark, NULL);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_settings_xft_dpi(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);
+
+  GtkSettings *settings;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "settings", (gpointer *) &settings);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    int dpi;
+
+    g_object_get(settings, "gtk-xft-dpi", &dpi, NULL);
+
+    err = js_create_int32(env, dpi, &result);
+    assert(err == 0);
+  } else {
+    int32_t dpi;
+    err = bare_gtk__read_int32(env, argv[1], "xft_dpi", &dpi);
+    if (err < 0) return NULL;
+
+    g_object_set(settings, "gtk-xft-dpi", (int) dpi, NULL);
+  }
+
+  return result;
+}
+
+#endif // BARE_GTK_SETTINGS_H

package/lib/settings.js

@@ -0,0 +1,34 @@
+const binding = require('../binding')
+const wrap = require('./wrap')
+const GObject = require('./object')
+
+module.exports = exports = class GTKSettings extends GObject {
+  static _events = {
+    'prefer-dark-theme': binding.SETTINGS_EVENT_PREFER_DARK_THEME,
+    'xft-dpi': binding.SETTINGS_EVENT_XFT_DPI
+  }
+
+  _eventMask(mask) {
+    binding.settingsEventMask(this._tag, mask)
+  }
+
+  static getDefault() {
+    return wrap(GTKSettings, binding.settingsGetDefault())
+  }
+
+  get preferDarkTheme() {
+    return binding.settingsPreferDarkTheme(this._tag)
+  }
+
+  set preferDarkTheme(value) {
+    binding.settingsPreferDarkTheme(this._tag, value)
+  }
+
+  get xftDpi() {
+    return binding.settingsXftDpi(this._tag)
+  }
+
+  set xftDpi(value) {
+    binding.settingsXftDpi(this._tag, value)
+  }
+}

package/lib/spinner.d.ts

@@ -0,0 +1,12 @@
+import GTKWidget = require('./widget')
+
+/** A spinning busy indicator, as a `GtkSpinner`. */
+interface GTKSpinner extends GTKWidget {
+  spinning: boolean
+}
+
+declare class GTKSpinner {
+  constructor()
+}
+
+export = GTKSpinner

package/lib/spinner.h

@@ -0,0 +1,61 @@
+#ifndef BARE_GTK_SPINNER_H
+#define BARE_GTK_SPINNER_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_spinner_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 *handle = gtk_spinner_new();
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, handle), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_spinner_spinning(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);
+
+  GtkSpinner *handle;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "spinner", (gpointer *) &handle);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    err = js_get_boolean(env, gtk_spinner_get_spinning(handle), &result);
+    assert(err == 0);
+  } else {
+    bool spinning;
+    err = bare_gtk__read_bool(env, argv[1], "spinning", &spinning);
+    if (err < 0) return NULL;
+
+    gtk_spinner_set_spinning(handle, spinning);
+  }
+
+  return result;
+}
+
+#endif // BARE_GTK_SPINNER_H

package/lib/spinner.js

@@ -0,0 +1,22 @@
+const binding = require('../binding')
+const GTKWidget = require('./widget')
+
+module.exports = exports = class GTKSpinner extends GTKWidget {
+  _init() {
+    return binding.spinnerInit()
+  }
+
+  get spinning() {
+    return binding.spinnerSpinning(this._tag)
+  }
+
+  set spinning(value) {
+    binding.spinnerSpinning(this._tag, value)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: GTKSpinner }
+    }
+  }
+}

package/lib/style-context.d.ts

@@ -0,0 +1,15 @@
+import GDKDisplay = require('./display')
+import GTKCssProvider = require('./css-provider')
+
+/**
+ * Apply a style sheet to every widget on `display`. `priority` is a `STYLE_PROVIDER_PRIORITY_*`
+ * constant.
+ */
+export function addProviderForDisplay(
+  display: GDKDisplay,
+  provider: GTKCssProvider,
+  priority: number
+): void
+
+/** Stop applying a style sheet added with `addProviderForDisplay()`. */
+export function removeProviderForDisplay(display: GDKDisplay, provider: GTKCssProvider): void