vigilem-evdev 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e80bd4eb4d68f4e6733160a7751b53eddc521418
+  data.tar.gz: 61a2de4f8075c808c18449fb5b7eb072fd09ebd7
+SHA512:
+  metadata.gz: 5c36fcfaf61bd5101b93deb38ce30118ceba52789428bb343d1a8a84fdcf0b3fe4bd92847608a805e31dfa77f7d774cbe23185d899fd497fb9e3c88d1c8d1f54
+  data.tar.gz: 5a98d71e5163fe763a1517c9a1188b17accee111480d555c5896496e34647d45ff95c859fa337bdb2349e206ae6889cd3b01061534b8bcc75bb68d6844ef9aa3

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 jtzero
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ext/Rakefile

@@ -0,0 +1,31 @@
+root = File.expand_path('../../', __FILE__)
+lib = File.join(root, 'lib')
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+task :setup_key_map do
+  require 'vigilem/evdev/system/keymap_loaders'
+  require 'fileutils'
+  
+  sudo_cmd = if not `which rvmsudo`.empty?
+    'rvmsudo' 
+  else
+    `which sudo`.chomp
+  end
+  user = `whoami`
+  puts `#{sudo_cmd} ruby ./rake_helper.rb #{user}`
+end
+
+task :x11_context_filter do
+  require 'vigilem/x11/stat'
+  vxd = Vigilem::X11::Stat.default
+  if vxd.available?
+    vxd.install
+  end
+end
+
+task :init_steps do
+  Rake::Task["setup_key_map"].invoke
+  Rake::Task["x11_context_filter"].invoke
+end
+
+task default: :init_steps

data/ext/rake_helper.rb

@@ -0,0 +1,10 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'vigilem/evdev/system/keymap_loaders'
+
+Vigilem::Evdev::System::KeymapLoaders.build_cache
+
+require 'fileutils'
+
+FileUtils.chown (user = ARGV[0]), user, Vigilem::Evdev.data_dir

data/lib/vigilem/_evdev.rb

@@ -0,0 +1,24 @@
+require 'vigilem/support/utils'
+
+module Vigilem
+  # loading this will load less than the tld
+  module Evdev
+   
+   module_function
+    
+    # 
+    # 
+    def data_dir
+      @data_dir ||= Support::GemUtils.data_dir(__FILE__)
+    end
+    
+    # 
+    # @return [KeyMap]
+    def key_map
+      System::KeymapLoaders.key_map
+    end
+    
+  end
+end
+
+require 'vigilem/evdev/system/keymap_loaders'

data/lib/vigilem/evdev.rb

@@ -0,0 +1,14 @@
+module Vigilem
+module Evdev
+end
+end
+
+require 'vigilem/_evdev'
+
+require 'vigilem/evdev/input_system_handler'
+
+require 'vigilem/evdev/dom'
+
+require 'vigilem/evdev/system'
+
+require 'vigilem/evdev/device'

data/lib/vigilem/evdev/at_exit.rb

@@ -0,0 +1,8 @@
+if $0 != "irb"
+  require 'io/console'
+  begin
+    $stdout.echo= false 
+    at_exit { $stdout.echo = true }
+  rescue Errno::EINVAL
+  end
+end

data/lib/vigilem/evdev/context_filter.rb

@@ -0,0 +1,92 @@
+require 'observer'
+
+require 'forwardable'
+
+module Vigilem
+module Evdev
+  # 
+  # 
+  module ContextFilter
+    
+    # 
+    # states of the ContextFilter
+    module States
+      ON      = 1
+      UNKNOWN = nil
+      OFF     = 0
+    end
+    
+    include States
+    
+    # 
+    # @return [Hash] 
+    def state_hash
+      @state_hash ||= States.constants.each_with_object({}) do |const, memo| 
+                        memo[States.const_get(const)] = const
+                      end
+    end
+    
+    include Observable
+    
+    # 
+    # 
+    def self.included(base)
+      base.extend Forwardable
+    end
+    
+    attr_reader :last_known_state
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def was_on?
+      last_known_state == ON
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def was_off?
+      last_known_state.nil? || last_known_state == OFF
+    end
+    
+    # 
+    # @raise  [NotImplementedError]
+    def on?
+      raise NotImplementedError, '#on?, not overriden'
+    end
+    
+    alias_method :filtered?, :on?
+    
+    # 
+    # @raise  [NotImplementedError]
+    def off?
+      raise NotImplementedError, '#off?, not overriden'
+    end
+    
+    # 
+    # @param  [Fixnum<1 || 0>] state
+    # @return 
+    def on_change(state)
+      self.last_known_state = state
+      changed
+      notify_observers(self, state)
+    end
+    
+   private
+    attr_writer :last_known_state
+    
+    # 
+    # @param  [TrueClass || FalseClass] bool
+    # @return [Fixnum<1 || 0>]
+    def was_on=(bool)
+      self.last_known_state= if bool then ON else OFF end
+    end
+    
+    # 
+    # @param  [TrueClass || FalseClass] bool
+    # @return [Fixnum<1 || 0>]
+    def was_off=(bool)
+      self.was_on=!bool
+    end
+  end
+end
+end

