mouse 0.0.1

data/.yardopts

@@ -0,0 +1,9 @@
+--no-cache
+--no-output
+--verbose
+--markup markdown
+--markup-provider kramdown
+--readme README.markdown
+--hide-void-return
+lib/**/*.rb
+ext/**/*{.m,.c}

data/History.markdown

@@ -0,0 +1,10 @@
+# 0.0.1 - Initial Release
+
+  * CRuby and MacRuby compatible
+
+  * Added Mouse.current_position
+  * Added Mouse.move_to
+  * Added Mouse.drag_to
+  * Added Mouse.scroll
+  * Added CGPoint on CRuby to mimic CGPoint in MacRuby
+  * Added Array#to_point to mimic MacRuby allowing Arrays for structs

data/README.markdown

@@ -0,0 +1,38 @@
+# MRMouse
+
+A port of mouse.rb from [AXElements](http://github.com/Marketcircle/AXElements),
+but cleaned up and rewritten in C to be more portable across languages and
+runtimes.
+
+Not much to see right now.
+
+## Copyright
+
+Copyright (c) 2012, Mark Rada
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of Mark Rada nor the names of its
+  contributors may be used to endorse or promote products derived
+  from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL Mark Rada BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+

data/Rakefile

@@ -0,0 +1,37 @@
+task :default => :install
+
+require 'rake/clean'
+CLEAN.include '*.plist', '*.gch'
+
+desc 'Run the Clang static analyzer'
+task :analyze do
+  sh "clang --analyze ext/mouse/mouser.c"
+end
+
+desc 'Startup an IRb console with Mouse loaded'
+task :console => [:compile] do
+  sh 'irb -Ilib -rmouse'
+end
+
+desc 'Run tests'
+task :test do
+  # @todo
+  ruby 'test/helper.rb'
+end
+
+
+# Gem stuff
+
+require 'rubygems/package_task'
+mouse_spec = Gem::Specification.load('mouse.gemspec')
+
+Gem::PackageTask.new(mouse_spec) { }
+
+desc 'Build and install gem (not including deps)'
+task :install => :gem do
+  require 'rubygems/installer'
+  Gem::Installer.new("pkg/#{mouse_spec.file_name}").install
+end
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('mouse', mouse_spec)

data/ext/mouse/extconf.rb

@@ -0,0 +1,23 @@
+require 'mkmf'
+
+$CFLAGS << ' -std=c99 -Wall -Werror -pedantic'
+$LIBS   << ' -framework Foundation -framework ApplicationServices -framework CoreGraphics'
+
+if RUBY_ENGINE == 'macruby'
+  $LIBS << ' -framework Cocoa'
+  $CFLAGS << ' -ObjC -fobjc-gc'
+else
+  unless RbConfig::CONFIG["CC"].match /clang/
+    clang = `which clang`.chomp
+    if clang.empty?
+      $stdout.puts "Clang not installed. Cannot build C extension"
+      raise "Clang not installed. Cannot build C extension"
+    else
+      RbConfig::MAKEFILE_CONFIG["CC"]  = clang
+      RbConfig::MAKEFILE_CONFIG["CXX"] = clang
+    end
+  end
+  $CFLAGS << ' -DNOT_MACRUBY'
+end
+
+create_makefile 'mouse/mouse'

data/ext/mouse/mouse.c

@@ -0,0 +1,116 @@
+#include "mouser.h"
+#include "ruby.h"
+
+static VALUE rb_mMouse;
+static VALUE rb_cCGPoint;
+static ID sel_x;
+static ID sel_y;
+static ID sel_to_point;
+static ID sel_to_i;
+static ID sel_new;
+
+#define CURRENT_POSITION rb_mouse_wrap_point(mouse_current_position())
+
+static
+VALUE
+rb_mouse_wrap_point(CGPoint point)
+{
+#if NOT_MACRUBY
+  return rb_struct_new(rb_cCGPoint, DBL2NUM(point.x), DBL2NUM(point.y));
+#else
+  return rb_funcall(rb_cCGPoint, sel_new, 2, DBL2NUM(point.x), DBL2NUM(point.y));
+#endif
+}
+
+static
+CGPoint
+rb_mouse_unwrap_point(VALUE point)
+{
+  point = rb_funcall(point, sel_to_point, 0);
+
+#if NOT_MACRUBY
+  double x = NUM2DBL(rb_struct_getmember(point, sel_x));
+  double y = NUM2DBL(rb_struct_getmember(point, sel_y));
+  return CGPointMake(x, y);
+
+#else
+  CGPoint* ptr;
+  Data_Get_Struct(point, CGPoint, ptr);
+  return *ptr;
+
+#endif
+}
+
+/***
+ * Returns the current co-ordinates of the Mouse
+ *
+ * @return [CGPoint]
+ */
+static
+VALUE
+rb_mouse_current_position(VALUE self)
+{
+  return CURRENT_POSITION;
+}
+
+/***
+ * Move the cursor to the given co-ordinates
+ *
+ * @param point [CGPoint,Array(Number,Number),#to_point]
+ * @return [CGPoint]
+ */
+static
+VALUE
+rb_mouse_move_to(VALUE self, VALUE point)
+{
+  mouse_move_to(rb_mouse_unwrap_point(point));
+  return CURRENT_POSITION;
+}
+
+/***
+ * Drag the cursor to the given co-ordinates
+ *
+ * @param point [CGPoint,Array(Number,Number),#to_point]
+ * @return [CGPoint]
+ */
+static
+VALUE
+rb_mouse_drag_to(VALUE self, VALUE point)
+{
+  mouse_drag_to(rb_mouse_unwrap_point(point));
+  return CURRENT_POSITION;
+}
+
+/***
+ * Generate `amount` scroll events at the current cursor position
+ *
+ * @param amount [Number]
+ * @return [CGPoint]
+ */
+static
+VALUE
+rb_mouse_scroll(VALUE self, VALUE amount)
+{
+  amount = rb_funcall(amount, sel_to_i, 0);
+  mouse_scroll(NUM2SIZET(amount));
+  return CURRENT_POSITION;
+}
+
+void
+Init_mouse()
+{
+  rb_cCGPoint = rb_const_get(rb_cObject, rb_intern("CGPoint"));
+  sel_x = rb_intern("x");
+  sel_y = rb_intern("y");
+  sel_to_point = rb_intern("to_point");
+  sel_to_i     = rb_intern("to_i");
+  sel_new = rb_intern("new");
+
+  rb_mMouse = rb_define_module("Mouse");
+  rb_funcall(rb_mMouse, rb_intern("extend"), 1, rb_mMouse);
+
+  rb_define_method(rb_mMouse, "current_position", rb_mouse_current_position, 0);
+  rb_define_method(rb_mMouse, "move_to",          rb_mouse_move_to,          1);
+  rb_define_method(rb_mMouse, "drag_to",          rb_mouse_drag_to,          1);
+  rb_define_method(rb_mMouse, "scroll",           rb_mouse_scroll,           1);
+}

data/ext/mouse/mouser.c

@@ -0,0 +1,347 @@
+//
+//  Mouser.c
+//  MRMouse
+//
+//  Created by Mark Rada on 12-03-17.
+//  Copyright (c) 2012 Mark Rada. All rights reserved.
+//
+
+#include <ApplicationServices/ApplicationServices.h>
+#include "mouser.h"
+
+static const double FPS              = 120.0;
+static const double QUANTUM          = 1 / 120; // Should be (1 / FPS), but gcc sucks
+static const double DEFAULT_DURATION = 0.2; // seconds
+
+#define NEW_EVENT(type,point,button) CGEventCreateMouseEvent(nil,type,point,button)
+#define POST(event) CGEventPost(kCGHIDEventTap, event)
+#define CHANGE(event,type) CGEventSetType(event, type)
+
+#define CLOSE_ENOUGH(a,b) ((pow(a.x-b.x,2)+pow(a.y-b.y,2)) <= 1.0)
+#define NOW (CFDateCreate(nil,CFAbsoluteTimeGetCurrent()))
+
+#ifdef NOT_MACRUBY
+#define RELEASE(x) CFRelease(x)
+#else
+#define RELEASE(x) CFMakeCollectable(x)
+#endif
+
+#define POSTRELEASE(x) do {			\
+  CGEventRef event = x;  	 		\
+  POST(event);					\
+  RELEASE(event);				\
+} while(false);
+
+
+static
+void
+mouse_sleep(size_t quanta)
+{
+  sleep(quanta * QUANTUM);
+}
+
+CGPoint
+mouse_current_position()
+{
+  CGEventRef event = CGEventCreate(nil);
+  CGPoint point = CGEventGetLocation(event);
+  RELEASE(event);
+  return point;
+}
+
+// Executes a linear mouse movement animation. It can be a simple cursor
+// move or a drag depending on what is passed to `type`.
+static
+void
+mouse_animate(
+	      CGEventType type,
+	      CGMouseButton button,
+	      CGPoint start_point,
+	      CGPoint end_point,
+	      double duration
+	      )
+{
+  CFDateRef current_time = NULL;
+  CGPoint current_point = start_point;
+  double     xstep = (end_point.x - start_point.x) / (duration * FPS);
+  double     ystep = (end_point.y - start_point.y) / (duration * FPS);
+  CFDateRef  start = NOW;
+  double remaining = 0.0;
+
+  while (!CLOSE_ENOUGH(current_point, end_point)) {
+    remaining  = end_point.x - current_point.x;
+    current_point.x += abs(xstep) > abs(remaining) ? remaining : xstep;
+
+    remaining  = end_point.y - current_point.y;
+    current_point.y += abs(ystep) > abs(remaining) ? remaining : ystep;
+
+    POSTRELEASE(NEW_EVENT(type, current_point, button));
+
+    mouse_sleep(1);
+    current_time = NOW;
+    if (CFDateGetTimeIntervalSinceDate(NOW, start) > 5.0)
+      break;
+    RELEASE(current_time);
+    current_time = NULL;
+
+    current_point = mouse_current_position();
+  }
+
+  RELEASE(start);
+  if (current_time)
+    RELEASE(current_time);
+}
+
+
+void
+mouse_move_to2(CGPoint point, double duration)
+{
+  mouse_animate(
+		kCGEventMouseMoved,
+		kCGMouseButtonLeft,
+		mouse_current_position(),
+		point,
+		duration
+		);
+}
+
+void
+mouse_move_to(CGPoint point)
+{
+  mouse_move_to2(point, DEFAULT_DURATION);
+}
+
+
+void
+mouse_drag_to2(CGPoint point, double duration)
+{
+  POSTRELEASE(NEW_EVENT(
+			kCGEventLeftMouseDown,
+			mouse_current_position(),
+			kCGMouseButtonLeft
+			));
+
+
+  mouse_animate(
+		kCGEventLeftMouseDragged,
+		kCGMouseButtonLeft,
+		mouse_current_position(),
+		point,
+		duration
+		);
+
+  POSTRELEASE(NEW_EVENT(
+			kCGEventLeftMouseUp,
+			mouse_current_position(),
+			kCGMouseButtonLeft
+			));
+}
+
+void
+mouse_drag_to(CGPoint point)
+{
+  mouse_drag_to2(point, DEFAULT_DURATION);
+}
+
+
+void
+mouse_scroll3(size_t amount, enum MouseMovementUnit units, double duration)
+{
+  size_t     steps = round(FPS * duration);
+  double   current = 0.0;
+  double      done = 0;
+  int32_t   scroll = 0;
+
+  for (size_t step = 0; step < steps; step++) {
+    done   = (double)(step+1) / (double)steps;
+    scroll = round((done - current) * amount);
+    POSTRELEASE(CGEventCreateScrollWheelEvent(nil, units, 1, scroll));
+    mouse_sleep(1);
+    current += (double)scroll / (double)amount;
+  }
+}
+
+void
+mouse_scroll2(size_t amount, enum MouseMovementUnit units)
+{
+  mouse_scroll3(amount, units, DEFAULT_DURATION);
+}
+
+void
+mouse_scroll(size_t amount)
+{
+  mouse_scroll2(amount, kMouseScrollByLine);
+}
+
+
+void
+mouse_click_down3(CGPoint point, size_t sleep_quanta)
+{
+  POSTRELEASE(NEW_EVENT(kCGEventLeftMouseDown, point, kCGMouseButtonLeft));
+  mouse_sleep(sleep_quanta);
+}
+
+void
+mouse_click_down2(CGPoint point)
+{
+  // TODO: replace constant 12 with something more abstract
+  mouse_click_down3(point, 12);
+}
+
+void
+mouse_click_down()
+{
+  mouse_click_down2(mouse_current_position());
+}
+
+
+void
+mouse_click_up2(CGPoint point)
+{
+  POSTRELEASE(NEW_EVENT(kCGEventLeftMouseUp, point, kCGMouseButtonLeft));
+}
+
+void
+mouse_click_up()
+{
+  mouse_click_up2(mouse_current_position());
+}
+
+
+void
+mouse_click2(CGPoint point)
+{
+  mouse_click_down2(point);
+  mouse_click_up2(point);
+}
+
+void
+mouse_click()
+{
+  mouse_click2(mouse_current_position());
+}
+
+
+void
+mouse_secondary_click3(CGPoint point, size_t sleep_quanta)
+{
+  CGEventRef base_event = NEW_EVENT(
+				    kCGEventRightMouseDown,
+				    point,
+				    kCGMouseButtonRight
+				    );
+  POST(base_event);
+  mouse_sleep(sleep_quanta);
+
+  CHANGE(base_event, kCGEventRightMouseUp);
+  POSTRELEASE(base_event);
+}
+
+void
+mouse_secondary_click2(CGPoint point)
+{
+  // TODO: replace constant 12 with something more abstract
+  mouse_secondary_click3(point, 12);
+}
+
+void
+mouse_secondary_click()
+{
+  mouse_secondary_click2(mouse_current_position());
+}
+
+
+void
+mouse_arbitrary_click3(CGEventMouseSubtype button, CGPoint point, size_t sleep_quanta)
+{
+  CGEventRef base_event = NEW_EVENT(
+				    kCGEventOtherMouseDown,
+				    point,
+				    button
+				    );
+  POST(base_event);
+  mouse_sleep(sleep_quanta);
+  CHANGE(base_event, kCGEventOtherMouseUp);
+  POSTRELEASE(base_event);
+}
+
+void
+mouse_arbitrary_click2(CGEventMouseSubtype button, CGPoint point)
+{
+  mouse_arbitrary_click3(button, point, 12);
+}
+
+void
+mouse_arbitrary_click(CGEventMouseSubtype button)
+{
+  mouse_arbitrary_click2(button, mouse_current_position());
+}
+
+
+void
+mouse_middle_click2(CGPoint point)
+{
+  mouse_arbitrary_click2(kCGMouseButtonCenter, point);
+}
+
+void
+mouse_middle_click()
+{
+  mouse_middle_click2(mouse_current_position());
+}
+
+
+void
+mouse_multi_click2(size_t num_clicks, CGPoint point)
+{
+  CGEventRef base_event = NEW_EVENT(
+				    kCGEventLeftMouseDown,
+				    point,
+				    kCGMouseButtonLeft
+				    );
+  CGEventSetIntegerValueField(base_event, kCGMouseEventClickState, num_clicks);
+
+  CHANGE(base_event, kCGEventLeftMouseDown);
+  POST(base_event);
+
+  CHANGE(base_event, kCGEventLeftMouseUp);
+  POSTRELEASE(base_event);
+}
+
+void
+mouse_multi_click(size_t num_clicks)
+{
+  mouse_multi_click2(num_clicks, mouse_current_position());
+}
+
+
+void
+mouse_double_click2(CGPoint point)
+{
+  // some apps still expect to receive the single click event first
+  // and then the double click event
+  mouse_multi_click2(1, point);
+  mouse_multi_click2(2, point);
+}
+
+void
+mouse_double_click()
+{
+  mouse_double_click2(mouse_current_position());
+}
+
+
+void
+mouse_triple_click2(CGPoint point)
+{
+  // some apps still expect to receive the single click event first
+  // and then the double and triple click events
+  mouse_double_click2(point);
+  mouse_multi_click2(3, point);
+}
+
+void
+mouse_triple_click()
+{
+  mouse_triple_click2(mouse_current_position());
+}

