bare-gtk 0.2.1 → 0.3.0

package/lib/frame-layout.h

@@ -0,0 +1,291 @@
+#ifndef BARE_GTK_FRAME_LAYOUT_H
+#define BARE_GTK_FRAME_LAYOUT_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+
+// Gives each child an exact frame. The stock layout managers size a child from
+// what it prefers, and a size request only sets a minimum.
+
+enum {
+  bare_gtk_frame_layout_event_resize = 1 << 0,
+};
+
+#define BARE_TYPE_FRAME_LAYOUT_CHILD (bare_frame_layout_child_get_type())
+
+G_DECLARE_FINAL_TYPE(BareFrameLayoutChild, bare_frame_layout_child, BARE, FRAME_LAYOUT_CHILD, GtkLayoutChild)
+
+struct _BareFrameLayoutChild {
+  GtkLayoutChild handle;
+
+  graphene_rect_t frame;
+  graphene_matrix_t transform;
+  bool transformed;
+};
+
+G_DEFINE_TYPE(BareFrameLayoutChild, bare_frame_layout_child, GTK_TYPE_LAYOUT_CHILD)
+
+static void
+bare_frame_layout_child_init(BareFrameLayoutChild *self) {
+  self->frame = GRAPHENE_RECT_INIT(0, 0, 0, 0);
+  self->transformed = false;
+}
+
+static void
+bare_frame_layout_child_class_init(BareFrameLayoutChildClass *class) {}
+
+#define BARE_TYPE_FRAME_LAYOUT (bare_frame_layout_get_type())
+
+G_DECLARE_FINAL_TYPE(BareFrameLayout, bare_frame_layout, BARE, FRAME_LAYOUT, GtkLayoutManager)
+
+struct _BareFrameLayout {
+  GtkLayoutManager handle;
+
+  bare_gtk_state_t *state;
+
+  uint32_t events;
+  int width, height;
+};
+
+G_DEFINE_TYPE(BareFrameLayout, bare_frame_layout, GTK_TYPE_LAYOUT_MANAGER)
+
+static void
+bare_frame_layout_measure(GtkLayoutManager *manager, GtkWidget *widget, GtkOrientation orientation, int for_size, int *minimum, int *natural, int *minimum_baseline, int *natural_baseline) {
+  int content = 0;
+
+  for (GtkWidget *child = gtk_widget_get_first_child(widget); child; child = gtk_widget_get_next_sibling(child)) {
+    BareFrameLayoutChild *layout_child = BARE_FRAME_LAYOUT_CHILD(gtk_layout_manager_get_layout_child(manager, child));
+
+    graphene_rect_t *frame = &layout_child->frame;
+
+    int edge = orientation == GTK_ORIENTATION_HORIZONTAL
+      ? (int) (frame->origin.x + frame->size.width)
+      : (int) (frame->origin.y + frame->size.height);
+
+    if (edge > content) content = edge;
+  }
+
+  // Report the size of everything placed, so a scrolled window knows how much
+  // it holds. The minimum stays zero, so a viewport can be smaller than its
+  // child.
+  *minimum = 0;
+  *natural = content;
+  *minimum_baseline = -1;
+  *natural_baseline = -1;
+}
+
+static void
+bare_frame_layout_allocate(GtkLayoutManager *manager, GtkWidget *widget, int width, int height, int baseline) {
+  BareFrameLayout *self = BARE_FRAME_LAYOUT(manager);
+
+  // Before the children are placed, so frames set by a listener apply in this
+  // pass. A listener must not change the widget tree.
+  if (self->width != width || self->height != height) {
+    self->width = width;
+    self->height = height;
+
+    if (self->state && self->events & bare_gtk_frame_layout_event_resize) {
+      bare_gtk__emit(self->state, self, "resize", 2, (const double[]) {width, height});
+    }
+  }
+
+  for (GtkWidget *child = gtk_widget_get_first_child(widget); child; child = gtk_widget_get_next_sibling(child)) {
+    BareFrameLayoutChild *layout_child = BARE_FRAME_LAYOUT_CHILD(gtk_layout_manager_get_layout_child(manager, child));
+
+    graphene_rect_t *frame = &layout_child->frame;
+
+    GskTransform *transform = gsk_transform_translate(NULL, &GRAPHENE_POINT_INIT(frame->origin.x, frame->origin.y));
+
+    // A widget is drawn through the transform its parent gives it, so the
+    // child's own transform is added to the translation that places it.
+    if (layout_child->transformed) {
+      transform = gsk_transform_matrix(transform, &layout_child->transform);
+    }
+
+    gtk_widget_allocate(child, (int) frame->size.width, (int) frame->size.height, -1, transform);
+  }
+}
+
+static GtkLayoutChild *
+bare_frame_layout_create_layout_child(GtkLayoutManager *manager, GtkWidget *widget, GtkWidget *for_child) {
+  return g_object_new(BARE_TYPE_FRAME_LAYOUT_CHILD, "layout-manager", manager, "child-widget", for_child, NULL);
+}
+
+static void
+bare_frame_layout_init(BareFrameLayout *self) {}
+
+static void
+bare_frame_layout_class_init(BareFrameLayoutClass *class) {
+  GtkLayoutManagerClass *layout_class = GTK_LAYOUT_MANAGER_CLASS(class);
+
+  layout_class->measure = bare_frame_layout_measure;
+  layout_class->allocate = bare_frame_layout_allocate;
+  layout_class->create_layout_child = bare_frame_layout_create_layout_child;
+  layout_class->layout_child_type = BARE_TYPE_FRAME_LAYOUT_CHILD;
+}
+
+static js_value_t *
+bare_gtk_frame_layout_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);
+
+  BareFrameLayout *layout = g_object_new(BARE_TYPE_FRAME_LAYOUT, NULL);
+
+  layout->state = state;
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, layout), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_frame_layout_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);
+
+  BareFrameLayout *layout;
+  err = bare_gobject_read_type(env, state->registry, argv[0], "frameLayout", BARE_TYPE_FRAME_LAYOUT, (gpointer *) &layout);
+  if (err < 0) return NULL;
+
+  if (argc == 1) {
+    js_value_t *result;
+    err = js_create_uint32(env, layout->events, &result);
+    assert(err == 0);
+
+    return result;
+  }
+
+  err = bare_gtk__read_uint32(env, argv[1], "events", &layout->events);
+  if (err < 0) return NULL;
+
+  return NULL;
+}
+
+static js_value_t *
+bare_gtk_frame_layout_child_frame(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 5;
+  js_value_t *argv[5];
+
+  bare_gtk_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1 || argc == 5);
+
+  BareFrameLayoutChild *layout_child;
+  err = bare_gobject_read_type(env, state->registry, argv[0], "layoutChild", BARE_TYPE_FRAME_LAYOUT_CHILD, (gpointer *) &layout_child);
+  if (err < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  if (argc == 1) {
+    graphene_rect_t *frame = &layout_child->frame;
+
+    err = js_create_array_with_length(env, 4, &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, frame->origin.x)
+    V(1, frame->origin.y)
+    V(2, frame->size.width)
+    V(3, frame->size.height)
+#undef V
+  } else {
+    double frame[4];
+
+#define V(i, name) \
+  { \
+    err = bare_gtk__read_double(env, argv[i + 1], name, &frame[i]); \
+    if (err < 0) return NULL; \
+  }
+    V(0, "x")
+    V(1, "y")
+    V(2, "width")
+    V(3, "height")
+#undef V
+
+    layout_child->frame = GRAPHENE_RECT_INIT((float) frame[0], (float) frame[1], (float) frame[2], (float) frame[3]);
+
+    gtk_layout_manager_layout_changed(gtk_layout_child_get_layout_manager(GTK_LAYOUT_CHILD(layout_child)));
+  }
+
+  return result;
+}
+
+// A `graphene_matrix_t` is sixteen numbers in the order CSS uses for
+// `matrix3d()`.
+static js_value_t *
+bare_gtk_frame_layout_child_transform(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);
+
+  BareFrameLayoutChild *layout_child;
+  err = bare_gobject_read_type(env, state->registry, argv[0], "layoutChild", BARE_TYPE_FRAME_LAYOUT_CHILD, (gpointer *) &layout_child);
+  if (err < 0) return NULL;
+
+  js_value_type_t type;
+  err = js_typeof(env, argv[1], &type);
+  assert(err == 0);
+
+  if (type == js_null) {
+    layout_child->transformed = false;
+  } else {
+    float components[16];
+
+    for (uint32_t i = 0; i < 16; i++) {
+      js_value_t *element;
+      err = js_get_element(env, argv[1], i, &element);
+      assert(err == 0);
+
+      double component;
+      err = bare_gtk__read_double(env, element, "transform", &component);
+      if (err < 0) return NULL;
+
+      components[i] = (float) component;
+    }
+
+    graphene_matrix_init_from_float(&layout_child->transform, components);
+
+    layout_child->transformed = true;
+  }
+
+  gtk_layout_manager_layout_changed(gtk_layout_child_get_layout_manager(GTK_LAYOUT_CHILD(layout_child)));
+
+  return NULL;
+}
+
+#endif // BARE_GTK_FRAME_LAYOUT_H

