x_do 0.1.0

data/lib/x_do/ffi_lib_ext.rb

@@ -0,0 +1,62 @@
+# Extensions to the structures in ffi_lib.
+
+# :nodoc: namespace
+class XDo
+
+# :nodoc: namespace
+module FFILib
+
+# :nodoc: extending with better constructor
+class XDoSearch
+  # Creates an XDoSearch structure from options passed to XDo#find_window.
+  def self.from_options(options = {})
+    search = self.new
+    search[:max_depth] = (options[:depth] || -1).to_i
+    
+    # SEARCH_ANY vs SEARCH_ALL in xdo.h
+    search[:require] = (options[:require] == :any) ? 0 : 1
+
+    search[:searchmask] = 0
+    [
+      [:title, :title, XDo::FFILib::Consts::SEARCH_TITLE],
+      [:name, :winname, XDo::FFILib::Consts::SEARCH_NAME],
+      [:class, :winclass, XDo::FFILib::Consts::SEARCH_CLASS],
+      [:class_name, :winclassname, XDo::FFILib::Consts::SEARCH_CLASSNAME]
+    ].each do |option, struct_key, bit|
+      if options[option]
+        search[:searchmask] |= bit
+
+        c_string = FFI::MemoryPointer.new options[option].length + 1
+        c_string.put_string 0, options[option]
+        search[struct_key] = c_string
+      else
+        search[struct_key] = nil
+      end
+    end
+    
+    if options[:visible]
+      search[:searchmask] |= XDo::FFILib::Consts::SEARCH_ONLYVISIBLE
+      search[:only_visible] = 1
+    else
+      search[:only_visible] = 0
+    end
+    
+    [
+      [:pid, :pid, XDo::FFILib::Consts::SEARCH_PID],
+      [:screen, :screen, XDo::FFILib::Consts::SEARCH_SCREEN]
+    ].each do |option, struct_key, bit|
+      if options[option]
+        search[:searchmask] |= bit
+        search[struct_key] = options[option].to_i
+      else
+        search[struct_key] = 0
+      end
+    end
+    
+    search
+  end
+end  # class XDo::FFILib::XDoSearch
+
+end  # module XDo::FFILib
+
+end  # namespace XDo

data/lib/x_do/keyboard.rb

@@ -0,0 +1,51 @@
+# :nodoc: namespace
+class XDo
+
+# The keyboard state for a libxdo context.
+class Keyboard
+  # Creates a keyboard state wrapper for an XDo context.
+  #
+  # This constructor is called internally by XDo#keyboard and client code
+  # should not need to call it directly.
+  #
+  # Args:
+  #   xdo:: the XDo wrapping a libxdo context
+  def initialize(xdo)
+    @xdo = xdo
+    @_xdo_pointer = xdo._pointer
+  end
+  
+  # The XDo context that produced the window.
+  attr_accessor :xdo
+  
+  # Types a string into the current window.
+  def type_string(string, delay = 0.12)
+    XDo::FFILib.xdo_type @_xdo_pointer, 0, string, (delay * 100_000).to_i
+  end
+  
+  # Sends a keysequence to this window.
+  #
+  # Examples: "alt+Return", "Alt_L+Tab", "l", "semicolon"
+  def type_keysequence(keysequence, delay = 0.12)
+    XDo::FFILib.xdo_keysequence @_xdo_pointer, 0, keysequence,
+                                (delay * 100_000).to_i
+  end
+  
+  # Presses a keysequence in this window.
+  #
+  # Examples: "alt+Return", "Alt_L+Tab", "l", "semicolon"
+  def press_keysequence(keysequence, delay = 0.12)
+    XDo::FFILib.xdo_keysequence_down @_xdo_pointer, 0, keysequence,
+                                     (delay * 100_000).to_i
+  end
+  
+  # Releases a keysequence in this window.
+  #
+  # Examples: "alt+Return", "Alt_L+Tab", "l", "semicolon"
+  def release_keysequence(keysequence, delay = 0.12)
+    XDo::FFILib.xdo_keysequence_up @_xdo_pointer, 0, keysequence,
+                                   (delay * 100_000).to_i
+  end
+end  # class XDo::Keyboard
+
+end  # namespace XDo

data/lib/x_do/mouse.rb

