xlib-objects 0.6.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a7de1f655c5f8f27b0741b9f991bfe08a162e5a
-  data.tar.gz: 8d0d1d94558f9093b12a0595bf1f43a1ab1917f9
+  metadata.gz: 5a7725013756732b19e1d6cad4a23e39db1db597
+  data.tar.gz: fd41104e5db94a5f0e9e162e7addfb73cae71c66
 SHA512:
-  metadata.gz: bf40a03630e0bb7e5754f57ac3486804fcf80b2a0c8c4f76288f321962200de83b2961a3b421894cf6f064aff6e841812a79db39264ce9cdd8005e9323f1a4fb
-  data.tar.gz: 5c2cf3f1bbb0ab353ead915c34068e78ef52c52dc352ee300a8e4b9a481fb99d6ca6bc9a58cd29df4516330e4e9499c62c46117d5d50f485a00bd04bfe4d44d3
+  metadata.gz: 2192da1bfc5495095d66616f9800c63723df3a3041fa04dc2557583887469d3cb383de1242f55a90edd6db8f887b38f503dcd6bb6c57cffd35c72773381d3d1e
+  data.tar.gz: 44300b382803c33c2cd5c3cfe2a51b5ec6c6b4eed1ac6a2eb4cddfe0755e88ca634c98ea32e106377bbc31999bb635169289d9ed1e40f098fda4d8d61801b5ea

data/lib/display.rb

@@ -20,9 +20,7 @@ module XlibObj
     end
 
     def initialize(name)
-      display_pointer = Xlib.XOpenDisplay(name)
-      raise ArgumentError, "Unknown display #{name}" if display_pointer.null?
-      @struct = Xlib::Display.new(display_pointer)
+      @struct = Xlib::X.open_display(name)
     end
 
     def to_native
@@ -41,12 +39,38 @@ module XlibObj
       (0..@struct[:nscreens]-1).map{ |number| screen(number) }
     end
 
+    def extensions
+      @extensions ||= ['CORE', *Xlib::X.list_extensions(self)].map do |name|
+        Extension.for(self, name)
+      end
+    end
+
+    def input_devices
+      device_infos = Xlib::XI.query_device(self, Xlib::XIAllDevices)
+      device_ids = device_infos.map{ |dev| dev[:deviceid] }
+      Xlib::XI.free_device_info(device_infos.first)
+      device_ids.map do |device_id|
+        InputDevice.new(self, device_id)
+      end
+    end
+
+    def keyboards
+      input_devices.select(&:keyboard?)
+    end
+
+    def pointers
+      input_devices.select(&:pointer?)
+    end
+
     def focused_window
       screens.reduce(nil){ |focused_window, s| focused_window or s.focused_window }
     end
 
     def handle_events
-      handle_event(next_event) while pending_events > 0
+      while Xlib::X.pending(self) > 0
+        xevent = Xlib::X.next_event(self)
+        Event.new(self, xevent).extension_event.handle
+      end
     end
 
     def selection(*args, &on_receive)
@@ -61,7 +85,7 @@ module XlibObj
 
     def on_error(&callback)
       @error_handler = if callback
-        FFI::Function.new(:pointer, [:pointer, :pointer]) do |display_ptr, error_ptr|
+        FFI::Function.new(:int, [:pointer, :pointer]) do |display_ptr, error_ptr|
           next if display_ptr != to_native
           x_error = Xlib::XErrorEvent.new(error_ptr)
           callback.call Error.new(self, x_error)
@@ -87,8 +111,11 @@ module XlibObj
     end
 
     def flush
-      Xlib.XFlush(to_native)
-      handle_events
+      handle_events # XPending flushes the output buffer: http://tronche.com/gui/x/xlib/event-handling/XFlush.html
+    end
+
+    def close
+      Xlib::X.close_display(self)
     end
 
     private
@@ -97,22 +124,6 @@ module XlibObj
       @internal_window ||= screen.root_window.create_window
     end
 
