bare-ui-kit 0.2.0 → 0.3.0

package/lib/font.js

@@ -0,0 +1,100 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+const wrap = require('./wrap')
+const UIKitFontDescriptor = require('./font-descriptor')
+
+module.exports = exports = class UIKitFont {
+  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 systemFont(size, weight = binding.FONT_WEIGHT_REGULAR) {
+    return wrap(UIKitFont, binding.fontSystemFont(size, weight))
+  }
+
+  static boldSystemFont(size) {
+    return wrap(UIKitFont, binding.fontBoldSystemFont(size))
+  }
+
+  static monospacedSystemFont(size, weight = binding.FONT_WEIGHT_REGULAR) {
+    return wrap(UIKitFont, binding.fontMonospacedSystemFont(size, weight))
+  }
+
+  static withName(name, size) {
+    return wrap(UIKitFont, binding.fontWithName(name, size))
+  }
+
+  static withDescriptor(descriptor, size) {
+    return wrap(UIKitFont, binding.fontWithDescriptor(descriptor._tag, size))
+  }
+
+  get fontDescriptor() {
+    return wrap(UIKitFontDescriptor, binding.fontFontDescriptor(this._tag))
+  }
+
+  get fontName() {
+    return binding.fontFontName(this._tag)
+  }
+
+  get familyName() {
+    return binding.fontFamilyName(this._tag)
+  }
+
+  get pointSize() {
+    return binding.fontPointSize(this._tag)
+  }
+
+  get ascender() {
+    return binding.fontAscender(this._tag)
+  }
+
+  get descender() {
+    return binding.fontDescender(this._tag)
+  }
+
+  get capHeight() {
+    return binding.fontCapHeight(this._tag)
+  }
+
+  get xHeight() {
+    return binding.fontXHeight(this._tag)
+  }
+
+  get leading() {
+    return binding.fontLeading(this._tag)
+  }
+
+  get lineHeight() {
+    return binding.fontLineHeight(this._tag)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitFont }
+    }
+  }
+}
+
+exports.WEIGHT = {
+  ULTRA_LIGHT: binding.FONT_WEIGHT_ULTRA_LIGHT,
+  THIN: binding.FONT_WEIGHT_THIN,
+  LIGHT: binding.FONT_WEIGHT_LIGHT,
+  REGULAR: binding.FONT_WEIGHT_REGULAR,
+  MEDIUM: binding.FONT_WEIGHT_MEDIUM,
+  SEMIBOLD: binding.FONT_WEIGHT_SEMIBOLD,
+  BOLD: binding.FONT_WEIGHT_BOLD,
+  HEAVY: binding.FONT_WEIGHT_HEAVY,
+  BLACK: binding.FONT_WEIGHT_BLACK
+}

package/lib/handle.d.ts

@@ -0,0 +1,5 @@
+import { Wrapper } from 'bare-foundation-registry'
+
+/** Return the tag of `object` in this addon, adopting it from another addon first if needed. */
+export function adopt(object: Wrapper): number
+export function adopt(object: null | undefined): null

package/lib/handle.js

@@ -0,0 +1,6 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+
+exports.adopt = function adopt(object) {
+  return registry.adopt(binding, object)
+}

package/lib/image-view.d.ts

@@ -0,0 +1,15 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+import UIKitView = require('./view')
+import UIKitImage = require('./image')
+
+/** A view that shows an image, as a `UIImageView`. */
+interface UIKitImageView extends UIKitView {
+  get image(): UIKitImage | null
+  set image(image: Wrapper | null)
+}
+
+declare class UIKitImageView {
+  constructor(frame?: Partial<UIKitView.Rect>)
+}
+
+export = UIKitImageView

package/lib/image-view.h

@@ -0,0 +1,75 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_image_view_init(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 4;
+  js_value_t *argv[4];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 4);
+
+  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 {
+    UIImageView *handle = [[[UIImageView alloc]
+      initWithFrame:CGRectMake(x, y, width, height)] autorelease];
+
+    result = bare_foundation_bridge(env, state->registry, handle);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_image_view_image(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 {
+    UIImageView *view = (__bridge UIImageView *) handle;
+
+    if (argc == 1) {
+      result = bare_foundation_bridge(env, state->registry, view.image);
+    } else {
+      view.image = bare_foundation_to_object(env, state->registry, argv[1]);
+    }
+  }
+
+  return result;
+}

package/lib/image-view.js

@@ -0,0 +1,27 @@
+const binding = require('../binding')
+const { adopt } = require('./handle')
+const wrap = require('./wrap')
+const UIKitImage = require('./image')
+const UIKitView = require('./view')
+
+module.exports = exports = class UIKitImageView extends UIKitView {
+  _init(opts) {
+    const { x = 0, y = 0, width = 0, height = 0 } = opts
+
+    return binding.imageViewInit(x, y, width, height)
+  }
+
+  get image() {
+    return wrap(UIKitImage, binding.imageViewImage(this._tag))
+  }
+
+  set image(image) {
+    binding.imageViewImage(this._tag, adopt(image))
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitImageView }
+    }
+  }
+}

package/lib/image.d.ts