@@ -0,0 +1,85 @@
+# :nodoc: namespace
+class XDo
+
+# The mouse state for a libxdo context.
+class Mouse
+  # Creates a mouse state wrapper for an XDo context.
+  #
+  # This constructor is called internally by XDo#mouse and client code
+  # should not need to call it directly.
+  #
+  # Args:
+  #   xdo:: the XDo wrapping a libxdo context
+  def initialize(xdo)
+    @xdo = xdo
+    @_xdo_pointer = xdo._pointer
+  end
+  
+  # The XDo context that produced the window.
+  attr_accessor :xdo
+  
+  # [x, y, screen] array of mouse coordinates.
+  def location
+    x_pointer = FFI::MemoryPointer.new :int, 1
+    y_pointer = FFI::MemoryPointer.new :int, 1
+    screen_pointer = FFI::MemoryPointer.new :int, 1
+    XDo::FFILib.xdo_mouselocation @_xdo_pointer, x_pointer, y_pointer,
+                                  screen_pointer
+    [x_pointer.read_int, y_pointer.read_int, screen_pointer.read_int]
+  end
+  
+  # Moves the mouse to a new position.
+  def move(x, y, screen)
+    old_location = self.location
+    move_async x, y, screen
+    unless old_location[0, 2] == [x, y]
+      wait_for_move_from old_location[0], old_location[1]
+    end
+  end
+
+  # Queues a mouse move request to the X server.
+  def move_async(x, y, screen)
+    XDo::FFILib.xdo_mousemove @_xdo_pointer, x, y, screen
+  end
+
+  # Moves the mouse relatively to its current position.
+  def move_relative(dx, dy)
+    old_location = self.location
+    move_relative_async dx, dy
+    unless dx == 0 && dy == 0
+      wait_for_move_from old_location[0], old_location[1]
+    end
+  end
+
+  # Queues a mouse move request to the X server.
+  def move_relative_async(dx, dy)
+    XDo::FFILib.xdo_mousemove_relative @_xdo_pointer, dx, dy
+  end
+
+  # Blocks until the mouse moves away from a position on screen.
+  def wait_for_move_from(x, y)
+    XDo::FFILib.xdo_mouse_wait_for_move_from @_xdo_pointer, x, y
+  end
+  
+  # Blocks until the mouse moves to a position on screen.
+  def wait_for_move_to(x, y)
+    XDo::FFILib.xdo_mouse_wait_for_move_to @_xdo_pointer, x, y
+  end
+  
+  # Clicks a mouse button.
+  def click(button)
+    XDo::FFILib.xdo_click @_xdo_pointer, 0, button
+  end
+
+  # Presses a mouse button.
+  def press(button)
+    XDo::FFILib.xdo_mousedown @_xdo_pointer, 0, button
+  end
+
+  # Releases a mouse button.
+  def release(button)
+    XDo::FFILib.xdo_mouseup @_xdo_pointer, 0, button
+  end
+end  # class XDo::Mouse
+
+end  # namespace XDo

data/lib/x_do/window.rb

