AXElements 0.9.0 → 1.0.0.alpha

data/lib/accessibility/graph.rb

@@ -47,7 +47,7 @@ class Accessibility::Graph
 
     def identifier
       klass = @element.class.to_s.split(NAMESPACE).last
-      ident = @element.pp_identifier.to_s.dup
+      ident = @element.pp_identifier.dup
       if ident.length > 12
         ident = "#{ident[0...12]}..."
       end
@@ -58,13 +58,9 @@ class Accessibility::Graph
     end
 
     def shape
-      if @element.attributes.include?(:focused) && @element.attribute(:focused)
-        OCTAGON
-      elsif @element.actions.empty?
-        OVAL
-      else
-        BOX
-      end
+      (@element.attribute(:focused) && OCTAGON) ||
+      (@element.actions.empty? && OVAL)         ||
+      BOX
     end
 
     def style
@@ -73,7 +69,7 @@ class Accessibility::Graph
         return FILLED unless @element.attribute(:enabled)
       end
       # bold if focused and no children
-      if @element.attributes.include?(:focused) && @element.attribute(:focused)
+      if @element.attribute(:focused)
         return BOLD if @element.size_of(:children).zero?
       end
       SOLID

data/lib/accessibility/highlighter.rb

@@ -0,0 +1,86 @@
+framework 'AppKit'
+require   'accessibility/version'
+
+##
+# A screen highlighter for debugging. When you initialize a highligter
+# object it will highlight the given bounds on the screen.
+#
+# Highligter objects can have their colour configured at initialization,
+# and can also have a timeout to automatically stop displaying.
+#
+# @example
+#
+#   h = Accessibility::Highlighter.new(CGRectMake(100,100,100,100))
+#   # when you are done...
+#   h.stop
+#
+class Accessibility::Highlighter < NSWindow
+
+  # @param bounds [CGRect]
+  # @param opts [Hash]
+  # @option opts [Number] :timeout
+  # @option opts [NSColor] :colour (NSColor.magentaColor)
+  def initialize bounds, opts = {}
+    colour = opts[:colour] || opts[:color] || NSColor.magentaColor
+
+    bounds.flip! # we assume the rect is in the other co-ordinate system
+
+    initWithContentRect bounds,
+             styleMask: NSBorderlessWindowMask,
+               backing: NSBackingStoreBuffered,
+                 defer: true
+    setOpaque false
+    setAlphaValue 0.20
+    setLevel NSStatusWindowLevel
+    setBackgroundColor colour
+    setIgnoresMouseEvents true
+    setFrame bounds, display: false
+    makeKeyAndOrderFront NSApp
+
+    if opts.has_key? :timeout
+      Dispatch::Queue.new(queue_id).after opts[:timeout] do
+        self.stop
+      end
+    end
+  end
+
+  ##
+  # Tell the highlighter to stop displaying.
+  #
+  # @return [self]
+  def stop
+    close
+  end
+
+
+  private
+
+  def queue_id
+    "com.marketcircle.axelements.window_killer_#{hash}"
+  end
+end
+
+
+##
+# AXElements extensions to `CGRect`.
+class CGRect
+  ##
+  # Treats the rect as belonging to one co-ordinate system and then
+  # converts it to the other system.
+  #
+  # This is useful because accessibility API's expect to work with
+  # the flipped co-ordinate system (origin in top left), but AppKit
+  # prefers to use the cartesian co-ordinate system (origin in bottom
+  # left).
+  #
+  # @return [CGRect]
+  def flip!
+    screen_height = NSMaxY(NSScreen.mainScreen.frame)
+    origin.y      = screen_height - NSMaxY(self)
+    self
+  end
+end
+
+
+# Initialize the shared application so that windows can be created
+NSApplication.sharedApplication

data/lib/accessibility/{pretty_printer.rb → pp_inspector.rb}

@@ -10,13 +10,13 @@
 #  - `#attribute` returns the value of a given attribute
 #  - `#size_of` returns the size for an attribute
 #
-module Accessibility::PrettyPrinter
+module Accessibility::PPInspector
 
   ##
   # Create an identifier for the receiver by using various attributes
   # that should make it very easy to identify the element.
   #
-  # @return [String,#to_s]
+  # @return [String]
   def pp_identifier
     # @note use, or lack of use, of #inspect is intentional for visual effect
 
@@ -49,7 +49,8 @@ module Accessibility::PrettyPrinter
       return " id=#{attribute(:identifier)}"
     end
 