package/lib/frame-layout.js

@@ -0,0 +1,19 @@
+const binding = require('../binding')
+const BareFrameLayoutChild = require('./frame-layout-child')
+const GTKLayoutManager = require('./layout-manager')
+
+module.exports = exports = class BareFrameLayout extends GTKLayoutManager {
+  static layoutChild = BareFrameLayoutChild
+
+  static _events = {
+    resize: binding.FRAME_LAYOUT_EVENT_RESIZE
+  }
+
+  _init(opts) {
+    return binding.frameLayoutInit()
+  }
+
+  _eventMask(mask) {
+    binding.frameLayoutEventMask(this._tag, mask)
+  }
+}

package/lib/gesture-click.d.ts

@@ -0,0 +1,19 @@
+import GTKGestureSingle = require('./gesture-single')
+
+/** Reports clicks and taps, as a `GtkGestureClick`. */
+interface GTKGestureClick extends GTKGestureSingle<GTKGestureClick.Events> {}
+
+declare class GTKGestureClick {
+  constructor()
+}
+
+declare namespace GTKGestureClick {
+  export interface Events {
+    /** `presses` counts quick repeated clicks, so 2 is a double click. */
+    pressed: [presses: number, x: number, y: number]
+    released: [presses: number, x: number, y: number]
+    cancel: []
+  }
+}
+
+export = GTKGestureClick