@@ -0,0 +1,37 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+
+/** An image, as a `UIImage`. */
+interface UIKitImage {
+  /** The size in points. */
+  readonly size: { width: number; height: number }
+
+  readonly scale: number
+
+  /** Whether the image is drawn as is or tinted, as a `RENDERING_MODE` constant. */
+  readonly renderingMode: number
+
+  /** The same image with another rendering mode. */
+  withRenderingMode(renderingMode: number): UIKitImage
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitImage {
+  protected constructor()
+
+  /** Load an image file, or return `null` if it cannot be read. */
+  static withContentsOfFile(path: string): UIKitImage | null
+
+  /** An image from the app bundle, or `null` if there is none by that name. */
+  static named(name: string): UIKitImage | null
+
+  static readonly RENDERING_MODE: {
+    readonly AUTOMATIC: number
+    readonly ALWAYS_ORIGINAL: number
+    readonly ALWAYS_TEMPLATE: number
+  }
+}
+
+export = UIKitImage

package/lib/image.h

@@ -0,0 +1,205 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_image_with_contents_of_file(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);
+
+  NSString *path = bare_ui_kit__to_string(env, argv[0]);
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    result = bare_foundation_bridge(env, state->registry, [UIImage imageWithContentsOfFile:path]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_image_named(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);
+
+  NSString *name = bare_ui_kit__to_string(env, argv[0]);
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    result = bare_foundation_bridge(env, state->registry, [UIImage imageNamed:name]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_image_size_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, 2, &out)) {
+    err = js_throw_type_error(env, NULL, "Expected an array buffer with room for 2 doubles");
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  @autoreleasepool {
+    UIImage *image = (__bridge UIImage *) handle;
+
+    out[0] = image.size.width;
+    out[1] = image.size.height;
+  }
+
+  return NULL;
+}
+
+static void
+bare_ui_kit_image_size_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, 2, &out)) return;
+
+  @autoreleasepool {
+    UIImage *image = (UIImage *) bare_object;
+
+    out[0] = image.size.width;
+    out[1] = image.size.height;
+  }
+}
+
+static js_value_t *
+bare_ui_kit_image_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 {
+    UIImage *image = (__bridge UIImage *) handle;
+
+    err = js_create_double(env, image.scale, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_image_rendering_mode(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 {
+    UIImage *image = (__bridge UIImage *) handle;
+
+    err = js_create_int32(env, image.renderingMode, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_image_with_rendering_mode(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 == 2);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  int32_t rendering_mode;
+  if (!bare_ui_kit__read_int32(env, argv[1], "rendering_mode", &rendering_mode)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIImage *image = (__bridge UIImage *) handle;
+
+    result = bare_foundation_bridge(env, state->registry, [image imageWithRenderingMode:rendering_mode]);
+  }
+
+  return result;
+}

package/lib/image.js

@@ -0,0 +1,60 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+const scratch = require('./scratch')
+const wrap = require('./wrap')
+
+module.exports = exports = class UIKitImage {
+  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 withContentsOfFile(path) {
+    return wrap(UIKitImage, binding.imageWithContentsOfFile(path))
+  }
+
+  static named(name) {
+    return wrap(UIKitImage, binding.imageNamed(name))
+  }
+
+  get size() {
+    binding.imageSizeInto(this._tag, scratch.buffer, 0)
+
+    return { width: scratch[0], height: scratch[1] }
+  }
+
+  get scale() {
+    return binding.imageScale(this._tag)
+  }
+
+  get renderingMode() {
+    return binding.imageRenderingMode(this._tag)
+  }
+
+  withRenderingMode(renderingMode) {
+    return wrap(UIKitImage, binding.imageWithRenderingMode(this._tag, renderingMode))
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitImage }
+    }
+  }
+}
+
+exports.RENDERING_MODE = {
+  AUTOMATIC: binding.IMAGE_RENDERING_MODE_AUTOMATIC,
+  ALWAYS_ORIGINAL: binding.IMAGE_RENDERING_MODE_ALWAYS_ORIGINAL,
+  ALWAYS_TEMPLATE: binding.IMAGE_RENDERING_MODE_ALWAYS_TEMPLATE
+}

package/lib/label.d.ts

@@ -0,0 +1,51 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+import UIKitView = require('./view')
+import UIKitAttributedString = require('./attributed-string')
+import UIKitColor = require('./color')
+import UIKitFont = require('./font')
+
+/** A view that shows text, as a `UILabel`. */
+interface UIKitLabel extends UIKitView {
+  text: string | null
+
+  get attributedText(): UIKitAttributedString | null
+  set attributedText(text: Wrapper | null)
+
+  get font(): UIKitFont | null
+  set font(font: Wrapper | null)
+
+  get textColor(): UIKitColor | null
+  set textColor(color: Wrapper | null)
+
+  /** A `TEXT_ALIGNMENT` constant. */
+  textAlignment: number
+
+  /** The most lines to show. 0 means no limit. */
+  numberOfLines: number
+
+  /** How lines wrap or are cut off, as a `LINE_BREAK_MODE` constant. */
+  lineBreakMode: number
+}
+
+declare class UIKitLabel {
+  constructor(frame?: Partial<UIKitView.Rect>)
+
+  static readonly TEXT_ALIGNMENT: {
+    readonly LEFT: number
+    readonly RIGHT: number
+    readonly CENTER: number
+    readonly JUSTIFIED: number
+    readonly NATURAL: number
+  }
+
+  static readonly LINE_BREAK_MODE: {
+    readonly WORD_WRAPPING: number
+    readonly CHAR_WRAPPING: number
+    readonly CLIPPING: number
+    readonly TRUNCATING_HEAD: number
+    readonly TRUNCATING_TAIL: number
+    readonly TRUNCATING_MIDDLE: number
+  }
+}
+
+export = UIKitLabel