bare-ui-kit 0.2.0 → 0.3.0

package/lib/screen.h

@@ -0,0 +1,194 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_screen_main_screen(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, NULL, NULL, NULL, (void **) &state);
+  assert(err == 0);
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    result = bare_foundation_bridge(env, state->registry, [UIScreen mainScreen]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_screen_bounds_into(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 3);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  uint32_t offset;
+  if (!bare_ui_kit__read_uint32(env, argv[2], "offset", &offset)) return NULL;
+
+  double *out;
+
+  if (!bare_ui_kit__buffer(env, argv[1], offset, 4, &out)) {
+    err = js_throw_type_error(env, NULL, "Expected an array buffer with room for 4 doubles");
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  @autoreleasepool {
+    UIScreen *screen = (__bridge UIScreen *) handle;
+
+    CGRect value = screen.bounds;
+
+    out[0] = value.origin.x;
+    out[1] = value.origin.y;
+    out[2] = value.size.width;
+    out[3] = value.size.height;
+  }
+
+  return NULL;
+}
+
+static void
+bare_ui_kit_screen_bounds_into_typed(js_value_t *receiver, int32_t bare_tag, js_value_t *bare_buffer, uint32_t bare_offset, js_typed_callback_info_t *info) {
+  int err;
+
+  bare_ui_kit_state_t *state;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, (void **) &state);
+  assert(err == 0);
+
+  id bare_object = bare_foundation_object(state->registry, bare_tag);
+
+  if (bare_object == nil) return;
+
+  double *out;
+
+  if (!bare_ui_kit__buffer(env, bare_buffer, bare_offset, 4, &out)) return;
+
+  @autoreleasepool {
+    UIScreen *screen = (UIScreen *) bare_object;
+
+    CGRect value = screen.bounds;
+
+    out[0] = value.origin.x;
+    out[1] = value.origin.y;
+    out[2] = value.size.width;
+    out[3] = value.size.height;
+  }
+}
+
+static js_value_t *
+bare_ui_kit_screen_native_bounds_into(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 3);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  uint32_t offset;
+  if (!bare_ui_kit__read_uint32(env, argv[2], "offset", &offset)) return NULL;
+
+  double *out;
+
+  if (!bare_ui_kit__buffer(env, argv[1], offset, 4, &out)) {
+    err = js_throw_type_error(env, NULL, "Expected an array buffer with room for 4 doubles");
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  @autoreleasepool {
+    UIScreen *screen = (__bridge UIScreen *) handle;
+
+    CGRect value = screen.nativeBounds;
+
+    out[0] = value.origin.x;
+    out[1] = value.origin.y;
+    out[2] = value.size.width;
+    out[3] = value.size.height;
+  }
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ui_kit_screen_scale(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIScreen *screen = (__bridge UIScreen *) handle;
+
+    err = js_create_double(env, screen.scale, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_screen_native_scale(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIScreen *screen = (__bridge UIScreen *) handle;
+
+    err = js_create_double(env, screen.nativeScale, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}

package/lib/screen.js

@@ -0,0 +1,52 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+const scratch = require('./scratch')
+const wrap = require('./wrap')
+
+module.exports = exports = class UIKitScreen {
+  constructor(opts = {}) {
+    const { tag = null } = opts
+
+    this._tag = tag
+
+    this._token = binding.claim(this._tag, this)
+  }
+
+  get [registry.tag]() {
+    return this._tag
+  }
+
+  get [registry.handle]() {
+    return binding.handle(this._tag)
+  }
+
+  static get mainScreen() {
+    return wrap(UIKitScreen, binding.screenMainScreen())
+  }
+
+  get bounds() {
+    binding.screenBoundsInto(this._tag, scratch.buffer, 0)
+
+    return { x: scratch[0], y: scratch[1], width: scratch[2], height: scratch[3] }
+  }
+
+  get nativeBounds() {
+    binding.screenNativeBoundsInto(this._tag, scratch.buffer, 0)
+
+    return { x: scratch[0], y: scratch[1], width: scratch[2], height: scratch[3] }
+  }
+
+  get scale() {
+    return binding.screenScale(this._tag)
+  }
+
+  get nativeScale() {
+    return binding.screenNativeScale(this._tag)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitScreen }
+    }
+  }
+}

package/lib/scroll-view.d.ts

@@ -0,0 +1,39 @@
+import UIKitView = require('./view')
+
+/** A view that scrolls its content, as a `UIScrollView`. It does not report touches. */
+interface UIKitScrollView<
+  M extends Record<keyof M, unknown[]> = UIKitScrollView.Events
+> extends UIKitView<M> {
+  /** The size of what there is to scroll. A scroll view does not work it out from its subviews. */
+  get contentSize(): { width: number; height: number }
+  set contentSize(size: { width?: number; height?: number })
+
+  /** How far the content is scrolled. */
+  get contentOffset(): { x: number; y: number }
+  set contentOffset(offset: { x?: number; y?: number })
+
+  /** How the safe area insets the content, as a `CONTENT_INSET_ADJUSTMENT_BEHAVIOR` constant. */
+  contentInsetAdjustmentBehavior: number
+
+  /** The insets actually applied, safe area included. */
+  readonly adjustedContentInset: UIKitView.Insets
+}
+
+declare class UIKitScrollView<M extends Record<keyof M, unknown[]> = UIKitScrollView.Events> {
+  constructor(frame?: Partial<UIKitView.Rect>)
+
+  static readonly CONTENT_INSET_ADJUSTMENT_BEHAVIOR: {
+    readonly AUTOMATIC: number
+    readonly SCROLLABLE_AXES: number
+    readonly NEVER: number
+    readonly ALWAYS: number
+  }
+}
+
+declare namespace UIKitScrollView {
+  export interface Events {
+    didScroll: [offset: { x: number; y: number }]
+  }
+}
+
+export = UIKitScrollView

package/lib/scroll-view.h

@@ -0,0 +1,246 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+enum {
+  bare_ui_kit_scroll_view_event_did_scroll = 1 << 0,
+};
+
+// A scroll view is its own delegate, like every other class here.
+@interface BareScrollView : UIScrollView <UIScrollViewDelegate, BareEventTarget> {
+@public
+  js_env_t *env;
+  js_ref_t *ctx;
+
+  int32_t mask;
+}
+
+@end
+
+@implementation BareScrollView
+
+- (void)dealloc {
+  int err;
+
+  err = js_delete_reference(env, ctx);
+  assert(err == 0);
+
+  [super dealloc];
+}
+
+- (int32_t)eventMask {
+  return mask;
+}
+
+- (void)setEventMask:(int32_t)value {
+  mask = value;
+}
+
+- (void)scrollViewDidScroll:(UIScrollView *)view {
+  if ((mask & bare_ui_kit_scroll_view_event_did_scroll) == 0) return;
+
+  CGPoint offset = view.contentOffset;
+
+  bare_ui_kit__emit_point(env, ctx, "_ondidscroll", offset.x, offset.y);
+}
+
+@end
+
+static js_value_t *
+bare_ui_kit_scroll_view_init(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 5;
+  js_value_t *argv[5];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 5);
+
+  double x;
+  if (!bare_ui_kit__read_double(env, argv[0], "x", &x)) return NULL;
+
+  double y;
+  if (!bare_ui_kit__read_double(env, argv[1], "y", &y)) return NULL;
+
+  double width;
+  if (!bare_ui_kit__read_double(env, argv[2], "width", &width)) return NULL;
+
+  double height;
+  if (!bare_ui_kit__read_double(env, argv[3], "height", &height)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    BareScrollView *handle = [[[BareScrollView alloc]
+      initWithFrame:CGRectMake(x, y, width, height)] autorelease];
+
+    result = bare_foundation_bridge(env, state->registry, handle);
+
+    handle->env = env;
+
+    err = js_create_reference(env, argv[4], 0, &handle->ctx);
+    assert(err == 0);
+
+    handle.delegate = handle;
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_scroll_view_content_size(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1 || argc == 3);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  @autoreleasepool {
+    UIScrollView *view = (__bridge UIScrollView *) handle;
+
+    if (argc == 1) {
+      result = bare_ui_kit__from_size(env, view.contentSize);
+    } else {
+      double width;
+      if (!bare_ui_kit__read_double(env, argv[1], "width", &width)) return NULL;
+
+      double height;
+      if (!bare_ui_kit__read_double(env, argv[2], "height", &height)) return NULL;
+
+      view.contentSize = CGSizeMake(width, height);
+    }
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_scroll_view_content_inset_adjustment_behavior(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1 || argc == 2);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  @autoreleasepool {
+    UIScrollView *view = (__bridge UIScrollView *) handle;
+
+    if (argc == 1) {
+      err = js_create_int32(env, (int32_t) view.contentInsetAdjustmentBehavior, &result);
+      assert(err == 0);
+    } else {
+      double behavior;
+      if (!bare_ui_kit__read_double(env, argv[1], "behavior", &behavior)) return NULL;
+
+      view.contentInsetAdjustmentBehavior = (UIScrollViewContentInsetAdjustmentBehavior) behavior;
+    }
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_scroll_view_adjusted_content_inset_into(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 3);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  uint32_t offset;
+  if (!bare_ui_kit__read_uint32(env, argv[2], "offset", &offset)) return NULL;
+
+  double *out;
+
+  if (!bare_ui_kit__buffer(env, argv[1], offset, 4, &out)) {
+    err = js_throw_type_error(env, NULL, "Expected an array buffer with room for 4 doubles");
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  @autoreleasepool {
+    UIScrollView *view = (__bridge UIScrollView *) handle;
+
+    UIEdgeInsets value = view.adjustedContentInset;
+
+    out[0] = value.top;
+    out[1] = value.left;
+    out[2] = value.bottom;
+    out[3] = value.right;
+  }
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ui_kit_scroll_view_content_offset(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1 || argc == 3);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  @autoreleasepool {
+    UIScrollView *view = (__bridge UIScrollView *) handle;
+
+    if (argc == 1) {
+      result = bare_ui_kit__from_point(env, view.contentOffset);
+    } else {
+      double x;
+      if (!bare_ui_kit__read_double(env, argv[1], "x", &x)) return NULL;
+
+      double y;
+      if (!bare_ui_kit__read_double(env, argv[2], "y", &y)) return NULL;
+
+      view.contentOffset = CGPointMake(x, y);
+    }
+  }
+
+  return result;
+}

package/lib/scroll-view.js

@@ -0,0 +1,64 @@
+const binding = require('../binding')
+const scratch = require('./scratch')
+const UIKitView = require('./view')
+
+module.exports = exports = class UIKitScrollView extends UIKitView {
+  // A scroll view does not report touches, so it has its own events instead of
+  // those of a view.
+  static _events = {
+    didScroll: binding.SCROLL_VIEW_EVENT_DID_SCROLL
+  }
+
+  _init(opts) {
+    const { x = 0, y = 0, width = 0, height = 0 } = opts
+
+    return binding.scrollViewInit(x, y, width, height, this)
+  }
+
+  _ondidscroll(x, y) {
+    this.emit('didScroll', { x, y })
+  }
+
+  get contentSize() {
+    return binding.scrollViewContentSize(this._tag)
+  }
+
+  set contentSize({ width = 0, height = 0 }) {
+    binding.scrollViewContentSize(this._tag, width, height)
+  }
+
+  get contentOffset() {
+    return binding.scrollViewContentOffset(this._tag)
+  }
+
+  set contentOffset({ x = 0, y = 0 }) {
+    binding.scrollViewContentOffset(this._tag, x, y)
+  }
+
+  get contentInsetAdjustmentBehavior() {
+    return binding.scrollViewContentInsetAdjustmentBehavior(this._tag)
+  }
+
+  set contentInsetAdjustmentBehavior(behavior) {
+    binding.scrollViewContentInsetAdjustmentBehavior(this._tag, behavior)
+  }
+
+  get adjustedContentInset() {
+    binding.scrollViewAdjustedContentInsetInto(this._tag, scratch.buffer, 0)
+
+    return { top: scratch[0], left: scratch[1], bottom: scratch[2], right: scratch[3] }
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitScrollView }
+    }
+  }
+}
+
+exports.CONTENT_INSET_ADJUSTMENT_BEHAVIOR = {
+  AUTOMATIC: binding.SCROLL_VIEW_CONTENT_INSET_ADJUSTMENT_BEHAVIOR_AUTOMATIC,
+  SCROLLABLE_AXES: binding.SCROLL_VIEW_CONTENT_INSET_ADJUSTMENT_BEHAVIOR_SCROLLABLE_AXES,
+  NEVER: binding.SCROLL_VIEW_CONTENT_INSET_ADJUSTMENT_BEHAVIOR_NEVER,
+  ALWAYS: binding.SCROLL_VIEW_CONTENT_INSET_ADJUSTMENT_BEHAVIOR_ALWAYS
+}

package/lib/switch.d.ts

@@ -0,0 +1,22 @@
+import UIKitView = require('./view')
+
+/** An on and off switch, as a `UISwitch`. */
+interface UIKitSwitch extends UIKitView<UIKitSwitch.Events> {
+  /** Whether the switch is on. Named so it does not hide the `on()` method of the emitter. */
+  isOn: boolean
+
+  enabled: boolean
+}
+
+declare class UIKitSwitch {
+  constructor(frame?: Partial<UIKitView.Rect>)
+}
+
+declare namespace UIKitSwitch {
+  export interface Events {
+    /** The user turned the switch on or off. Setting `isOn` does not emit this. */
+    valueChanged: []
+  }
+}
+
+export = UIKitSwitch