xlib-objects 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d9c4da9ee32958e2f1e4e43b8835fdd448296e97
+  data.tar.gz: 785ff3eebe82631886e79e7dbb557c32b61bc6d0
+SHA512:
+  metadata.gz: 14374fec2bf80b0107b7c6caff07e1c9a0d532a9378cd85a70a9bf41491526043f48dc82b6d9203467e93d1ff449f2d3ea002d77a040e1512d74887413110482
+  data.tar.gz: 2acfd879198ce45c68c55230eff53d429d4c40fe128fa7272c910b5ad59a1485dc1f2673f445db33ec3cec06f56ad44341c12566a120bbec464eca6bdb151e81

data/lib/atom.rb

@@ -0,0 +1,34 @@
+#
+# 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 Atom
+    def initialize(display, atom)
+      @display = display
+      @to_native = if atom.is_a? Integer
+                     atom
+                   else
+                     Xlib.XInternAtom(@display.to_native, atom.to_s, false)
+                   end
+    end
+
+    attr_reader :to_native
+
+    def name
+      Xlib.XGetAtomName(@display.to_native, @to_native).to_sym
+    end
+
+    def exists?
+      @to_native != 0
+    end
+
+    def to_s
+      name.to_s
+    end
+  end
+end

data/lib/display.rb

@@ -0,0 +1,73 @@
+#
+# 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.
+#
+
+require 'socket'
+
+module XlibObj
+  class Display
+    class << self
+      def names
+        Dir['/tmp/.X11-unix/*'].map do |file_name|
+          match = file_name.match(/X(\d+)$/)
+          ":#{match[1]}" if match
+        end.compact
+      end
+    end
+
+    def initialize(name)
+      display_pointer = Xlib.XOpenDisplay(name)
+      raise ArgumentError, "Unknown display #{name}" if display_pointer.null?
+      @struct = Xlib::Display.new(display_pointer)
+    end
+
+    def to_native
+      @struct.pointer
+    end
+
+    def name
+      @struct[:display_name]
+    end
+
+    def socket
+      UNIXSocket.for_fd(Xlib.XConnectionNumber(to_native))
+    end
+
+    def screens
+      (0..@struct[:nscreens]-1).map{ |number| screen(number) }
+    end
+
+    def handle_events
+      handle_event(next_event) while pending_events > 0
+    end
+
+    private
+    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
+      handling_window = Window.new(self, handling_window_id)
+      handling_window.handle(event)
+    end
+
+    def screen_pointer(number)
+      @struct[:screens] + number*Xlib::Screen.size
+    end
+
+    def screen(number)
+      Screen.new(self, screen_pointer(number))
+    end
+  end
+end

data/lib/event/client_message.rb

@@ -0,0 +1,63 @@
+#
+# 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
+    class ClientMessage
+      def initialize(type=nil, data=nil, subject=nil)
+        self.type = type
+        self.data = data
+        self.subject = subject
+      end
+
+      attr_writer :subject, :data, :type
+
+      def send_to(receiver)
+        raise "The client message needs a type at least." unless @type
+        @receiver = receiver
+        Xlib.XSendEvent(@receiver.display.to_native, @receiver.to_native, false,
+          Xlib::SubstructureNotifyMask | Xlib::SubstructureRedirectMask,
+          to_native)
+        Xlib.XFlush(@receiver.display.to_native)
+      end
+
+      private
+      def to_native
+        event = Xlib::XEvent.new
+        event[:xclient][:type]         = Xlib::ClientMessage
+        event[:xclient][:message_type] = message_type
+        event[:xclient][:window]       = (@subject || @receiver).to_native
+
+        if @data
+          event[:xclient][:format] = format
+          @data.each_with_index do |item, idx|
+            event[:xclient][:data][data_member][idx] = item
+          end
+        end
+
+        event.pointer
+      end
+
+      def message_type
+        Atom.new(@receiver.display, @type).to_native
+      end
+
+      def format
+        160/@data.size
+      end
+
+      def data_member
+        case @data.size
+        when 5  then :l
+        when 10 then :s
+        else :b
+        end
+      end
+    end
+  end
+end