-    def pending_events
-      Xlib.XPending(to_native)
-    end
-
-    def next_event
-      x_event = Xlib::XEvent.new
-      Xlib.XNextEvent(to_native, x_event) # blocks
-      Event.new(x_event)
-    end
-
-    def handle_event(event)
-      handling_window_id = event.event || event.parent || event.window || event.owner || event.requestor
-      handling_window = Window.new(self, handling_window_id)
-      handling_window.handle(event)
-    end
-
     def screen_pointer(number)
       @struct[:screens] + number*Xlib::Screen.size
     end

data/lib/error.rb

@@ -10,78 +10,50 @@ module XlibObj
   class Error < StandardError
     def initialize(display, error)
       @display = display
-      @error = error
-    end
-
-    def code
-      @error[:error_code]
-    end
-
-    def minor_code
-      @error[:minor_code]
-    end
-
-    def request
-      @error[:request_code]
-    end
-
-    def resource
-      @error[:resourceid]
+      @error_code = error[:error_code]
+      @request_code = error[:request_code]
+      @minor_code = error[:minor_code]
+      @resource = error[:resourceid]
     end
 
     def description
-      "#{general_description}\n" <<
-      " #{code_description}\n" <<
-      ((code >= 128) ? " #{minor_code_description}\n" : "") <<
-      " #{resource_description}"
+      "#{request_description}\n" <<
+      "Error: #{error_description}\n" <<
+      "Resource: #{resource_description}"
     end
+    alias_method :message, :description
 
-    def general_description
-      type_size = 2**16
-      type = FFI::MemoryPointer.new(:char, type_size)
-      Xlib.XGetErrorDatabaseText(@display.to_native, @display.name, 'XError', 'X Error', type,
-        type_size)
-
-      details_size = 2**16
-      details = FFI::MemoryPointer.new(:char, details_size)
-      Xlib.XGetErrorText(@display.to_native, code, details, details_size)
-
-      "#{type.read_string}: #{details.read_string}"
+    def request_description
+      @request_code < 128 ? major_request_description : minor_request_description
     end
 
-    def code_description
-      message_size = 2**16
+    def major_request_description
+      message_size = 256
       message = FFI::MemoryPointer.new(:char, message_size)
-      Xlib.XGetErrorDatabaseText(@display.to_native, @display.name, 'MajorCode',
-        'Request Major code %d', message, message_size)
-      message.read_string.gsub('%d', code.to_s)
+      Xlib.XGetErrorDatabaseText(@display.to_native, 'XRequest', "#{@request_code}",
+        "Major code #{@request_code}", message, message_size)
+      message.read_string
     end
 
-    def minor_code_description
-      message_size = 2**16
+    def minor_request_description
+      message_size = 256
       message = FFI::MemoryPointer.new(:char, message_size)
-      Xlib.XGetErrorDatabaseText(@display.to_native, @display.name, 'MinorCode',
-        'Request Minor code %d', message, message_size)
-      message.read_string.gsub('%d', minor_code.to_s)
+      extension = @display.extensions.find{ |ext| ext.opcode == @request_code }
+      Xlib.XGetErrorDatabaseText(@display.to_native, "XRequest.#{extension.name}", "#{@minor_code}",
+        "Minor code #{@minor_code}", message, message_size)
+      "#{extension.name} #{message.read_string}"
     end
 
-    def resource_description
-      message_size = 2**16
+    def error_description
+      message_size = 256
       message = FFI::MemoryPointer.new(:char, message_size)
+      Xlib.XGetErrorDatabaseText(@display.to_native, 'XProtoError', "#{@error_code}",
+        "Error code #{@error_code}", message, message_size)
+      message.read_string
+    end
 