package/lib/gesture-click.h

@@ -0,0 +1,66 @@
+#ifndef BARE_GTK_GESTURE_CLICK_H
+#define BARE_GTK_GESTURE_CLICK_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+#include "event-controller.h"
+
+enum {
+  bare_gtk_gesture_click_event_pressed = 1 << 0,
+  bare_gtk_gesture_click_event_released = 1 << 1,
+  bare_gtk_gesture_click_event_cancel = 1 << 2,
+};
+
+static void
+bare_gtk_gesture_click__on_pressed(GtkGestureClick *gesture, int n_press, double x, double y, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, gesture) & bare_gtk_gesture_click_event_pressed) == 0) return;
+
+  bare_gtk__emit(state, gesture, "pressed", 3, (const double[]) {n_press, x, y});
+}
+
+static void
+bare_gtk_gesture_click__on_released(GtkGestureClick *gesture, int n_press, double x, double y, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, gesture) & bare_gtk_gesture_click_event_released) == 0) return;
+
+  bare_gtk__emit(state, gesture, "released", 3, (const double[]) {n_press, x, y});
+}
+
+static void
+bare_gtk_gesture_click__on_cancel(GtkGesture *gesture, GdkEventSequence *sequence, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, gesture) & bare_gtk_gesture_click_event_cancel) == 0) return;
+
+  bare_gtk__emit(state, gesture, "cancel", 0, NULL);
+}
+
+static js_value_t *
+bare_gtk_gesture_click_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);
+
+  GtkGesture *gesture = gtk_gesture_click_new();
+
+  g_signal_connect(gesture, "pressed", G_CALLBACK(bare_gtk_gesture_click__on_pressed), state);
+  g_signal_connect(gesture, "released", G_CALLBACK(bare_gtk_gesture_click__on_released), state);
+  g_signal_connect(gesture, "cancel", G_CALLBACK(bare_gtk_gesture_click__on_cancel), state);
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, gesture), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+#endif // BARE_GTK_GESTURE_CLICK_H

package/lib/gesture-click.js

