xlib-objects 0.6.3 → 0.7.0

data/lib/input_device.rb

@@ -0,0 +1,89 @@
+#
+# Copyright (c) 2015 Christopher Aue <mail@christopheraue.net>
+#
+# This file is part of the ruby xlib-objects gem. It is subject to the license
+# terms in the LICENSE file found in the top-level directory of this
+# distribution and at http://github.com/christopheraue/ruby-xlib-objects.
+#
+
+module XlibObj
+  class InputDevice
+    def initialize(display, device_id)
+      @display = display
+      @device_id = device_id
+    end
+
+    attr_reader :display
+
+    def to_native
+      @device_id
+    end
+    alias_method :id, :to_native
+
+    def name
+      device_info(:name, &:read_string)
+    end
+
+    def master?
+      [Xlib::XIMasterPointer, Xlib::XIMasterKeyboard].include? device_info(:use)
+    end
+
+    def slave?
+      [Xlib::XISlavePointer, Xlib::XISlaveKeyboard].include? device_info(:use)
+    end
+
+    def floating?
+      device_info(:use) == Xlib::XIFloatingSlave
+    end
+
+    def pointer?
+      [Xlib::XIMasterPointer, Xlib::XISlavePointer].include? device_info(:use)
+    end
+
+    def keyboard?
+      [Xlib::XIMasterKeyboard, Xlib::XISlaveKeyboard].include? device_info(:use)
+    end
+
+    def master
+      self.class.new(@display, device_info(:attachment)) if slave?
+    end
+
+    def slaves
+      @display.input_devices.select{ |device| device.master == self }
+    end
+
+    def enabled?
+      device_info(:enabled)
+    end
+
+    def disabled?
+      not enabled?
+    end
+
+    def focus(window = nil)
+      if window
+        Xlib::XI.set_focus(@display, self, window, Xlib::CurrentTime)
+      else
+        Xlib::XI.get_focus(@display, self) if keyboard?
+      end
+    end
+
+    def grab(report_to:, cursor: Xlib::None, mode: Xlib::GrabModeAsync, pair_mode: Xlib::GrabModeAsync,
+        owner_events: true, event_mask: 0)
+      Xlib::XI.grab_device(@display, self, report_to, Xlib::CurrentTime, cursor, mode, pair_mode, owner_events, event_mask)
+    end
+
+    def ungrab
+      Xlib::XI.ungrab_device(@display, self, Xlib::CurrentTime)
+    end
+
+    private
+
+    def device_info(member, &do_with_member)
+      device_info = Xlib::XI.query_device(@display, @device_id).first
+      do_with_member ? yield(device_info[member]) : device_info[member]
+    ensure
+      Xlib::XI.free_device_info(device_info)
+    end
+  end
+end

data/lib/window.rb

@@ -11,7 +11,7 @@ module XlibObj
     def initialize(display, window_id)
       @display = display
       @to_native = window_id
-      @event_handler = EventHandler.singleton(display, window_id)
+      @event_handler = EventHandler.singleton(display, self)
     end
 
     # Queries
@@ -206,6 +206,13 @@ module XlibObj
       Window.new(@display, win_id)
     end
 
+    def create_input_window
+      attributes = Xlib::SetWindowAttributes.new
+      win_id = Xlib.XCreateWindow(@display.to_native, to_native, 0, 0, 1, 1, 0, Xlib::CopyFromParent,
+        Xlib::InputOnly, nil, 0, attributes.pointer)
+      Window.new(@display, win_id)
+    end
+
     def destroy
       @event_handler.destroy
       Xlib.XDestroyWindow(@display.to_native, to_native)

data/lib/window/event_handler.rb

@@ -9,117 +9,75 @@
 module XlibObj
   class Window
     class EventHandler
+      @instances = {}
+
       class << self
-        def singleton(display, window_id)
-          @handlers ||= {}
-          @handlers[display] ||= {}
-          @handlers[display][window_id] ||= new(display, window_id)
+        def singleton(display, window)
+          @instances[display] ||= {}
+          @instances[display][window.id] ||= new(display, window)
         end
 
-        def remove(display, window_id)
-          @handlers[display].delete(window_id) if @handlers and @handlers[display]
+        def remove(display, window)
+          @instances[display].delete(window.id) if @instances[display]
         end
       end
 
-      def initialize(display, window_id)
+      def initialize(display, window)
         @display = display
-        @window_id = window_id
+        @window = window
         @event_handlers = {}
-        @event_mask = 0
-        @rr_event_mask = 0
       end
 
+      attr_reader :display, :window
+
       def on(mask, event, &handler)
         add_event_mask(mask)
         add_event_handler(mask, event, &handler)
       end
 
-      def off(mask, type, handler = nil)
-        remove_event_handler(mask, type, handler)
+      def off(mask, event, handler = nil)
+        remove_event_handler(mask, event, handler)
         remove_event_mask(mask)
       end
 
       def handle(event)
