mouse 1.1.0 → 2.0.0

data/ext/mouse/mouse.c

@@ -1,14 +1,15 @@
 #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_new;
-static ID unit_pixel;
-static ID unit_line;
+static VALUE rb_mMouse, rb_cCGPoint;
+
+static ID sel_x, sel_y, sel_to_point, sel_new;
+
+static VALUE sym_pixel, sym_line,
+  sym_up, sym_down, sym_left, sym_right,
+  sym_zoom, sym_unzoom, sym_expand, sym_contract,
+  sym_cw, sym_clockwise, sym_clock_wise,
+  sym_ccw, sym_counter_clockwise, sym_counter_clock_wise;
 
 #define CURRENT_POSITION rb_mouse_wrap_point(mouse_current_position())
 
@@ -16,7 +17,6 @@ static
 VALUE
 rb_mouse_wrap_point(CGPoint point)
 {
-  // TODO: Data_Wrap_Struct instead
 #if NOT_MACRUBY
   return rb_struct_new(rb_cCGPoint, DBL2NUM(point.x), DBL2NUM(point.y));
 #else
@@ -118,8 +118,11 @@ rb_mouse_drag_to(int argc, VALUE *argv, VALUE self)
  * Returns number of lines scrolled. A positive `amount` will scroll up
  * and a negative `amount` will scroll down.
  *
+ * An animation duration can also be specified.
+ *
  * @param amount [Number]
  * @param units [Symbol] `:pixel` or `:line` (_default_: `:line` ) (__optional__)
+ * @param duration [Float] (_default_: `0.2`) (__optional__)
  * @return [Number]
  */
 static
@@ -133,29 +136,71 @@ rb_mouse_scroll(int argc, VALUE *argv, VALUE self)
 
   if (argc == 1) {
     mouse_scroll(amt);
-    return argv[0];
-  }
 
-  ID units = rb_to_id(argv[1]);
+  } else {
+    VALUE             input_units = argv[1];
+    CGScrollEventUnit units;
 
-  if (argc == 2) {
-    if (units == unit_pixel)
-      mouse_scroll2(amt, kCGScrollEventUnitPixel);
-    else if (units == unit_line)
-      mouse_scroll2(amt, kCGScrollEventUnitLine);
+    if (input_units == sym_pixel)
+      units = kCGScrollEventUnitPixel;
+    else if (input_units == sym_line)
+      units = kCGScrollEventUnitLine;
     else
-      rb_raise(rb_eArgError, "unknown units `%s'", rb_id2name(units));
+      rb_raise(rb_eArgError, "unknown units `%s'", rb_id2name(input_units));
+
+    if (argc == 2)
+      mouse_scroll2(amt, units);
+    else
+      mouse_scroll3(amt, units, NUM2DBL(argv[2]));
   }
 
-  if (argc == 3) {
-    double duration = NUM2DBL(argv[2]);
+  return argv[0];
+}
+
+/*
+ * @note Scrolling by `:pixel` may not actually be by real pixels, but instead
+ *       correspond to Cocoa co-ords (I don't have a retina display, so I haven't
+ *       checked it out yet).
+ *
+ * Generate `amount` of horizontal scroll events at the current cursor position
+ *
+ * Returns number of lines scrolled. A positive `amount` will scroll left
+ * and a negative `amount` will scroll right.
+ *
+ * An animation duration can also be specified.
+ *
+ * @param amount [Number]
+ * @param units [Symbol] `:pixel` or `:line` (_default_: `:line` ) (__optional__)
+ * @param duration [Float] (_default_: `0.2`) (__optional__)
+ * @return [Number]
+ */
+static
+VALUE
+rb_mouse_horizontal_scroll(int argc, VALUE *argv, VALUE self)
+{
+  if (argc == 0 || argc > 3)
+    rb_raise(rb_eArgError, "scroll requires 1..3 arguments, you gave %d", argc);
+
+  int amt = NUM2INT(argv[0]);
 
-    if (units == unit_pixel)
-      mouse_scroll3(amt, kCGScrollEventUnitPixel, duration);
-    else if (units == unit_line)
-      mouse_scroll3(amt, kCGScrollEventUnitLine, duration);
+  if (argc == 1) {
+    mouse_horizontal_scroll(amt);
+
+  } else {
+    VALUE             input_units = argv[1];
+    CGScrollEventUnit units;
+
+    if (input_units == sym_pixel)
+      units = kCGScrollEventUnitPixel;
+    else if (input_units == sym_line)
+      units = kCGScrollEventUnitLine;
     else
-      rb_raise(rb_eArgError, "unknown units `%s'", rb_id2name(units));
+      rb_raise(rb_eArgError, "unknown units `%s'", rb_id2name(input_units));
+
+    if (argc == 2)
+      mouse_horizontal_scroll2(amt, units);
+    else
+      mouse_horizontal_scroll3(amt, units, NUM2DBL(argv[2]));
   }
 
   return argv[0];
@@ -574,6 +619,231 @@ rb_mouse_triple_click(int argc, VALUE *argv, VALUE self)
   return CURRENT_POSITION;
 }
 
+
+/* @!group Gestures */
+
+/*
+ * Perform a smart magnify (double tap on trackpad)
+ *
+ * You can optionally specify the point on the screen where to perform
+ * the smart magnification.
+ *
+ * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
+ * @return [CGPoint]
+ */
+static
+VALUE
+rb_mouse_smart_magnify(int argc, VALUE* argv, VALUE self)
+{
+  switch (argc)
+    {
+    case 0:
+      mouse_smart_magnify();
+      break;
+    case 1:
+    default:
+      mouse_smart_magnify2(rb_mouse_unwrap_point(argv[0]));
+    }
+
+  return CURRENT_POSITION;
+}
+
+/*
+ * Perform a swipe gesture in the given `direction`
+ *
+ * You can optionally specify a point on screen for the mouse
+ * pointer to be moved to before the gesture begins. The movement will
+ * be instantaneous.
+ *
+ * You can also optionally specify the duration of the swipe event.
+ *
+ * @param direction [Symbol]
+ * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
+ * @param duration [Float] (_default_: `0.2`) (__optional__)
+ * @return [CGPoint]
+ */
+static
+VALUE
+rb_mouse_swipe(int argc, VALUE* argv, VALUE self)
+{
+  if (!argc)
+    rb_raise(rb_eArgError, "wrong number of arguments (0 for 1+)");
+
+  CGSwipeDirection direction;
+  VALUE direction_input = argv[0];
+  if (direction_input == sym_up)
+    direction = kCGSwipeDirectionUp;
+  else if (direction_input == sym_down)
+    direction = kCGSwipeDirectionDown;
+  else if (direction_input == sym_left)
+    direction = kCGSwipeDirectionLeft;
+  else if (direction_input == sym_right)
+    direction = kCGSwipeDirectionRight;
+  else
+    rb_raise(
+	     rb_eArgError,
+	     "invalid swipe direction `%s'",
+	     rb_id2name(SYM2ID(direction_input))
+	     );
+
+  if (argc == 1) {
+    mouse_swipe(direction);
+    return CURRENT_POSITION;
+  }
+
+  CGPoint point = rb_mouse_unwrap_point(argv[1]);
+
+  if (argc == 2)
+    mouse_swipe2(direction, point);
+  else
+    mouse_swipe3(direction, point, NUM2DBL(argv[1]));
+
+  return CURRENT_POSITION;
+}
+
+/*
+ * Perform a pinch gesture in given `direction`
+ *
+ * You can optionally specify the `magnification` factor and/or
+ * `duration` for the pinch event.
+ *
+ * Available pinch directions are:
+ *
+ *   - `:zoom` or `:expand`
+ *   - `:unzoom` or `:contract`
+ *
+ * Magnification is a relative magnification setting. A zoom value of
+ * `1.0` means `1.0` more than the current zoom level. `2.0` would be
+ * `2.0` levels higher than the current zoom.
+ *
+ * You can also optionally specify a point on screen for the mouse
+ * pointer to be moved to before the gesture begins. The movement will
+ * be instantaneous.
+ *
+ * An animation duration can also be specified.
+ *
+ * @param direction [Symbol]
+ * @param magnification [Float] (_default_: `1.0`) (__optional__)
+ * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
+ * @param duration [Float] (_default_: `0.2`) (__optional__)
+ * @return [CGPoint]
+ */
+static
+VALUE
+rb_mouse_pinch(int argc, VALUE* argv, VALUE self)
+{
+  if (!argc)
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 1+)", argc);
+
+  VALUE            input_direction = argv[0];
+  CGPinchDirection       direction = kCGPinchNone;
+
+  if (input_direction == sym_expand || input_direction == sym_zoom)
+    direction = kCGPinchExpand;
+  else if (input_direction == sym_contract || input_direction == sym_unzoom)
+    direction = kCGPinchContract;
+  else
+    rb_raise(
+	     rb_eArgError,
+	     "invalid pinch direction `%s'",
+	     rb_id2name(SYM2ID(input_direction))
+	     );
+
+  if (argc == 1) {
+    mouse_pinch(direction);
+    return CURRENT_POSITION;
+  }
+
+  double magnification = NUM2DBL(argv[1]);
+  if (argc == 2) {
+    mouse_pinch2(direction, magnification);
+    return CURRENT_POSITION;
+  }
+
+  CGPoint point = rb_mouse_unwrap_point(argv[2]);
+  if (argc == 3) {
+    mouse_pinch3(direction, magnification, point);
+    return CURRENT_POSITION;
+  }
+
+  double duration = NUM2DBL(argv[3]);
+  mouse_pinch4(direction, magnification, point, duration);
+  return CURRENT_POSITION;
+}
+
+/*
+ * Perform a rotation gesture in the given `direction` the given `angle` degrees
+ *
+ * Possible directions are:
+ *
+ *   - `:cw`, ':clockwise`, ':clock_wise` to rotate in the clockwise
+ *     direction
+ *   - `:ccw`, ':counter_clockwise`, `:counter_clock_wise` to rotate in
+ *     the the counter clockwise direction
+ *
+ * The `angle` parameter is a number of degrees to rotate. There are 360
+ * degrees in a full rotation, as you would expect in Euclidian geometry.
+ *
+ * You can also optionally specify a point on screen for the mouse
+ * pointer to be moved to before the gesture begins. The movement will
+ * be instantaneous.
+ *
+ * An animation duration can also be specified.
+ *
+ * @param direction [Symbol]
+ * @param angle [Float]
+ * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
+ * @param duration [Float] (_default_: `0.2`) (__optional__)
+ * @return [CGPoint]
+ */
+static
+VALUE
+rb_mouse_rotate(int argc, VALUE* argv, VALUE self)
+{
+  if (argc < 2)
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 2+)", argc);
+
+  CGRotateDirection direction = kCGRotateNone;
+  VALUE             input_dir = argv[0];
+  if (
+      input_dir == sym_cw ||
+      input_dir == sym_clockwise ||
+      input_dir == sym_clock_wise
+      )
+    direction = kCGRotateClockwise;
+  else if (
+      input_dir == sym_ccw ||
+      input_dir == sym_counter_clockwise ||
+      input_dir == sym_counter_clock_wise
+	   )
+    direction = kCGRotateCounterClockwise;
+  else
+    rb_raise(
+	     rb_eArgError,
+	     "invalid rotation direction `%s'",
+	     rb_id2name(SYM2ID(input_dir))
+	     );
+
+  double angle = NUM2DBL(argv[1]);
+
+  if (argc == 2) {
+    mouse_rotate(direction, angle);
+    return CURRENT_POSITION;
+  }
+
+  CGPoint point = rb_mouse_unwrap_point(argv[2]);
+  if (argc == 3) {
+    mouse_rotate2(direction, angle, point);
+    return CURRENT_POSITION;
+  }
+
+  mouse_rotate3(direction, angle, point, NUM2DBL(argv[3]));
+  return CURRENT_POSITION;
+}
+
+/* @!endgroup */
+
+
 void
 Init_mouse()
 {
@@ -585,8 +855,26 @@ Init_mouse()
   sel_to_point = rb_intern("to_point");
   sel_new      = rb_intern("new");
 
-  unit_pixel   = rb_intern("pixel");
-  unit_line    = rb_intern("line");
+  sym_pixel    = ID2SYM(rb_intern("pixel"));
+  sym_line     = ID2SYM(rb_intern("line"));
+
+  sym_up       = ID2SYM(rb_intern("up"));
+  sym_down     = ID2SYM(rb_intern("down"));
+  sym_left     = ID2SYM(rb_intern("left"));
+  sym_right    = ID2SYM(rb_intern("right"));
+
+  sym_zoom     = ID2SYM(rb_intern("zoom"));
+  sym_unzoom   = ID2SYM(rb_intern("unzoom"));
+  sym_expand   = ID2SYM(rb_intern("expand"));
+  sym_contract = ID2SYM(rb_intern("contract"));
+
+  sym_cw                 = ID2SYM(rb_intern("cw"));
+  sym_clockwise          = ID2SYM(rb_intern("clockwise"));
+  sym_clock_wise         = ID2SYM(rb_intern("clock_wise"));
+  sym_ccw                = ID2SYM(rb_intern("ccw"));
+  sym_counter_clockwise  = ID2SYM(rb_intern("counter_clockwise"));
+  sym_counter_clock_wise = ID2SYM(rb_intern("counter_clock_wise"));
+
 
   /*
    * Document-module: Mouse
@@ -611,6 +899,7 @@ Init_mouse()
   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);
+  rb_define_method(rb_mMouse, "horizontal_scroll",    rb_mouse_horizontal_scroll,    -1);
   rb_define_method(rb_mMouse, "click_down",           rb_mouse_click_down,           -1);
   rb_define_method(rb_mMouse, "click_up",             rb_mouse_click_up,             -1);
   rb_define_method(rb_mMouse, "click",                rb_mouse_click,                -1);
@@ -625,7 +914,14 @@ Init_mouse()
   rb_define_method(rb_mMouse, "double_click",         rb_mouse_double_click,         -1);
   rb_define_method(rb_mMouse, "triple_click",         rb_mouse_triple_click,         -1);
 
-  rb_define_alias(rb_mMouse, "right_click_down", "secondary_click_down");
-  rb_define_alias(rb_mMouse, "right_click_up",   "secondary_click_up");
-  rb_define_alias(rb_mMouse, "right_click",      "secondary_click");
+  rb_define_method(rb_mMouse, "smart_magnify",        rb_mouse_smart_magnify,        -1);
+  rb_define_method(rb_mMouse, "swipe",                rb_mouse_swipe,                -1);
+  rb_define_method(rb_mMouse, "pinch",                rb_mouse_pinch,                -1);
+  rb_define_method(rb_mMouse, "rotate",               rb_mouse_rotate,               -1);
+
+  rb_define_alias(rb_mMouse, "hscroll",               "horizontal_scroll");
+  rb_define_alias(rb_mMouse, "right_click_down",      "secondary_click_down");
+  rb_define_alias(rb_mMouse, "right_click_up",        "secondary_click_up");
+  rb_define_alias(rb_mMouse, "right_click",           "secondary_click");
+  rb_define_alias(rb_mMouse, "two_finger_double_tap", "smart_magnify");
 }

data/ext/mouse/mouser.c

@@ -9,10 +9,12 @@
 #include <ApplicationServices/ApplicationServices.h>
 #include "mouser.h"
 
-static const uint_t FPS              = 240;
-static const uint_t QUANTUM          = 1000000 / 240; // should be FPS, but GCC sucks
-static const double DEFAULT_DURATION = 0.2; // seconds
+static const uint_t FPS     = 240;
+static const uint_t QUANTUM = 1000000 / 240; // should be FPS, but GCC sucks
+static const double DEFAULT_DURATION      = 0.2; // seconds
+static const double DEFAULT_MAGNIFICATION = 1.0; // factor
 
+#define NEW_GESTURE(name) CGEventRef name = CGEventCreate(nil);	CHANGE(name, kCGEventGesture);
 #define NEW_EVENT(type,point,button) CGEventCreateMouseEvent(nil,type,point,button)
 #define POST(event) CGEventPost(kCGHIDEventTap, event)
 #define CHANGE(event,type) CGEventSetType(event, type)
@@ -27,9 +29,9 @@ static const double DEFAULT_DURATION = 0.2; // seconds
 #endif
 
 #define POSTRELEASE(x) do {			\
-    CGEventRef event = x;  	 		\
-    POST(event);				\
-    RELEASE(event);				\
+    CGEventRef _event = x;  	 		\
+    POST(_event);				\
+    RELEASE(_event);				\
   } while(false);
 
 
@@ -147,21 +149,25 @@ mouse_drag_to(CGPoint point)
 }
 
 
+#define SCROLL(vval, hval) do {				\
+    size_t     steps = round(FPS * duration);		\
+    double   current = 0.0;				\
+    double      done = 0.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, 2, vval, hval)); \
+      mouse_sleep(2);							\
+      current += (double)scroll / (double)amount;			\
+    }									\
+  } while (false);
+
 void
 mouse_scroll3(int amount, CGScrollEventUnit units, double duration)
 {
-  size_t     steps = round(FPS * duration);
-  double   current = 0.0;
-  double      done = 0.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(2);
-    current += (double)scroll / (double)amount;
-  }
+  SCROLL(scroll, 0);
 }
 
 void
@@ -176,6 +182,23 @@ mouse_scroll(int amount)
   mouse_scroll2(amount, kCGScrollEventUnitLine);
 }
 
+void
+mouse_horizontal_scroll3(int amount, CGScrollEventUnit units, double duration)
+{
+  SCROLL(0, scroll);
+}
+
+void
+mouse_horizontal_scroll2(int amount, CGScrollEventUnit units)
+{
+  mouse_horizontal_scroll3(amount, units, DEFAULT_DURATION);
+}
+
+void
+mouse_horizontal_scroll(int amount)
+{
+  mouse_horizontal_scroll2(amount, kCGScrollEventUnitLine);
+}
 
 void
 mouse_click_down3(CGPoint point, uint_t sleep_quanta)
@@ -423,3 +446,213 @@ mouse_triple_click()
 {
   mouse_triple_click2(mouse_current_position());
 }
+
+
+static
+void
+mouse_gesture(CGPoint point, uint_t sleep_quanta, void (^gesture_block)(void))
+{
+  POSTRELEASE(NEW_EVENT(kCGEventMouseMoved, point, kCGMouseButtonLeft));
+
+  NEW_GESTURE(gesture);
+  CGEventSetIntegerValueField(
+                              gesture,
+			      kCGEventGestureType,
+			      kCGGestureTypeGestureStarted
+			      );
+  POST(gesture);
+
+  gesture_block();
+
+  CGEventSetIntegerValueField(gesture, kCGEventGestureType, kCGGestureTypeGestureEnded);
+  POSTRELEASE(gesture);
+
+  mouse_sleep(sleep_quanta);
+}
+
+void
+mouse_smart_magnify2(CGPoint point)
+{
+  mouse_gesture(point, (FPS / 2), ^(void) {
+      NEW_GESTURE(event);
+      CGEventSetIntegerValueField(event, kCGEventGestureType, kCGGestureTypeSmartMagnify);
+      POSTRELEASE(event);
+    });
+}
+
+void
+mouse_smart_magnify()
+{
+  mouse_smart_magnify2(mouse_current_position());
+}
+
+void
+mouse_swipe3(
+	     CGSwipeDirection direction,
+	     CGPoint point,
+	     double duration
+	     )
+{
+  uint16_t            axis = 0;
+  CGFloat         distance = 1.0;
+  CGGestureMotion   motion = kCGGestureMotionNone;
+
+  switch (direction)
+    {
+    case kCGSwipeDirectionUp:
+      axis     = kCGEventGestureSwipePositionY;
+      motion   = kCGGestureMotionVertical;
+      distance = -(distance);
+      break;
+    case kCGSwipeDirectionDown:
+      axis     = kCGEventGestureSwipePositionY;
+      motion   = kCGGestureMotionVertical;
+      break;
+    case kCGSwipeDirectionLeft:
+      axis     = kCGEventGestureSwipePositionX;
+      motion   = kCGGestureMotionHorizontal;
+      break;
+    case kCGSwipeDirectionRight:
+      axis     = kCGEventGestureSwipePositionX;
+      motion   = kCGGestureMotionHorizontal;
+      distance = -(distance);
+      break;
+    default:
+      return;
+    }
+
+  mouse_gesture(point, (FPS / 10), ^(void) {
+      NEW_GESTURE(swipe);
+
+      CGEventSetIntegerValueField(swipe, kCGEventGestureType,           kCGGestureTypeSwipe);
+      CGEventSetIntegerValueField(swipe, kCGEventGestureSwipeMotion,    motion);
+      CGEventSetIntegerValueField(swipe, kCGEventGestureSwipeDirection, direction);
+      CGEventSetIntegerValueField(swipe, kCGEventGesturePhase,          kCGGesturePhaseBegan);
+      CGEventSetDoubleValueField( swipe, kCGEventGestureSwipeProgress,  distance);
+      CGEventSetDoubleValueField( swipe, axis,                          distance);
+
+      // TODO: animation steps don't seem to do anything...
+      // kCGGesturePhaseChanged
+      // kCGGesturePhaseEnded
+
+      POSTRELEASE(swipe);
+    });
+}
+
+void
+mouse_swipe2(CGSwipeDirection direction, CGPoint point)
+{
+  mouse_swipe3(direction, point, DEFAULT_DURATION);
+}
+
+void
+mouse_swipe(CGSwipeDirection direction)
+{
+  mouse_swipe2(direction, mouse_current_position());
+}
+
+void
+mouse_pinch4(
+	     CGPinchDirection direction,
+	     double magnification,
+	     CGPoint point,
+	     double duration
+	     )
+{
+  switch (direction)
+    {
+    case kCGPinchExpand:
+      break;
+    case kCGPinchContract:
+      magnification = -(magnification);
+      break;
+    default:
+      return;
+    }
+
+  mouse_gesture(point, FPS / 10, ^(void) {
+      NEW_GESTURE(pinch);
+      CGEventSetIntegerValueField(pinch, kCGEventGestureType, kCGGestureTypePinch);
+
+      size_t steps       = FPS / duration;
+      double step_size   = magnification / steps;
+      double step_period = (duration / steps) * 1000000;
+
+      CGEventSetDoubleValueField(pinch, kCGEventGesturePinchValue, step_size);
+
+      for (size_t i = 0; i < steps; i++) {
+	POST(pinch);
+	usleep(step_period);
+      }
+
+      RELEASE(pinch);
+    });
+}
+
+void
+mouse_pinch3(CGPinchDirection direction, double magnification, CGPoint point)
+{
+  mouse_pinch4(direction, magnification, point, DEFAULT_DURATION);
+}
+
+void
+mouse_pinch2(CGPinchDirection direction, double magnification)
+{
+  mouse_pinch3(direction, magnification, mouse_current_position());
+}
+
+void
+mouse_pinch(CGPinchDirection direction)
+{
+  mouse_pinch2(direction, DEFAULT_MAGNIFICATION);
+}
+
+void
+mouse_rotate3(
+	      CGRotateDirection direction,
+	      double angle,
+	      CGPoint point,
+	      double duration
+	      )
+{
+  switch (direction)
+    {
+    case kCGRotateClockwise:
+      angle = -(angle);
+      break;
+    case kCGRotateCounterClockwise:
+      break;
+    default:
+      return;
+    }
+
+  mouse_gesture(point, (FPS / 10), ^(void) {
+      NEW_GESTURE(rotation);
+      CGEventSetIntegerValueField(rotation, kCGEventGestureType, kCGGestureTypeRotation);
+
+      size_t steps       = FPS / duration;
+      double step_size   = angle / steps;
+      double step_period = (duration / steps) * 1000000;
+
+      CGEventSetDoubleValueField(rotation, kCGEventGestureRotationValue, step_size);
+
+      for (size_t i = 0; i < steps; i++) {
+        POST(rotation);
+	usleep(step_period);
+      }
+
+      RELEASE(rotation);
+    });
+}
+
+void
+mouse_rotate2(CGRotateDirection direction, double angle, CGPoint point)
+{
+  mouse_rotate3(direction, angle, point, DEFAULT_DURATION);
+}
+
+void
+mouse_rotate(CGRotateDirection direction, double angle)
+{
+  mouse_rotate2(direction, angle, mouse_current_position());
+}