xdo 0.0.1-x86-linux

data/Rakefile

@@ -0,0 +1,46 @@
+#Encoding: UTF-8
+#This file is part of Xdo. 
+#Copyright © 2009 Marvin Gülker
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "rake/testtask"
+
+spec = Gem::Specification.new do |s|
+  s.name = "xdo"
+  s.summary = "Simulate keyboard and mouse input via a ruby interface to xdotool and other console programs."
+  s.description =<<DESCRIPTION
+XDo is a library to automate your mouse, fake keyboard input and 
+manipulate windows in a Linux X server environment. It's wrapped 
+around a lot of command line tools (see requirements) of which xdotool 
+is the main one, the others are usually installed. 
+DESCRIPTION
+  s.add_dependency("test-unit", ">= 2.0")
+  s.requirements = ["The xdotool command-line tool.", "xwininfo (usually installed)", "The xsel command-line tool.", "eject (usually installed)", "xkill (usually installed)"]
+  s.requirements << "The unit-test gem (will be installed if you don't have it)"
+  s.version = "0.0.1"
+  s.author = "Marvin Gülker"
+  s.email = "sutniuq@gmx.net"
+  s.platform = Gem::Platform::CURRENT
+  s.required_ruby_version = ">=1.9"
+  s.files = ["bin/xinfo.rb", Dir["lib/**/*.rb"], Dir["test/*.rb"], Dir["samples/*.rb"], "Rakefile", "lib/README.rdoc"].flatten
+  s.executables = ["xinfo.rb"]
+  s.has_rdoc = true
+  s.test_files = Dir["test/test_*.rb"]
+  s.rubyforge_project = "Automations"
+end
+Rake::GemPackageTask.new(spec).define
+
+Rake::RDocTask.new do |rd|
+  rd.rdoc_files.include("lib/**/*.rb", "lib/README.rdoc")
+  rd.title = "xdo RDocs"
+  rd.main = "lib/README.rdoc"
+end
+
+Rake::TestTask.new("test") do |t|
+  t.pattern = "test/test_*.rb"
+  t.warning = true
+end
+
+desc "Tests XDo and then builds the gem file."
+task :full_gem => [:test, :gem]

