accessibility_core 0.1.0

data/ext/accessibility/bridge/test/boxed_test.rb

@@ -0,0 +1,23 @@
+require 'test/helper'
+
+if on_macruby?
+
+##
+# Boxed is the common ancestor of all structs defined by bridge support
+# in MacRuby.
+class BoxedTest < MiniTest::Unit::TestCase
+
+  def test_to_ax_raises_for_arbitrary_boxes
+    assert_raises(NotImplementedError) { NSEdgeInsets.new.to_ax }
+  end
+
+  def test_to_ruby # bet you would never dare to abuse the parser like this!
+    assert_equal CGPointZero,         CGPointZero        .to_ax.to_ruby
+    assert_equal CGSize.new(10,10),   CGSize.new(10, 10) .to_ax.to_ruby
+    assert_equal CGRectMake(1,2,3,4), CGRectMake(1,2,3,4).to_ax.to_ruby
+    assert_equal 1..10,               CFRange.new(1, 10) .to_ax.to_ruby
+    assert_equal Range.new(1,10),     CFRange.new(1,10)  .to_ax.to_ruby
+  end
+
+end
+end

data/ext/accessibility/bridge/test/cfrange_test.rb

@@ -0,0 +1,21 @@
+require 'test/helper'
+
+if on_macruby?
+class CFRangeTest < MiniTest::Unit::TestCase
+
+  def test_to_ax
+    range = CFRange.new(5, 4)
+    value = range.to_ax
+    ptr   = Pointer.new CFRange.type
+    AXValueGetValue(value, 4, ptr)
+    assert_equal range, ptr.value, 'range makes a value'
+  end
+
+  def test_cf_range_to_ruby_range_compatability
+    assert_equal CFRangeMake(1,10).to_ax, (1..10  ).to_ax
+    assert_equal CFRangeMake(1, 9).to_ax, (1...10 ).to_ax
+    assert_equal CFRangeMake(0, 3).to_ax, (0..2   ).to_ax
+  end
+
+end
+end

data/ext/accessibility/bridge/test/cgpoint_test.rb

@@ -0,0 +1,54 @@
+require 'test/helper'
+
+class CGPointTest < MiniTest::Unit::TestCase
+
+  def test_attributes
+    p = CGPoint.new
+    assert_respond_to p, :x
+    assert_respond_to p, :y
+  end
+
+  def test_to_a
+    p = CGPoint.new 1, 2
+    assert_equal [1, 2], p.to_a
+  end
+
+  def test_to_point
+    p = CGPoint.new
+    assert_same p, p.to_point
+
+    p = CGPoint.new 4, 2
+    assert_same p, p.to_point
+  end
+
+  def test_initialize
+    p = CGPoint.new
+    assert_equal 0, p.x
+    assert_equal 0, p.y
+
+    x, y = rand_nums 2
+    p = CGPoint.new x, y
+    assert_equal x, p.x
+    assert_equal y, p.y
+
+    x, y = rand_floats 2
+    p = CGPoint.new x, y
+    assert_equal x, p.x
+    assert_equal y, p.y
+  end
+
+  def test_inspect
+    assert_match /Point x=1.0 y=2.0>/, CGPoint.new(1, 2).inspect
+    assert_match /Point x=3.0 y=5.0>/, CGPoint.new(3, 5).inspect
+  end
+
+  if on_macruby?
+    def test_to_ax
+      value = CGPointZero.to_ax
+      ptr   = Pointer.new CGPoint.type
+      AXValueGetValue(value, 1, ptr)
+      assert_equal CGPointZero, ptr.value, 'point makes a value'
+    end
+  end
+
+end

data/ext/accessibility/bridge/test/cgrect_test.rb