@@ -0,0 +1,14 @@
+const binding = require('../binding')
+const GTKGestureSingle = require('./gesture-single')
+
+module.exports = exports = class GTKGestureClick extends GTKGestureSingle {
+  static _events = {
+    pressed: binding.GESTURE_CLICK_EVENT_PRESSED,
+    released: binding.GESTURE_CLICK_EVENT_RELEASED,
+    cancel: binding.GESTURE_CLICK_EVENT_CANCEL
+  }
+
+  _init() {
+    return binding.gestureClickInit()
+  }
+}

package/lib/gesture-drag.d.ts

@@ -0,0 +1,25 @@
+import GTKGestureSingle = require('./gesture-single')
+
+/** Reports drags, as a `GtkGestureDrag`. */
+interface GTKGestureDrag extends GTKGestureSingle<GTKGestureDrag.Events> {
+  /** Where the drag started, or `null` while no drag is under way. */
+  readonly startPoint: [x: number, y: number] | null
+
+  /** How far the drag has moved, or `null` while no drag is under way. */
+  readonly offset: [x: number, y: number] | null
+}
+
+declare class GTKGestureDrag {
+  constructor()
+}
+
+declare namespace GTKGestureDrag {
+  export interface Events {
+    'drag-begin': [startX: number, startY: number]
+    'drag-update': [offsetX: number, offsetY: number]
+    'drag-end': [offsetX: number, offsetY: number]
+    cancel: []
+  }
+}
+
+export = GTKGestureDrag

package/lib/gesture-drag.h

@@ -0,0 +1,165 @@
+#ifndef BARE_GTK_GESTURE_DRAG_H
+#define BARE_GTK_GESTURE_DRAG_H
+
+#include <assert.h>
+#include <js.h>
+
+#include <gtk/gtk.h>
+
+#include "bridging.h"
+#include "event-controller.h"
+
+enum {
+  bare_gtk_gesture_drag_event_drag_begin = 1 << 0,
+  bare_gtk_gesture_drag_event_drag_update = 1 << 1,
+  bare_gtk_gesture_drag_event_drag_end = 1 << 2,
+  bare_gtk_gesture_drag_event_cancel = 1 << 3,
+};
+
+static void
+bare_gtk_gesture_drag__on_drag_begin(GtkGestureDrag *gesture, double start_x, double start_y, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, gesture) & bare_gtk_gesture_drag_event_drag_begin) == 0) return;
+
+  bare_gtk__emit(state, gesture, "drag-begin", 2, (const double[]) {start_x, start_y});
+}
+
+static void
+bare_gtk_gesture_drag__on_drag_update(GtkGestureDrag *gesture, double offset_x, double offset_y, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, gesture) & bare_gtk_gesture_drag_event_drag_update) == 0) return;
+
+  bare_gtk__emit(state, gesture, "drag-update", 2, (const double[]) {offset_x, offset_y});
+}
+
+static void
+bare_gtk_gesture_drag__on_drag_end(GtkGestureDrag *gesture, double offset_x, double offset_y, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, gesture) & bare_gtk_gesture_drag_event_drag_end) == 0) return;
+
+  bare_gtk__emit(state, gesture, "drag-end", 2, (const double[]) {offset_x, offset_y});
+}
+
+static void
+bare_gtk_gesture_drag__on_cancel(GtkGesture *gesture, GdkEventSequence *sequence, gpointer data) {
+  bare_gtk_state_t *state = data;
+
+  if ((bare_gtk__observed(state, gesture) & bare_gtk_gesture_drag_event_cancel) == 0) return;
+
+  bare_gtk__emit(state, gesture, "cancel", 0, NULL);
+}
+
+static js_value_t *
+bare_gtk_gesture_drag_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);
+
+  GtkGesture *gesture = gtk_gesture_drag_new();
+
+  g_signal_connect(gesture, "drag-begin", G_CALLBACK(bare_gtk_gesture_drag__on_drag_begin), state);
+  g_signal_connect(gesture, "drag-update", G_CALLBACK(bare_gtk_gesture_drag__on_drag_update), state);
+  g_signal_connect(gesture, "drag-end", G_CALLBACK(bare_gtk_gesture_drag__on_drag_end), state);
+  g_signal_connect(gesture, "cancel", G_CALLBACK(bare_gtk_gesture_drag__on_cancel), state);
+
+  js_value_t *result;
+  err = js_create_uint32(env, bare_gobject_tag(state->registry, gesture), &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_gtk_gesture_drag__point(js_env_t *env, double x, double y) {
+  int err;
+
+  js_value_t *result;
+  err = js_create_array_with_length(env, 2, &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, x)
+  V(1, y)
+#undef V
+
+  return result;
+}
+
+// Both points are `null` while no drag is under way, so the caller can tell
+// that apart from a drag at the origin.
+static js_value_t *
+bare_gtk_gesture_drag_start_point(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);
+
+  GtkGestureDrag *gesture;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "gesture", (gpointer *) &gesture);
+  if (err < 0) return NULL;
+
+  double x, y;
+
+  js_value_t *result;
+
+  if (!gtk_gesture_drag_get_start_point(gesture, &x, &y)) {
+    err = js_get_null(env, &result);
+    assert(err == 0);
+
+    return result;
+  }
+
+  return bare_gtk_gesture_drag__point(env, x, y);
+}
+
+static js_value_t *
+bare_gtk_gesture_drag_offset(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);
+
+  GtkGestureDrag *gesture;
+  err = bare_gobject_read_tag(env, state->registry, argv[0], "gesture", (gpointer *) &gesture);
+  if (err < 0) return NULL;
+
+  double x, y;
+
+  js_value_t *result;
+
+  if (!gtk_gesture_drag_get_offset(gesture, &x, &y)) {
+    err = js_get_null(env, &result);
+    assert(err == 0);
+
+    return result;
+  }
+
+  return bare_gtk_gesture_drag__point(env, x, y);
+}
+
+#endif // BARE_GTK_GESTURE_DRAG_H