data/bin/xinfo.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+#This file is part of Xdo. 
+#Copyright © 2009 Marvin Gülker
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+#
+#This program displays information about the currently selected window 
+#and the mouse. The displayed infos are updated every 1/2 second, 
+#but set XInfo::UPDATE_TIME to another value if you'd like to change that. 
+require_relative("../lib/xdo/xwindow")
+require_relative("../lib/xdo/mouse")
+require "wx"
+require_relative("../lib/xdo/wxaliases")
+
+puts "=" * 80
+puts "Started: #{Time.now}"
+at_exit{puts "Finished: #{Time.now}"}
+
+
+#--
+#=================================================
+#Backend
+#=================================================
+#++
+
+#Class that retrieves the information of windows. 
+class InfoGetter
+  
+  attr_reader :act_win
+  attr_reader :cursorpos
+  
+  def initialize
+    @act_win = XDo::XWindow.from_active
+    @cursorpos = XDo::Mouse.position
+  end
+  
+  def update
+    @act_win = XDo::XWindow.from_active
+    @cursorpos = XDo::Mouse.position
+  end
+  
+end
+
+#--
+#=================================================
+#Frontend
+#=================================================
+#++
+include Wx
+
+#Frontend of this program. 
+class XInfo < App
+  
+  #Time intervall of updating the infos, in milliseconds. 
+  #Default is 500, which is 1/2 second. 
+  UPDATE_TIME = 500
+  
+  def on_init
+    puts "Creating main window"
+    @mainwindow = Frame.new(nil, -1, "XInfo", DEFAULT_POSITION, Size.new(300, 400), DEFAULT_FRAME_STYLE | STAY_ON_TOP)
+    @mainwindow.background_colour = NULL_COLOUR
+    puts "Creating controls"
+    create_controls
+    puts "Setting up timer"
+    create_updater
+    
+    puts "Display GUI"
+    @mainwindow.show
+  end
+  
+  def create_controls
+    StaticText.new(@mainwindow, -1, "Title of active window: ", Point.new(20, 20))
+    @title = TextCtrl.new(@mainwindow, -1, "", Point.new(20, 50), Size.new(260, 24), TE_READONLY)
+    StaticText.new(@mainwindow, -1, "ID of active window: ", Point.new(20, 80))
+    @id = TextCtrl.new(@mainwindow, -1, "", Point.new(20, 110), Size.new(260, 24), TE_READONLY)
+    StaticText.new(@mainwindow, -1, "Absoloute and relative upper-left coords: ", Point.new(20,140))
+    StaticText.new(@mainwindow, -1, "Abs: ", Point.new(20, 173))
+    @abs_xy = TextCtrl.new(@mainwindow, -1, "", Point.new(60, 170), Size.new(70, 24), TE_READONLY)
+    StaticText.new(@mainwindow, -1, "Rel: ", Point.new(150, 173))
+    @rel_xy = TextCtrl.new(@mainwindow, -1, "", Point.new(190, 170), Size.new(70, 24), TE_READONLY)
+    StaticText.new(@mainwindow, -1, "Size: ", Point.new(20, 200))
+    StaticText.new(@mainwindow, -1, "Width: ", Point.new(20, 233))
+    @width = TextCtrl.new(@mainwindow, -1, "", Point.new(65, 230), Size.new(70, 24), TE_READONLY)
+    StaticText.new(@mainwindow, -1, "Height: ", Point.new(150, 233))
+    @height = TextCtrl.new(@mainwindow, -1, "", Point.new(200, 230), Size.new(70, 24), TE_READONLY)
+    
+    StaticText.new(@mainwindow, -1, "Mouse position: ", Point.new(20, 300))
+    StaticText.new(@mainwindow, -1, "X: ", Point.new(20, 333))
+    @x = TextCtrl.new(@mainwindow, -1, "", Point.new(60, 330), Size.new(70, 24), TE_READONLY)
+    StaticText.new(@mainwindow, -1, "Y: ", Point.new(150, 333))
+    @y = TextCtrl.new(@mainwindow, -1, "", Point.new(190, 330), Size.new(70, 24), TE_READONLY)
+    
+  end
+  
+  def create_updater
+    @updater = InfoGetter.new
+    Timer.every(UPDATE_TIME) do
+      begin
+        @updater.update
+        @title.text = @updater.act_win.title
+        @id.text = @updater.act_win.id.inspect
+        @abs_xy.text = @updater.act_win.abs_position.join(", ")
+        @rel_xy.text = @updater.act_win.rel_position.join(", ")
+        ary = @updater.act_win.size
+        @width.text = ary[0].inspect
+        @height.text = ary[1].inspect
+      rescue NoMethodError
+        puts "Window closed. Skipping NoMethodError. "
+        #Das aktive Fenster wird wohl gerade gelöscht. 
+        #Daher nichts machen. 
+      end
+      
+      curpos = @updater.cursorpos
+      @x.text = curpos[0].inspect
+      @y.text = curpos[1].inspect
+    end
+    
+  end
+  
+end
+
+
+begin
+  puts "Creating GUI"
+  x = XInfo.new
+  puts "Starting main loop"
+  x.main_loop
+rescue
+  message = "An #{$!.class} occured. Backtrace: \n\n#{$@.join("\n")}"
+  message << "\n\nThe error message will be printed in the ~/.xinfo.rb.log file. "
+  message << "If you want to contact me about the error, send an email to sutniuq ät gmx Dot net and "
+  message << "attach the Err.log file."
+  msgbox = Wx::MessageDialog.new(nil, message, $!.class.to_s, OK | ICON_ERROR)
+  msgbox.show_modal
+  raise #for logging
+end

data/lib/README.rdoc