data/lib/event.rb

@@ -0,0 +1,248 @@
+#
+# 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)
+    end
+
+    def method_missing(name)
+      nil
+    end
+
+    private
+    def type
+      @event[:type]
+    end
+
+    def struct
+      @struct ||= (xrr_struct || x_struct)
+    end
+
+    def union_member
+      self.class::TYPE_TO_UNION_MEMBER[type]
+    end
+
+    def x_struct
+      @event[union_member]
+    end
+
+    def xrr_type
+      type-self.class.xrr_type_offset(@event[:xany][:display])
+    end
+
+    def xrr_struct
+      xrr_subtype_struct || xrr_type_struct
+    end
+
+    def xrr_type_struct
+      struct = self.class::RR_TYPE_TO_STRUCT[xrr_type]
+      struct.new(@event.pointer) if struct
+    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
+      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
+    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

data/lib/screen/crtc/output.rb

@@ -0,0 +1,49 @@
+#
+# 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 Screen
+    class Crtc
+      class Output
+        def initialize(crtc, id)
+          @crtc = crtc
+          @id = id
+
+          ObjectSpace.define_finalizer(self) do
+            Xlib.XRRFreeOutputInfo(@attributes.pointer) if @attributes
+          end
+        end
+
+        attr_reader :crtc, :id
+
+        def attribute(attribute)
+          return unless attributes.layout.members.include? attribute.to_sym
+          attributes[attribute.to_sym]
+        end
+
+        def method_missing(name)
+          attribute(name)
+        end
+
+        private
+        def attributes
+          unless @attributes
+            screen_resources_ptr = Xlib.XRRGetScreenResources(@crtc.screen.
+              display.to_native, @crtc.screen.root_window.to_native)
+            output_info_ptr = Xlib.XRRGetOutputInfo(@crtc.screen.display.
+              to_native, screen_resources_ptr, @id)
+            @attributes = Xlib::XRROutputInfo.new(output_info_ptr)
+            Xlib.XRRFreeScreenResources(screen_resources_ptr)
+          end
+
+          @attributes
+        end
+      end
+    end
+  end
+end

data/lib/screen/crtc.rb

@@ -0,0 +1,63 @@
+#
+# 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 Screen
+    class Crtc
+      def initialize(screen, id)
+        @screen = screen
+        @id = id
+
+        ObjectSpace.define_finalizer(self) do
+          Xlib.XRRFreeCrtcInfo(@attributes.pointer) if @attributes
+        end
+      end
+
+      attr_reader :screen, :id
+
+      def attribute(attribute)
+        return unless attributes.layout.members.include? attribute.to_sym
+        attributes[attribute.to_sym]
+      end
+
+      def method_missing(name)
+        attribute(name)
+      end
+
+      def outputs
+        (0..attribute(:noutput)-1).map do |output_number|
+          output_id(attribute(:outputs), output_number)
+        end.map do |output_id|
+          Output.new(self, output_id)
+        end
+      end
+
+      private
+      def attributes
+        unless @attributes
+          screen_resources_ptr = Xlib.XRRGetScreenResources(@screen.
+            display.to_native, @screen.root_window.to_native)
+          crtc_info_ptr = Xlib.XRRGetCrtcInfo(@screen.display.to_native,
+            screen_resources_ptr, @id)
+          @attributes = Xlib::XRRCrtcInfo.new(crtc_info_ptr)
+          Xlib.XRRFreeScreenResources(screen_resources_ptr)
+        end
+
+        @attributes
+      end
+
+      def read_item(pointer, item_pos, item_size)
+        (pointer + item_pos*item_size).read_ulong
+      end
+
+      def output_id(pointer, number)
+        read_item(pointer, number, FFI.type_size(:RROutput))
+      end
+    end
+  end
+end

data/lib/screen.rb