package/lib/gesture-drag.js

@@ -0,0 +1,23 @@
+const binding = require('../binding')
+const GTKGestureSingle = require('./gesture-single')
+
+module.exports = exports = class GTKGestureDrag extends GTKGestureSingle {
+  static _events = {
+    'drag-begin': binding.GESTURE_DRAG_EVENT_DRAG_BEGIN,
+    'drag-update': binding.GESTURE_DRAG_EVENT_DRAG_UPDATE,
+    'drag-end': binding.GESTURE_DRAG_EVENT_DRAG_END,
+    cancel: binding.GESTURE_DRAG_EVENT_CANCEL
+  }
+
+  _init() {
+    return binding.gestureDragInit()
+  }
+
+  get startPoint() {
+    return binding.gestureDragStartPoint(this._tag)
+  }
+
+  get offset() {
+    return binding.gestureDragOffset(this._tag)
+  }
+}

package/lib/gesture-single.d.ts

@@ -0,0 +1,13 @@
+import GTKGesture = require('./gesture')
+
+/** A gesture made with one touch or one mouse button, as a `GtkGestureSingle`. */
+interface GTKGestureSingle<M extends Record<keyof M, unknown[]> = {}> extends GTKGesture<M> {
+  /** The mouse button the gesture listens to. 0 means any button. */
+  button: number
+}
+
+declare class GTKGestureSingle<M extends Record<keyof M, unknown[]> = {}> {
+  protected constructor()
+}
+
+export = GTKGestureSingle

package/lib/gesture-single.js

@@ -0,0 +1,12 @@
+const binding = require('../binding')
+const GTKGesture = require('./gesture')
+
+module.exports = exports = class GTKGestureSingle extends GTKGesture {
+  get button() {
+    return binding.gestureSingleButton(this._tag)
+  }
+
+  set button(button) {
+    binding.gestureSingleButton(this._tag, button)
+  }
+}

package/lib/gesture.d.ts

@@ -0,0 +1,13 @@
+import GTKEventController = require('./event-controller')
+
+/** The base of the controllers that recognise gestures, as a `GtkGesture`. */
+interface GTKGesture<M extends Record<keyof M, unknown[]> = {}> extends GTKEventController<M> {
+  /** Claim or deny the current event sequence, as an `EVENT_SEQUENCE_STATE_*` constant. */
+  setState(state: number): boolean
+}
+
+declare class GTKGesture<M extends Record<keyof M, unknown[]> = {}> {
+  protected constructor()
+}
+
+export = GTKGesture