bare-gtk 0.2.0 → 0.3.0

package/lib/widget.js

@@ -1,26 +1,191 @@
-const EventEmitter = require('bare-events')
 const binding = require('../binding')
+const GObject = require('./object')
+const wrap = require('./wrap')
+const { hold, drop } = require('./reachable')
+const GDKCursor = require('./cursor')
 
-module.exports = class GTKWidget extends EventEmitter {
-  constructor(handle = null) {
-    super()
+module.exports = exports = class GTKWidget extends GObject {
+  get visible() {
+    return binding.widgetVisible(this._tag)
+  }
 
-    this._handle = handle
+  set visible(value) {
+    binding.widgetVisible(this._tag, value)
   }
 
-  get visible() {
-    return binding.widgetVisible(this._handle)
+  get opacity() {
+    return binding.widgetOpacity(this._tag)
   }
 
-  set visible(value) {
-    binding.widgetVisible(this._handle, value)
+  set opacity(value) {
+    binding.widgetOpacity(this._tag, value)
+  }
+
+  get overflow() {
+    return binding.widgetOverflow(this._tag)
+  }
+
+  set overflow(value) {
+    binding.widgetOverflow(this._tag, value)
   }
 
   get sizeRequest() {
-    return binding.widgetSizeRequest(this._handle)
+    return binding.widgetSizeRequest(this._tag)
   }
 
   set sizeRequest([width, height]) {
-    binding.widgetSizeRequest(this._handle, width, height)
+    binding.widgetSizeRequest(this._tag, width, height)
+  }
+
+  get scaleFactor() {
+    return binding.widgetScaleFactor(this._tag)
+  }
+
+  get native() {
+    return wrap(GTKWidget, binding.widgetNative(this._tag))
+  }
+
+  get parent() {
+    return wrap(GTKWidget, binding.widgetParent(this._tag))
+  }
+
+  get firstChild() {
+    return wrap(GTKWidget, binding.widgetFirstChild(this._tag))
+  }
+
+  get lastChild() {
+    return wrap(GTKWidget, binding.widgetLastChild(this._tag))
+  }
+
+  get nextSibling() {
+    return wrap(GTKWidget, binding.widgetNextSibling(this._tag))
+  }
+
+  get prevSibling() {
+    return wrap(GTKWidget, binding.widgetPrevSibling(this._tag))
+  }
+
+  get layoutManager() {
+    return wrap(GObject, binding.widgetLayoutManager(this._tag))
+  }
+
+  set layoutManager(manager) {
+    drop(this, this.layoutManager)
+
+    binding.widgetLayoutManager(this._tag, manager === null ? null : manager._tag)
+
+    hold(this, manager)
+  }
+
+  get width() {
+    return binding.widgetWidth(this._tag)
+  }
+
+  get height() {
+    return binding.widgetHeight(this._tag)
+  }
+
+  grabFocus() {
+    return binding.widgetGrabFocus(this._tag)
+  }
+
+  setRootFocus(widget) {
+    binding.widgetSetRootFocus(this._tag, widget === null ? null : widget._tag)
+
+    return this
+  }
+
+  addCssClass(name) {
+    binding.widgetAddCssClass(this._tag, name)
+
+    return this
+  }
+
+  removeCssClass(name) {
+    binding.widgetRemoveCssClass(this._tag, name)
+
+    return this
+  }
+
+  hasCssClass(name) {
+    return binding.widgetHasCssClass(this._tag, name)
+  }
+
+  get canTarget() {
+    return binding.widgetCanTarget(this._tag)
+  }
+
+  set canTarget(value) {
+    binding.widgetCanTarget(this._tag, value)
+  }
+
+  get cursor() {
+    return wrap(GDKCursor, binding.widgetCursor(this._tag))
+  }
+
+  set cursor(value) {
+    binding.widgetCursor(this._tag, value === null ? null : value._tag)
+  }
+
+  setCursorFromName(name) {
+    binding.widgetSetCursorFromName(this._tag, name)
+
+    return this
+  }
+
+  get sensitive() {
+    return binding.widgetSensitive(this._tag)
+  }
+
+  set sensitive(value) {
+    binding.widgetSensitive(this._tag, value)
+  }
+
+  measure(orientation, forSize = -1) {
+    return binding.widgetMeasure(this._tag, orientation, forSize)
+  }
+
+  computeBounds(target) {
+    return binding.widgetComputeBounds(this._tag, target._tag)
+  }
+
+  insertAfter(parent, previousSibling = null) {
+    binding.widgetInsertAfter(
+      this._tag,
+      parent._tag,
+      previousSibling === null ? null : previousSibling._tag
+    )
+
+    return hold(parent, this)
+  }
+
+  insertBefore(parent, nextSibling = null) {
+    binding.widgetInsertBefore(
+      this._tag,
+      parent._tag,
+      nextSibling === null ? null : nextSibling._tag
+    )
+
+    return hold(parent, this)
+  }
+
+  addController(controller) {
+    binding.widgetAddController(this._tag, controller._tag)
+
+    return hold(this, controller)
+  }
+
+  removeController(controller) {
+    binding.widgetRemoveController(this._tag, controller._tag)
+
+    return drop(this, controller)
+  }
+
+  unparent() {
+    const parent = this.parent
+
+    binding.widgetUnparent(this._tag)
+
+    return parent === null ? this : drop(parent, this)
   }
 }

package/lib/window.d.ts

@@ -0,0 +1,31 @@
+import GTKWidget = require('./widget')
+import GDKSurface = require('./surface')
+
+/** A top level window, as a `GtkWindow`. */
+interface GTKWindow extends GTKWidget<GTKWindow.Events> {
+  /** The surface the window draws on, or `null` before it is shown. */
+  readonly surface: GDKSurface | null
+
+  title: string | null
+
+  /** The size the window opens at, as `[width, height]`. */
+  get defaultSize(): [width: number, height: number]
+  set defaultSize(size: [width: number, height: number])
+
+  /** The one widget the window holds, or `null`. */
+  child: GTKWidget | null
+}
+
+declare class GTKWindow {
+  /** Create a hidden window. Set `visible` to show it. */
+  constructor()
+}
+
+declare namespace GTKWindow {
+  export interface Events {
+    /** The user asked to close the window. */
+    'close-request': []
+  }
+}
+
+export = GTKWindow

package/lib/window.h

@@ -1,16 +1,27 @@
+#ifndef BARE_GTK_WINDOW_H
+#define BARE_GTK_WINDOW_H
+
 #include <assert.h>
-#include <bare.h>
 #include <js.h>
+#include <utf.h>
 
 #include <gtk/gtk.h>
 
-extern GtkApplication *bare_gtk_app;
+#include "bridging.h"
+
+extern GtkApplication *bare_gtk_app __attribute__((weak));
+
+enum {
+  bare_gtk_window_event_close_request = 1 << 0,
+};
 
 typedef struct {
   GtkWindow handle;
 
-  js_env_t *env;
-  js_ref_t *ctx;
+  bare_gtk_state_t *state;
+
+  uint32_t events;
+  gulong on_close_request;
 } BareWindow;
 
 typedef struct {
@@ -22,63 +33,84 @@ G_DEFINE_TYPE(BareWindow, bare_window, GTK_TYPE_WINDOW)
 static void
 bare_window_init(BareWindow *self) {}
 
+static void
+bare_window_class_init(BareWindowClass *class) {}
+
 BareWindow *
 bare_window_new(void) {
   return g_object_new(bare_window_get_type(), NULL);
 }
 
-static void
-bare_window_finalize(GObject *object) {
-  int err;
+static gboolean
+bare_gtk_window__on_close_request(GtkWindow *window, gpointer data) {
+  BareWindow *self = (BareWindow *) window;
 
-  BareWindow *self = (BareWindow *) object;
+  bare_gtk__emit(self->state, window, "close-request", 0, NULL);
 
-  js_env_t *env = self->env;
+  return GDK_EVENT_PROPAGATE;
+}
 
-  err = js_delete_reference(env, self->ctx);
+static js_value_t *
+bare_gtk_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);
 
-  G_OBJECT_CLASS(bare_window_parent_class)->finalize(object);
-}
+  BareWindow *window = bare_window_new();
 
-static void
-bare_window_class_init(BareWindowClass *class) {
-  GObjectClass *object_class = G_OBJECT_CLASS(class);
+  window->state = state;
 
-  object_class->finalize = bare_window_finalize;
-}
+  if (&bare_gtk_app && bare_gtk_app) gtk_application_add_window(bare_gtk_app, GTK_WINDOW(window));
 
-static void
-bare_gtk_window__on_release(js_env_t *env, void *data, void *finalize_hint) {
-  g_object_unref(data);
+  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_window_init(js_env_t *env, js_callback_info_t *info) {
+bare_gtk_window_title(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 1;
-  js_value_t *argv[1];
+  size_t argc = 2;
+  js_value_t *argv[2];
 
-  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
   assert(err == 0);
 
-  assert(argc == 1);
+  assert(argc == 1 || argc == 2);
 
-  BareWindow *window = bare_window_new();
+  GtkWindow *window;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "window", (gpointer *) &window);
+  if (err < 0) return NULL;
 
-  gtk_application_add_window(bare_gtk_app, GTK_WINDOW(window));
+  js_value_t *result = NULL;
 
-  window->env = env;
+  if (argc == 1) {
+    const char *title = gtk_window_get_title(window);
 
-  err = js_create_reference(env, argv[0], 1, &window->ctx);
-  assert(err == 0);
+    if (title) {
+      err = js_create_string_utf8(env, (const utf8_t *) title, (size_t) -1, &result);
+      assert(err == 0);
+    } else {
+      err = js_get_null(env, &result);
+      assert(err == 0);
+    }
+  } else {
+    char *title;
+    err = bare_gtk__read_string_or_null(env, argv[1], "title", &title);
+    if (err < 0) return NULL;
 
-  js_value_t *handle;
-  err = js_create_external(env, window, bare_gtk_window__on_release, NULL, &handle);
-  assert(err == 0);
+    gtk_window_set_title(window, title);
 
-  return handle;
+    g_free(title);
+  }
+
+  return result;
 }
 
 static js_value_t *
@@ -88,20 +120,21 @@ bare_gtk_window_default_size(js_env_t *env, js_callback_info_t *info) {
   size_t argc = 3;
   js_value_t *argv[3];
 
-  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
   assert(err == 0);
 
   assert(argc == 1 || argc == 3);
 
-  BareWindow *window;
-  err = js_get_value_external(env, argv[0], (void **) &window);
-  assert(err == 0);
+  GtkWindow *window;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "window", (gpointer *) &window);
+  if (err < 0) return NULL;
 
   js_value_t *result = NULL;
 
   if (argc == 1) {
     int width, height;
-    gtk_window_get_default_size(GTK_WINDOW(window), &width, &height);
+    gtk_window_get_default_size(window, &width, &height);
 
     err = js_create_array_with_length(env, 2, &result);
     assert(err == 0);
@@ -115,18 +148,18 @@ bare_gtk_window_default_size(js_env_t *env, js_callback_info_t *info) {
     assert(err == 0); \
   }
     V(0, width)
-    V(1, width)
+    V(1, height)
 #undef V
   } else {
     int32_t width;
-    err = js_get_value_int32(env, argv[1], &width);
-    assert(err == 0);
+    err = bare_gtk__read_int32(env, argv[1], "width", &width);
+    if (err < 0) return NULL;
 
     int32_t height;
-    err = js_get_value_int32(env, argv[2], &height);
-    assert(err == 0);
+    err = bare_gtk__read_int32(env, argv[2], "height", &height);
+    if (err < 0) return NULL;
 
-    gtk_window_set_default_size(GTK_WINDOW(window), width, height);
+    gtk_window_set_default_size(window, width, height);
   }
 
   return result;
@@ -139,34 +172,82 @@ bare_gtk_window_child(js_env_t *env, js_callback_info_t *info) {
   size_t argc = 2;
   js_value_t *argv[2];
 
-  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  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);
 
-  BareWindow *window;
-  err = js_get_value_external(env, argv[0], (void **) &window);
-  assert(err == 0);
+  GtkWindow *window;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "window", (gpointer *) &window);
+  if (err < 0) return NULL;
 
   js_value_t *result = NULL;
 
   if (argc == 1) {
-    GtkWidget *handle = gtk_window_get_child(GTK_WINDOW(window));
-
-    if (handle) {
-      err = js_create_external(env, handle, NULL, NULL, &result);
-      assert(err == 0);
-    } else {
-      err = js_get_null(env, &result);
-      assert(err == 0);
-    }
+    result = bare_gtk__create_tag(env, state, gtk_window_get_child(window));
   } else {
-    void *handle;
-    err = js_get_value_external(env, argv[1], &handle);
+    bool is;
+    err = js_is_null(env, argv[1], &is);
     assert(err == 0);
 
-    gtk_window_set_child(GTK_WINDOW(window), handle);
+    GtkWidget *child = NULL;
+
+    if (!is) {
+      err = bare_gobject_read_tag(env, state->registry, argv[1], "child", (gpointer *) &child);
+      if (err < 0) return NULL;
+    }
+
+    gtk_window_set_child(window, child);
   }
 
   return result;
 }
+
+static js_value_t *
+bare_gtk_window_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 == 1 || argc == 2);
+
+  BareWindow *window;
+  err = bare_gobject_read_type(env, state->registry, argv[0], "window", bare_window_get_type(), (gpointer *) &window);
+  if (err < 0) return NULL;
+
+  if (argc == 1) {
+    js_value_t *result;
+    err = js_create_uint32(env, window->events, &result);
+    assert(err == 0);
+
+    return result;
+  }
+
+  uint32_t events;
+  err = bare_gtk__read_uint32(env, argv[1], "events", &events);
+  if (err < 0) return NULL;
+
+  uint32_t changed = window->events ^ events;
+
+  if (changed & bare_gtk_window_event_close_request) {
+    if (events & bare_gtk_window_event_close_request) {
+      window->on_close_request = g_signal_connect(window, "close-request", G_CALLBACK(bare_gtk_window__on_close_request), state);
+    } else {
+      g_signal_handler_disconnect(window, window->on_close_request);
+
+      window->on_close_request = 0;
+    }
+  }
+
+  window->events = events;
+
+  return NULL;
+}
+
+#endif // BARE_GTK_WINDOW_H

package/lib/window.js

@@ -1,30 +1,51 @@
 const binding = require('../binding')
 const GTKWidget = require('./widget')
+const GDKSurface = require('./surface')
+const wrap = require('./wrap')
+const { hold, drop } = require('./reachable')
 
 module.exports = exports = class GTKWindow extends GTKWidget {
-  constructor() {
-    super()
+  static _events = {
+    'close-request': binding.WINDOW_EVENT_CLOSE_REQUEST
+  }
+
+  _init(opts) {
+    return binding.windowInit()
+  }
+
+  _eventMask(mask) {
+    binding.windowEventMask(this._tag, mask)
+  }
+
+  get surface() {
+    return wrap(GDKSurface, binding.nativeSurface(this._tag))
+  }
 
-    this._handle = binding.windowInit(this)
+  get title() {
+    return binding.windowTitle(this._tag)
+  }
+
+  set title(value) {
+    binding.windowTitle(this._tag, value)
   }
 
   get defaultSize() {
-    return binding.windowDefaultSize(this._handle)
+    return binding.windowDefaultSize(this._tag)
   }
 
   set defaultSize([width, height]) {
-    binding.windowDefaultSize(this._handle, width, height)
+    binding.windowDefaultSize(this._tag, width, height)
   }
 
   get child() {
-    const handle = binding.windowChild(this._handle)
-
-    if (handle === null) return null
-
-    return new GTKWidget(handle)
+    return hold(this, wrap(GTKWidget, binding.windowChild(this._tag)))
   }
 
   set child(widget) {
-    binding.windowChild(this._handle, widget._handle)
+    drop(this, wrap(GTKWidget, binding.windowChild(this._tag)))
+
+    binding.windowChild(this._tag, widget === null ? null : widget._tag)
+
+    hold(this, widget)
   }
 }

package/lib/wrap.js

@@ -0,0 +1,7 @@
+const binding = require('../binding')
+
+module.exports = exports = function wrap(Class, tag) {
+  if (tag === null) return null
+
+  return binding.wrapper(tag) || new Class({ tag })
+}

package/package.json

@@ -1,14 +1,22 @@
 {
   "name": "bare-gtk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "GTK bindings and runtime for Bare",
   "exports": {
     "./package": "./package.json",
-    ".": "./index.js",
-    "./runtime": "./runtime.js"
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./runtime": "./runtime.js",
+    "./*": {
+      "types": "./lib/*.d.ts",
+      "default": "./lib/*.js"
+    }
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "runtime.js",
     "binding.c",
     "binding.js",
@@ -33,6 +41,7 @@
   },
   "homepage": "https://github.com/holepunchto/bare-gtk#readme",
   "dependencies": {
+    "bare-gobject-registry": "^0.1.0",
     "require-asset": "^1.1.0"
   },
   "peerDependencies": {

package/prebuilds/linux-arm64/bare

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/prebuilds/linux-arm64/bare
-size: 81529824 bytes
-sha256: 5dc57b03af88f7ba85825eebb0f4df4012571cfcc756fc4407f75e35a9b4449c
+size: 83698384 bytes
+sha256: 1c66e934fb561ed507bcb4edc4560c9d5d56ac3dcfb33938e1455ff776f14114

package/prebuilds/linux-x64/bare

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/prebuilds/linux-x64/bare
-size: 80286240 bytes
-sha256: 609d87584d0ae040d892ebd0e535a9c64de889787aacdbbbf03fdf8d6f44170a
+size: 82479072 bytes
+sha256: 2d37fc00479b09c15c13038649accf82a9946f3ae4d31557ff414936bec98259