xkbcommon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a33e1dab78a94efb73575ca12f53fc05b456699c
+  data.tar.gz: ae8dce5f97d43acc6548c5a8f94338d7510a54c6
+SHA512:
+  metadata.gz: 237bad6821313b087c490928cb8dd0c9871594a65ea6c2ab115380d8c9c7f11bfed8376da53a5cda3190d8e2ebb07a6149fad2b012ffd1a01268c7047fa22f15
+  data.tar.gz: c88eeb0d8ef13831d705db505cbae076be058cfcbfba27c984ad2b42551b3840de11d797ce9fd6fc25bd13f45a0d3b3053f1c6f09d87196c87f7dd10cc1ad501

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rakeTasks

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Settings><!--This file was automatically generated by Ruby plugin.
+You are allowed to: 
+1. Remove rake task
+2. Add existing rake tasks
+To add existing rake tasks automatically delete this file and reload the project.
+--><RakeGroup description="" fullCmd="" taksId="rake"><RakeTask description="Build xkbcommon-0.1.0.gem into the pkg directory" fullCmd="build" taksId="build" /><RakeTask description="Build and install xkbcommon-0.1.0.gem into system gems" fullCmd="install" taksId="install" /><RakeTask description="Create tag v0.1.0 and build and push xkbcommon-0.1.0.gem to Rubygems" fullCmd="release" taksId="release" /><RakeGroup description="" fullCmd="" taksId="release"><RakeTask description="" fullCmd="release:guard_clean" taksId="guard_clean" /><RakeTask description="" fullCmd="release:rubygem_push" taksId="rubygem_push" /><RakeTask description="" fullCmd="release:source_control_push" taksId="source_control_push" /></RakeGroup></RakeGroup></Settings>

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+gem 'libxkbcommon', path: '../ruby-libxkbcommon'
+gem 'uinput', path: '../ruby-uinput'

data/README.md