data/lib/vigilem/evdev/demultiplexer.rb

@@ -0,0 +1,26 @@
+require 'vigilem/core/demultiplexer'
+
+require 'vigilem/core/buffer'
+
+module Vigilem
+module Evdev
+  # 
+  # 
+  class Demultiplexer  < Core::Demultiplexer
+    
+    class << self
+      # @todo move away from singleton and look at the one used by x11
+      # there should only be one demultiplexer for Evdev
+      # @param  [Array<Array<observer_object, Hash{@see #add_observer}>>] observers
+      # @return [Demultiplexer]
+      def acquire(outputs=[])
+        @demultiplexer ||= new(nil, outputs || [])
+      end
+      
+      private :new
+      
+    end
+  end
+  
+end
+end

data/lib/vigilem/evdev/device.rb

@@ -0,0 +1,182 @@
+require 'vigilem/evdev/system/input'
+
+require 'vigilem/evdev/device_capabilities'
+
+require 'vigilem/support/core_ext/enumerable'
+
+module Vigilem
+module Evdev
+  # 
+  # 
+  # 
+  class Device < File
+    
+    BITS_PER_BYTE          = 8
+    
+    include System::Input
+    extend System::Input
+    
+    include DeviceCapabilities
+    
+    class << self
+      
+      alias_method :super_open, :open
+      
+      private :super_open
+      
+      # 
+      # implement with udev
+      # @raises [NotImplemented]
+      # @param  fd
+      # @param  [String] mode
+      # @param  [Hash] opt
+      # @return 
+      def new(fd, mode='r', opt={})
+        raise NotImplemented, 'Cannot create device yet'
+      end
+      
+      # @todo  mode, opt
+      # open(filename, mode="r" [, opt])
+      # open(filename [, mode [, perm]] [, opt]) {|file| block } → obj
+      # /lib/udev/findkeyboards; method_missing -> get_keyboards?
+      # @see  File::open
+      def open(filename, mode='r', opt={})
+        if dev = all.find {|d| File.expand_path(filename) == d.path }
+          dev
+        else
+          raise NotImplemented, "mode of #{mode} not supported yet" if mode != 'r'
+          obj_register(super(filename, mode, opt))
+        end
+      end
+      
+      # 
+      # @return [Array<Device>]
+      def all
+        @all ||= chardev_glob(default_glob).map {|fp| send(:super_open, fp) }
+      end
+      
+      # defaults to "/dev/input"
+      # @return [String]
+      def default_dir
+        @default_dir ||= '/dev/input'
+      end
+      
+      # defaults to "/dev/input/event*"
+      # @return [String]
+      def default_glob
+        @default_glob ||= File.join(default_dir, 'event*')
+      end
+      
+      attr_writer :default_dir, :default_glob
+      
+      # @todo 
+      #def [](opts={})
+      #  
+      #end
+      
+      # executes EVIOCGNAME against known chardev's, and compares that to the
+      # regexp. If there is a filename_glob it checks that first.
+      # @param  [Regexp] name_regexp
+      # @param  [NilClass || String] glob
+      # @return [Array<Device>]
+      def name_grep(name_regexp, filename_glob=nil)
+        if filename_glob
+          file_paths = chardev_glob(filename_glob).map {|fn| File.expand_path(fn) }
+          file_paths.map {|f_path| dev if (dev = send(:super_open, f_path)).name =~ name_regexp }.compact.uniq
+        else
+          all.select {|dev| dev.name =~ name_regexp }
+        end
+      end
+      
+      # Expands pattern, which is an Array of patterns or a pattern String, 
+      # and returns the results as matches or as arguments given to the block.
+      # and returns only character devices
+      # @see    Dir::glob
+      # @param  [String] glob defaults to './*'
+      # @return [Array<String>]
+      def chardev_glob(glob='./*')
+        Dir[glob].select {|f| File::Stat.new(f).chardev? }
+      end
+    end
+    
+    # name of this device
+    # @return [String]
+    def name
+      @name ||= begin 
+                 ioctl(EVIOCGNAME(len = 256), out_name = " " * len)
+                 out_name.rstrip
+               end
+    end
+    
+    # 
+    # gets the ids of this device in an array
+    # @return [Array<Fixnum, Fixnum, Fixnum, Fixnum>] [idbus, idvendor, idproduct, idversion]
+    def ids
+      @ids ||= begin
+                ioctl(EVIOCGID, buf = '\x00' * 8)
+                buf.unpack('S!4')
+              end
+    end
+    
+    # @todo test
+    # @todo this doesn't really belong here
+    def led_bits
+      
+      no_of_bytes = bit_count_to_byte_count(LED_CNT - 1)
+      
+      ledbit = "\x00" * no_of_bytes
+      
+      ioctl(EVIOCGLED(System.sizeof("C#{no_of_bytes}")), ledbit)
+      
+      ledbit[0..no_of_bytes].unpack("b*").first
+    end
+    
+    # 
+    # @todo test
+    def _bits
+      unless @bits
+        ioctl(EVIOCGBIT(0), bits = [0].pack('i'))
+        @bits = bits.unpack('i')[0]
+      end
+      return @bits
+    end
+    
+=begin @todo
+    def grab
+    
+    end
+    
+    def ungrab
+     
+    end
+=end
+    
+    # 
+    # @param  max_len
+    # @param  out_buf=nil
+    # @return [Array?]
+    def read_nonblock(maxlen, out_buf=nil)
+      raise Evdev::SizeError, 'maxlen', maxlen, ie_size if maxlen < (ie_size = InputEvent.size)
+      super(*[maxlen, out_buf])
+    end
+    
+    # 
+    # @param  [Fixnum] length
+    # @param  out_buf=nill
+    # @return [Array?]
+    def read(length=nil, outbuf=nil)
+      length ||= Event.size
+      raise Evdev::SizeError, arg_name: 'length', arg_size: length, max_size: sze if length < (sze = InputEvent.size)
+      super(*[length, outbuf])
+    end
+    
+   private
+    # 
+    # @todo  test
+    def bit_count_to_byte_count(no_of_bits)
+      # closest without going over
+      (no_of_bits+7)/BITS_PER_BYTE
+    end
+  end
+end
+end