-      if [Xlib::BadWindow, Xlib::BadPixmap, Xlib::BadCursor, Xlib::BadFont, Xlib::BadDrawable,
-        Xlib::BadColor, Xlib::BadGC, Xlib::BadIDChoice].include?(code)
-        Xlib.XGetErrorDatabaseText(@display.to_native, @display.name, "ResourceID",
-          "ResourceID %x", message, message_size)
-      elsif code == Xlib::BadValue
-        Xlib.XGetErrorDatabaseText(@display.to_native, @display.name, "Value", "Value 0x%x",
-          message, message_size)
-      elsif code == Xlib::BadAtom
-        Xlib.XGetErrorDatabaseText(@display.to_native, @display.name, "AtomID", "AtomID 0x%x",
-          message, message_size)
-      end
-
-      message.read_string.gsub('%x', resource.to_s)
+    def resource_description
+      @resource
     end
   end
 end

data/lib/event.rb

@@ -1,248 +1,40 @@
-#
-# Copyright (c) 2014 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 Event
-    def initialize(event)
-      @event = event
-      struct && (struct.members-[:type]).each do |key|
-        define_singleton_method(key) { struct[key] }
-      end
-    end
-
-    def name
-      @name ||= (x_name || xrr_name)
+    def initialize(display, xevent)
+      @display = display
+      @xevent = xevent
     end
 
-    def method_missing(name)
-      nil
-    end
+    attr_reader :xevent
 
-    private
     def type
-      @event[:type]
-    end
-
-    def struct
-      @struct ||= (xrr_struct || x_struct)
-    end
-
-    def union_member
-      self.class::TYPE_TO_UNION_MEMBER[type]
+      @xevent[:type]
     end
 
-    def x_struct
-      @event[union_member]
+    def generic?
+      type == Xlib::GenericEvent
     end
 
-    def xrr_type
-      type-self.class.xrr_type_offset(@event[:xany][:display])
+    def data?
+      @is_cookie ||= generic? && Xlib::X.get_event_data(@display, cookie)
     end
 
-    def xrr_struct
-      xrr_subtype_struct || xrr_type_struct
+    def cookie
+      @xevent[:xcookie]
     end
 
-    def xrr_type_struct
-      struct = self.class::RR_TYPE_TO_STRUCT[xrr_type]
-      struct.new(@event.pointer) if struct
+    def opcode
+      (data? and cookie[:extension])
     end
 
-    def xrr_subtype_struct
-      if xrr_type == Xlib::RRNotify
-        struct = self.class::RR_SUBTYPE_TO_STRUCT[xrr_type_struct[:subtype]]
-        struct.new(@event.pointer) if struct
+    def extension
+      @extension ||= @display.extensions.find do |ext|
+        data? ? opcode == ext.opcode : ext.event_range.include?(type)
       end
     end
 
-    def x_name
-      self.class::TYPE.key(type)
-    end
-
-    def xrr_name
-      xrr_subtype_name || xrr_type_name
-    end
-
-    def xrr_type_name
-      self.class::RR_TYPE.key(xrr_type)
-    end
-
-    def xrr_subtype_name
-      if xrr_type == Xlib::RRNotify
-        self.class::RR_SUBTYPE.key(xrr_type_struct[:subtype])
-      end
+    def extension_event
+      extension.event(data? ? cookie : xevent)
     end
   end
