bare-ui-kit 0.2.0 → 0.3.0

package/lib/label.h

@@ -0,0 +1,331 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_label_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 {
+    UILabel *handle = [[[UILabel 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_label_text(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 {
+    UILabel *label = (__bridge UILabel *) handle;
+
+    if (argc == 1) {
+      result = bare_ui_kit__from_string(env, label.text);
+    } else {
+      label.text = bare_ui_kit__to_string(env, argv[1]);
+    }
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_label_font(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 {
+    UILabel *label = (__bridge UILabel *) handle;
+
+    if (argc == 1) {
+      result = bare_foundation_bridge(env, state->registry, label.font);
+    } else {
+      label.font = bare_foundation_to_object(env, state->registry, argv[1]);
+    }
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_label_text_color(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 {
+    UILabel *label = (__bridge UILabel *) handle;
+
+    if (argc == 1) {
+      result = bare_foundation_bridge(env, state->registry, label.textColor);
+    } else {
+      label.textColor = bare_foundation_to_object(env, state->registry, argv[1]);
+    }
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_label_text_alignment(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 {
+    UILabel *label = (__bridge UILabel *) handle;
+
+    if (argc == 1) {
+      err = js_create_int32(env, (int32_t) label.textAlignment, &result);
+      assert(err == 0);
+    } else {
+      int32_t text_alignment;
+      if (!bare_ui_kit__read_int32(env, argv[1], "text_alignment", &text_alignment)) return NULL;
+
+      label.textAlignment = text_alignment;
+    }
+  }
+
+  return result;
+}
+
+static void
+bare_ui_kit_label_text_alignment_typed(js_value_t *receiver, int32_t bare_tag, int32_t text_alignment, js_typed_callback_info_t *info) {
+  int err;
+
+  bare_ui_kit_state_t *state;
+  err = js_get_typed_callback_info(info, NULL, (void **) &state);
+  assert(err == 0);
+
+  id bare_object = bare_foundation_object(state->registry, bare_tag);
+
+  if (bare_object == nil) return;
+
+  @autoreleasepool {
+    UILabel *label = (UILabel *) bare_object;
+
+    label.textAlignment = text_alignment;
+  }
+}
+
+static js_value_t *
+bare_ui_kit_label_number_of_lines(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 {
+    UILabel *label = (__bridge UILabel *) handle;
+
+    if (argc == 1) {
+      err = js_create_int32(env, (int32_t) label.numberOfLines, &result);
+      assert(err == 0);
+    } else {
+      int32_t number_of_lines;
+      if (!bare_ui_kit__read_int32(env, argv[1], "number_of_lines", &number_of_lines)) return NULL;
+
+      label.numberOfLines = number_of_lines;
+    }
+  }
+
+  return result;
+}
+
+static void
+bare_ui_kit_label_number_of_lines_typed(js_value_t *receiver, int32_t bare_tag, int32_t number_of_lines, js_typed_callback_info_t *info) {
+  int err;
+
+  bare_ui_kit_state_t *state;
+  err = js_get_typed_callback_info(info, NULL, (void **) &state);
+  assert(err == 0);
+
+  id bare_object = bare_foundation_object(state->registry, bare_tag);
+
+  if (bare_object == nil) return;
+
+  @autoreleasepool {
+    UILabel *label = (UILabel *) bare_object;
+
+    label.numberOfLines = number_of_lines;
+  }
+}
+
+static js_value_t *
+bare_ui_kit_label_line_break_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 == 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 {
+    UILabel *label = (__bridge UILabel *) handle;
+
+    if (argc == 1) {
+      err = js_create_int32(env, (int32_t) label.lineBreakMode, &result);
+      assert(err == 0);
+    } else {
+      int32_t line_break_mode;
+      if (!bare_ui_kit__read_int32(env, argv[1], "line_break_mode", &line_break_mode)) return NULL;
+
+      label.lineBreakMode = line_break_mode;
+    }
+  }
+
+  return result;
+}
+
+static void
+bare_ui_kit_label_line_break_mode_typed(js_value_t *receiver, int32_t bare_tag, int32_t line_break_mode, js_typed_callback_info_t *info) {
+  int err;
+
+  bare_ui_kit_state_t *state;
+  err = js_get_typed_callback_info(info, NULL, (void **) &state);
+  assert(err == 0);
+
+  id bare_object = bare_foundation_object(state->registry, bare_tag);
+
+  if (bare_object == nil) return;
+
+  @autoreleasepool {
+    UILabel *label = (UILabel *) bare_object;
+
+    label.lineBreakMode = line_break_mode;
+  }
+}
+
+
+static js_value_t *
+bare_ui_kit_label_attributed_text(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 {
+    UILabel *label = (__bridge UILabel *) handle;
+
+    if (argc == 1) {
+      result = bare_foundation_bridge(env, state->registry, label.attributedText);
+    } else {
+      label.attributedText = bare_foundation_to_object(env, state->registry, argv[1]);
+    }
+  }
+
+  return result;
+}

package/lib/label.js

@@ -0,0 +1,94 @@
+const binding = require('../binding')
+const { adopt } = require('./handle')
+const wrap = require('./wrap')
+const UIKitAttributedString = require('./attributed-string')
+const UIKitColor = require('./color')
+const UIKitFont = require('./font')
+const UIKitView = require('./view')
+
+module.exports = exports = class UIKitLabel extends UIKitView {
+  _init(opts) {
+    const { x = 0, y = 0, width = 0, height = 0 } = opts
+
+    return binding.labelInit(x, y, width, height)
+  }
+
+  get text() {
+    return binding.labelText(this._tag)
+  }
+
+  set text(text) {
+    binding.labelText(this._tag, text)
+  }
+
+  get attributedText() {
+    return wrap(UIKitAttributedString, binding.labelAttributedText(this._tag))
+  }
+
+  set attributedText(value) {
+    binding.labelAttributedText(this._tag, adopt(value))
+  }
+
+  get font() {
+    return wrap(UIKitFont, binding.labelFont(this._tag))
+  }
+
+  set font(font) {
+    binding.labelFont(this._tag, adopt(font))
+  }
+
+  get textColor() {
+    return wrap(UIKitColor, binding.labelTextColor(this._tag))
+  }
+
+  set textColor(textColor) {
+    binding.labelTextColor(this._tag, adopt(textColor))
+  }
+
+  get textAlignment() {
+    return binding.labelTextAlignment(this._tag)
+  }
+
+  set textAlignment(textAlignment) {
+    binding.labelTextAlignment(this._tag, textAlignment)
+  }
+
+  get numberOfLines() {
+    return binding.labelNumberOfLines(this._tag)
+  }
+
+  set numberOfLines(numberOfLines) {
+    binding.labelNumberOfLines(this._tag, numberOfLines)
+  }
+
+  get lineBreakMode() {
+    return binding.labelLineBreakMode(this._tag)
+  }
+
+  set lineBreakMode(lineBreakMode) {
+    binding.labelLineBreakMode(this._tag, lineBreakMode)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitLabel }
+    }
+  }
+}
+
+exports.TEXT_ALIGNMENT = {
+  LEFT: binding.TEXT_ALIGNMENT_LEFT,
+  RIGHT: binding.TEXT_ALIGNMENT_RIGHT,
+  CENTER: binding.TEXT_ALIGNMENT_CENTER,
+  JUSTIFIED: binding.TEXT_ALIGNMENT_JUSTIFIED,
+  NATURAL: binding.TEXT_ALIGNMENT_NATURAL
+}
+
+exports.LINE_BREAK_MODE = {
+  WORD_WRAPPING: binding.LINE_BREAK_MODE_WORD_WRAPPING,
+  CHAR_WRAPPING: binding.LINE_BREAK_MODE_CHAR_WRAPPING,
+  CLIPPING: binding.LINE_BREAK_MODE_CLIPPING,
+  TRUNCATING_HEAD: binding.LINE_BREAK_MODE_TRUNCATING_HEAD,
+  TRUNCATING_TAIL: binding.LINE_BREAK_MODE_TRUNCATING_TAIL,
+  TRUNCATING_MIDDLE: binding.LINE_BREAK_MODE_TRUNCATING_MIDDLE
+}

package/lib/paragraph-style.d.ts

@@ -0,0 +1,20 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+
+/** How paragraphs in an attributed string are laid out, as an `NSMutableParagraphStyle`. */
+interface UIKitParagraphStyle {
+  /** A `UIKitLabel.TEXT_ALIGNMENT` constant. */
+  alignment: number
+
+  /** A `UIKitLabel.LINE_BREAK_MODE` constant. */
+  lineBreakMode: number
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitParagraphStyle {
+  constructor()
+}
+
+export = UIKitParagraphStyle

package/lib/paragraph-style.h

@@ -0,0 +1,94 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_paragraph_style_init(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, [[[NSMutableParagraphStyle alloc] init] autorelease]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_paragraph_style_alignment(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 {
+    NSMutableParagraphStyle *style = (__bridge NSMutableParagraphStyle *) handle;
+
+    if (argc == 1) {
+      err = js_create_int32(env, (int32_t) style.alignment, &result);
+      assert(err == 0);
+    } else {
+      int32_t alignment;
+      if (!bare_ui_kit__read_int32(env, argv[1], "alignment", &alignment)) return NULL;
+
+      style.alignment = (NSTextAlignment) alignment;
+    }
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_paragraph_style_line_break_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 == 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 {
+    NSMutableParagraphStyle *style = (__bridge NSMutableParagraphStyle *) handle;
+
+    if (argc == 1) {
+      err = js_create_int32(env, (int32_t) style.lineBreakMode, &result);
+      assert(err == 0);
+    } else {
+      int32_t mode;
+      if (!bare_ui_kit__read_int32(env, argv[1], "lineBreakMode", &mode)) return NULL;
+
+      style.lineBreakMode = (NSLineBreakMode) mode;
+    }
+  }
+
+  return result;
+}

package/lib/paragraph-style.js

@@ -0,0 +1,42 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+
+module.exports = exports = class UIKitParagraphStyle {
+  constructor(opts = {}) {
+    const { tag = null } = opts
+
+    this._tag = tag === null ? binding.paragraphStyleInit() : tag
+
+    this._token = binding.claim(this._tag, this)
+  }
+
+  get [registry.tag]() {
+    return this._tag
+  }
+
+  get [registry.handle]() {
+    return binding.handle(this._tag)
+  }
+
+  get alignment() {
+    return binding.paragraphStyleAlignment(this._tag)
+  }
+
+  set alignment(value) {
+    binding.paragraphStyleAlignment(this._tag, value)
+  }
+
+  get lineBreakMode() {
+    return binding.paragraphStyleLineBreakMode(this._tag)
+  }
+
+  set lineBreakMode(value) {
+    binding.paragraphStyleLineBreakMode(this._tag, value)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitParagraphStyle }
+    }
+  }
+}

package/lib/pasteboard.d.ts

@@ -0,0 +1,31 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+
+/** The clipboard, as a `UIPasteboard`. */
+interface UIKitPasteboard {
+  string: string | null
+
+  readonly hasStrings: boolean
+
+  readonly hasURLs: boolean
+
+  readonly hasImages: boolean
+
+  readonly hasColors: boolean
+
+  readonly numberOfItems: number
+
+  /** A number that changes every time the contents change. */
+  readonly changeCount: number
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitPasteboard {
+  protected constructor()
+
+  static readonly generalPasteboard: UIKitPasteboard
+}
+
+export = UIKitPasteboard