-  rescue NoMethodError
+    # @todo should we have other fallbacks?
+    return EMPTY_STRING
   end
 
   ##

data/lib/accessibility/qualifier.rb

@@ -1,6 +1,4 @@
 # -*- coding: utf-8 -*-
-
-require 'active_support/core_ext/object/blank'
 require 'accessibility/translator'
 
 ##
@@ -31,7 +29,7 @@ class Accessibility::Qualifier
     @klass    = TRANSLATOR.classify(klass)
     @criteria = criteria
     @block    = Proc.new if block_given?
-    compile!
+    compile criteria
   end
 
   ##
@@ -65,8 +63,8 @@ class Accessibility::Qualifier
   # {#qualifies?}.
   #
   # @param criteria [Hash]
-  def compile!
-    @filters = @criteria.map do |key, value|
+  def compile criteria
+    @filters = criteria.map do |key, value|
       if value.kind_of? Hash
         [:subsearch, key, value]
       elsif key.kind_of? Array

data/lib/accessibility/screen_recorder.rb

@@ -0,0 +1,217 @@
+framework 'AVFoundation'
+require   'accessibility/version'
+require   'ax_elements/core_graphics_workaround'
+
+##
+# Screen recordings, easy as pie.
+#
+# Things that you need to be concerned about:
+#   - screen going to sleep
+#   - short recordings (~1 second) don't work too well; it looks like
+#     the last bit of the buffer does not get saved so the last ~0.5
+#     seconds are not saved to disk (we could add a 0.5 second sleep)
+#   - small memory leak when a recording starts on Mountain Lion (GC)
+#   - constantly leaking memory during recording on Lion (GC)
+#   - run loop hack is not needed if code is already being called from
+#     in a run loop
+#   - pausing is not working...not sure why
+#
+class Accessibility::ScreenRecorder
+
+  ##
+  # Record the screen while executing the given block. The path to the
+  # recording will be returned.
+  #
+  # The recorder object is yielded.
+  #
+  # @yield
+  # @yieldparam recorder [ScreenRecorder]
+  # @return [String]
+  def self.record file_name = nil
+    raise 'block required' unless block_given?
+
+    recorder = new
+    file_name ? recorder.start(file_name) : recorder.start
+    yield recorder
+    recorder.file
+
+  ensure
+    recorder.stop
+  end
+
+  ##
+  # Path to the screen recording. This is `nil` until the screen
+  # recording begins.
+  #
+  # @return [String]
+  attr_reader :file
+
+  ##
+  # @todo Expose configuration options at initialie time
+  def initialize
+    @session = AVCaptureSession.alloc.init
+
+    @input = AVCaptureScreenInput.alloc.initWithDisplayID CGMainDisplayID()
+    @input.capturesMouseClicks = true
+
+    @output = AVCaptureMovieFileOutput.alloc.init
+    @output.setDelegate self
+
+    @session.addInput @input
+    @session.addOutput @output
+
+    @sema = Dispatch::Semaphore.new 0
+  end
+
+  ##
+  # Synchrnously start recording. You can optionally specify a file
+  # name for the recording; if you do not then a default name will be
+  # provided in the form `~/Movies/TestRecording-20121017123230.mov`
+  # (the timestamp will be different for you).
+  #
+  # @param file_name [String]
+  def start file_name = default_file_name
+    @file = default_file_name
+    file_url = NSURL.fileURLWithPath @file, isDirectory: false
+
+    @session.startRunning
+    @output.startRecordingToOutputFileURL file_url,
+                       recordingDelegate: self
+
+    @sema.wait
+  end
+
+  ##
+  # Whether or not the recording has begun. This will be `true`
+  # after calling {#start} until {#stop} is called. It will be
+  # `true` while the recording is paused.
+  def started?
+    @output.recording?
+  end
+
+  # ##
+  # # Whether or not the recording has been paused.
+  # def paused?
+  #   @output.paused?
+  # end
+
+  ##
+  # Duration of the recording, in seconds.
+  #
+  # @return [Float]
+  def length
+    duration = @output.recordedDuration
+    (duration.value.to_f / duration.timescale.to_f)
+  end
+
+  ##
+  # Size of the recording on disk, in bytes.
+  #
+  # @return [Fixnum]
+  def size
+    @output.recordedFileSize
+  end
+
+  # ##
+  # # Synchronously pause the recording. You can optionally pass a block
+  # # to this method.
+  # #
+  # # If you pass a block, the recording is paused so that the block
+  # # can execute and recording resumes after the block finishes. If
+  # # you do not pass a block then the recording is paused until you
+  # # call {#resume} on the receiver.
+  # #
+  # # @yield Optionally pass a block
+  # def pause
+  #   @output.pauseRecording
+  #   wait_for_callback
+  #   @sema.wait
+
+  #   if block_given?
+  #     yield
+  #     resume
+  #   end
+  # end
+
+  # ##
+  # # Synchronously resume a {#pause}d recording.
+  # def resume
+  #   @output.resumeRecording
+  #   wait_for_callback
+  #   @sema.wait
+  # end
+
+  ##
+  # Synchronously stop recording and finish up commiting any data to disk.
+  # A recording cannot be {#start}ed again after it has been stopped; if
+  # you want to pause a recording then you should use {#pause} instead.
+  def stop
+    @session.stopRunning
+    @output.stopRecording
+    @sema.wait
+    wait_for_callback
+    @sema.wait
+  end
+
+
+  # @!group AVCaptureFileOutputDelegate
+
+  def captureOutput captureOutput, didOutputSampleBuffer:sampleBuffer, fromConnection:connection
+    # gets called for every chunk of the recording getting committed to disk
+  end
+
+  def captureOutput captureOutput, didDropSampleBuffer:sampleBuffer,   fromConnection:connection
+    NSLog("Error: dropped same data from recording")
+  end
+
+
+  # @!group AVCaptureFileOutputRecordingDelegate
+
+  def captureOutput captureOutput, didFinishRecordingToOutputFileAtURL:outputFileURL, fromConnections:connections, error:error
+    NSLog('Finishing')
+    CFRunLoopStop(CFRunLoopGetCurrent())
+    @sema.signal
+  end
+
+  def captureOutput captureOutput, didPauseRecordingToOutputFileAtURL:fileURL, fromConnections:connections
+    NSLog('Pausing')
+    CFRunLoopStop(CFRunLoopGetCurrent())
+    @sema.signal
+  end
+
+  def captureOutput captureOutput, didResumeRecordingToOutputFileAtURL:fileURL, fromConnections:connections
+    NSLog('Resuming')
+    CFRunLoopStop(CFRunLoopGetCurrent())
+    @sema.signal
+  end
+
+  def captureOutput captureOutput, didStartRecordingToOutputFileAtURL:fileURL, fromConnections:connections
+    NSLog('Starting')
+    @sema.signal
+  end
+
+  def captureOutput captureOutput, willFinishRecordingToOutputFileAtURL:fileURL, fromConnections:connections, error:error
+    NSLog('Will Finish')
+    @sema.signal
+  end
+
+
+  private
+
+  def default_file_name
+    date = Time.now.strftime '%Y%m%d%H%M%S'
+    File.expand_path("~/Movies/TestRecording-#{date}.mov")
+  end
+
+  def wait_for_callback
+    case CFRunLoopRunInMode(KCFRunLoopDefaultMode, 30, false)
+    when KCFRunLoopRunStopped
+      true
+    when KCFRunLoopRunTimedOut
+      raise 'did not get callback'
+    else
+      raise 'unexpected result from waiting for callback'
+    end
+  end
+
+end

