cyberweb 0.4.174

data/lib/cyberweb/javascript_code/rgb_to_hex.js

@@ -0,0 +1,14 @@
+function rgb_to_hex(r,g,b) {
+  r = r.toString(16);
+  g = g.toString(16);
+  b = b.toString(16);
+
+  if (r.length == 1)
+    r = "0" + r;
+  if (g.length == 1)
+    g = "0" + g;
+  if (b.length == 1)
+    b = "0" + b;
+
+  return "#" + r + g + b;
+}

data/lib/cyberweb/javascript_code/select_even_numbers.js

@@ -0,0 +1,7 @@
+/*
+ * This function will return all even numbers of the
+ * given input-Array.
+ */
+function select_even_numbers(i) {
+  i.filter( x => x % 2 === 0 );
+}

data/lib/cyberweb/javascript_code/select_everything.js

@@ -0,0 +1,22 @@
+/*
+ * Use this function when you want to select all. You must pass
+ * the id of the element to the function.
+ *
+ * To use this, try:
+ *
+ *    <textarea rows="3" id="txtarea" onClick="select_everything('txtarea');" style="width:200px" >
+ *    This text you can select all by clicking here.
+ *    </textarea>
+ *
+ * Input TextBox:
+ *
+ *  <input type="text" id="txtfld" onClick="select_everything('txtfld');" style="width:200px" value = "This text you can select all" />
+ *
+ */
+
+function select_everything(id)
+{
+  var element = document.getElementById(id);
+  element.focus();
+  element.select();
+}

data/lib/cyberweb/javascript_code/simple_calculator.js

@@ -0,0 +1,15 @@
+/*
+ * The code in this file can be used for a simple javascript-calculator.
+ */
+
+function updateTextbox(value){
+  document.getElementById("screen").value += value;
+}
+
+function result(){
+  document.getElementById("screen").value = eval(document.getElementById("screen").value);
+}
+
+function reset(){
+  document.getElementById("screen").value = '';
+}

data/lib/cyberweb/javascript_code/sleep.js

@@ -0,0 +1,3 @@
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

data/lib/cyberweb/javascript_code/to_celsius.js

@@ -0,0 +1,8 @@
+/*
+ * to_celsius
+ *
+ * Convert into n Celsius, from the given input (as Fahrenheit).
+ */
+function to_celsius(fahrenheit) {
+  return (5/9) * (fahrenheit-32);
+}

data/lib/cyberweb/mouse/README.md

@@ -0,0 +1,3 @@
+People who visit a website, may have to use the mouse to interact
+with the website. Code that is stored here within mouse/ may be
+used to automate testing via mouse-interfaces.

data/lib/cyberweb/mouse/libxdo.rb