@@ -0,0 +1,70 @@
+#
+# 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 Screen
+    def initialize(display, screen_pointer)
+      @display = display
+      @struct = Xlib::Screen.new(screen_pointer)
+
+      ObjectSpace.define_finalizer(self) do
+        Xlib.XRRFreeScreenResources(@resources.pointer) if @resources
+      end
+    end
+
+    attr_reader :display
+
+    def to_native
+      @struct.pointer
+    end
+
+    def attribute(name)
+      return unless @struct.layout.members.include? name.to_sym
+      @struct[name]
+    end
+
+    def method_missing(name)
+      attribute(name)
+    end
+
+    def number
+      Xlib.XScreenNumberOfScreen(to_native)
+    end
+
+    def root_window
+      @root_window ||= Window.new(@display, Xlib.XRootWindowOfScreen(to_native))
+    end
+
+    def crtcs
+      (0..resources[:ncrtc]-1).map do |crtc_number|
+        crtc_id(resources[:crtcs], crtc_number)
+      end.map do |crtc_id|
+        Crtc.new(self, crtc_id)
+      end
+    end
+
+    private
+    def resources
+      unless @resources
+        resources_ptr = Xlib.XRRGetScreenResources(@display.to_native,
+          root_window.to_native)
+        @resources = Xlib::XRRScreenResources.new(resources_ptr)
+      end
+
+      @resources
+    end
+
+    def read_item(pointer, item_pos, item_size)
+      (pointer + item_pos*item_size).read_ulong
+    end
+
+    def crtc_id(pointer, number)
+      read_item(pointer, number, FFI.type_size(:RRCrtc))
+    end
+  end
+end

data/lib/window/event_handler.rb

@@ -0,0 +1,118 @@
+#
+# 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 Window
+    class EventHandler
+      class << self
+        def singleton(display, window_id)
+          @handlers ||= {}
+          @handlers[display] ||= {}
+          @handlers[display][window_id] ||= new(display, window_id)
+        end
+      end
+
+      def initialize(display, window_id)
+        @display = display
+        @window_id = window_id
+        @event_handlers = {}
+        @event_mask = 0
+        @rr_event_mask = 0
+      end
+
+      def on(mask, event, &handler)
+        add_event_mask(mask)
+        add_event_handler(mask, event, &handler)
+      end
+
+      def off(mask, type, handler)
+        remove_event_handler(mask, type, 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
+        end
+      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
+      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
+      end
+
+      def add_event_handler(mask, event, &handler)
+        check_event(event)
+        @event_handlers[event] ||= {}
+        @event_handlers[event][mask] ||= []
+        @event_handlers[event][mask] << 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)
+        @event_handlers[event].delete(mask) if @event_handlers[event][mask].empty?
+        @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 normalize_mask(mask).zero? && normalize_rr_mask(mask).zero?
+          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)
+        Xlib.XFlush(@display.to_native)
+      end
+    end
+  end
+end

data/lib/window/property.rb