data/lib/accessibility/statistics.rb

@@ -0,0 +1,57 @@
+require 'accessibility/version'
+
+class Accessibility::Statistics
+
+  def initialize
+    @stats = Hash.new do |h,k| h[k] = 0 end
+    @q     = Dispatch::Queue.new "com.marketcircle.axelements.stats"
+  end
+
+  def increment key
+    @q.async do
+      @stats[key] += 1
+    end
+  end
+
+  def to_s
+    @q.sync do # must be synchronized
+      set_max_length
+      @out = output_header << output_body << "\n"
+    end
+    @out
+  end
+
+
+  private
+
+  def set_max_length
+    @max_key_len = @stats.keys.map(&:length).max
+    @max_val_len = @stats.values.max.to_s.length
+  end
+
+  def dot key, val
+    length  = 4
+    length += @max_key_len - key.length
+    length += @max_val_len - val.to_s.length
+    "." * length
+  end
+
+  def output_header
+    <<-EOS
+######################
+# AX Call Statistics #
+######################
+    EOS
+  end
+
+  def output_body
+    pairs = @stats.to_a.sort { |x,y| y.last <=> x.last }
+    pairs.map do |key, val|
+      key.to_s << dot(key,val) << val.to_s
+    end.join("\n")
+  end
+
+end
+
+# @return [Accessibility::Statistics]
+STATS = Accessibility::Statistics.new