bare-gtk 0.2.1 → 0.3.0

package/lib/viewport.h

@@ -0,0 +1,151 @@
+#ifndef BARE_GTK_VIEWPORT_H
+#define BARE_GTK_VIEWPORT_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+static js_value_t *
+bare_gtk_viewport_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 *viewport = gtk_viewport_new(NULL, NULL);
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, viewport), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_viewport_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);
+
+  GtkViewport *viewport;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "viewport", (gpointer *) &viewport);
+  if (err < 0) return NULL;
+
+  if (argc == 1) {
+    GtkWidget *child = gtk_viewport_get_child(viewport);
+
+    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_viewport_set_child(viewport, NULL);
+
+    return NULL;
+  }
+
+  GtkWidget *child;
+  err = bare_gobject_read_tag(env, state->registry, argv[1], "child", (gpointer *) &child);
+  if (err < 0) return NULL;
+
+  gtk_viewport_set_child(viewport, child);
+
+  return NULL;
+}
+
+// The scroll policy decides whether the child gets its minimum size along an
+// axis or the size it asked for. A child that reports a minimum of zero, as a
+// placed layout does, has nothing to scroll by default.
+static js_value_t *
+bare_gtk_viewport_hscroll_policy(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);
+
+  GtkViewport *viewport;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "viewport", (gpointer *) &viewport);
+  if (err < 0) return NULL;
+
+  if (argc == 1) {
+    js_value_t *result;
+    err = js_create_uint32(env, gtk_scrollable_get_hscroll_policy(GTK_SCROLLABLE(viewport)), &result);
+    assert(err == 0);
+
+    return result;
+  }
+
+  uint32_t policy;
+  err = bare_gtk__read_uint32(env, argv[1], "policy", &policy);
+  if (err < 0) return NULL;
+
+  gtk_scrollable_set_hscroll_policy(GTK_SCROLLABLE(viewport), policy);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_viewport_vscroll_policy(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);
+
+  GtkViewport *viewport;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "viewport", (gpointer *) &viewport);
+  if (err < 0) return NULL;
+
+  if (argc == 1) {
+    js_value_t *result;
+    err = js_create_uint32(env, gtk_scrollable_get_vscroll_policy(GTK_SCROLLABLE(viewport)), &result);
+    assert(err == 0);
+
+    return result;
+  }
+
+  uint32_t policy;
+  err = bare_gtk__read_uint32(env, argv[1], "policy", &policy);
+  if (err < 0) return NULL;
+
+  gtk_scrollable_set_vscroll_policy(GTK_SCROLLABLE(viewport), policy);
+
+  return NULL;
+}
+
+#endif // BARE_GTK_VIEWPORT_H

package/lib/viewport.js

@@ -0,0 +1,38 @@
+const binding = require('../binding')
+const GTKWidget = require('./widget')
+const wrap = require('./wrap')
+const { hold, drop } = require('./reachable')
+
+module.exports = exports = class GTKViewport extends GTKWidget {
+  _init() {
+    return binding.viewportInit()
+  }
+
+  get child() {
+    return wrap(GTKWidget, binding.viewportChild(this._tag))
+  }
+
+  set child(child) {
+    drop(this, this.child)
+
+    binding.viewportChild(this._tag, child === null ? null : child._tag)
+
+    hold(this, child)
+  }
+
+  get hscrollPolicy() {
+    return binding.viewportHscrollPolicy(this._tag)
+  }
+
+  set hscrollPolicy(policy) {
+    binding.viewportHscrollPolicy(this._tag, policy)
+  }
+
+  get vscrollPolicy() {
+    return binding.viewportVscrollPolicy(this._tag)
+  }
+
+  set vscrollPolicy(policy) {
+    binding.viewportVscrollPolicy(this._tag, policy)
+  }
+}

package/lib/widget.d.ts

@@ -0,0 +1,102 @@
+import GObject = require('./object')
+import GDKCursor = require('./cursor')
+import GTKEventController = require('./event-controller')
+import GTKLayoutManager = require('./layout-manager')
+
+/** The base of every widget, as a `GtkWidget`. */
+interface GTKWidget<M extends Record<keyof M, unknown[]> = {}> extends GObject<M> {
+  /** Whether the widget is shown. */
+  visible: boolean
+
+  /** How opaque the widget is, from 0 to 1. */
+  opacity: number
+
+  /** Whether content that does not fit is shown or clipped, as an `OVERFLOW_*` constant. */
+  overflow: number
+
+  /** The smallest size the widget asks for, as `[width, height]`. -1 means no request. */
+  get sizeRequest(): [width: number, height: number]
+  set sizeRequest(size: [width: number, height: number])
+
+  /** How many device pixels the widget has per logical pixel. */
+  readonly scaleFactor: number
+
+  /** The nearest widget above this one with a surface of its own, such as a window, or `null`. */
+  readonly native: GTKWidget | null
+
+  readonly parent: GTKWidget | null
+
+  readonly firstChild: GTKWidget | null
+
+  readonly lastChild: GTKWidget | null
+
+  readonly nextSibling: GTKWidget | null
+
+  readonly prevSibling: GTKWidget | null
+
+  /** What places the children of the widget, or `null` for the default of its type. */
+  layoutManager: GTKLayoutManager | null
+
+  /** The width the widget was given in the last layout. */
+  readonly width: number
+
+  /** The height the widget was given in the last layout. */
+  readonly height: number
+
+  /** Whether the widget can be the target of pointer events. */
+  canTarget: boolean
+
+  /** The cursor shown over the widget, or `null` for the cursor of its parent. */
+  cursor: GDKCursor | null
+
+  /** Whether the widget responds to input. */
+  sensitive: boolean
+
+  /** Move the keyboard focus to the widget. Returns whether it took it. */
+  grabFocus(): boolean
+
+  /** Set which widget in this root has the focus, or `null` to take it away from all of them. */
+  setRootFocus(widget: GTKWidget | null): this
+
+  addCssClass(name: string): this
+
+  removeCssClass(name: string): this
+
+  hasCssClass(name: string): boolean
+
+  /** Show the cursor called `name`, such as `'pointer'` or `'text'`. */
+  setCursorFromName(name: string): this
+
+  /**
+   * Ask how big the widget wants to be along `orientation`, an `ORIENTATION_*` constant, given
+   * `forSize` along the other axis. -1, the default, means any size.
+   */
+  measure(
+    orientation: number,
+    forSize?: number
+  ): [minimum: number, natural: number, minimumBaseline: number, naturalBaseline: number]
+
+  /** The bounds of the widget in the coordinates of `target`, or `null` if they are unrelated. */
+  computeBounds(target: GTKWidget): [x: number, y: number, width: number, height: number] | null
+
+  /** Add the widget to `parent`, after `previousSibling`, or first when that is `null`. */
+  insertAfter(parent: GTKWidget, previousSibling?: GTKWidget | null): this
+
+  /** Add the widget to `parent`, before `nextSibling`, or last when that is `null`. */
+  insertBefore(parent: GTKWidget, nextSibling?: GTKWidget | null): this
+
+  /** Add a controller that reports input on the widget. Returns `controller`. */
+  addController<C extends GTKEventController<any>>(controller: C): C
+
+  /** Remove a controller added with `addController()`. Returns `controller`. */
+  removeController<C extends GTKEventController<any>>(controller: C): C
+
+  /** Remove the widget from its parent. */
+  unparent(): this
+}
+
+declare class GTKWidget<M extends Record<keyof M, unknown[]> = {}> {
+  protected constructor()
+}
+
+export = GTKWidget