@@ -0,0 +1,60 @@
+require 'test/helper'
+
+class CGRectTest < MiniTest::Unit::TestCase
+
+  def test_attributes
+    r = CGRect.new
+    assert_respond_to r, :origin
+    assert_respond_to r, :size
+  end
+
+  def test_to_a # we want to match MacRuby here
+    r = CGRect.new
+    assert_equal [CGPoint.new, CGSize.new], r.to_a
+  end
+
+  def test_to_rect
+    r = CGRect.new
+    assert_same r, r.to_rect
+
+    r = CGRect.new CGPoint.new(4, 2), CGSize.new(8, 3)
+    assert_same r, r.to_rect
+  end
+
+  def test_initialize
+    r = CGRect.new
+    assert_equal 0, r.origin.x
+    assert_equal 0, r.origin.y
+    assert_equal 0, r.size.width
+    assert_equal 0, r.size.height
+
+    x, y, w, h = rand_nums 4
+    p = CGPoint.new x, y
+    s = CGSize.new w, h
+    r = CGRect.new p, s
+    assert_equal p, r.origin
+    assert_equal s, r.size
+  end
+
+  def test_inspect
+    p1 = CGPoint.new *rand_nums(2)
+    p2 = CGPoint.new *rand_nums(2)
+    s1 = CGSize.new *rand_nums(2)
+    s2 = CGSize.new *rand_nums(2)
+    r1 = CGRect.new p1, s1
+    r2 = CGRect.new p2, s2
+    assert_match /Rect origin=#{p1.inspect} size=#{s1.inspect}>/, r1.inspect
+    assert_match /Rect origin=#{p2.inspect} size=#{s2.inspect}>/, r2.inspect
+  end
+
+  if on_macruby?
+    def test_to_ax
+      value = CGRectZero.to_ax
+      ptr   = Pointer.new CGRect.type
+      AXValueGetValue(value, 3, ptr)
+      assert_equal CGRectZero, ptr.value, 'rect makes a value'
+    end
+  end
+
+
+end

data/ext/accessibility/bridge/test/cgsize_test.rb

@@ -0,0 +1,54 @@
+require 'test/helper'
+
+class CGSizeTest < MiniTest::Unit::TestCase
+
+  def test_attributes
+    s = CGSize.new
+    assert_respond_to s, :width
+    assert_respond_to s, :height
+  end
+
+  def test_to_a
+    s = CGSize.new 1, 2
+    assert_equal [1, 2], s.to_a
+  end
+
+  def test_to_size
+    s = CGSize.new
+    assert_same s, s.to_size
+
+    s = CGSize.new 4, 2
+    assert_same s, s.to_size
+  end
+
+  def test_initialize
+    s = CGSize.new
+    assert_equal 0, s.width
+    assert_equal 0, s.height
+
+    w, h = rand_nums 2
+    s = CGSize.new w, h
+    assert_equal w, s.width
+    assert_equal h, s.height
+
+    w, h = rand_floats 2
+    s = CGSize.new w, h
+    assert_equal w, s.width
+    assert_equal h, s.height
+  end
+
+  def test_inspect
+    assert_match /Size width=1.0 height=2.0>/, CGSize.new(1, 2).inspect
+    assert_match /Size width=3.0 height=5.0>/, CGSize.new(3, 5).inspect
+  end
+
+  if on_macruby?
+    def test_to_ax
+      value = CGSizeZero.to_ax
+      ptr   = Pointer.new CGSize.type
+      AXValueGetValue(value, 2, ptr)
+      assert_equal CGSizeZero, ptr.value, 'size makes a value'
+    end
+  end
+
+end

data/ext/accessibility/bridge/test/helper.rb

@@ -0,0 +1,19 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'accessibility/bridge'
+
+class MiniTest::Unit::TestCase
+
+  def rand_nums count, range = 1_000
+    Array.new count do
+      rand range
+    end
+  end
+
+  def rand_floats count, range = 1_000.0
+    Array.new count do
+      rand * range
+    end
+  end
+
+end

data/ext/accessibility/bridge/test/nsstring_test.rb