@@ -0,0 +1,182 @@
+# :nodoc: namespace
+class XDo
+
+# Wraps an xdolib Window pointer.
+class Window
+  # Brings a window forward and gives it focus.
+  def activate
+    XDo::FFILib.xdo_window_activate @_xdo_pointer, @_window
+  end
+  
+  # Gives the input focus to a window
+  def focus
+    XDo::FFILib.xdo_window_focus @_xdo_pointer, @_window
+  end
+
+  # Moves the window at the top of the stack, making it visible.
+  def raise
+    XDo::FFILib.xdo_window_raise @_xdo_pointer, @_window
+  end
+  
+  # The PID of the process owning the window.
+  def pid
+    XDo::FFILib.xdo_window_get_pid @_xdo_pointer, @_window
+  end
+  
+  # [x, y] array containing the window's coordinates.
+  def location
+    x_pointer = FFI::MemoryPointer.new :int, 1
+    y_pointer = FFI::MemoryPointer.new :int, 1
+    XDo::FFILib.xdo_get_window_location @_xdo_pointer, @_window, x_pointer,
+                                        y_pointer, nil
+    [x_pointer.read_int, y_pointer.read_int]
+  end
+  
+  # [width, height] array containing the window's size.
+  def size
+    width_pointer = FFI::MemoryPointer.new :int, 1
+    height_pointer = FFI::MemoryPointer.new :int, 1
+    XDo::FFILib.xdo_get_window_size @_xdo_pointer, @_window, width_pointer,
+                                    height_pointer
+    [width_pointer.read_int, height_pointer.read_int]
+  end
+
+  def move(x, y)
+    move_raw x, y
+    glitched_location = self.location
+    x_decoration = glitched_location.first - x
+    y_decoration = glitched_location.last - y
+    move_raw x - x_decoration, y - y_decoration
+  end
+  
+  # Moves this window to a new position.
+  #
+  # The position is given directly to X, and does not account for window
+  # decorations.
+  def move_raw(x, y)
+    old_location = self.location
+    return_value = move_raw_async x, y
+    100.times do
+      break unless self.location == old_location
+      sleep 0.01
+    end
+    return_value
+  end
+  
+  # Asks X to move this window to a new position.
+  def move_raw_async(x, y)
+    XDo::FFILib.xdo_window_move @_xdo_pointer, @_window, x, y
+  end
+  
+  # Resizes this window.
+  #
+  # Args:
+  #   width:: the new window's width
+  #   height:: the new window's height
+  #   use_hints:: if false, width and height are specified in pixels; otherwise,
+  #               the unit is relative to window size hints
+  def resize(width, height, use_hints = false)
+    old_size = self.size
+    return_value = resize_async width, height, use_hints
+    100.times do
+      break unless self.size == old_size
+      sleep 0.01
+    end
+    return_value
+  end
+  
+  # Asks X to resize this window.
+  def resize_async(width, height, use_hints = false)
+    flags = use_hints ? XDo::FFILib::Consts::SIZE_U : 0
+    XDo::FFILib.xdo_window_setsize @_xdo_pointer, @_window, width, height, flags
+  end
+  
+  # Moves the mouse in window coordinates.
+  def move_mouse(window_x, window_y)
+    old_location = @xdo.mouse.location
+    move_mouse_async window_x, window_y
+    @xdo.mouse.wait_for_move_from old_location[0], old_location[1]
+  end
+
+  # Moves the mouse in window coordinates.
+  def move_mouse_async(window_x, window_y)
+    XDo::FFILib.xdo_mousemove_relative_to_window @_xdo_pointer, @_window,
+                                                 window_x, window_y
+  end
+  
+  # Clicks a mouse button.
+  def click_mouse(button)
+    XDo::FFILib.xdo_click @_xdo_pointer, @_window, button
+  end
+
+  # Presses a mouse button.
+  def press_mouse(button)
+    XDo::FFILib.xdo_mousedown @_xdo_pointer, @_window, button
+  end
+
+  # Releases a mouse button.
+  def release_mouse(button)
+    XDo::FFILib.xdo_mouseup @_xdo_pointer, @_window, button
+  end
+  
+  # Types a string into this window.
+  def type_string(string, delay = 0.12)
+    XDo::FFILib.xdo_type @_xdo_pointer, @_window, string, (delay * 100_000).to_i
+  end
+  
+  # Sends a keysequence to this window.
+  #
+  # Examples: "alt+Return", "Alt_L+Tab", "l", "semicolon"
+  def type_keysequence(keysequence, delay = 0.12)
+    XDo::FFILib.xdo_keysequence @_xdo_pointer, @_window, keysequence,
+                                (delay * 100_000).to_i
+  end
+  
+  # Presses a keysequence in this window.
+  #
+  # Examples: "alt+Return", "Alt_L+Tab", "l", "semicolon"
+  def press_keysequence(keysequence, delay = 0.12)
+    XDo::FFILib.xdo_keysequence_down @_xdo_pointer, @_window, keysequence,
+                                     (delay * 100_000).to_i
+  end
+  
+  # Releases a keysequence in this window.
+  #
+  # Examples: "alt+Return", "Alt_L+Tab", "l", "semicolon"
+  def release_keysequence(keysequence, delay = 0.12)
+    XDo::FFILib.xdo_keysequence_up @_xdo_pointer, @_window, keysequence,
+                                   (delay * 100_000).to_i
+  end
+  
+  # Creates a wrapper for an X Window handle.
+  #
+  # This constructor is called internally by XDo#find_windows and client code
+  # should not need to call it directly.
+  #
+  # Args:
+  #   xdo:: the XDo wrapping the libxdo context used to get this Window
+  #   _window:: the X Window handle to be wrapped
+  def initialize(xdo, _window)
+    @xdo = xdo
+    @_xdo_pointer = xdo._pointer
+    @_window = _window
+  end
+  
+  # The XDo context that produced the window.
+  attr_accessor :xdo
+  
+  # The underlying X Window handle.
+  attr_accessor :_window
+
+  # :nodoc: underlying window handle should impact equality
+  def ==(other)
+    other.kind_of?(XDo::Window) && @_window == other._window
+  end
+  
+  # :nodoc: override hash to match ==
+  def hash
+    _window.hash
+  end
+end  # class XDo::Window
+
+end  # namespace XDo

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'x_do'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/support/stdlib.rb