data/ext/mouse/mouser.h

@@ -0,0 +1,58 @@
+//
+//  Mouser.h
+//  MRMouse
+//
+//  Created by Mark Rada on 12-03-17.
+//  Copyright (c) 2012 Mark Rada. All rights reserved.
+//
+
+#include <ApplicationServices/ApplicationServices.h>
+
+enum MouseMovementUnit {
+  kMouseScrollByLine  = kCGScrollEventUnitLine,
+  // TODO: might not be real pixels, might be Cocoa co-ords, need to investigate
+  kMouseScrollByPixel = kCGScrollEventUnitPixel
+};
+
+
+CGPoint mouse_current_position();
+
+void mouse_move_to(CGPoint point);
+void mouse_move_to2(CGPoint point, double duration);
+
+void mouse_drag_to(CGPoint point);
+void mouse_drag_to2(CGPoint point, double duration);
+
+void mouse_scroll(size_t amount);
+void mouse_scroll2(size_t amount, enum MouseMovementUnit units);
+void mouse_scroll3(size_t amount, enum MouseMovementUnit units, double duration);
+
+void mouse_click_down();
+void mouse_click_down2(CGPoint point);
+void mouse_click_down3(CGPoint point, size_t sleep_quanta);
+
+void mouse_click_up();
+void mouse_click_up2(CGPoint point);
+
+void mouse_click();
+void mouse_click2(CGPoint point);
+
+void mouse_secondary_click();
+void mouse_secondary_click2(CGPoint point);
+void mouse_secondary_click3(CGPoint point, size_t sleep_quanta);
+
+void mouse_arbitrary_click(CGEventMouseSubtype button);
+void mouse_arbitrary_click2(CGEventMouseSubtype button, CGPoint point);
+void mouse_arbitrary_click3(CGEventMouseSubtype button, CGPoint point, size_t sleep_quanta);
+
+void mouse_middle_click();
+void mouse_middle_click2(CGPoint point);
+
+void mouse_multi_click(size_t num_clicks);
+void mouse_multi_click2(size_t num_clicks, CGPoint point);
+
+void mouse_double_click();
+void mouse_double_click2(CGPoint point);
+
+void mouse_triple_click();
+void mouse_triple_click2(CGPoint point);