-        if @event_handlers[event.name]
-          @event_handlers[event.name].each do |_, handlers|
-            handlers.each{ |handler| handler.call(event) }
-          end
-          true
-        else
-          false
+        @event_handlers.each do |mask, handlers|
+          next unless handlers[event.name]
+          handlers[event.name].each{ |handler| handler.call(event) }
         end
       end
 
       def destroy
-        self.class.remove(@display, @window_id)
+        self.class.remove(@display, @window)
       end
 
       private
+
       def add_event_mask(mask)
-        check_mask(mask)
-        return if mask_in_use?(mask)
-        @event_mask    |= normalize_mask(mask)
-        @rr_event_mask |= normalize_rr_mask(mask)
-        select_events
+        return if @event_handlers[mask]
+
+        @event_handlers[mask] = {}
+        extension = @display.extensions.find{ |ext| ext.handles_event_mask?(mask) }
+        extension.select_mask(@window, mask)
       end
 
       def remove_event_mask(mask)
-        check_mask(mask)
-        return if mask_in_use?(mask)
-        return unless mask_selected?(mask)
-        @event_mask    &= ~normalize_mask(mask)
-        @rr_event_mask &= ~normalize_rr_mask(mask)
-        select_events
+        return unless @event_handlers[mask].empty?
+
+        extension = @display.extensions.find{ |ext| ext.handles_event_mask?(mask) }
+        extension.deselect_mask(@window, mask)
+        @event_handlers.delete(mask)
       end
 
       def add_event_handler(mask, event, &handler)
-        check_event(event)
-        @event_handlers[event] ||= {}
-        @event_handlers[event][mask] ||= []
-        @event_handlers[event][mask] << handler
+        @event_handlers[mask][event] ||= []
+        @event_handlers[mask][event] << handler
         handler
       end
 
       def remove_event_handler(mask, event, handler)
-        check_event(event)
-        return unless mask_in_use?(mask)
-        return unless @event_handlers[event]
-        @event_handlers[event][mask].delete(handler) if handler
-        @event_handlers[event].delete(mask) if @event_handlers[event][mask].empty? or handler.nil?
-        @event_handlers.delete(event) if @event_handlers[event].empty?
-      end
-
-      def mask_in_use?(mask)
-        @event_handlers.select{ |_, handlers| handlers.has_key?(mask) }.any?
-      end
-
-      def mask_selected?(mask)
-        (@event_mask & ~normalize_mask(mask) != @event_mask) or
-          (@rr_event_mask & ~normalize_rr_mask(mask) != @rr_event_mask)
-      end
-
-      def check_mask(mask)
-        if XlibObj::Event::MASK[mask].nil? && XlibObj::Event::RR_MASK[mask].nil?
-          raise("Unknown event mask #{mask}.")
-        end
-      end
-
-      def normalize_mask(mask)
-        XlibObj::Event::MASK[mask] || 0
-      end
-
-      def normalize_rr_mask(mask)
-        XlibObj::Event::RR_MASK[mask] || 0
-      end
-
-      def check_event(event)
-        XlibObj::Event.valid_name?(event) || raise("Unknown event #{event}.")
-      end
-
-      def select_events
-        Xlib.XSelectInput(@display.to_native, @window_id, @event_mask)
-        Xlib.XRRSelectInput(@display.to_native, @window_id, @rr_event_mask)
-        @display.flush
+        @event_handlers[mask][event].delete(handler)
+        @event_handlers[mask].delete(event) if @event_handlers[mask][event].empty?
       end
     end
   end

data/lib/xlib-objects.rb

@@ -7,18 +7,11 @@
 #
 
 require 'xlib'
+require 'xlib/xinput2'
 
 module XlibObj; end
 
-require_relative 'atom'
-require_relative 'display'
-require_relative 'event'
-require_relative 'error'
-require_relative 'event/client_message'
-require_relative 'event/selection_notify'
-require_relative 'screen'
-require_relative 'screen/crtc'
-require_relative 'screen/crtc/output'
-require_relative 'window'
-require_relative 'window/property'
-require_relative 'window/event_handler'
+lib_dir = File.dirname __FILE__
+lib_files = File.join(lib_dir, '**/*.rb')
+
+Dir[lib_files].sort.each { |f| require f }

data/lib/xlib/x.rb

