xdo 0.0.1-x86-linux

data/lib/xdo/xwindow.rb

@@ -0,0 +1,416 @@
+#Encoding: UTF-8
+#This file is part of Xdo. 
+#Copyright © 2009 Marvin Gülker
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+require "open3"
+require_relative("../xdo")
+module XDo
+  
+  #This class represents a window on the screen. Each window is uniquely identified by 
+  #an internal ID; before you can create a reference to a window (a XWindow object) you 
+  #have to obtain the internal ID of that window and pass it into XWindow.new. 
+  #Or you use the class methods of this class, notably XWindow.active_window. 
+  #
+  #Via the XWindow object you get you can manipulate a window in serveral ways, e.g. 
+  #you can move or resize it. Some methods are not available on every window 
+  #manager: XWindow.active_window, XWindow.desktop_num, XWindow.desktop_num=, XWindow.desktop, 
+  #XWindow.desktop=, XWindow.from_active, #raise, #activate, #desktop, #desktop=. 
+  #Some of them may be available, some not. On my machine (an Ubuntu Jaunty) for 
+  #example I can use active_window, desktop_num and #activate, but not #raise or #desktop=. 
+  #Those methods are tagged with the sentence "Part of the EWMH standard XY". Not all 
+  #parts of the EWMH standard are provided by every window manager. 
+  #
+  #Many methods accept a +name+ parameter; be aware that this name is not the whole 
+  #name of a window, but a pattern to match. So, if you pass in "edit", it will even match "gedit". 
+  #+xdotool+ handles that parameter with C style regexps. 
+  #
+  #The +opt+ parameter of many methods is a hash that can have the following keys: 
+  #  Key          | Effect if true
+  #  =============+====================================
+  #  :title       | Window titles are searched. 
+  #  -------------+------------------------------------
+  #  :name        | Window names are searched. 
+  #  -------------+------------------------------------
+  #  :class       | Window classes are searched. 
+  #  -------------+------------------------------------
+  #  :onlyvisible | Only visible windows are searched. 
+  #The default values for them depend on the method you want to use. See the method's 
+  #argument list to find out if a parameter is set to true or, if it isn't mentioned, to nil. 
+  #
+  #Be <i>very careful</i> with the methods that are part of the two desktop EWMH standards. 
+  #After I set the number of desktops and changed the current desktop, I had to reboot my 
+  #system to get the original configuration back. I don't know if I'm not using +xdotool+ correct, 
+  #but neither my library nor +xdotool+ itself could rescue my desktop settings. Btw, that's the 
+  #reason why it's not in XDo's unit tests (but it should work; at least in one way...). 
+  class XWindow
+    include Open3
+    #The internal ID of the window. 
+    attr_reader :id
+    
+    class << self
+      include Open3
+      #Checks if a window whose name matches +name+ exists. 
+      #Think about passing :onlyvisible in the +opt+ hash. 
+      def exists?(name, opts = {title: true, name: true, :class => true})
+        begin
+          !search(name, opts).empty?
+        rescue
+          false
+        end
+      end
+      
+      #Returns true if the given window ID exists, false otherwise. 
+      def id_exists?(id)
+        err = ""
+        popen3("#{XDo::XWININFO} -id #{id}"){|stdin, stdout, stderr| err << stderr.read}
+        return false unless err.empty?
+        return true
+      end
+      
+      #Waits for a window name to exist and returns the ID of that window. 
+      #Returns immediately if the window does already exist. 
+      def wait_for_window(name, opts = {title: true, name: true, :class => true, :onlyvisible => true})
+        loop{break if exists?(name, opts);sleep(0.5)}
+        sleep 1 #To ensure it's really there
+        search(name, opts).first
+      end
+      
+      #Waits for a window to close. If the window does not exists when calling +wait_for_close+, 
+      #the method returns immediately. 
+      def wait_for_close(name, opts = {title: true, name: true, :class => true, :onlyvisible => true})
+        loop{break if !exists?(name, opts);sleep(0.5)}
+        nil
+      end
+      
+      #Search for a window name to get the internal ID of a window. 
+      #Return value is an array containing all found IDs or an 
+      #empty array if none is found. 
+      def search(name, opts = {title: true, name: true, :class => true})
+        cmd = "#{XDo::XDOTOOL} search "
+        opts.each_pair{|key, value| cmd << "--#{key} " if value}
+        cmd << '"' << name << '"'
+        #Error wird nicht behandelt, weil im Fehlerfall einfach nur ein leeres Array zurückkommen soll
+        out = `#{cmd}`
+        out.lines.to_a.collect{|l| l.strip.to_i}
+      end
+      
+      #Returns the internal ID of the currently focused window. 
+      #If the +notice_childs+ parameter is true, also childwindows 
+      #are noticed. This method may find an invisible window, see 
+      #active_window for a more reliable method. 
+      def focused_window(notice_childs = false)
+        err = ""
+        out = ""
+        popen3("#{XDo::XDOTOOL} getwindowfocus #{notice_childs ? "-f" : ""}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        return out.to_i
+      end
+      
+      #Returns the internal ID of the currently focused window. 
+      #This method is more reliable than focused_window. 
+      #Part of the EWMH standard ACTIVE_WINDOW. 
+      def active_window
+        err = ""
+        out = ""
+        popen3("#{XDo::XDOTOOL} getactivewindow"){|stdin, stdout, stderr| out = stdout.read; err = stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        return Integer(out)
+      end
+      
+      #Set the number of working desktops. 
+      #Part of the EWMH standard WM_DESKTOP. 
+      def desktop_num=(num)
+        err = ""
+        popen3("#{XDo::XDOTOOL} set_num_desktops #{num}"){|stdin, stdout, stderr| err << stderr.read}
+        raise(XDo::Error, err) unless err.empty?
+        num
+      end
+      
+      #Get the number of working desktops. 
+      #Part of the EWMH standard WM_DESKTOP. 
+      def desktop_num
+        err = ""
+        out = ""
+        popen3("#{XDo::XDOTOOL} get_num_desktops"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        Integer(out)
+      end
+      
+      #Change the view to desktop +num+. 
+      #Part of the EWMH standard CURRENT_DESKTOP. 
+      def desktop=(num)
+        err = ""
+        popen3("#{XDo::XDOTOOL} set_desktop #{num}"){|stdin, stdout, stderr| err << stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        num
+      end
+      
+      #Output the number of the active desktop. 
+      #Part of the EWMH standard CURRENT_DESKTOP. 
+      def desktop
+        err = ""
+        out = ""
+        popen3("#{XDo::XDOTOOL} get_desktop"){|stdin, stdout, stderr| out = stdout.read; err = stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        Integer(out)
+      end
+      
+      #Creates a XWindow by calling search with the given parameters. 
+      #The window is created from the first ID found. 
+      def from_name(name, opts = {title: true, name: true, :class => true})
+        ids = search(name, opts)
+        raise(XDo::XError, "The window '#{name}' wasn't found!") if ids.empty?
+        new(ids.first)
+      end
+      
+      #Creates a XWindow by calling focused_window with the given parameter. 
+      def from_focused(notice_childs = false)
+        new(focused_window(notice_childs))
+      end
+      
+      #Creates a XWindow by calling active_window. 
+      def from_active
+        new(active_window)
+      end
+      
+      #Set this to the name of your desktop window. 
+      def desktop_name=(name)
+        @desktop_name = name
+      end
+      
+      #Name of the desktop window. Default is "x-nautilus-desktop". 
+      def desktop_name
+        @desktop_name ||= "x-nautilus-desktop"
+      end
+      
+      #Activate the desktop
+      def focus_desktop
+        desktop = from_name(desktop_name)
+        desktop.focus
+        desktop.activate
+      end
+      alias activate_desktop focus_desktop
+      
+      #Minimize all windows (or restore, if already) by sending [CTRL]+[ALT]+[D]. 
+      #Available after requireing  "xdo/keyboard". 
+      def toggle_minimize_all
+        raise(NotImplementedError, "You have to require 'xdo/keyboard' before you can use #{__method__}!") unless defined? XDo::Keyboard
+        XDo::Keyboard.ctrl_alt_d
+      end
+      
+      #Minimizes the active window. There's no way to restore a specific minimized window. 
+      #Available after requireing "xdo/keyboard". 
+      def minimize
+        raise(NotImplementedError, "You have to require 'xdo/keyboard' before you can use #{__method__}!") unless defined? XDo::Keyboard
+        XDo::Keyboard.key("Alt+F9")
+      end
+      
+      #Maximize or normalize the active window if already maximized. 
+      #Available after requireing "xdo/keyboard". 
+      def toggle_maximize
+        raise(NotImplementedError, "You have to require 'xdo/keyboard' before you can use #{__method__}!") unless defined? XDo::Keyboard
+        XDo::Keyboard.key("Alt+F10")
+      end
+      
+    end
+    
+    #Creates a new XWindow object from an internal ID. See the XWindow class methods. 
+    def initialize(id)
+      @id = id.to_i
+    end
+    
+    #Human-readable output of form
+    #  <XDo::XWindow: "title" (window_id)>
+    def inspect
+      %Q|<XDo::XWindow: "#{title}" (#{id})>|
+    end
+    
+    #Set the size of a window. This has no effect on maximized winwows. 
+    def resize(width, height, use_hints = false)
+      err = ""
+      cmd = "#{XDo::XDOTOOL} windowsize #{use_hints ? "--usehints " : ""}#{@id} #{width} #{height}"
+      popen3("#{cmd}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Moves a window. +xdotool+ is not really exact with the coordinates, 
+    #the window will be within a range of +-10 pixels. 
+    def move(x, y)
+      err = ""
+      popen3("#{XDo::XDOTOOL} windowmove #{@id} #{x} #{y}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Set the input focus to the window (but don't bring it to the front). 
+    def focus
+      err = ""
+      popen3("#{XDo::XDOTOOL} windowfocus #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #The window loses the input focus by setting it to the desktop. 
+    def unfocus
+      XDo::XWindow.focus_desktop
+    end
+    
+    #Map a window to the screen (make it visible). 
+    def map
+      err = ""
+      popen3("#{XDo::XDOTOOL} windowmap #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Unmap a window from the screen (make it invisible). 
+    def unmap
+      err = ""
+      popen3("#{XDo::XDOTOOL} windowunmap #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Bring a window to the front (but don't give it the input focus). 
+    #Not implemented in all window managers. 
+    def raise
+      err = ""
+      popen3("#{XDo::XDOTOOL} windowraise #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Activate a window. That is, bring it to top and give it the input focus. 
+    #Part of the EWMH standard ACTIVE_WINDOW. 
+    def activate
+      err = ""
+      popen3("#{XDo::XDOTOOL} windowactivate #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Move a window to a desktop. 
+    #Part of the EWMH standard CURRENT_DESKTOP. 
+    def desktop=(num)
+      err = ""
+      popen3("#{XDo::XDOTOOL} set_desktop_for_window #{@id} #{num}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Get the desktop the window is on. 
+    #Part of the EWMH standard CURRENT_DESKTOP. 
+    def desktop
+      err = ""
+      out = ""
+      popen3("#{XDo::XDOTOOL} get_desktop_for_window #{@id}"){|stdin, stdout, stderr| out = stdout.read; err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      Integer(out)
+    end
+    
+    #The title of the window or nil if it doesn't have a title. 
+    def title
+      err = ""
+      out = ""
+      popen3("#{XDo::XWININFO} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      title = out.strip.lines.to_a[0].match(/"(.*)"/)[1] rescue Kernel.raise(XDo::XError, "No window with ID #{@id} found!")
+      return title #Kann auch nil sein, dann ist das Fenster namenlos. 
+    end
+    
+    #The absolute position of the window on the screen. 
+    def abs_position
+      out = ""
+      err = ""
+      popen3("#{XDo::XWININFO} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      out = out.strip.lines.to_a
+      x = out[2].match(/:\s+(\d+)/)[1]
+      y = out[3].match(/:\s+(\d+)/)[1]
+      [x.to_i, y.to_i]
+    end
+    alias position abs_position
+    
+    #The position of the window relative to it's parent window. 
+    def rel_position
+      out = ""
+      err = ""
+      popen3("#{XDo::XWININFO} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      out = out.strip.lines.to_a
+      x = out[4].match(/:\s+(\d+)/)[1]
+      y = out[5].match(/:\s+(\d+)/)[1]
+      [x.to_i, y.to_i]
+    end
+    
+    #The size of the window. 
+    def size
+      out = ""
+      err = ""
+      popen3("#{XDo::XWININFO} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      out = out.strip.lines.to_a
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      width = out[6].match(/:\s+(\d+)/)[1]
+      height = out[7].match(/:\s+(\d+)/)[1]
+      [width.to_i, height.to_i]
+    end
+    
+    #true if the window is mapped to the screen. 
+    def visible?
+      err = ""
+      out = ""
+      popen3("#{XDo::XWININFO} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      out = out.strip.lines.to_a
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      return out[17].match(/:\s+(\w+)/)[1] == "IsViewable" ? true : false
+    end
+    
+    #Returns true if the window exists. 
+    def exists?
+      XDo::XWindow.exists?(@id)
+    end
+    
+    #Closes a window by activating it and then sending [ALT] + [F4]. 
+    #A program could ask to save data. 
+    #Use #kill! to kill the process running the window. 
+    #Available after requireing "xdo/keyboard"
+    def close
+      raise(NotImplementedError, "You have to require 'xdo/keyboard' before you can use #{__method__}!") unless defined? XDo::Keyboard
+      activate
+      sleep 0.5
+      XDo::Keyboard.char("Alt+F4")
+      sleep 0.5
+      nil
+    end
+    
+    #More aggressive variant of #close. Think of +close!+ as 
+    #the middle between #close and #kill!. It first tries 
+    #to close the window by calling #close and if that 
+    #does not succeed (within +timeout+ seconds), it will call #kill!. 
+    #Available after requireing "xdo/keyboard". 
+    def close!(timeout = 2)
+      raise(NotImplementedError, "You have to require 'xdo/keyboard' before you can use #{__method__}!") unless defined? XDo::Keyboard
+      #Try to close normally
+      close
+      #Check if it's deleted
+      if exists?
+        #If not, wait some seconds and then check again
+        sleep timeout
+        if exists?
+          #If it's not deleted after some time, force it to close. 
+          kill!
+        else
+          return
+        end
+      else
+        return
+      end
+    end
+    
+    #Kills the process that runs a window. The window will be 
+    #terminated immediatly, if that isn't what you want, have 
+    #a look at #close. 
+    def kill!
+      out = ""
+      err = ""
+      popen3("#{XDo::XKILL} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      nil
+    end
+    
+  end
+  
+end

data/samples/full_demo.rb

@@ -0,0 +1,189 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+#--
+#This file is part of XDo. Copyright © 2009 by Marvin Gülker. 
+#XDo is published under Ruby's license. See http://www.ruby-lang.org/en/LICENSE.txt
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+#++
+
+=begin
+This is the full XDo demo. We will create a 
+command-line program that will be able to open 
+and close the default CD drive, open gedit and 
+type some text in tabular form and click the 
+"show desktop" button in the lower-left corner of 
+the Ubuntu desktop. Even if you don't use Ubuntu, 
+you may get the logic and find this demo useful. 
+
+Every OS and even every computer are different in their 
+user interface. If you'd like to add sample files for a 
+specific OS, feel free to contact me at sutniuq ät gmx Dot net. 
+=end
+
+#First, require all Xdo files. 
+require "xdo/clipboard"
+require "xdo/drive"
+require "xdo/keyboard"
+require "xdo/mouse"
+require "xdo/xwindow"
+
+class XXX
+  
+  def keyboard
+    #Make sure gedit is not running, since it would open 
+    #a new tab and not a new window if invoked again. 
+    raise(RuntimeError, "gedit is already running; please close it before using.") unless XDo::XWindow.search("gedit").empty?
+    #If we would use system in the main program to open 
+    #gedit, it would hang until gedit is closed. That's why 
+    #we run it in a separate process. 
+    fork{system("gedit")}
+    #Now we wait until gedit has made up its GUI. 
+    #wait_for_window returns the ID of the found window, so 
+    #we catch it and...
+    id = XDo::XWindow.wait_for_window("gedit")
+    #...use it to create a new reference to gedit's window. 
+    #Note that this is a pseudo reference, not a real one. 
+    #XDo allows you to create references even to unexisting 
+    #windows, so the X window manager will not recognize 
+    #the pseudo reference. You can check if the window 
+    #you're looking for exists by calling #exists? on the 
+    #XWindow object. 
+    xwin = XDo::XWindow.new(id)
+    #Now we move it 20 pixels right and 10 down. 
+    xwin.move(xwin.position[0] + 20, xwin.position[1] + 10)
+    #After having fun with it, let's do something useful. 
+    #XDo::Keyboard.simulate fakes keystrokes and recognizes 
+    #special escape sequences in braces { and }. For some 
+    #special characters like tab you can use an ASCII escape 
+    #like \t. The most special keys like [ESC] don't have 
+    #those a shortcut, so you will have to write {ESC} in 
+    #order to send them. 
+    XDo::Keyboard.simulate("This will be some test text.")
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.delete #This will send a BackSpace keypress. If you want a DEL, pass in true as a parameter. 
+    #I promised at the beginning, we were goint to create data in tabular form, 
+    #so here it is: 
+    XDo::Keyboard.type("Percentage of smokers in different jobs in Germany".upcase) #type is usually faster than simulate if the text doesn't contain special characters or escape sequences
+    2.times{XDo::Keyboard.return} #Return is the Enter key
+    #Set up the data
+    headings = ["Job", "Percentage"]
+    data = [
+      ["Judge", 28], 
+      ["Architect", 29], 
+      ["Doctor", 30], 
+      ["Nurse", 45], 
+      ["Teacher", 53]
+    ]
+    #Create the table headings
+    str =""
+    headings[0..-2].each{|h| str << h << "{TAB}{TAB}"}
+    str << headings[-1] << "\n"#No tab after the last heading
+    #Type the heading
+    XDo::Keyboard.simulate(str)
+    #Make a line between the heading and the data
+    XDo::Keyboard.type("=" * 30)
+    XDo::Keyboard.return
+    #Write the table data
+    data.each do |job, percentage|
+      #Insert tabs. If a word is longer than 8 (the normal tab size), don't append a second tab. 
+      XDo::Keyboard.simulate("#{job}#{job.length > 8 ? "\t" : "\t\t"}#{percentage}\n") #\t will trigger the Tab key, \n the Return key. 
+    end
+    #Oh yes, and save it of course. XDo::Keyboard tries to 
+    #send every method name as a key combination if the 
+    #method is not defined already. The method name 
+    #will be capitalized and every underscore _ replaced 
+    #by a + (that's internally important to combine keys). 
+    File.delete("#{ENV["HOME"]}/testXDo.txt") if File.file? "#{ENV["HOME"]}/testXDo.txt" #This is the file we'll save to
+    XDo::Keyboard.ctrl_s
+    #Wait for the save window to exist. I can't use wait_for_window here, since 
+    #it's named different in every language. Me as a German user have a title 
+    #of "Speichern unter...", an english OS may show "Save as...". 
+    sleep 1
+    #You really shouldn't try to simulate the ~ sign. xdotool seems to have a bug, so 
+    #~ can't be simulated with one command. My library tries to simulate it with one 
+    #command and it sometimes works, but you mustn't rely on it. Therefore I use 
+    #the HOME environment variable here to get the home directory, rather than ~. 
+    XDo::Keyboard.simulate("#{ENV["HOME"]}/testXDo.txt")
+    sleep 1 #gedit terminates if send [ALT]+[A] immediatly after the path
+    XDo::Keyboard.alt_s
+    #Now, let's duplicate our table. We could send all the stuff again, 
+    #but I want to introduce you in the use of the X clipboard. 
+    #First, we have to mark our text in order to be copied to the clipboard: 
+    xwin.activate #After saving the window isn't active anymore
+    sleep 1 #Wait for the gedit window to be active again
+    XDo::Keyboard.ctrl_a
+    #Then copy it to the clipboard (you see, it's quite useful to know keyboard shortcuts)
+    XDo::Keyboard.ctrl_c
+    #gedit copies, like the most programs, it's data to the CLIPBOARD clipboard. 
+    #There are two other clipboard, PRIMARY and SECONDARY, but we won't 
+    #diskuss them here. If you are sure you've copied data to the clipboard and 
+    ##read_clipboard doesn't find anything, check out #read_primary and #read_secondary. 
+    #Also note, that XDo can only handle plain text data. 
+    cliptext = XDo::Clipboard.read_clipboard
+    #Move to the end of the text
+    XDo::Keyboard.simulate("{DOWN}" * 9)
+    XDo::Keyboard.simulate("{END}")
+    #Since #simulate interprets \t correctly as a tab, we can simply put 
+    #the clipboard's text in that method: 
+    XDo::Keyboard.simulate("\n#{cliptext}") #Begin a new line before inserting the duplicate
+    sleep 1
+    XDo::Keyboard.ctrl_s
+    #Give some time to see the result
+    sleep 5
+    #Than close gedit. There are three methods to close a window, 
+    ##close, #close! and #kill!. #close is like sending an [ALT]+[F4] keypress which may result in 
+    #a dialog box asking you for confimation. #close! is a bit stronger. First it calls #close and waits 
+    #a few seconds (you can specify how long exactly) then shuts down the window process. What 
+    #leads us to the third method: #kill!. Be sure to call #kill! only on windows you know - 
+    #it kills the process of a window by sending SIGTERM first and then SIGKILL. I've not tried 
+    #what happens if you send this to the desktop window, but if you like to...
+    xwin.close #We use the normal #close here since we saved our data and gedit shouldn't complain. 
+  end
+  
+  def mouse
+    #Assuming that the first entry of your right-click menu is "Create folder", 
+    #you can create new folders on your desktop. 
+    XDo::XWindow.toggle_minimize_all
+    sleep 2
+    
+    #Mouse.click is the method for executing mouse clicks. If you call it 
+    #without any arguments, it will execute a left click on the current cursor position. 
+    XDo::Mouse.click(400, 400, XDo::Mouse::RIGHT)
+    sleep 1 #Give the menu time to appear
+    XDo::Mouse.click
+    sleep 1 #Wait for the folder to be created
+    #Give it a name
+    XDo::Keyboard.simulate("A test folder\n") # Return to confirm
+    sleep 1 #Wait to accept the name
+    #Move the folder icon a bit upwards
+    XDo::Mouse.drag(nil, nil, 400, 200)
+    sleep 2
+    XDo::XWindow.toggle_minimize_all #Restore all windows
+  end
+  
+end
+
+USAGE =<<USAGE
+USAGE: 
+./full_demo.rb [methodname]
+
+Executes the full_demo XDo demo file. You can optionally provide a method 
+name, if you don't, both methods will be run. 
+USAGE
+
+if ARGV.include?("-h") or ARGV.include?("--help")
+  puts USAGE
+end
+
+xxx = XXX.new
+if ARGV.empty?
+  xxx.keyboard
+  sleep 3
+  xxx.mouse
+elsif ARGV[0] == "mouse"
+  xxx.mouse
+elsif ARGV[0] == "keyboard"
+  xxx.keyboard
+else
+  puts USAGE
+end