data/lib/vigilem/evdev/device_capabilities.rb

@@ -0,0 +1,53 @@
+require 'vigilem/evdev/system/input'
+
+module Vigilem
+module Evdev
+  #/sys/class/input/event1/device/capabilities
+  module DeviceCapabilities
+    
+    def keys?(fd)
+      ((_bits >> System::Input::EV_KEY) & 1) == 1
+    end
+    
+    def leds?
+      ((_bits >> System::Input::EV_LED) & 1) == 1
+    end
+    
+    def sound?
+      ((_bits >> System::Input::EV_SND) & 1) == 1
+    end
+    
+    def relative_axes?
+        ((_bits >> System::Input::EV_REL) & 1) == 1
+    end
+    
+    def absolute_axes?
+      ((_bits >> System::Input::EV_ABS) & 1) == 1
+    end
+    
+    def misc?
+      ((_bits >> System::Input::EV_MSC) & 1) == 1
+    end
+    
+    def switches?
+      ((_bits >> System::Input::EV_SW) & 1) == 1
+    end
+     
+    def repeat?
+      ((_bits >> System::Input::EV_REP) & 1) == 1
+    end
+    
+    def forcefeedback?
+      ((_bits >> System::Input::EV_FF) & 1) == 1
+    end
+    
+    def forcefeedback_status?
+      ((_bits >> System::Input::EV_FF_STATUS) & 1) == 1
+    end
+    
+    def power?
+      ((_bits >> System::Input::EV_PWR) & 1) == 1
+    end
+  end
+end
+end