@@ -0,0 +1,57 @@
+module Xlib
+  module X; end
+  class << X
+    def open_display(name)
+      display_pointer = Xlib.XOpenDisplay(name)
+      raise ArgumentError, "Unknown display #{name}" if display_pointer.null?
+      Xlib::Display.new(display_pointer)
+    end
+
+    def close_display(display)
+      Xlib.XCloseDisplay(display.to_native)
+    end
+
+    def list_extensions(display)
+      nextensions_ptr = FFI::MemoryPointer.new :pointer
+      extensions_ptr = Xlib.XListExtensions(display.to_native, nextensions_ptr)
+      nextensions = nextensions_ptr.read_int
+      extensions = extensions_ptr.get_array_of_string(0, nextensions)
+      Xlib.XFreeExtensionList(extensions_ptr)
+      extensions
+    end
+
+    def query_extension(display, name)
+      opcode_ptr = FFI::MemoryPointer.new :int
+      evcode_ptr = FFI::MemoryPointer.new :int
+      errcode_ptr = FFI::MemoryPointer.new :int
+      if Xlib.XQueryExtension(display.to_native, name, opcode_ptr, evcode_ptr, errcode_ptr)
+        { opcode: opcode_ptr.read_int, first_event: evcode_ptr.read_int, first_error: errcode_ptr.read_int}
+      else
+        false
+      end
+    end
+
+    def get_event_data(display, event_cookie)
+      Xlib::XGetEventData(display.to_native, event_cookie.pointer)
+    end
+
+    def select_input(display, window, mask)
+      Xlib.XSelectInput(display.to_native, window.to_native, mask)
+      flush(display)
+    end
+
+    def next_event(display)
+      xevent = Xlib::XEvent.new
+      Xlib.XNextEvent(display.to_native, xevent) # blocks
+      xevent
+    end
+
+    def pending(display)
+      Xlib.XPending(display.to_native)
+    end
+
+    def flush(display)
+      Xlib.XFlush(display.to_native)
+    end
+  end
+end

data/lib/xlib/xi.rb

@@ -0,0 +1,60 @@
+module Xlib
+  module XI
+    class << self
+      def query_device(display, device_id)
+        ndevices_ptr = FFI::MemoryPointer.new :int
+        device_infos_ptr = Xlib::XIQueryDevice(display.to_native, device_id, ndevices_ptr)
+        ndevices = ndevices_ptr.read_int
+
+        0.upto(ndevices-1).map do |position|
+          device_info_ptr = device_infos_ptr + position * Xlib::XIDeviceInfo.size
+          Xlib::XIDeviceInfo.new(device_info_ptr)
+        end
+      end
+
+      def free_device_info(device_info)
+        Xlib.XIFreeDeviceInfo(device_info.pointer)
+        true
+      end
+
+      def set_focus(display, device, window, time)
+        0 == Xlib::XISetFocus(display.to_native, device.to_native, window.to_native, time).tap do
+          Xlib::X.flush(display)
+        end
+      end
+
+      def get_focus(display, device)
+        window_id_ptr = FFI::MemoryPointer.new :Window
+        if 0 == Xlib::XIGetFocus(display.to_native, device.to_native, window_id_ptr)
+          case window_id = window_id_ptr.read_int
+          when Xlib::PointerRoot
+            display.screens.first.root_window
+          when Xlib::None
+            nil
+          else
+            XlibObj::Window.new(display, window_id)
+          end
+        end
+      end
+
+      def grab_device(display, device, window, time, cursor, mode, pair_mode, owner_events, event_mask)
+        event_mask = EventMask.new(device, event_mask)
+        0 == Xlib::XIGrabDevice(display.to_native, device.to_native, window.to_native, time, cursor,
+          mode, pair_mode, owner_events, event_mask.to_native)
+      end
+
+      def ungrab_device(display, device, time)
+        0 == Xlib::XIUngrabDevice(display.to_native, device.to_native, time).tap do
+          Xlib::X.flush(display)
+        end
+      end
+
+      def select_events(display, devices, window, event_mask)
+        event_mask = EventMask.new(devices, event_mask)
+        Xlib.XISelectEvents(display.to_native, window.to_native, event_mask.to_native, devices.size)
+        Xlib::X.flush(display)
+        true
+      end
+    end
+  end
+end

data/lib/xlib/xi/event_mask.rb

@@ -0,0 +1,32 @@
+module Xlib
+  module XI
+    class EventMask
+      def initialize(devices, mask)
+        @devices = [*devices]
+        @mask = mask
+      end
+
+      attr_reader :devices, :mask
+
+      def to_native
+        @structs ||= begin
+          masks_ptr = FFI::MemoryPointer.new(Xlib::XIEventMask.size, @devices.count)
+
+          @devices.each.with_index do |device, idx|
+            byte_length = (@mask.bit_length/8.0).ceil
+            mask_ptr = FFI::MemoryPointer.new :int
+            mask_ptr.write_int @mask
+
+            Xlib::XIEventMask.new(masks_ptr[idx]).tap do |event_mask|
+              event_mask[:deviceid] = device.is_a?(XlibObj::InputDevice) ? device.id : device
+              event_mask[:mask_len] = FFI.type_size(:int)
+              event_mask[:mask] = mask_ptr
+            end
+          end
+
+          Xlib::XIEventMask.new(masks_ptr[0]).pointer
+        end
+      end
+    end
+  end
+end

data/lib/xlib/xrr.rb

@@ -0,0 +1,10 @@
+module Xlib
+  module XRR
+    class << self
+      def select_input(display, window, mask)
+        Xlib.XRRSelectInput(display.to_native, window.to_native, mask)
+        Xlib::X.flush(display)
+      end
+    end
+  end
+end