@@ -0,0 +1,63 @@
+# Xkbcommon
+
+xkbcommon bindings for ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'xkbcommon'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xkbcommon
+
+## Usage
+
+```ruby
+require 'xkbcommon'
+
+keymap = Xkbcommon::Context.new.keymap_from_names(rules: 'evdev', model: 'pc104', layout: 'de', variant: 'nodeadkeys')
+
+# Available keys in keymap
+keymap.keys                 # => [ #<Xkbcommon::Key>, #<Xkbcommon::Key>, ... ]
+
+# Xkbcommon::Key interface
+key = keymap.keys.find{ |key| key.name == :A }
+key.name                    # => :A
+key.scan_code               # => 30
+key.code                    # => 38
+
+
+# Available modifiers in keymap
+keymap.modifiers            # => [ #<Xkbcommon::Modifier>, #<Xkbcommon::Modifier>, ... ]
+
+# Xkbcommon::Modifier interface
+mod = keymap.modifiers.first
+mod.name                    # => :Shift
+mod.index                   # => 0
+mod.keys.map(&:name)        # => [:LEFTSHIFT], keys activating the modifier
+
+
+# Available symbols in keymap
+keymap.symbols              # => { :Escape => #<Xkbcommon::Symbol>, :"1" => #<Xkbcommon::Symbol>, ... }
+
+# Xkbcommon::Symbol interface
+sym = keymap.symbols[:A]
+sym.keysym                  # => 65
+sym..keys.map(&:name)       # => [:LEFTSHIFT, :A], keys producing the symbol
+sym.name                    # => :A
+sym.character               # => "A"
+
+
+# Available characters in keymap
+keymap.characters           # => { "\e" => #<Xkbcommon::Symbol>, "1" => #<Xkbcommon::Symbol>, ... }
+
+# Xkbcommon::Symbol interface (see above)
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/xkbcommon.rb

@@ -0,0 +1,10 @@
+require 'libxkbcommon'
+require "xkbcommon/version"
+
+require "xkbcommon/context"
+require "xkbcommon/keymap"
+require "xkbcommon/keymap/parser"
+require "xkbcommon/key"
+require "xkbcommon/symbol"
+require "xkbcommon/modifier"
+require "xkbcommon/state"

data/lib/xkbcommon/context.rb

@@ -0,0 +1,52 @@
+module Xkbcommon
+  class Context
+    class << self
+      def finalize(native)
+        Proc.new { Libxkbcommon.xkb_context_unref(native) }
+      end
+    end
+
+    def initialize(flags = Libxkbcommon::XKB_CONTEXT_NO_FLAGS)
+      @to_native = Libxkbcommon.xkb_context_new(flags)
+
+      ObjectSpace.define_finalizer(self, self.class.finalize(to_native))
+    end
+
+    attr_reader :to_native
+
+    def default_keymap
+      keymap_from_names
+    end
+
+    def keymap_from_names(rules: nil, model: nil, layout: nil, variant: nil, options: nil,
+        flags: Libxkbcommon::XKB_KEYMAP_COMPILE_NO_FLAGS)
+      names = Libxkbcommon::XkbRuleNames.new
+      names.rules = rules if rules
+      names.model = model if model
+      names.layout = layout if layout
+      names.variant = variant if variant
+      names.options = options if options
+
+      Keymap.new(self, Libxkbcommon.xkb_keymap_new_from_names(to_native, names, flags))
+    end
+
+    def keymap_from_file(file,
+                         format: Libxkbcommon::XKB_KEYMAP_FORMAT_TEXT_V1,
+                         flags: Libxkbcommon::XKB_KEYMAP_COMPILE_NO_FLAGS)
+      Keymap.new(self, Libxkbcommon.xkb_keymap_new_from_file(to_native, file, format, flags))
+    end
+
+    def keymap_from_string(string,
+                           format: Libxkbcommon::XKB_KEYMAP_FORMAT_TEXT_V1,
+                           flags: Libxkbcommon::XKB_KEYMAP_COMPILE_NO_FLAGS)
+      Keymap.new(self, Libxkbcommon.xkb_keymap_new_from_string(to_native, string, format, flags))
+    end
+
+    def keymap_from_buffer(buffer,
+                           length,
+                           format: Libxkbcommon::XKB_KEYMAP_FORMAT_TEXT_V1,
+                           flags: Libxkbcommon::XKB_KEYMAP_COMPILE_NO_FLAGS)
+      Keymap.new(self, Libxkbcommon.xkb_keymap_new_from_buffer(to_native, buffer, length, format, flags))
+    end
+  end
+end

data/lib/xkbcommon/key.rb

@@ -0,0 +1,34 @@
+require 'uinput'
+
+module Xkbcommon
+  class Key
+    class << self
+      def code_to_name(code)
+        codes_to_names[code]
+      end
+
+      private
+
+      def codes_to_names
+        @names ||= begin
+          keys = Uinput.constants.select{ |c| c.to_s.start_with?('KEY_') }
+          keys.map do |c|
+            code = Uinput.const_get(c)
+            name = c.to_s[4..-1]
+            name = Integer(name) rescue name.to_sym
+            [code, name]
+          end.to_h
+        end
+      end
+    end
+
+    def initialize(keymap, code)
+      @keymap = keymap
+      @code = code
+      @scan_code = code - 8 # about offset 8: http://xkbcommon.org/doc/current/xkbcommon_8h.html#ac29aee92124c08d1953910ab28ee1997
+      @name = self.class.code_to_name(@scan_code)
+    end
+
+    attr_reader :keymap, :code, :scan_code, :name
+  end
+end

data/lib/xkbcommon/keymap.rb

@@ -0,0 +1,28 @@
+require 'forwardable'
+
+module Xkbcommon
+  class Keymap
+    extend Forwardable
+
+    class << self
+      def finalize(native)
+        Proc.new { Libxkbcommon.xkb_keymap_unref(native) }
+      end
+    end
+
+    def initialize(context, keymap)
+      @context = context
+      @to_native = keymap
+      @parser = Parser.new(self)
+
+      ObjectSpace.define_finalizer(self, self.class.finalize(to_native))
+    end
+
+    attr_reader :context, :to_native
+    delegate [:keys, :modifiers, :symbols, :characters] => :@parser
+
+    def to_s(format: Libxkbcommon::XKB_KEYMAP_USE_ORIGINAL_FORMAT)
+      Libxkbcommon.xkb_keymap_get_as_string(to_native, format)
+    end
+  end
+end

data/lib/xkbcommon/keymap/parser.rb

@@ -0,0 +1,109 @@
+module Xkbcommon
+  class Keymap
+    class Parser
+      def initialize(keymap)
+        @keymap = keymap
+      end
+
+      attr_reader :keymap
+
+      def keys
+        @keys ||= begin
+          min_code = Libxkbcommon.xkb_keymap_min_keycode(@keymap.to_native)
+          max_code = Libxkbcommon.xkb_keymap_max_keycode(@keymap.to_native)
+          keycode_range = min_code..max_code
+
+          codes = keycode_range.select do |code|
+            # Todo: This does not seem to filter out keys that do not exist on the keyboard?
+            0 < Libxkbcommon.xkb_keymap_num_layouts_for_key(@keymap.to_native, code)
+          end
+          codes.map{ |code| Key.new(self, code) }
+        end
+      end
+
+      def modifiers
+        symbols # will be parsed while parsing symbols
+        @modifiers
+      end
+
+      def symbols
+        @symbols ||= begin
+          symbols = parse_symbols
+          # first parse round will give us all modifier keys, so we can parse
+          # what keys active which modifiers next
+
+          @modifiers = parse_modifiers(symbols)
+
+          all_combinations(@modifiers).each do |modifiers|
+            symbols = parse_symbols(symbols, modifiers)
+          end
+
+          symbols
+        end
+      end
+
+      def characters
+        symbols # will be parsed while parsing symbols
+        @characters
+      end
+
+      private
+
+      def parse_symbols(symbols = {}, modifiers = [])
+        state = Xkbcommon::State.new(@keymap)
+        modifier_mask = modifiers.map{ |mod| 1 << mod.index }.reduce(0, :|)
+        state.update_mask(depressed_mods: modifier_mask)
+
+        keys.each do |key|
+          symbol = state.symbol_for_key(key)
+          if symbol
+            symbol.keys = [modifiers.map(&:keys), key].flatten
+            # We just need one key combo to create the symbol. The first should be the simplest,
+            # we take that one.
+            symbols[symbol.name] ||= symbol
+            if symbol.character
+              @characters ||= {}
+              # We just need one key combo to create the character. The first should be the simplest,
+              # we take that one.
+              @characters[symbol.character] ||= symbol
+            end
+          end
+        end
+
+        symbols
+      end
+
+      def parse_modifiers(symbols)
+        modifier_count = Libxkbcommon.xkb_keymap_num_mods(@keymap.to_native)
+        not_activated_modifiers = (0..modifier_count-1).map{ |idx| Modifier.new(@keymap, idx) }
+        activated_modifiers = []
+
+        state = Xkbcommon::State.new(@keymap)
+
+        modifier_keys = Modifier::SYMBOLS.select{ |sym| symbols[sym] }.map{ |sym| symbols[sym].keys }
+        modifier_keys.each do |keys|
+          new_state_components = state.press_keys(keys) || 0
+
+          if new_state_components & Libxkbcommon::XKB_STATE_MODS_EFFECTIVE != 0
+            # Once we found a modifier and know how to activate it we no longer need to check it
+            newly_activated_modifiers = not_activated_modifiers.select{ |mod| state.modifier_active?(mod) }
+            newly_activated_modifiers.each{ |mod| mod.keys = keys }
+
+            not_activated_modifiers -= newly_activated_modifiers
+            activated_modifiers += newly_activated_modifiers
+          end
+
+          state.release_keys(keys)
+        end
+
+        activated_modifiers
+      end
+
+      def all_combinations(array)
+        1.upto(array.size).inject([]) do |memo, group_size|
+          memo + array.combination(group_size).to_a
+        end
+      end
+    end
+  end
+end

data/lib/xkbcommon/modifier.rb

@@ -0,0 +1,51 @@
+module Xkbcommon
+  class Modifier
+    SYMBOLS = [
+      :Shift_L,
+      :Shift_R,
+      :Control_L,
+      :Control_R,
+      #:Caps_Lock,
+      #:Shift_Lock,
+      :Meta_L,
+      :Meta_R,
+      :Alt_L,
+      :Alt_R,
+      :Super_L,
+      :Super_R,
+      :Hyper_L,
+      :Hyper_R,
+      #:ISO_Lock,
+      :ISO_Level2_Latch,
+      :ISO_Level3_Shift,
+      :ISO_Level3_Latch,
+      #:ISO_Level3_Lock,
+      :ISO_Level5_Shift,
+      :ISO_Level5_Latch,
+      #:ISO_Level5_Lock,
+      :ISO_Group_Shift,
+      :ISO_Group_Latch,
+      #:ISO_Group_Lock,
+      :ISO_Next_Group,
+      #:ISO_Next_Group_Lock,
+      :ISO_Prev_Group,
+      #:ISO_Prev_Group_Lock,
+      :ISO_First_Group,
+      #:ISO_First_Group_Lock,
+      :ISO_Last_Group#,
+      #:ISO_Last_Group_Lock
+    ]
+
+    def initialize(keymap, index)
+      @keymap, @index = keymap, index
+      @name = Libxkbcommon.xkb_keymap_mod_get_name(keymap.to_native, index).to_sym
+    end
+
+    attr_reader :keymap, :index, :name, :keys
+
+    def keys=(keys)
+      return if @keys
+      @keys = [*keys].freeze
+    end
+  end
+end

data/lib/xkbcommon/state.rb

@@ -0,0 +1,60 @@
+module Xkbcommon
+  class State
+    class << self
+      def finalize(native)
+        Proc.new { Libxkbcommon.xkb_state_unref(native) }
+      end
+    end
+
+    def initialize(keymap)
+      @keymap = keymap
+      @to_native = Libxkbcommon.xkb_state_new(keymap.to_native)
+
+      ObjectSpace.define_finalizer(self, self.class.finalize(to_native))
+    end
+
+    attr_reader :keymap, :to_native
+
+    def update_mask(depressed_mods: 0,
+                    latched_mods: 0,
+                    locked_mods: 0,
+                    depressed_layout: 0,
+                    latched_layout: 0,
+                    locked_layout: 0)
+      Libxkbcommon.xkb_state_update_mask(to_native, depressed_mods, latched_mods, locked_mods,
+        depressed_layout, latched_layout, locked_layout)
+    end
+
+    def press_key(key)
+      Libxkbcommon.xkb_state_update_key(to_native, key.code, Libxkbcommon::XKB_KEY_DOWN)
+    end
+
+    def press_keys(keys)
+      [*keys].map{ |key| press_key(key) }.last
+    end
+
+    def release_key(key)
+      Libxkbcommon.xkb_state_update_key(to_native, key.code, Libxkbcommon::XKB_KEY_UP)
+    end
+
+    def release_keys(keys)
+      [*keys].map{ |key| release_key(key) }.last
+    end
+
+    def utf8_of_key(key)
+      utf8_size = 8
+      utf8 = FFI::MemoryPointer.new(:char, utf8_size)
+      Libxkbcommon.xkb_state_key_get_utf8(to_native, key.code, utf8, utf8_size)
+      utf8.read_string.force_encoding('UTF-8')
+    end
+
+    def symbol_for_key(key)
+      keysym = Libxkbcommon.xkb_state_key_get_one_sym(to_native, key.code)
+      Symbol.new(@keymap, keysym) if keysym
+    end
+
+    def modifier_active?(modifier)
+      0 < Libxkbcommon.xkb_state_mod_index_is_active(to_native, modifier.index, Libxkbcommon::XKB_STATE_MODS_EFFECTIVE)
+    end
+  end
+end

data/lib/xkbcommon/symbol.rb

@@ -0,0 +1,32 @@
+module Xkbcommon
+  class Symbol
+    def initialize(keymap, keysym)
+      @keymap, @keysym = keymap, keysym
+    end
+
+    attr_reader :keymap, :keysym, :keys
+
+    def keys=(keys)
+      return if @keys
+      @keys = [*keys].freeze
+    end
+
+    def name
+      @name ||= begin
+        char_size = 64
+        char = FFI::MemoryPointer.new(:char, char_size)
+        Libxkbcommon.xkb_keysym_get_name(@keysym, char, char_size)
+        char.read_string.to_sym
+      end
+    end
+
+    def character
+      @character ||= begin
+        char_size = 8
+        char = FFI::MemoryPointer.new(:char, char_size)
+        Libxkbcommon.xkb_keysym_to_utf8(@keysym, char, char_size)
+        char.read_string.force_encoding('UTF-8')
+      end
+    end
+  end
+end

data/lib/xkbcommon/version.rb

@@ -0,0 +1,3 @@
+module Xkbcommon
+  VERSION = "0.1.0"
+end

data/test.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+require 'bundler/setup'
+require 'xkbcommon'
+
+keymap = Xkbcommon::Context.new.keymap_from_names(rules: 'evdev', model: 'pc104', layout: 'de', variant: 'nodeadkeys')
+
+def format_keys(keys)
+  keys.map{ |key| "#{key.name}(#{key.scan_code})" }
+end
+
+puts "KEYS"
+puts format_keys(keymap.keys)
+puts
+puts "MODIFIERS"
+puts keymap.modifiers.map{ |mod| "#{mod.name}: #{format_keys(mod.keys).join(' + ')}" }
+puts
+puts "SYMBOLS"
+puts keymap.symbols.map{ |symbol_name, symbol| "#{symbol_name}: #{format_keys(symbol.keys).join(' + ')}" }
+puts
+puts "CHARACTERS"
+puts keymap.characters.map{ |char, symbol| "#{char} #{char.bytes}: #{format_keys(symbol.keys).join(' + ')}" }

data/xkbcommon.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'xkbcommon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "xkbcommon"
+  spec.version       = Xkbcommon::VERSION
+  spec.authors       = ["Christopher Aue"]
+  spec.email         = ["mail@christopheraue.net"]
+
+  spec.summary       = %q{xkbcommon bindings for ruby}
+  spec.homepage      = "https://github.com/christopheraue/ruby-xkbcommon"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "libxkbcommon", "~> 1.0"
+  spec.add_dependency "uinput", "~> 1.0"
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: xkbcommon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Christopher Aue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: libxkbcommon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: uinput
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
+email:
+- mail@christopheraue.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rakeTasks"
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- lib/xkbcommon.rb
+- lib/xkbcommon/context.rb
+- lib/xkbcommon/key.rb
+- lib/xkbcommon/keymap.rb
+- lib/xkbcommon/keymap/parser.rb
+- lib/xkbcommon/modifier.rb
+- lib/xkbcommon/state.rb
+- lib/xkbcommon/symbol.rb
+- lib/xkbcommon/version.rb
+- test.rb
+- xkbcommon.gemspec
+homepage: https://github.com/christopheraue/ruby-xkbcommon
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: xkbcommon bindings for ruby
+test_files: []