-
-  class Event
-    class << self
-      def xrr_type_offset(display)
-        @xrr_type_offset ||= {}
-        @xrr_type_offset[display] ||= (
-          rr_event_offset = FFI::MemoryPointer.new :int
-          rr_error_offset = FFI::MemoryPointer.new :int
-          Xlib.XRRQueryExtension(display, rr_event_offset, rr_error_offset)
-          rr_event_offset.read_int
-        )
-      end
-
-      def valid_name?(name)
-        TYPE[name] || RR_SUBTYPE[name] || RR_TYPE[name]
-      end
-    end
-
-    MASK = {
-      no_event:                 Xlib::NoEventMask,
-      key_press:                Xlib::KeyPressMask,
-      key_release:              Xlib::KeyReleaseMask,
-      button_press:             Xlib::ButtonPressMask,
-      button_release:           Xlib::ButtonReleaseMask,
-      enter_window:             Xlib::EnterWindowMask,
-      leave_window:             Xlib::LeaveWindowMask,
-      pointer_motion:           Xlib::PointerMotionMask,
-      pointer_motion_hint:      Xlib::PointerMotionHintMask,
-      button1_motion:           Xlib::Button1MotionMask,
-      button2_motion:           Xlib::Button2MotionMask,
-      button3_motion:           Xlib::Button3MotionMask,
-      button4_motion:           Xlib::Button4MotionMask,
-      button5_motion:           Xlib::Button5MotionMask,
-      button_motion:            Xlib::ButtonMotionMask,
-      keymap_state:             Xlib::KeymapStateMask,
-      exposure:                 Xlib::ExposureMask,
-      visibility_change:        Xlib::VisibilityChangeMask,
-      structure_notify:         Xlib::StructureNotifyMask,
-      resize_redirect:          Xlib::ResizeRedirectMask,
-      substructure_notify:      Xlib::SubstructureNotifyMask,
-      substructure_redirect:    Xlib::SubstructureRedirectMask,
-      focus_change:             Xlib::FocusChangeMask,
-      property_change:          Xlib::PropertyChangeMask,
-      colormap_change:          Xlib::ColormapChangeMask,
-      owner_grab_button:        Xlib::OwnerGrabButtonMask,
-      screen_change_notify:     Xlib::RRScreenChangeNotifyMask,
-      crtc_change_notify:       Xlib::RRCrtcChangeNotifyMask,
-      output_change_notify:     Xlib::RROutputChangeNotifyMask,
-      output_property_notify:   Xlib::RROutputPropertyNotifyMask,
-      provider_change_notify:   Xlib::RRProviderChangeNotifyMask,
-      provider_property_notify: Xlib::RRProviderPropertyNotifyMask,
-      resource_change_notify:   Xlib::RRResourceChangeNotifyMask
-    }
-
-    RR_MASK = {
-      screen_change_notify:     Xlib::RRScreenChangeNotifyMask,
-      crtc_change_notify:       Xlib::RRCrtcChangeNotifyMask,
-      output_change_notify:     Xlib::RROutputChangeNotifyMask,
-      output_property_notify:   Xlib::RROutputPropertyNotifyMask,
-      provider_change_notify:   Xlib::RRProviderChangeNotifyMask,
-      provider_property_notify: Xlib::RRProviderPropertyNotifyMask,
-      resource_change_notify:   Xlib::RRResourceChangeNotifyMask
-    }
-
-    TYPE = {
-      key_press:         Xlib::KeyPress,
-      key_release:       Xlib::KeyRelease,
-      button_press:      Xlib::ButtonPress,
-      button_release:    Xlib::ButtonRelease,
-      motion_notify:     Xlib::MotionNotify,
-      enter_notify:      Xlib::EnterNotify,
-      leave_notify:      Xlib::LeaveNotify,
-      focus_in:          Xlib::FocusIn,
-      focus_out:         Xlib::FocusOut,
-      keymap_notify:     Xlib::KeymapNotify,
-      expose:            Xlib::Expose,
-      graphics_expose:   Xlib::GraphicsExpose,
-      no_expose:         Xlib::NoExpose,
-      visibility_notify: Xlib::VisibilityNotify,
-      create_notify:     Xlib::CreateNotify,
-      destroy_notify:    Xlib::DestroyNotify,
-      unmap_notify:      Xlib::UnmapNotify,
-      map_notify:        Xlib::MapNotify,
-      map_request:       Xlib::MapRequest,
-      reparent_notify:   Xlib::ReparentNotify,
-      configure_notify:  Xlib::ConfigureNotify,
-      configure_request: Xlib::ConfigureRequest,
-      gravity_notify:    Xlib::GravityNotify,
-      resize_request:    Xlib::ResizeRequest,
-      circulate_notify:  Xlib::CirculateNotify,
-      circulate_request: Xlib::CirculateRequest,
-      property_notify:   Xlib::PropertyNotify,
-      selection_clear:   Xlib::SelectionClear,
-      selection_request: Xlib::SelectionRequest,
-      selection_notify:  Xlib::SelectionNotify,
-      colormap_notify:   Xlib::ColormapNotify,
-      client_message:    Xlib::ClientMessage,
-      mapping_notify:    Xlib::MappingNotify,
-      generic_event:     Xlib::GenericEvent,
-      last_event:        Xlib::LASTEvent
-    }
-
-    RR_TYPE = {
-      screen_change_notify: Xlib::RRScreenChangeNotify,
-      notify:               Xlib::RRNotify
-    }
-
-    RR_SUBTYPE = {
-      crtc_change_notify:       Xlib::RRNotify_CrtcChange,
-      output_change_notify:     Xlib::RRNotify_OutputChange,
-      output_property_notify:   Xlib::RRNotify_OutputProperty,
-      provider_change_notify:   Xlib::RRNotify_ProviderChange,
-      provider_property_notify: Xlib::RRNotify_ProviderProperty,
-      resource_change_notify:   Xlib::RRNotify_ResourceChange
-    }
-
-    TYPE_TO_UNION_MEMBER = {
-      Xlib::KeyPress         => :xkey,
-      Xlib::KeyRelease       => :xkey,
-      Xlib::ButtonPress      => :xbutton,
-      Xlib::ButtonRelease    => :xbutton,
-      Xlib::MotionNotify     => :xmotion,
-      Xlib::EnterNotify      => :xcrossing,
-      Xlib::LeaveNotify      => :xcrossing,
-      Xlib::FocusIn          => :xfocus,
-      Xlib::FocusOut         => :xfocus,
-      Xlib::KeymapNotify     => :xkeymap,
-      Xlib::Expose           => :xexpose,
-      Xlib::GraphicsExpose   => :xgraphicsexpose,
-      Xlib::NoExpose         => :xnoexpose,
-      Xlib::VisibilityNotify => :xvisibility,
-      Xlib::CreateNotify     => :xcreatewindow,
-      Xlib::DestroyNotify    => :xdestroywindow,
-      Xlib::UnmapNotify      => :xunmap,
-      Xlib::MapNotify        => :xmap,
-      Xlib::MapRequest       => :xmaprequest,
-      Xlib::ReparentNotify   => :xreparent,
-      Xlib::ConfigureNotify  => :xconfigure,
-      Xlib::ConfigureRequest => :xconfigurerequest,
-      Xlib::GravityNotify    => :xgravity,
-      Xlib::ResizeRequest    => :xresizerequest,
-      Xlib::CirculateNotify  => :xcirculate,
-      Xlib::CirculateRequest => :xcirculaterequest,
-      Xlib::PropertyNotify   => :xproperty,
-      Xlib::SelectionClear   => :xselectionclear,
-      Xlib::SelectionRequest => :xselectionrequest,
-      Xlib::SelectionNotify  => :xselection,
-      Xlib::ColormapNotify   => :xcolormap,
-      Xlib::ClientMessage    => :xclient,
-      Xlib::MappingNotify    => :xmapping,
-      Xlib::GenericEvent     => :xgeneric
-    }
-
-    RR_TYPE_TO_STRUCT = {
-      Xlib::RRScreenChangeNotify => Xlib::XRRScreenChangeNotifyEvent,
-      Xlib::RRNotify             => Xlib::XRRNotifyEvent
-    }
-
-    RR_SUBTYPE_TO_STRUCT = {
-      Xlib::RRNotify_CrtcChange       => Xlib::XRRCrtcChangeNotifyEvent,
-      Xlib::RRNotify_OutputChange     => Xlib::XRROutputChangeNotifyEvent,
-      Xlib::RRNotify_OutputProperty   => Xlib::XRROutputPropertyNotifyEvent,
-      Xlib::RRNotify_ProviderChange   => Xlib::XRRProviderChangeNotifyEvent,
-      Xlib::RRNotify_ProviderProperty => Xlib::XRRProviderPropertyNotifyEvent,
-      Xlib::RRNotify_ResourceChange   => Xlib::XRRResourceChangeNotifyEvent
-    }
-  end
 end