data/lib/mouse.rb

@@ -0,0 +1,48 @@
+if RUBY_ENGINE == 'macruby'
+
+  framework '/System/Library/Frameworks/CoreGraphics.framework'
+
+else
+
+  ##
+  #
+  class CGPoint < Struct.new(:x, :y)
+    ##
+    # Return a nice string representation of the point
+    #
+    # Overrides `Object#inspect` to more closely mimic MacRuby `Boxed#inspect`.
+    #
+    # @return [String]
+    def inspect
+      "#<CGPoint x=#{self[:x]} y=#{self[:y]}>"
+    end
+  end
+
+end
+
+
+##
+# Mouse extensions to `CGPoint`
+class CGPoint
+  ##
+  # Returns the receiver, since the receiver is already a {CGPoint}
+  #
+  # @return [CGPoint]
+  def to_point
+    self
+  end
+end
+
+##
+# Mouse extensions to `Array`
+class Array
+  ##
+  # Coerce the first two elements of the receiver into a {CGPoint}
+  #
+  # @return [CGPoint]
+  def to_point
+    CGPoint.new self[0], self[1]
+  end
+end
+
+require 'mouse.bundle'

data/lib/mouse/version.rb

@@ -0,0 +1,4 @@
+module Mouse
+  VERSION = '0.0.1'
+end
+

data/test/helper.rb

@@ -0,0 +1,3 @@
+require 'minitest/autorun'
+
+

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: mouse
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors:
+- Mark Rada
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-02 00:00:00 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: 'mouse is a rich, high level wrapper around OS X CGEvent APIs that allow
+
+  programmatic manipulation of the mouse cursor.
+
+
+  Originally extracted from the AXElements project.
+
+'
+email: markrada26@gmail.com
+executables: []
+extensions:
+- ext/mouse/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/mouse/version.rb
+- lib/mouse.rb
+- ext/mouse/mouse.c
+- ext/mouse/mouser.c
+- ext/mouse/mouser.h
+- ext/mouse/extconf.rb
+- Rakefile
+- README.markdown
+- History.markdown
+- .yardopts
+- test/helper.rb
+homepage: http://github.com/ferrous26/MRMouse
+licenses:
+- BSD 3-clause
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: "0"
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A library for automating the mouse
+test_files:
+- test/helper.rb