@@ -0,0 +1,177 @@
+#
+# 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 Window
+    class Property
+      def initialize(window, name)
+        @window = window
+        @name = name
+        @atom = Atom.new(window.display, name)
+      end
+
+      def get
+        return unless @atom.exists?
+
+        data_offset     = 0
+        data_max_length = 2**16  # multiple of 32 bit
+        allow_deleted   = false  # don't retrieve deleted properties
+        requested_type  = Xlib::AnyPropertyType
+
+        # response data
+        pointer     = FFI::MemoryPointer.new :pointer
+        item_type   = FFI::MemoryPointer.new :Atom
+        item_width  = FFI::MemoryPointer.new :int
+        item_count  = FFI::MemoryPointer.new :ulong
+        cutoff_data = FFI::MemoryPointer.new :ulong
+
+        # do and validate the request
+        status = Xlib.XGetWindowProperty(
+          @window.display.to_native, @window.to_native, @atom.to_native,
+          data_offset, data_max_length, allow_deleted, requested_type,
+          item_type, item_width, item_count, cutoff_data, pointer
+        )
+
+        return unless status == 0
+
+        return if pointer.read_pointer.null? # property is not set for the window
+
+        # extract response data
+        item_type = Atom.new(@window.display, item_type.read_int).name
+        item_width = item_width.read_int
+        item_count = item_count.read_int
+
+        return if item_count == 0
+
+        # get the property's value
+        bytes = read_bytes(pointer, item_width, item_count)
+        items = bytes_to_items(bytes, item_type, item_count)
+
+        return if items.empty?
+
+        items_to_objects(items, item_type)
+      end
+
+      def set(value, type = nil)
+        objects = value.is_a?(Array) ? value : [value]
+        item_type = type || type_from_objects(objects)
+        items = objects_to_items(objects, item_type)
+        item_width = width_from_type(item_type)
+        bytes = items_to_bytes(items, item_type)
+        item_count = item_type[-6..-1] == 'STRING' ? bytes.size : items.size
+
+        Xlib.XChangeProperty(
+          @window.display.to_native, @window.to_native, @atom.to_native,
+          Atom.new(@window.display, item_type).to_native, item_width,
+          Xlib::PropModeReplace, bytes, item_count)
+        Xlib.XFlush(@window.display.to_native)
+        self
+      end
+
+      private
+      def read_bytes(pointer, width, count)
+        pointer.read_pointer.read_string(count*native_width(width))
+      end
+
+      def native_width(width)
+        # translate word size to platform dependent bit count
+        FFI.type_size({ 8 => :char, 16 => :short, 32 => :long }[width])
+      end
+
+      def width(native_width)
+        { char: 8, short: 16, long: 32 }[native_width]
+      end
+
+      def bytes_to_items(bytes, type, item_count)
+        if [:STRING, :UTF8_STRING].include? type
+          bytes.split("\0")
+        else
+          bytes.unpack(format(type) * item_count)
+        end
+      end
+
+      def items_to_bytes(items, type)
+        items.pack(format(type) * items.size)
+      end
+
+      def format(type)
+        case type
+        when :INTEGER     then 'i!'
+        when :CARDINAL    then 'L!'
+        when :ATOM        then 'L!'
+        when :WINDOW      then 'L!'
+        when :STRING      then 'Z*'
+        when :UTF8_STRING then 'Z*'
+        else 'a'
+        end
+      end
+
+      def items_to_objects(items, type)
+        transform = case type
+                    when :UTF8_STRING
+                      Proc.new{ |s| s.force_encoding('UTF-8') }
+                    when :ATOM
+                      Proc.new{ |a| Atom.new(@window.display, a) }
+                    when :WINDOW
+                      Proc.new{ |w| Window.new(@window.display, w) }
+                    else
+                      Proc.new{ |a| a }
+                    end
+
+        items.map(&transform)
+      end
+
+      def objects_to_items(objects, type)
+        transform = case type
+                    when :ATOM
+                      Proc.new{ |a| a.to_native }
+                    when :WINDOW
+                      Proc.new{ |w| w.to_native }
+                    else
+                      Proc.new{ |a| a }
+                    end
+
+        objects.map(&transform)
+      end
+
+      def type_from_objects(objects)
+        if objects.all? { |o| o.is_a? Window }
+          :WINDOW
+        elsif objects.all? { |o| o.is_a? Atom }
+          :ATOM
+        elsif objects.all? { |o| o.is_a? Integer }
+          if objects.any? { |o| o <= 0 }
+            :INTEGER
+          else
+            :CARDINAL
+          end
+        elsif objects.all? { |o| o.is_a? String }
+          if objects.any? { |o| o.encoding == Encoding::UTF_8 }
+            :UTF8_STRING
+          else
+            :STRING
+          end
+        else
+          :BYTES
+        end
+      end
+
+      def width_from_type(type)
+        case type
+        when :INTEGER     then 16
+        when :CARDINAL    then 32
+        when :ATOM        then 32
+        when :WINDOW      then 32
+        when :STRING      then 8
+        when :UTF8_STRING then 8
+        else 8
+        end
+      end
+    end
+  end
+end