@@ -0,0 +1,321 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+if false # Disabled for the time being.
+
+begin
+  require 'ffi' # Note that sometimes ffi can cause problems.
+rescue LoadError; end
+
+module Cyberweb
+
+module Libxdo # === Cyberweb::Libxdo
+
+  begin
+    extend FFI::Library
+  rescue LoadError; end # Must rescue this error because sometimes it may cause problems.
+
+  # ========================================================================= #
+  # === CURRENT_WINDOW
+  # ========================================================================= #
+  CURRENT_WINDOW = 0
+    
+  ffi_lib 'xdo'
+
+  # ========================================================================= #
+  # xdo_t * xdo_new (char *display)
+  # ========================================================================= #
+  attach_function 'xdo_new', [ :string ], :pointer
+
+  # ========================================================================= #
+  # xdo_t * xdo_new_with_opened_display (Display *xdpy, const char *display, int close_display_when_freed)
+  #
+  # URL: http://www.semicomplete.com/files/xdotool/docs/html/xdo_8h.html#a6626d106a5b4a19600f31b8b28b1c51b
+  # ========================================================================= #
+  attach_function 'xdo_new_with_opened_display', [:pointer, :string, :int], :pointer
+
+  # ========================================================================= #
+  # const char * xdo_version (void)
+  # ========================================================================= #
+  attach_function 'xdo_version', [], :string
+
+  # ========================================================================= #
+  # void xdo_free (xdo_t *xdo)
+  # ========================================================================= #
+  attach_function 'xdo_free', [:pointer], :void
+
+  # ========================================================================= #
+  # int xdo_mousemove (const xdo_t *xdo, int x, int y, int screen)
+  # ========================================================================= #
+  attach_function 'xdo_mousemove', [:pointer, :int, :int, :int], :int
+
+  # ========================================================================= #
+  # int xdo_mousemove_relative_to_window (const xdo_t *xdo, Window window, int x, int y)
+  # XXX: Window is not a pointer - find the typedef
+  # ========================================================================= #
+  attach_function 'xdo_mousemove_relative_to_window', [:pointer, :pointer, :int, :int], :int
+    
+  # ========================================================================= #
+  # int xdo_mousemove_relative (const xdo_t *xdo, int x, int y)
+  # ========================================================================= #
+  attach_function 'xdo_mousemove_relative', [:pointer, :int, :int], :int
+
+  # ========================================================================= #
+  # int xdo_mousedown (const xdo_t *xdo, Window window, int button)
+  # ========================================================================= #
+  attach_function 'xdo_mousedown', [:pointer, :int, :int], :int
+
+  # ========================================================================= #
+  # int xdo_mouseup (const xdo_t *xdo, Window window, int button)
+  # ========================================================================= #
+  attach_function 'xdo_mouseup', [:pointer, :int, :int], :int
+
+  # ========================================================================= #
+  # int xdo_mouselocation (const xdo_t *xdo, int *x, int *y, int *screen_num)
+  # ========================================================================= #
+  attach_function 'xdo_mouselocation', [:pointer, :pointer, :pointer, :pointer], :int
+
+  # ========================================================================= #
+  # int xdo_mouse_wait_for_move_from (const xdo_t *xdo, int origin_x, int origin_y)
+  # ========================================================================= #
+  attach_function 'xdo_mouse_wait_for_move_from', [:pointer, :int, :int], :int
+
+  # ========================================================================= #
+  # int xdo_mouse_wait_for_move_to (const xdo_t *xdo, int dest_x, int dest_y)
+  # ========================================================================= #
+  attach_function 'xdo_mouse_wait_for_move_to', [:pointer, :int, :int], :int
+
+  # ========================================================================= #
+  # int xdo_click (const xdo_t *xdo, Window window, int button)
+  # ========================================================================= #
+  attach_function 'xdo_click', [:pointer, :int, :int], :int
+
+  # ========================================================================= #
+  # int xdo_type (const xdo_t *xdo, Window window, char *string, useconds_t delay)
+  # XXX: Map useconds_t
+  # ========================================================================= #
+  attach_function 'xdo_type', [:pointer, :int, :string, :int], :int
+
+  # ========================================================================= #
+  # int xdo_keysequence (const xdo_t *xdo, Window window, const char *keysequence, useconds_t delay)
+  # XXX: Window != pointer
+  # XXX: Map useconds_t
+  # ========================================================================= #
+  attach_function 'xdo_keysequence', [:pointer, :pointer, :string, :int], :int
+
+  # ========================================================================= #
+  # int xdo_keysequence_up (const xdo_t *xdo, Window window, const char *keysequence, useconds_t delay)
+  # XXX: Window != pointer
+  # XXX: Map useconds_t
+  # ========================================================================= #
+  attach_function 'xdo_keysequence_up', [:pointer, :pointer, :string, :int], :int
+
+  # ========================================================================= #
+  # int xdo_keysequence_down (const xdo_t *xdo, Window window, const char *keysequence, useconds_t delay)
+  # XXX: Window != pointer
+  # XXX: Map useconds_t
+  # ========================================================================= #
+  attach_function 'xdo_keysequence_down', [:pointer, :pointer, :string, :int], :int
+
+  # ========================================================================= #
+  # int xdo_keysequence_list_do (const xdo_t *xdo, Window window, charcodemap_t *keys, int nkeys, int pressed, int *modifier, useconds_t delay)
+  # XXX: Window != pointer
+  # XXX: What's a charcodemap_t?
+  # XXX: Map useconds_t
+  # ========================================================================= #
+  attach_function 'xdo_keysequence_list_do', [:pointer, :pointer, :pointer, :int, :int, :pointer, :int], :int
+
+  # ========================================================================= #
+  # int xdo_active_keys_to_keycode_list (const xdo_t *xdo, charcodemap_t **keys, int *nkeys)
+  # XXX: Map useconds_t
+  # XXX: What's a pointer to pointer to charcodemap_t?
+  # ========================================================================= #
+  attach_function 'xdo_active_keys_to_keycode_list', [:pointer, :pointer, :pointer], :int
+
+  # ========================================================================= #
+  # int xdo_window_wait_for_map_state (const xdo_t *xdo, Window wid, int map_state)
+  # XXX: Window != pointer
+  # ========================================================================= #
+  attach_function 'xdo_window_wait_for_map_state', [:pointer, :pointer, :int], :int
+
+  # ========================================================================= #
+  # int xdo_window_move (const xdo_t *xdo, Window wid, int x, int y)
+  # XXX: Window != pointer
+  # ========================================================================= #
+  attach_function 'xdo_window_move', [:pointer, :pointer, :int, :int], :int
+
+  # ========================================================================= #
+  # int xdo_window_setsize (const xdo_t *xdo, Window wid, int w, int h, int flags)
+  # XXX: Window != pointer
+  # ========================================================================= #
+  attach_function 'xdo_window_setsize', [:pointer, :pointer, :int, :int, :int], :int
+
+  # ========================================================================= #
+  # int xdo_window_setprop (const xdo_t *xdo, Window wid, const char *property, const char *value)
+  # XXX: Window != pointer
+  # ========================================================================= #
+  attach_function 'xdo_window_setprop', [:pointer, :pointer, :string, :string], :int
+
+  # int xdo_window_setclass (const xdo_t *xdo, Window wid, const char *name, const char *class)
+  # XXX: Window != pointer
+  attach_function 'xdo_window_setclass', [:pointer, :pointer, :string, :string], :int
+
+  # int xdo_window_focus (const xdo_t *xdo, Window wid)
+  # XXX: Window != pointer
+  attach_function 'xdo_window_focus', [:pointer, :pointer], :int
+
+  # int xdo_window_raise (const xdo_t *xdo, Window wid)
+  # XXX: Window != pointer
+  attach_function 'xdo_window_raise', [:pointer, :pointer], :int
+
+  # ========================================================================= #
+  # int xdo_window_get_focus (const xdo_t *xdo, Window *window_ret)
+  # NOTE: This window is actually a pointer.  Watch out
+  # ========================================================================= #
+  attach_function 'xdo_window_get_focus', [:pointer, :pointer], :int
+
+  # int xdo_window_wait_for_focus (const xdo_t *xdo, Window window, int want_focus)
+  # XXX: Window != pointer
+  attach_function 'xdo_window_wait_for_focus', [:pointer, :pointer, :int], :int
+
+  # int xdo_window_get_pid (const xdo_t *xdo, Window window)
+  # XXX: Window != pointer
+  attach_function 'xdo_window_get_pid', [:pointer, :pointer], :int
+
+  # int xdo_window_sane_get_focus (const xdo_t *xdo, Window *window_ret)
+  # NOTE: This window is actually a pointer.  Watch out
+  attach_function 'xdo_window_sane_get_focus', [:pointer, :pointer], :int
+
+  # int xdo_window_activate (const xdo_t *xdo, Window wid)
+  # XXX: Window != pointer
+  attach_function 'xdo_window_activate', [:pointer, :pointer], :int
+
+  # int xdo_window_wait_for_active (const xdo_t *xdo, Window window, int active)
+  # XXX: Window != pointer
+  attach_function 'xdo_window_wait_for_active', [:pointer, :pointer, :int], :int
+
+  # int xdo_window_map (const xdo_t *xdo, Window wid)
+  # XXX: Window != pointer
+  attach_function 'xdo_window_map', [:pointer, :pointer], :int
+
+  # int xdo_window_unmap (const xdo_t *xdo, Window wid)
+  attach_function 'xdo_window_unmap', [:pointer, :pointer], :int
+
+  # int xdo_get_window_location (const xdo_t *xdo, Window wid, int *x_ret, int *y_ret, Screen **screen_ret)
+  # XXX: Window != pointer
+  # XXX: What's a screen double pointer
+  attach_function 'xdo_get_window_location', [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+
+  # int xdo_get_window_size (const xdo_t *xdo, Window wid, unsigned int *width_ret, unsigned int *height_ret)
+  # XXX: Window != pointer
+  attach_function 'xdo_get_window_size', [:pointer, :pointer, :pointer, :pointer], :int
+
+  # int xdo_window_get_active (const xdo_t *xdo, Window *window_ret)
+  # NOTE: This window is actually a pointer.  Watch out
+  attach_function 'xdo_window_get_active', [:pointer, :pointer], :int
+
+  # int xdo_set_number_of_desktops (const xdo_t *xdo, long ndesktops)
+  attach_function 'xdo_set_number_of_desktops', [:pointer, :long], :int
+
+  # int xdo_get_number_of_desktops (const xdo_t *xdo, long *ndesktops)
+  attach_function 'xdo_get_number_of_desktops', [:pointer, :pointer], :int
+
+  # int xdo_set_current_desktop (const xdo_t *xdo, long desktop)
+  attach_function 'xdo_set_current_desktop', [:pointer, :long], :int
+
+  # int xdo_get_current_desktop (const xdo_t *xdo, long *desktop)
+  attach_function 'xdo_get_current_desktop', [:pointer, :pointer], :int
+
+  # int xdo_set_desktop_for_window (const xdo_t *xdo, Window wid, long desktop)
+  # XXX: Window != pointer
+  attach_function 'xdo_set_desktop_for_window', [:pointer, :pointer, :long], :int
+
+  # int xdo_get_desktop_for_window (const xdo_t *xdo, Window wid, long *desktop)
+  # XXX: Window != pointer
+  attach_function 'xdo_get_desktop_for_window', [:pointer, :pointer, :pointer], :int
+
+  # int xdo_window_search (const xdo_t *xdo, const xdo_search_t *search, Window **windowlist_ret, int *nwindows_ret)
+  # XXX: xdo_search_t?  How do I make that.
+  attach_function 'xdo_window_search', [:pointer, :pointer, :pointer, :pointer], :int
+
+  # unsigned char * xdo_getwinprop (const xdo_t *xdo, Window window, Atom atom, long *nitems, Atom *type, int *size)
+  # XXX: Window != pointer
+  # XXX: Atom != pointer
+  # XXX: Unsigned char * != :string?
+  attach_function 'xdo_getwinprop', [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :string
+
+  # unsigned int xdo_get_input_state (const xdo_t *xdo)
+  attach_function 'xdo_get_input_state', [:pointer], :uint
+
+  # const keysym_charmap_t * xdo_keysym_charmap (void)
+  attach_function 'xdo_keysym_charmap', [], :pointer
+
+  # XXX: char** is an array of strings?
+  # const char ** xdo_symbol_map (void)
+  attach_function 'xdo_symbol_map', [], :string
+
+  # xdo_active_mods_t * xdo_get_active_modifiers (const xdo_t *xdo)
+  attach_function 'xdo_get_active_modifiers', [:pointer], :pointer
+
+  # int xdo_clear_active_modifiers (const xdo_t *xdo, Window window, xdo_active_mods_t *active_mods)
+  attach_function 'xdo_clear_active_modifiers', [:pointer, :pointer, :pointer], :int
+
+  # int xdo_set_active_modifiers (const xdo_t *xdo, Window window, const xdo_active_mods_t *active_mods)
+  # XXX: Window != pointer
+  attach_function 'xdo_set_active_modifiers', [], :int
+
+  # void xdo_free_active_modifiers (xdo_active_mods_t *active_mods)
+  attach_function 'xdo_free_active_modifiers', [:pointer], :void
+
+  class Xdo < FFI::Struct
+ 	  # The Display for Xlib. 
+    # Display * xdpy
+    layout :xdpy,                     :pointer, # Display * xdpy
+           :display_name,             :string,  # The display name.
+           :charcodes,                :pointer, # charcodemap_t * charcodes
+           :charcodes_len,            :int, 
+           :modmap,                   :pointer, # XModifierKeymap * modmap
+           :keymap,                   :pointer, # KeySym * keymap
+           :keycode_high,             :int, 
+           :keycode_low,              :int, 
+           :keysyms_per_keycode,      :int, 
+           :close_display_when_freed, :int  # Should we close the display when calling xdo_free?
+  end
+
+  class KeysymCharmap < FFI::Struct
+    layout :keysym ,:string, 
+           :key    ,:char
+  end
+
+  # XXX: Is the native documentation off by a field?  Feels like it.
+  # class Charcodemap < FFI::Struct
+  #   # XXX: keycode isn't a type
+  #   layout :code          ,:KeyCode, # the letter for this key, like 'a'
+  #          :symbol        ,:KeySym,  # the keycode that this key is on
+  #          :index         ,:int,     # the symbol representing this key
+  #          :modmask       ,:int,     # the index in the keysym-per-keycode list that is this key
+  #          :needs_binding ,:int      # the modifiers activated by this key
+  # end
+  class XdoActiveMods < FFI::Struct
+    layout :keymods, :pointer,  # charcodemap_t * keymods
+           :nkeymods, :int,     # int nkeymods
+           :input_state, :uint  # unsigned int input_state
+  end
+
+  # class XdoSearch < FFI::Struct
+  #   layout :title        ,:string,      # char * title
+  #          :winclass     ,:string,      # char * winclass # pattern to test against a window title
+  #          :winclassname ,:string,      # char * winclassname # pattern to test against a window class
+  #          :winname      ,:string,      # char *  winname # pattern to test against a window class
+  #          :pid          ,:int,         # int pid # window pid (From window atom _NET_WM_PID)
+  #          :max_depth    ,:long,        # long max_depth # depth of search.
+  #          :only_visible ,:int,         # only_visible   boolean; set true to search only visible windows
+  #          :screen       ,:int,         # screen
+  #          # XXX: Map this enum. Not sure how that works.
+  #          :xdo_search   ,:search_enum, # what screen to search, if any.
+  #          :searchmask   ,:uint         # unsigned int searchmask # bitmask of things you are searching for, such as SEARCH_NAME                                               , etc.
+  # end
+end; end if Object.const_defined? :FFI
+
+end

data/lib/cyberweb/mouse/mouse.rb

@@ -0,0 +1,264 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'cyberweb/mouse/mouse.rb'
+# =========================================================================== #
+if false # Disabled for the time being.
+
+begin
+  require 'ffi'
+rescue LoadError; end
+
+require 'cyberweb/mouse/libxdo.rb'
+
+module Cyberweb
+
+class Mouse # === Cyberweb::Mouse
+
+  # ========================================================================= #
+  # === CURRENT_WINDOW
+  # ========================================================================= #
+  CURRENT_WINDOW = ::Cyberweb::Libxdo::CURRENT_WINDOW
+
+  # ========================================================================= #
+  # === @delay
+  # ========================================================================= #
+  @delay = 0
+
+  # ========================================================================= #
+  # === Cyberweb::Mouse.delay=
+  #
+  # This method will set a time (in seconds, pass floats for fractions of
+  # a second) to delay after every operation.
+  #
+  # It is especially useful for situations where the commands are going
+  # to a window and you want to give the window a little time to react
+  # before sending more commands to it, e. g. by letting the browser
+  # fire events.
+  # 
+  # Defaults to 0 (no delay).
+  # ========================================================================= #
+  def self.delay=(delay = 0)
+    @delay = delay
+  end
+    
+  # ========================================================================= #
+  # === Cyberweb::Mouse.delay?
+  #
+  # Returns the current delay time.
+  # ========================================================================= #
+  def self.delay?
+    @delay
+  end; self.instance_eval { alias delay delay? } # === Cyberweb::Mouse.delay
+
+  # ========================================================================= #
+  # === Cyberweb::Mouse.move                                       (move tag)
+  #
+  # Move the mouse directly to the specified x/y coordinates.
+  # 
+  # If relative = true the x/y coordinates used are relative from the
+  # current position, otherwise they are considered to be absolute.
+  #
+  # The first argument may also be a Hash.
+  #
+  # Usage example:
+  #
+  #   Cyberweb::Mouse.move x: 200, y: 300
+  #
+  # ========================================================================= #
+  def self.move(
+      x, y = :default, use_relative_coordinates = false
+    )
+    if x.is_a? Hash
+      y = x.delete(:y)
+      x = x.delete(:x)
+    end
+    if y == :default # This clause is just a generic fallback - it won't really be used IMHO.
+      y = x
+    end
+    if use_relative_coordinates
+      relative(x, y)
+    else
+      absolute(x, y) # This here is the default.
+    end
+  end
+
+  # ========================================================================= #
+  # === Cyberweb::Mouse.drag
+  #
+  # Perform a drag operation with the given options. A drag is performed
+  # by moving the mouse to a starting location, pressing the primary mouse
+  # button down, incrementally moving to another location, and then
+  # releasing the primary mouse button.
+  # 
+  # Available options are:
+  # 
+  # * :from => [ x, y ] -- The absolute x/y coordinates to start from. If
+  #   omitted the drag will be started from the current mouse location.
+  # * :to => [ x, y ] -- The absolute x/y coordinates to end at. Can use
+  #   :distance instead for relative movements.
+  # * :distance => [ x, y ] -- Can be used instead of :to to provide an
+  #   end point relative to the starting point.
+  # * :increments => i -- The number of increments to include in the drag
+  #   from the start to the end, defaults to 10. More increments cause a
+  #   smoother, slower drag. Fewer increments cause a faster "jerkier"
+  #   drag.
+  # 
+  # Also a block can be passed which will be yielded before the mouse is
+  # released. This can be used to drag and hover for a period of time, or
+  # chain multiple drags, etc...
+  # 
+  # i.e.
+  # 
+  #     drag :to => [ 300, 350 ]
+  #     drag :from => [ 200, 300 ], :to => [ 400, 800 ]
+  #     drag :from => [ 200, 300 ], :distance => [ 200, 500 ]
+  #     drag :from => [ 200, 300 ], :distance => [ 220, 340 ], :increments => 20
+  #     drag :from => [ 200, 300 ], :to => [ 300, 400 ] do
+  #       sleep 0.5
+  #     end
+  #     drag :distance => [ 20, 0 ] do
+  #       drag :distance => [ 0, 30 ]
+  #     end
+  # 
+  # NOTE: that if :increments is not evenly divisble by the total distance
+  # the mouse will move in either direction then the distance of each
+  # iteration will not be consistent. The iterations are individually
+  # rounded to try to provide a smooth movement. For instance, take:
+  # 
+  #     drag :from => [ 0, 0 ], :distance => [ 20, 20 ], :increments => 8
+  # 
+  # will still occur in 8 iterations, however each iteration will alternate
+  # between 2px and 3px (interpolated movement).
+  # ========================================================================= #
+  def self.drag(
+      options = {}, &block
+    )
+    raise ArgumentError.new(
+      ':to or :distance is required to provide ending location'
+    ) unless options.has_key?(:to) || options.has_key?(:distance)
+    raise ArgumentError.new(
+      ':increments must be > 0'
+    ) if options.has_key?(:increments) && options[:increments] <= 0
+        
+    from       ||= options[:from] || location
+    increments   = options[:increments] || 10
+    distance     = options[:distance] || [ options[:to][0] - from[0], options[:to][1] - from[1] ]
+
+    move from[0], from[1]
+    down
+    increments.times { |i|
+      x = (from[0] + (distance[0].to_f / increments) * (i + 1)).round
+      y = (from[1] + (distance[1].to_f / increments) * (i + 1)).round
+      move(x, y)
+    }
+    yield if block_given?
+  ensure
+    up
+  end
+
+  # ========================================================================= #
+  # === Cyberweb::Mouse.down
+  #
+  # Press the given mouse button down (default is 1: primary)
+  # ========================================================================= #
+  def self.down(
+      button = 1
+    )
+    xdo { |entry|
+      ::Cyberweb::Libxdo.xdo_mousedown(entry, CURRENT_WINDOW, button)
+    }
+  end
+
+  # ========================================================================= #
+  # === Cyberweb::Mouse.up
+  #
+  # Release the given mouse button (default is 1: primary)
+  # ========================================================================= #
+  def self.up(button = 1)
+    xdo { |entry|
+      ::Cyberweb::Libxdo.xdo_mouseup(entry, CURRENT_WINDOW, button)
+    }
+  end
+
+  # ========================================================================= #
+  # === Cyberweb::Mouse.click                                     (click tag)
+  #
+  # Click the given mouse button (default is 1: primary)
+  # ========================================================================= #
+  def self.click(button = 1)
+    xdo { |entry|
+      ::Cyberweb::Libxdo.xdo_click(entry, CURRENT_WINDOW, button)
+    }
+  end; self.instance_eval { alias do_click click } # === Cyberweb::Mouse.do_click
+
+  # ========================================================================= #
+  # === Cyberweb::Mouse.location
+  #
+  # Gives the current mouse position.
+  # ========================================================================= #
+  def self.location
+    # ======================================================================= #
+    # We obtain the x and y coordinates next.
+    # ======================================================================= #
+    x = FFI::MemoryPointer.new :pointer
+    y = FFI::MemoryPointer.new :pointer
+    s = FFI::MemoryPointer.new :pointer
+    xdo { |xdo|
+      ::Cyberweb::Libxdo.xdo_mouselocation(xdo, x, y, s)
+    }
+    [ x.read_int, y.read_int ]
+  end
+
+  private # The rest is private.
+  
+  # ========================================================================= #
+  # === Cyberweb::Mouse.xdo
+  #
+  # Returns a new xdo instance.
+  # ========================================================================= #
+  def self.xdo(&block)
+    xdo = ::Cyberweb::Libxdo.xdo_new(nil)
+    yield(xdo)
+    sleep delay
+  ensure
+    ::Cyberweb::Libxdo.xdo_free(xdo)
+  end
+
+  # ======================================================================= #
+  # === Cyberweb::Mouse.absolute
+  #
+  # Performs an absolute mouse move
+  # ======================================================================= #
+  def self.absolute(x, y)
+    xdo { |xdo|
+      ::Cyberweb::Libxdo.xdo_mousemove(xdo, x, y, 0)
+      ::Cyberweb::Libxdo.xdo_mouse_wait_for_move_to(xdo, x, y)
+    }
+  end
+
+  # ======================================================================= #
+  # === Cyberweb::Mouse.relative
+  #
+  # Performs a relative mouse move
+  # ======================================================================= #
+  def self.relative(x, y)
+    loc = location
+    xdo { |xdo|
+      ::Cyberweb::Libxdo.xdo_mousemove_relative(xdo, x, y)
+      ::Cyberweb::Libxdo.xdo_mouse_wait_for_move_to(xdo, loc[0] + x, loc[1] + y)
+    }
+  end
+
+end; end if Object.const_defined? :FFI
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  Cyberweb::Mouse.drag :from => [ 200, 300 ], :distance => [ 30, 60 ], :increments => 10 do
+    Cyberweb::Mouse.drag :distance => [ 80, 120 ] do
+      sleep 0.25
+    end
+  end
+end

data/lib/cyberweb/objectified_html_tags/README.md

@@ -0,0 +1,8 @@
+"Objectified HTML Tags" refers to things such as:
+
+    Span.new('Hey there')
+
+We want to operate on the OOP level here.
+
+Note that this will also include non-html tags, so this
+is a slight misnomer.