@@ -0,0 +1,55 @@
+--
+This file is part of Xdo. 
+Copyright © 2009 Marvin Gülker
+  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+++
+=XDo
+XDo is a library to simmulate keyboard and mouse input and manipulating windows on the X server. 
+It's wrapped around the command-line tools xdotool[http://www.semicomplete.com/projects/xdotool/], 
+xsel[http://linux.die.net/man/1/xsel], xwininfo[http://linux.die.net/man/1/xwininfo], ecject[http://linux.die.net/man/1/eject] and xkill[http://linux.die.net/man/1/xkill], 
+so you will need to have them installed if you want to use Xdo (even if xsel, xwininfo, eject and xkill are usually already installed). 
+If not, as an Ubuntu or Debian user try to install them via 
+  sudo apt-get install xdotool xsel xwininfo eject xkill
+After they're installed, install XDo via RubyGems: 
+  sudo gem install xdo
+If you want to run the tests, change to the gem's installation directory and type "rake test". 
+Keep in mind that, while the tests run, you won't be able to use your computer, since they take control 
+of all things XDo is able to. 
+==Usage
+  #Require some of XDo's files
+  require "xdo/keyboard"
+  require "xdo/mouse"
+  require "xdo/xwindow"
+  #Move the cursor
+  XDo::Mouse.move(100, 100)
+  #Simulate text (with special escape sequences!)
+  XDo::Keyboard.simulate("This is{TAB}text.")
+  #And this will move a window containing the string "gedit", 
+  #unless it's maximized. 
+  win = XDo::XWindow.from_name("gedit")
+  win.move(200, 200)
+==Files
+You can require the following files in your projects: 
+* xdo/clipboard: Clipboard access
+* xdo/drive: Get control of CD/DVD devices
+* xdo/keyboard: Pretty self-explaining
+* xdo/mouse: Automate the mouse
+* xdo/xwindow: Manipulate windows in various ways
+As an helpful extra, I created an executable ruby file "xinfo.rb". Thanks to RubyGems, 
+you can start this GUI tool right from the command line by typing: 
+  xinfo.rb
+It's by far not perfect, maybe not even good, but I think it can be useful sometimes 
+(you will need to have wxRuby installed, try <tt>sudo gem install wxruby-ruby19</tt>). 
+If you're looking for a more professional program, try the "X window information" tool. 
+==Notes
+* +xdotool+ rejects to accept the --window option although it's documented, so you can't use the +w_id+ parameter of many methods in XDo::Keyboard. 
+* I recommand the "X window information" tool to get infos about your windows if you aren't satisfied by the xinfo.rb shipped with this package. 
+==Fairly incomplete
+* I'm sure there are several things I didn't notice that can be automated somehow. If you know about, email me! Please add a description of the possibilities and a sample script (but don't expect that I will understand it - I only speak Ruby fluently, a bit C and a bit sh ;-) )
+* Another interesting thing are the samples. There are many Linux distrubitions out there, and even many of them rely on X. I cannot test with another than a recent Ubuntu machine, but if you want to contribute and send samples for another OS, I want to encourage you to - I surely won't reject your work. :-)
+==License/Copyright
+  Copyright © 2009 Marvin Gülker
+  This library is free software; you may redistribute it and/or modify it 
+  under the terms of Ruby's license (see http://www.ruby-lang.org/en/LICENSE.txt). 
+  You can contact me at sutniuq ät gmx Dot net. 
+  Initia in potestate nostra sunt, de eventu fortuna iudicat. 

data/lib/xdo.rb

@@ -0,0 +1,28 @@
+#Encoding: UTF-8
+#This file is part of Xdo. 
+#Copyright © 2009 Marvin Gülker
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+
+#The namespace of this library. 
+module XDo
+  
+  #The command to start xdotool. 
+  XDOTOOL = "xdotool"
+  
+  #The command to start xsel. 
+  XSEL = "xsel"
+  
+  #The command to start xwininfo. 
+  XWININFO = "xwininfo"
+  
+  #The command to start xkill. 
+  XKILL = "xkill"
+  
+  #The command to start eject. 
+  EJECT = "eject"
+  
+  #Class for errors in this library. 
+  class XError < StandardError
+  end
+  
+end #module XDo

data/lib/xdo/clipboard.rb

@@ -0,0 +1,109 @@
+#Encoding: UTF-8
+require_relative("../xdo")
+
+module XDo
+  
+  #A module for interaction with the X clipboard. Please note, that the X clipboard 
+  #consists of three parts: The PRIMARY clipboard, the CLIPBOARD clipboard, and 
+  #the SECONDARY clipboard. The clipboard you access normally via [CTRL]+[C] 
+  #or by right-clicking and selecting "copy", is usually the CLIPBOARD clipboard (but that 
+  #depends on the application you use). The three main methods of this module (#read, #write 
+  #and #clear) take a hash with the symbols of the clipboards to interact with. If you don't want to 
+  #pass in the symbols, use the predefined read_xy, write_xy and clear_xy methods. They cannot 
+  #access more than one clipboard at a time. 
+  #The symbols for the clipboards are: 
+  #[PRIMARY] :primary
+  #[SECONDARY] :secondary
+  #[CLIPBOARD] :clipboard
+  module Clipboard
+    
+    class << self
+      
+      ##
+      # :singleton-method: read_primary
+      
+      ##
+      # :singleton-method: read_clipboard
+      
+      ##
+      # :singleton-method: read_secondary
+      
+      ##
+      # :singleton-method: write_primary
+      
+      ##
+      # :singleton-method: write_clipboard
+      
+      ##
+      # :singleton-method: write_secondary
+      
+      ##
+      # :singleton-method: clear_primary
+      
+      ##
+      # :singleton-method: clear_clipboard
+      
+      ##
+      # :singleton-method: clear_secondary
+      
+      [:primary, :clipboard, :secondary].each do |sym|
+        
+        define_method(:"read_#{sym}") do
+          read({sym => true})[sym]
+        end
+        
+        define_method(:"write_#{sym}") do |text|
+          write(text, {sym => true})
+          text
+        end
+        
+        define_method(:"clear_#{sym}") do
+          clear({sym => true})
+          nil
+        end
+        
+      end
+      
+      #Reads text from the X clipboard. The +from+ argument specifies 
+      #from what clipboard you want to read (in 70% of all cases you 
+      #want to read from :clipboard). Return value is a hash with the 
+      #clipboards you specified as the keys. The contents of the clipboards 
+      #are the values. You can also use one of the read_xy methods directly. 
+      def read(from = {:clipboard => true})
+        hsh = {}
+        hsh[:primary] = `#{XSEL}` if from[:primary]
+        hsh[:clipboard] = `#{XSEL} -b` if from[:clipboard]
+        hsh[:secondary] = `#{XSEL} -s` if from[:secondary]
+        hsh
+      end
+      
+      #Writes data to the X clipboard. The +to+ argument soecifies 
+      #the clipboard you want to write to. If you want to be able to paste 
+      #your text via [CTRL]+[v], use :clipboard. You can also use the 
+      #write_xy methods if you don't want to pass in the hash. 
+      def write(text, to = {:primary => true, :clipboard => true})
+        IO.popen("xsel -i", "w"){|io| io.write(text)} if to[:primary]
+        IO.popen("xsel -b -i", "w"){|io| io.write(text)} if to[:clipboard]
+        IO.popen("xsel -s -i", "w"){|io| io.write(text)} if to[:secondary]
+        text
+      end
+      
+      #Append data to text already written to the X clipboard. As in #write, 
+      #you can specify the clipboard you want to append text to. 
+      def append(text, to = {:primary => true, :clipboard => true})
+        IO.popen("xsel -a -i", "w"){|io| io.write(text)} if to[:primary]
+        IO.popen("xsel -b -a -i", "w"){|io| io.write(text)} if to[:clipboard]
+        IO.popen("xsel -s -a -i", "w"){|io| io.write(text)} if to[:secondary]
+      end
+      
+      #Clears the specified clipboards. 
+      def clear(clips = {:primary => true, :clipboard => true})
+        `#{XSEL} -c` if clips[:primary]
+        `#{XSEL} -b -c` if clips[:clipboard]
+        `#{XSEL} -s -c` if clips[:secondary]
+        nil
+      end
+      
+    end
+  end
+end

data/lib/xdo/drive.rb

@@ -0,0 +1,66 @@
+#Encoding: UTF-8
+require "open3"
+require_relative("../xdo")
+
+module XDo
+  
+  #Some methods to interact with CD (and DVD, of course) drives. 
+  #The value of the +drive+ parameter of many methods can be 
+  #either a mount point or a device file like scd0. 
+  #
+  #If you don't pass in a drive name, the returnvalue of #default will 
+  #be used. 
+  module Drive
+    
+    class << self
+      include Open3
+      #Opens a drive. 
+      def eject(drive = nil)
+        err = ""
+        drive = default unless drive
+        popen3("#{XDo::EJECT} #{drive}"){|stdin, stdout, stderr| err << stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        true
+      end
+      
+      #Closes a drive. 
+      def close(drive = nil)
+        drive = default unless drive
+        err = ""
+        popen3("eject -t #{drive}"){|stdin, stdout, stderr| err << stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+      end
+      
+      #Returns the mount point of the default drive. 
+      #You can use it as a value for a +drive+ parameter. 
+      def default
+        err = ""
+        out = ""
+        popen3("#{XDo::EJECT} -d"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        out.match(/`(.*)'/)[1]
+      end
+      
+      #Locks a drive, so that it can't be opened by 
+      #using the eject button. 
+      def lock(drive = nil)
+        drive = default unless drive
+        err = ""
+        popen3("#{XDo::EJECT} -i on #{drive}"){|stdin, stdout, stderr| err << stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        true
+      end
+      
+      #Unlocks a drive, so that it can be opened 
+      #by the eject button. 
+      def release(drive = nil)
+        drive = default unless drive
+        err = ""
+        popen3("#{XDo::EJECT} -i off #{drive}")
+        raise(XDo::XError,err) unless err.empty?
+        true
+      end
+      
+    end
+  end
+end