data/lib/window.rb

@@ -0,0 +1,108 @@
+#
+# 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 Window
+    def initialize(display, window_id)
+      @display = display
+      @to_native = window_id
+      @event_handler = EventHandler.singleton(display, window_id)
+    end
+
+    # Queries
+    attr_reader :display, :to_native
+    alias_method :id, :to_native
+
+    def attribute(name)
+      attributes = Xlib::WindowAttributes.new
+      Xlib.XGetWindowAttributes(@display.to_native, @to_native, attributes.
+        pointer)
+      attributes[name.to_sym]
+    rescue
+      nil
+    end
+
+    def method_missing(name)
+      attribute(name)
+    end
+
+    def screen
+      Screen.new(@display, attribute(:screen))
+    end
+
+    def property(name)
+      Property.new(self, name).get
+    end
+
+    def set_property(name, value)
+      Property.new(self, name).set(value)
+    end
+
+    def absolute_position
+      x_abs = FFI::MemoryPointer.new :int
+      y_abs = FFI::MemoryPointer.new :int
+      child = FFI::MemoryPointer.new :Window
+      root_win = screen.root_window
+
+      Xlib.XTranslateCoordinates(@display.to_native, @to_native,
+        root_win.to_native, 0, 0, x_abs, y_abs, child)
+
+      { x: x_abs.read_int, y: y_abs.read_int }
+    end
+
+    # Commands
+    def move_resize(x, y, width, height)
+      Xlib.XMoveResizeWindow(@display.to_native, @to_native, x, y, width,
+        height)
+      Xlib.XFlush(@display.to_native)
+      self
+    end
+
+    def map
+      Xlib.XMapWindow(@display.to_native, @to_native)
+      Xlib.XFlush(@display.to_native)
+      self
+    end
+
+    def unmap
+      Xlib.XUnmapWindow(@display.to_native, @to_native)
+      Xlib.XFlush(@display.to_native)
+      self
+    end
+
+    def iconify
+      Xlib.XIconifyWindow(@display.to_native, @to_native, screen.number)
+      Xlib.XFlush(@display.to_native)
+      self
+    end
+
+    def raise
+      Xlib.XRaiseWindow(@display.to_native, @to_native)
+      Xlib.XFlush(@display.to_native)
+      self
+    end
+
+    def on(mask, type, &callback)
+      @event_handler.on(mask, type, &callback)
+    end
+
+    def off(mask, type, callback)
+      @event_handler.off(mask, type, callback)
+      self
+    end
+
+    def handle(event)
+      @event_handler.handle(event)
+      self
+    end
+
+    def send_to_itself(type, data = nil, subject = nil)
+      Event::ClientMessage.new(type, data, subject).send_to(self)
+    end
+  end
+end

data/lib/xlib-objects.rb

@@ -0,0 +1,22 @@
+#
+# 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.
+#
+
+require 'xlib'
+
+module XlibObj; end
+
+require_relative 'atom'
+require_relative 'display'
+require_relative 'event'
+require_relative 'event/client_message'
+require_relative 'screen'
+require_relative 'screen/crtc'
+require_relative 'screen/crtc/output'
+require_relative 'window'
+require_relative 'window/property'
+require_relative 'window/event_handler'

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: xlib-objects
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Christopher Aue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xlib
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks-matchers-send_message
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: Ruby bindings for X11
+email: mail@christopheraue.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/atom.rb
+- lib/display.rb
+- lib/event.rb
+- lib/event/client_message.rb
+- lib/screen.rb
+- lib/screen/crtc.rb
+- lib/screen/crtc/output.rb
+- lib/window.rb
+- lib/window/event_handler.rb
+- lib/window/property.rb
+- lib/xlib-objects.rb
+homepage: https://github.com/christopheraue/ruby-xlib-objects
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A light object wrapper around xlib
+test_files: []