@@ -0,0 +1,22 @@
+require 'test/helper'
+
+if on_macruby?
+class NSStringTest < MiniTest::Unit::TestCase
+
+  def test_to_url
+    site = 'http://marketcircle.com/'
+    url  = site.to_url
+    refute_nil url
+    assert_equal NSURL.URLWithString(site), url
+
+    file = 'file://localhost/Applications/Calculator.app/'
+    url  = file.to_url
+    refute_nil url
+    assert_equal NSURL.fileURLWithPath('/Applications/Calculator.app/'), url
+
+    void = 'not a url at all'
+    assert_nil void.to_url
+  end
+
+end
+end

data/ext/accessibility/bridge/test/nsurl_test.rb

@@ -0,0 +1,17 @@
+require 'test/helper'
+
+if on_macruby?
+class TestNSURL < MiniTest::Unit::TestCase
+
+  def test_to_url_returns_self
+    url = NSURL.URLWithString 'http://macruby.org'
+    assert_same url, url.to_url
+  end
+
+  def test_to_s
+    s = 'http://marketcircle.com'
+    assert_equal s, NSURL.URLWithString(s).to_s
+  end
+
+end
+end

data/ext/accessibility/bridge/test/object_test.rb

@@ -0,0 +1,19 @@
+require 'test/helper'
+
+class ObjectTest < MiniTest::Unit::TestCase
+
+  if on_macruby?
+    def test_to_ruby
+      assert_same Object, Object.to_ruby
+      assert_same 10, 10.to_ruby
+    end
+
+    def test_to_ax
+      assert_same Object, Object.to_ax
+      assert_same 10, 10.to_ax
+    end
+  end
+
+  # we may have other tests for extensions to the Object class
+
+end

data/ext/accessibility/bridge/test/range_test.rb

@@ -0,0 +1,16 @@
+require 'test/helper'
+
+if on_macruby?
+class RangeTest < MiniTest::Unit::TestCase
+
+  def test_to_ax
+    assert_equal CFRange.new(5, 4).to_ax, (5..8).to_ax
+  end
+
+  def test_to_ax_raises_when_given_negative_indicies
+    assert_raises(ArgumentError) { (1..-10).to_ax  }
+    assert_raises(ArgumentError) { (-5...10).to_ax }
+  end
+
+end
+end

data/ext/accessibility/bridge/test/string_test.rb

@@ -0,0 +1,35 @@
+require 'test/helper'
+
+class StringTest < MiniTest::Unit::TestCase
+
+  if on_macruby?
+    def test_to_url
+      site = 'http://marketcircle.com/'
+      url  = site.to_url
+      refute_nil url
+      assert_equal NSURL.URLWithString(site), url
+
+      file = 'file://localhost/Applications/Calculator.app/'
+      url  = file.to_url
+      refute_nil url
+      assert_equal NSURL.fileURLWithPath('/Applications/Calculator.app/'), url
+
+      assert_nil 'not a url at all'.to_url
+    end
+
+  else
+
+    def test_to_url
+      site = 'http://marketcircle.com/'
+      url  = site.to_url
+      refute_nil url
+      assert_equal URI.parse(site), url
+
+      # Ruby's URI class does not handle the file scheme :(
+      # @todo propose the change upstream at some point?
+
+      assert_raises(URI::InvalidURIError) { 'not a url at all'.to_url }
+    end
+  end
+
+end

data/ext/accessibility/bridge/test/uri_test.rb

@@ -0,0 +1,15 @@
+require 'test/helper'
+
+unless on_macruby?
+class TestURIExtensions < MiniTest::Unit::TestCase
+
+  def test_to_url_returns_self
+    url = URI.parse 'http://macruby.org'
+    assert_same url, url.to_url
+
+    url = URI.parse 'ftp://herp.com'
+    assert_same url, url.to_url
+  end
+
+end
+end

data/ext/accessibility/core/bridge.h

@@ -0,0 +1 @@
+#include "../bridge/ext/accessibility/bridge/bridge.c"