@@ -0,0 +1,2 @@
+# Additional stdlib files used in rspecs but not in code.
+require 'English'

data/spec/x_do/context_spec.rb

@@ -0,0 +1,127 @@
+require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
+
+describe XDo do
+  describe 'with no display specification' do
+    let(:xdo) { XDo.new }
+    
+    it 'should use the value of $DISPLAY' do
+      xdo.display_name.should == ENV['DISPLAY']
+    end
+    
+    describe 'after close' do
+      before { xdo.close }
+      
+      it 'should not accept method calls' do
+        lambda {
+          xdo.display_name
+        }.should raise_error(NoMethodError)
+      end
+      
+      it 'should accept #close without crashing' do
+        lambda {
+          xdo.close
+        }.should_not raise_error
+      end
+    end
+  end
+  
+  describe 'find_windows' do
+    let(:xdo) { XDo.new }
+    
+    describe 'with .* name pattern' do
+      let(:windows) { xdo.find_windows :name => '.*' }
+      
+      it 'should return at least 1 element' do
+        windows.should_not be_empty
+      end
+      
+      it 'should return same number of windows as xdotool' do
+        windows.length.should == `xdotool search --all --name ".*"`.split.length
+      end
+      
+      it 'should have a XDo::Window as the first element' do
+        windows.first.should be_kind_of(XDo::Window)
+      end
+
+      it 'should include the active window' do
+        windows.should include(xdo.active_window)
+      end
+
+      it 'should include the "real" focused window' do
+        windows.should include(xdo.real_focused_window)
+      end
+    end
+    
+    describe 'with no conditions' do
+      let(:windows) { xdo.find_windows }
+      
+      it 'should include the active window' do
+        windows.should include(xdo.active_window)
+      end
+
+      it 'should include the "real" focused window' do
+        windows.should include(xdo.real_focused_window)
+      end
+
+      it 'should include the focused window' do
+        windows.should include(xdo.focused_window)
+      end
+    end
+    
+    describe 'with the current PID' do
+      let(:windows) { xdo.find_windows :pid => $PID }
+      
+      it 'should not return any windows for console process' do
+        windows.should be_empty
+      end
+    end
+  end
+  
+  describe 'active_window' do
+    let(:xdo) { XDo.new }
+    let(:window) { xdo.active_window }
+    
+    it 'should be an XDo::Window' do
+      window.should be_kind_of(XDo::Window)
+    end
+  end
+  
+  describe 'focused_window' do
+    let(:xdo) { XDo.new }
+    let(:window) { xdo.focused_window }
+    
+    it 'should be an XDo::Window' do
+      window.should be_kind_of(XDo::Window)
+    end
+  end
+  
+  describe 'mouse' do
+    let(:xdo) { XDo.new }
+    let(:mouse) { xdo.mouse }
+    
+    it 'should be an XDo::Mouse' do
+      mouse.should be_kind_of(XDo::Mouse)
+    end
+  end
+  
+  describe 'with :0 display name' do
+    let(:display) { ':0'}
+    let(:xdo) { XDo.new display }
+    
+    it 'should use given display name' do
+      xdo.display_name.should == display
+    end
+  end
+  
+  describe 'lib_version' do
+    let(:version) { XDo.lib_version }
+    
+    it 'should be non-nil' do
+      version.should_not be_nil
+    end
+
+    it 'should be non-empty' do
+      version.should_not be_empty
+    end
+  end
+end