data/ext/accessibility/core/core.c

@@ -0,0 +1,705 @@
+#include "ruby.h"
+
+#ifdef NOT_MACRUBY /* This entire extension is pointless when running on MacRuby */
+
+#import <Cocoa/Cocoa.h>
+#include "bridge.h"
+
+
+static ID ivar_attrs;
+static ID ivar_param_attrs;
+static ID ivar_actions;
+static ID ivar_pid;
+static ID ivar_key_rate;
+
+static ID sel_to_f;
+
+static ID rate_very_slow;
+static ID rate_slow;
+static ID rate_normal;
+static ID rate_default;
+static ID rate_fast;
+static ID rate_zomg;
+
+
+static
+VALUE
+handle_error(VALUE self, AXError code)
+{
+  // TODO port the error handler from AXElements
+  switch (code)
+    {
+    case kAXErrorInvalidUIElement:
+      rb_raise(rb_eArgError, "invalid element (probably dead)");
+    case kAXErrorAttributeUnsupported:
+      rb_raise(rb_eArgError, "attribute unsupported");
+    case kAXErrorActionUnsupported:
+      rb_raise(rb_eArgError, "action unsupported");
+    case kAXErrorParameterizedAttributeUnsupported:
+      rb_raise(rb_eArgError, "parameterized attribute unsupported");
+    default:
+      rb_raise(rb_eRuntimeError, "you done goofed [%d]", code);
+    }
+
+  return Qnil;
+}
+
+
+static
+VALUE
+rb_acore_application_for(VALUE self, VALUE pid)
+{
+  NSDate* date = [NSDate date];
+  [[NSRunLoop currentRunLoop] runUntilDate:date];
+  CFRelease(date);
+
+  pid_t                     the_pid = NUM2PIDT(pid);
+  NSRunningApplication* running_app =
+    [NSRunningApplication runningApplicationWithProcessIdentifier:the_pid];
+
+  if (running_app) {
+    VALUE app = wrap_ref(AXUIElementCreateApplication(the_pid));
+    CFRelease(running_app);
+    return app;
+  }
+
+  rb_raise(
+	   rb_eArgError,
+	   "pid `%d' must belong to a running application",
+	   the_pid
+	   );
+
+  return Qnil; // unreachable
+}
+
+
+static
+VALUE
+rb_acore_system_wide(VALUE self)
+{
+  return wrap_ref(AXUIElementCreateSystemWide());
+}
+
+
+static
+VALUE
+rb_acore_key_rate(VALUE self)
+{
+  return rb_ivar_get(self, ivar_key_rate);
+}
+
+
+static
+VALUE
+rb_acore_set_key_rate(VALUE self, VALUE rate)
+{
+  if (TYPE(rate) == T_SYMBOL) {
+    ID key_rate = SYM2ID(rate);
+    if (key_rate == rate_very_slow)
+      rate = DBL2NUM(0.9);
+    else if (key_rate == rate_slow)
+      rate = DBL2NUM(0.09);
+    else if (key_rate == rate_normal || rate == rate_default)
+      rate = DBL2NUM(0.009);
+    else if (key_rate == rate_fast)
+      rate = DBL2NUM(0.0009);
+    else if (key_rate == rate_zomg)
+      rate = DBL2NUM(0.00009);
+    else
+      rb_raise(rb_eArgError, "Unknown rate `%s'", rb_id2name(key_rate));
+  }
+  else {
+    rate = rb_funcall(rate, sel_to_f, 0);
+  }
+
+  return rb_ivar_set(self, ivar_key_rate, rate);
+}
+
+
+static
+int
+acore_is_system_wide(VALUE other)
+{
+  AXUIElementRef system = AXUIElementCreateSystemWide();
+  int result = CFEqual(unwrap_ref(other), system);
+  CFRelease(system);
+  return result;
+}
+#define IS_SYSTEM_WIDE(x) (acore_is_system_wide(x))
+
+
+static
+VALUE
+rb_acore_attributes(VALUE self)
+{
+  VALUE cached_attrs = rb_ivar_get(self, ivar_attrs);
+  if (cached_attrs != Qnil)
+    return cached_attrs;
+
+  CFArrayRef attrs = NULL;
+  AXError     code = AXUIElementCopyAttributeNames(unwrap_ref(self), &attrs);
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      cached_attrs = wrap_array_strings(attrs);
+      rb_ivar_set(self, ivar_attrs, cached_attrs);
+      CFRelease(attrs);
+      return cached_attrs;
+    case kAXErrorInvalidUIElement:
+      return rb_ary_new();
+    default:
+      // TODO we should actually allow for a grace period and try again in
+      //      every case where would be deferring to the default error handler,
+      //      and maybe even in every case where we get a non-zero result code
+      //
+      //      WE SHOULD HANDLE THINGS LIKE FAILURE AND CANNOT COMPLETE LIKE THIS
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_attribute(VALUE self, VALUE name)
+{
+  CFTypeRef        attr = NULL;
+  CFStringRef attr_name = unwrap_string(name);
+  AXError          code = AXUIElementCopyAttributeValue(
+							unwrap_ref(self),
+							attr_name,
+							&attr
+							);
+  CFRelease(attr_name);
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return to_ruby(attr);
+    case kAXErrorFailure:
+    case kAXErrorNoValue:
+    case kAXErrorInvalidUIElement:
+    case kAXErrorAttributeUnsupported:
+      return Qnil;
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_size_of(VALUE self, VALUE name)
+{
+  CFIndex          size = 0;
+  CFStringRef attr_name = unwrap_string(name);
+  AXError          code = AXUIElementGetAttributeValueCount(
+							    unwrap_ref(self),
+							    attr_name,
+							    &size
+							    );
+  CFRelease(attr_name);
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return INT2FIX(size);
+    case kAXErrorFailure:
+    case kAXErrorNoValue:
+    case kAXErrorInvalidUIElement:
+      return INT2FIX(0);
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_is_writable(VALUE self, VALUE name)
+{
+  Boolean        result;
+  CFStringRef attr_name = unwrap_string(name);
+  AXError          code = AXUIElementIsAttributeSettable(
+							unwrap_ref(self),
+							attr_name,
+							&result
+							);
+  CFRelease(attr_name);
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return (result ? Qtrue : Qfalse);
+    case kAXErrorFailure:
+    case kAXErrorNoValue:
+    case kAXErrorInvalidUIElement:
+      return Qfalse;
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_set(VALUE self, VALUE name, VALUE value)
+{
+  CFTypeRef    ax_value = to_ax(value);
+  CFStringRef attr_name = unwrap_string(name);
+  AXError          code = AXUIElementSetAttributeValue(
+						       unwrap_ref(self),
+						       attr_name,
+						       ax_value
+						       );
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return value;
+    default:
+      return handle_error(self, code); // name, value
+    }
+}
+
+
+static
+VALUE
+rb_acore_role(VALUE self)
+{
+  CFTypeRef value = NULL;
+  AXError    code = AXUIElementCopyAttributeValue(
+						  unwrap_ref(self),
+						  kAXRoleAttribute,
+						  &value
+						  );
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return wrap_string(value);
+    case kAXErrorNoValue:
+    case kAXErrorInvalidUIElement:
+      return Qnil;
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_subrole(VALUE self)
+{
+  CFTypeRef value = NULL;
+  AXError    code = AXUIElementCopyAttributeValue(
+						  unwrap_ref(self),
+						  kAXSubroleAttribute,
+						  &value
+						  );
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return wrap_string((CFStringRef)value);
+    case kAXErrorFailure:
+    case kAXErrorNoValue:
+    case kAXErrorInvalidUIElement:
+    case kAXErrorAttributeUnsupported:
+      return Qnil;
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_parent(VALUE self)
+{
+  CFTypeRef value = NULL;
+  AXError    code = AXUIElementCopyAttributeValue(
+						  unwrap_ref(self),
+						  kAXParentAttribute,
+						  &value
+						  );
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return wrap_ref(value);
+    case kAXErrorFailure:
+    case kAXErrorNoValue:
+    case kAXErrorInvalidUIElement:
+    case kAXErrorAttributeUnsupported:
+      return Qnil;
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_children(VALUE self)
+{
+  CFTypeRef value = NULL;
+  AXError    code = AXUIElementCopyAttributeValue(
+						  unwrap_ref(self),
+						  kAXChildrenAttribute,
+						  &value
+						  );
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return wrap_array_refs(value);
+    case kAXErrorNoValue:
+    case kAXErrorInvalidUIElement:
+      return rb_ary_new();
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_value(VALUE self)
+{
+  CFTypeRef value = NULL;
+  AXError    code = AXUIElementCopyAttributeValue(
+						  unwrap_ref(self),
+						  kAXValueAttribute,
+						  &value
+						  );
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return to_ruby(value);
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_pid(VALUE self)
+{
+  VALUE cached_pid = rb_ivar_get(self, ivar_pid);
+  if (cached_pid != Qnil)
+    return cached_pid;
+
+  pid_t    pid = 0;
+  AXError code = AXUIElementGetPid(unwrap_ref(self), &pid);
+
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      break;
+    case kAXErrorInvalidUIElement:
+      if (IS_SYSTEM_WIDE(self)) {
+	pid = 0;
+	break;
+      }
+    default:
+      handle_error(self, code);
+    }
+
+  cached_pid = PIDT2NUM(pid);
+  rb_ivar_set(self, ivar_pid, cached_pid);
+  return cached_pid;
+}
+
+
+static
+VALUE
+rb_acore_parameterized_attributes(VALUE self)
+{
+  VALUE cached_attrs = rb_ivar_get(self, ivar_param_attrs);
+  if (cached_attrs != Qnil)
+    return cached_attrs;
+
+  CFArrayRef attrs = NULL;
+  AXError     code = AXUIElementCopyParameterizedAttributeNames(
+                                                                unwrap_ref(self),
+								&attrs
+								);
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      cached_attrs = wrap_array_strings(attrs);
+      rb_ivar_set(self, ivar_param_attrs, cached_attrs);
+      CFRelease(attrs);
+      return cached_attrs;
+    case kAXErrorInvalidUIElement:
+      return rb_ary_new();
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_parameterized_attribute(VALUE self, VALUE name, VALUE parameter)
+{
+  CFTypeRef       param = to_ax(parameter);
+  CFTypeRef        attr = NULL;
+  CFStringRef attr_name = unwrap_string(name);
+  AXError          code = AXUIElementCopyParameterizedAttributeValue(
+								     unwrap_ref(self),
+								     attr_name,
+								     param,
+								     &attr
+								     );
+  CFRelease(param);
+  CFRelease(attr_name);
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return to_ruby(attr);
+    case kAXErrorNoValue:
+    case kAXErrorInvalidUIElement:
+      return Qnil;
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_actions(VALUE self)
+{
+  VALUE cached_actions = rb_ivar_get(self, ivar_actions);
+  if (cached_actions != Qnil)
+    return cached_actions;
+
+  CFArrayRef actions = NULL;
+  AXError       code = AXUIElementCopyActionNames(unwrap_ref(self), &actions);
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      cached_actions = wrap_array_strings(actions);
+      rb_ivar_set(self, ivar_actions, cached_actions);
+      CFRelease(actions);
+      return cached_actions;
+    case kAXErrorInvalidUIElement:
+      return rb_ary_new();
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_perform(VALUE self, VALUE name)
+{
+  CFStringRef action = unwrap_string(name);
+  AXError       code = AXUIElementPerformAction(unwrap_ref(self), action);
+
+  CFRelease(action);
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return Qtrue;
+    case kAXErrorInvalidUIElement:
+      return Qfalse;
+    default:
+      return handle_error(self, code);
+    }
+}
+
+
+static
+VALUE
+rb_acore_post(VALUE self, VALUE events)
+{
+  events = rb_ary_to_ary(events);
+  long length = RARRAY_LEN(events);
+  useconds_t sleep_time = NUM2DBL(rb_ivar_get(rb_cElement, ivar_key_rate)) * 100000;
+
+  // CGCharCode key_char = 0; // TODO this value seems to not matter?
+  VALUE            pair;
+  CGKeyCode virtual_key;
+  int         key_state;
+  AXError          code;
+
+
+  for (long i = 0; i < length; i++) {
+    pair        = rb_ary_entry(events, i);
+    virtual_key = NUM2INT(rb_ary_entry(pair, 0));
+    key_state   = rb_ary_entry(pair, 1) == Qtrue ? true : false;
+    code        = AXUIElementPostKeyboardEvent(
+					       unwrap_ref(self),
+					       0,
+					       virtual_key,
+					       key_state
+					       );
+    switch (code)
+      {
+      case kAXErrorSuccess:
+	break;
+      default:
+	handle_error(self, code);
+      }
+
+    usleep(sleep_time);
+  }
+
+  return self;
+}
+
+
+static
+VALUE
+rb_acore_is_invalid(VALUE self)
+{
+  CFTypeRef value = NULL;
+  AXError    code = AXUIElementCopyAttributeValue(
+						  unwrap_ref(self),
+						  kAXRoleAttribute,
+						  &value
+						  );
+  if (value)
+    CFRelease(value);
+  return (code == kAXErrorInvalidUIElement ? Qtrue : Qfalse);
+}
+
+
+static
+VALUE
+rb_acore_application(VALUE self)
+{
+  return rb_acore_application_for(rb_cElement, rb_acore_pid(self));
+}
+
+
+static
+VALUE
+rb_acore_set_timeout_to(VALUE self, VALUE seconds)
+{
+  float timeout = NUM2DBL(seconds);
+  AXError  code = AXUIElementSetMessagingTimeout(unwrap_ref(self), timeout);
+
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return seconds;
+    default:
+      return handle_error(self, code); // seconds
+    }
+}
+
+
+static
+VALUE
+rb_acore_element_at(VALUE self, VALUE point)
+{
+  if (self == rb_cElement)
+    self = rb_acore_system_wide(self);
+
+  AXUIElementRef ref = NULL;
+  CGPoint          p = unwrap_point(point);
+  AXError       code = AXUIElementCopyElementAtPosition(
+							unwrap_ref(self),
+							p.x,
+							p.y,
+							&ref
+							);
+  switch (code)
+    {
+    case kAXErrorSuccess:
+      return wrap_ref(ref);
+    case kAXErrorNoValue:
+      return Qnil;
+    case kAXErrorInvalidUIElement:
+      if (!IS_SYSTEM_WIDE(self))
+	return rb_acore_element_at(rb_acore_system_wide(rb_cElement), point);
+      else
+	return Qnil;
+    default:
+      return handle_error(self, code); // point, nil, nil
+    }
+}
+
+
+static
+VALUE
+rb_acore_equality(VALUE self, VALUE other)
+{
+  if (CLASS_OF(other) == rb_cElement)
+    if (CFEqual(unwrap_ref(self), unwrap_ref(other)))
+      return Qtrue;
+  return Qfalse;
+}
+#endif
+
+
+void
+Init_core()
+{
+#ifdef NOT_MACRUBY
+  if (!AXAPIEnabled())
+    rb_raise(
+	     rb_eRuntimeError,
+	     "\n"                                                                         \
+	     "------------------------------------------------------------------------\n" \
+	     "Universal Access is disabled on this machine.\n"                            \
+	     "Please enable it in the System Preferences.\n"                              \
+	     "See https://github.com/Marketcircle/AXElements#getting-setup\n"             \
+	     "------------------------------------------------------------------------\n"
+	     );
+
+  Init_bridge();
+
+  // these should be defined by now
+  rb_mAccessibility = rb_const_get(rb_cObject, rb_intern("Accessibility"));
+  rb_cElement = rb_define_class_under(rb_mAccessibility, "Element", rb_cObject);
+
+  ivar_attrs       = rb_intern("@attrs");
+  ivar_param_attrs = rb_intern("@param_attrs");
+  ivar_actions     = rb_intern("@actions");
+  ivar_pid         = rb_intern("@pid");
+  ivar_key_rate    = rb_intern("@key_rate");
+
+  rb_define_singleton_method(rb_cElement, "application_for", rb_acore_application_for,          1);
+  rb_define_singleton_method(rb_cElement, "system_wide",     rb_acore_system_wide,              0);
+  rb_define_singleton_method(rb_cElement, "element_at",      rb_acore_element_at,               1);
+  rb_define_singleton_method(rb_cElement, "key_rate",        rb_acore_key_rate,                 0);
+  rb_define_singleton_method(rb_cElement, "key_rate=",       rb_acore_set_key_rate,             1);
+
+  sel_to_f       = rb_intern("to_f");
+  rate_very_slow = rb_intern("very_slow");
+  rate_slow      = rb_intern("slow");
+  rate_normal    = rb_intern("normal");
+  rate_default   = rb_intern("default");
+  rate_fast      = rb_intern("fast");
+  rate_zomg      = rb_intern("zomg");
+  rb_acore_set_key_rate(rb_cElement, DBL2NUM(0.009)); // initialize the value right now
+
+  rb_define_method(rb_cElement, "attributes",                rb_acore_attributes,               0);
+  rb_define_method(rb_cElement, "attribute",                 rb_acore_attribute,                1);
+  rb_define_method(rb_cElement, "size_of",                   rb_acore_size_of,                  1);
+  rb_define_method(rb_cElement, "writable?",                 rb_acore_is_writable,              1);
+  rb_define_method(rb_cElement, "set",                       rb_acore_set,                      2);
+
+  rb_define_method(rb_cElement, "role",                      rb_acore_role,                     0);
+  rb_define_method(rb_cElement, "subrole",                   rb_acore_subrole,                  0);
+  rb_define_method(rb_cElement, "parent",                    rb_acore_parent,                   0);
+  rb_define_method(rb_cElement, "children",                  rb_acore_children,                 0);
+  rb_define_method(rb_cElement, "value",                     rb_acore_value,                    0);
+  rb_define_method(rb_cElement, "pid",                       rb_acore_pid,                      0);
+
+  rb_define_method(rb_cElement, "parameterized_attributes",  rb_acore_parameterized_attributes, 0);
+  rb_define_method(rb_cElement, "parameterized_attribute",   rb_acore_parameterized_attribute,  2);
+
+  rb_define_method(rb_cElement, "actions",                   rb_acore_actions,                  0);
+  rb_define_method(rb_cElement, "perform",                   rb_acore_perform,                  1);
+  rb_define_method(rb_cElement, "post",                      rb_acore_post,                     1);
+
+  rb_define_method(rb_cElement, "invalid?",                  rb_acore_is_invalid,               0);
+  rb_define_method(rb_cElement, "set_timeout_to",            rb_acore_set_timeout_to,           1);
+  // TODO make this meaningful, currently has no effect on calling rb_acore_post
+  rb_define_method(rb_cElement, "key_rate",                  rb_acore_key_rate,                 0);
+  rb_define_method(rb_cElement, "key_rate=",                 rb_acore_set_key_rate,             1);
+  rb_define_method(rb_cElement, "application",               rb_acore_application,              0);
+  rb_define_method(rb_cElement, "element_at",                rb_acore_element_at,               1);
+  rb_define_method(rb_cElement, "==",                        rb_acore_equality,                 1);
+
+#endif
+}