active_window_x 0.0.1

data/lib/active_window_x/atom.rb

@@ -0,0 +1,30 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module ActiveWindowX
+
+  # binding for Atom on X11
+  class Atom < Xid
+    @@cache = {}
+
+    def initialize display, second
+      if second.kind_of? Numeric
+        super
+      elsif second.kind_of? String
+        super
+        @id = display.intern_atom second
+        if @id == Xlib::None
+          raise ArgumentError, 'invalid an atom name: #{second}'
+        end
+      else
+        raise ArgumentError, 'expect Numeric or String with the second argument'
+      end
+    end
+
+    alias :intern :id
+
+    def name
+      @display.atom_name @id
+    end
+  end
+
+end

data/lib/active_window_x/client_message_event.rb

@@ -0,0 +1,44 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module ActiveWindowX
+
+  # binding for XClientMessageEvent on X11
+  class ClientMessageEvent < Event
+
+    # the number of last request processed by server
+    attr_reader :serial
+
+    # true if this came from a SendEvent request
+    attr_reader :send_event
+
+    # Display the event was read from
+    attr_reader :display
+
+    # the window whose associated property was changed
+    attr_reader :window
+
+    # an atom that indicates how the data should be interpreted
+    # by the receiving client
+    attr_reader :message_type
+
+    # 8, 16, or 32 and specifies whether the data should be viewed
+    # as a list of bytes, shorts, or longs
+    attr_reader :format
+
+    # a union that contains the members b, s, and l.  The b, s, and l members
+    # represent data of twenty 8-bit values, ten 16-bit values,
+    # and five 32-bit values
+    attr_reader :data
+
+    def initialize display, raw
+      super
+      @serial = raw.serial
+      @send_event = (raw.send_event != 0)
+      @display = display
+      @window = Window.new display, raw.window
+      @message_type = Atom.new display, raw.message_type
+      @format = raw.message_type
+      @data = raw.data
+    end
+  end
+end

data/lib/active_window_x/display.rb

@@ -0,0 +1,79 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module ActiveWindowX
+
+  # binding for Display on X11
+  class Display
+
+    # raw class of Display
+    attr_reader :raw
+
+    # a boolean which be true if this display was closed
+    attr_reader :closed
+    alias :closed? :closed
+
+    def initialize arg=nil
+      @raw =
+        if arg.nil? or arg.kind_of? String
+          Xlib::x_open_display arg
+        elsif arg.kind_of? Xlib::Display
+          arg
+        else
+          raise ArgumentError, 'expect nil, String or Xlib::Display'
+        end
+      @closed = false
+      @root_window = nil
+      @cache = {}
+    end
+
+    def close
+      Xlib::x_close_display @raw
+      @closed = true
+    end
+
+    def root_window
+      @root_window ||= RootWindow.new(self, Xlib::default_root_window(@raw))
+    end
+
+    # return IO to select and poll a XEvent with timeout
+    def connection
+      @conn ||= IO.new(Xlib::connection_number @raw)
+    end
+
+    # return the number of events that have been received from the X server
+    def pending
+      Xlib::x_pending @raw
+    end
+
+    def active_window
+      root_window.active_window
+    end
+
+    def intern_atom name
+      if @cache.has_key? name
+        @cache[name]
+      else
+        @cache[name] = Xlib::x_intern_atom @raw, name, false
+      end
+    end
+
+    def atom_name id
+      if @cache.has_key? id
+        @cache[id]
+      else
+        @cache[id] = Xlib::x_get_atom_name @raw, id
+      end
+    end
+
+    def next_event
+      xevent = Xlib::x_next_event @raw
+
+      case xevent.type
+      when Xlib::PropertyNotify; PropertyEvent.new self, xevent
+      when Xlib::ClientMessage; ClientMessageEvent.new self, xevent
+      else Event.new self, xevent
+      end
+    end
+  end
+
+end

data/lib/active_window_x/event.rb

@@ -0,0 +1,15 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module ActiveWindowX
+
+  # event type
+  attr_reader :type
+
+  # binding for XEvent on X11
+  class Event
+    def initialize display, raw
+      @type = raw.type
+    end
+  end
+
+end

data/lib/active_window_x/event_listener.rb

@@ -0,0 +1,119 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module ActiveWindowX
+
+  # listen event changing active window
+  class EventListener
+
+    DEFAULT_TIMEOUT = 0.5
+
+    # current active window
+    attr_reader :active_window
+
+    # true  if #start loop continued
+    # false if #start loop did not continue
+    # nil   if #start loop was not started
+    # set false if you want to terminate #start loop when next timeout or event receiving
+    attr_accessor :continue
+
+    def initialize name=nil, timeout=DEFAULT_TIMEOUT, &block
+      @display = Display.new name
+      @default_timeout = timeout
+
+      @root = @display.root_window
+      @aw_atom = Atom.new @display, '_NET_ACTIVE_WINDOW'
+      @name_atom = Atom.new @display, 'WM_NAME'
+      @delete_atom = Atom.new @display, 'WM_DELETE_WINDOW'
+      @conn = @display.connection
+      @active_window = @root.active_window
+
+      @active_window.select_input Xlib::PropertyChangeMask if @active_window
+      @root.select_input Xlib::PropertyChangeMask
+
+      if block_given?
+        start @default_timeout, &block
+      end
+    end
+
+    # event listener loop
+    #
+    # ActiveWindowX::EventListener.new.start do |e|
+    #   puts e.type, e.window.id
+    # end
+    def start timeout=@default_timeout
+
+      if not block_given?
+        raise ArgumentError, 'expect to give a block'
+      end
+
+      @continue = true
+      begin
+        while @continue
+          event = listen timeout
+          next if not event
+
+          if window_closed?(event.window)
+            event.window = @root.active_window
+          end
+          yield event if event.type
+        end
+      ensure
+        destroy
+      end
+    end
+
+    def destroy
+      @display.close if @display.closed?
+    end
+
+    # receive a event
+    #
+    # return value:
+    #  a ActiveWindowX::EventListener::Event if an event was send within _timeout_ sec
+    #  nil if timeout
+    def listen timeout=nil
+      if @display.pending == 0 and
+          select([@conn], [], [], timeout) == nil
+        # ope on timeout
+        return nil
+      end
+
+      type = nil
+      active_window = nil
+
+      event = @display.next_event
+      if event.atom == @aw_atom
+        type = :active_window
+        active_window = @root.active_window
+      elsif event.atom == @name_atom
+        type = :title
+        active_window = event.window
+      end
+
+      if type == :active_window and @active_window != active_window
+        @active_window.select_input(Xlib::NoEventMask) if @active_window
+        @active_window = active_window
+        @active_window.select_input(Xlib::PropertyChangeMask) if @active_window
+      end
+
+      Event.new type, active_window
+    end
+
+    def window_closed? w
+      return false if w.nil?
+      begin
+        w.prop_raw 'WM_STATE'
+        false
+      rescue Xlib::XErrorEvent
+        true
+      end
+    end
+
+    class Event
+      attr_accessor :type, :window
+      def initialize type, window
+        @type = type; @window = window
+      end
+    end
+  end
+end

data/lib/active_window_x/property_event.rb

@@ -0,0 +1,46 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module ActiveWindowX
+
+  # binding for XPropertyEvent on X11
+  class PropertyEvent < Event
+
+    # the number of last request processed by server
+    attr_reader :serial
+
+    # true if this came from a SendEvent request
+    attr_reader :send_event
+
+    # Display the event was read from
+    attr_reader :display
+
+    # the window whose associated property was changed
+    attr_reader :window
+
+    # the property's atom and indicates which property was changed or desired
+    attr_reader :atom
+
+    # the server time when the property was changed
+    attr_reader :time
+
+    # * PropertyNewValue when a property of the window is changed using
+    #   XChangeProperty or XRotateWindowProperties (even when adding zero-length
+    #   data using XChangeProperty) and when replacing all or part of a property
+    #   with identical data using XChangeProperty or XRotateWindowProperties.
+    # * PropertyDelete when a property of the window is deleted using
+    #   XDeleteProperty or, if the delete argument is True, XGetWindowProperty
+    attr_reader :state
+
+    def initialize display, raw
+      super
+      @serial = raw.serial
+      @send_event = (raw.send_event != 0)
+      @display = display
+      @window = Window.new display, raw.window
+      @atom = Atom.new display, raw.atom
+      @time = raw.time
+      @state = raw.state
+    end
+  end
+
+end

data/lib/active_window_x/root_window.rb

@@ -0,0 +1,20 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require "active_window_x/window"
+
+module ActiveWindowX
+
+  # binding for a root Window on X11
+  class RootWindow < Window
+
+    def active_window
+      prop_val = prop '_NET_ACTIVE_WINDOW'
+      if prop_val.nil? or prop_val.first == Xlib::None
+        nil
+      else
+        Window.new(@display, prop_val.first)
+      end
+    end
+
+  end
+end

data/lib/active_window_x/version.rb

@@ -0,0 +1,3 @@
+module ActiveWindowX
+  VERSION = "0.0.1"
+end

data/lib/active_window_x/window.rb

@@ -0,0 +1,123 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module ActiveWindowX
+
+  # binding for Window on X11
+  class Window < Xid
+
+    # a buffer for #x_get_window_property
+    READ_BUFF_LENGTH = 1024
+
+    def x_query_tree
+      Xlib::x_query_tree @display.raw, @id
+    end
+
+    # a return value of XQueryTree
+    # which is the root window for a display contains this window
+    def root
+      (r = x_query_tree[0]) and Window.new(@display, r)
+    end
+
+    # a return value of XQueryTree
+    # which is nil, if this window is RootWindow, or a Window.
+    def parent
+      (r = x_query_tree[1]) and Window.new(@display, r)
+    end
+
+    # a return value of XQueryTree
+    # which is an Array of Window
+    def children
+      x_query_tree[2].map{|w| Window.new(@display, w)}
+    end
+
+    # window title (current web page title in browser, current command or dir in terminal app, etc.)
+    def title
+      title = prop('_NET_WM_NAME')
+      title or prop('WM_NAME')
+    end
+
+    # window name (terminal, google-chrome, etc.)
+    def app_name
+      val = app_class_prop
+      val and val[0]
+    end
+
+    # window class (Terminal, Google-chrome, etc.)
+    # TODO write the difference of app_name and app_class
+    def app_class
+      val = app_class_prop
+      val and val[1]
+    end
+
+    def app_class_prop
+      val = prop('WM_CLASS')
+      val and val.split("\0")
+    end
+
+    def pid
+      val = prop('_NET_WM_PID')
+      val and val.first
+    end
+
+    def command
+      id = pid
+      return nil if id.nil?
+
+      path = "/proc/#{id}/cmdline"
+      return nil unless File.readable_real? path
+
+      File.read path
+    end
+
+    # window property getter with easy way for XGetWindowProperty
+    # which return nil, if the specified property name does not exist,
+    # a String or a Array of Number
+    def prop atom
+      val, format, nitems = prop_raw atom
+      case format
+      when 32; val.unpack("l!#{nitems}")
+      when 16; val.unpack("s#{nitems}")
+      when 8; val[0, nitems]
+      when 0; nil
+      end
+    end
+
+    # window property getter with easy way for XGetWindowProperty
+    # which return [propety_value, format, number_of_items]
+    def prop_raw atom
+      if atom.kind_of?(Numeric) or atom.kind_of?(String)
+        atom = Atom.new @display, atom
+      elsif not atom.kind_of? Atom
+        raise ArgumentError, "expect Numeric, String or #{Atom.name}"
+      end
+      actual_type, actual_format, nitems, bytes_after, val =
+        Xlib::x_get_window_property @display.raw, @id, atom.id, 0, READ_BUFF_LENGTH, false, Xlib::AnyPropertyType
+      return [val, actual_format, nitems]
+    end
+
+    # Array of the property atom ID(Numeric) list for this window
+    def prop_atom_ids
+      r = Xlib::x_list_properties @display.raw, @id
+      r.nil? ? [] : r
+    end
+
+    # Array of the property atom list for this window
+    def prop_atoms
+      prop_atom_ids.map{|i| Atom.new @display, i}
+    end
+
+    def select_input mask
+      Xlib::x_select_input @display.raw, @id, mask
+    end
+
+    def set_wm_protocols msgs
+      atoms =
+        if msgs.kind_of? Atom then [msgs.id]
+        elsif msgs.kind_of? Array then msgs.map {|m| m.id }
+        else raise ArgumentError, 'expect Atom or Array of Atom'
+        end
+      Xlib::x_set_wm_protocols @display.raw, @id, atoms
+    end
+  end
+
+end

data/lib/active_window_x/xid.rb

@@ -0,0 +1,29 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module ActiveWindowX
+
+  # binding for XID on X11
+  class Xid
+    # a display which has this XID
+    attr_reader :display
+
+    # raw XID (#define Window unsinged long)
+    attr_reader :id
+
+    def initialize display, id
+      if display.kind_of? Display
+        @display = display
+      elsif display.kind_of? Xlib::Display
+        @display = Display.new display
+      else
+        raise ArgumentError, "expect #{Display.name} or #{Xlib::Display.name}"
+      end
+      @id ||= id
+    end
+
+    def == xid
+      xid.kind_of?(Xid) and (xid.id == @id)
+    end
+  end
+
+end

data/lib/active_window_x.rb

@@ -0,0 +1,30 @@
+# -*- coding:undecided-unix; mode:ruby; -*-
+
+require "active_window_x/version"
+require "active_window_x/xlib"
+require "active_window_x/display"
+require "active_window_x/xid"
+require "active_window_x/window"
+require "active_window_x/root_window"
+require "active_window_x/atom"
+require "active_window_x/event"
+require "active_window_x/property_event"
+require "active_window_x/client_message_event"
+require "active_window_x/event_listener"
+
+module ActiveWindowX
+  module Xlib; end
+
+  class Display; end
+
+  class XID; end
+  class Window < Xid; end
+  class RootWindow < Window; end
+  class Atom < Xid; end
+
+  class Event; end
+  class PropertyEvent < Event; end
+  class ClientMessageEvent < Event; end
+
+  class EventListener; end
+end

data/sample/active_window_dump.rb

@@ -0,0 +1,30 @@
+# dump all properties of window on changing active window
+
+require 'active_window_x'
+
+@listener = ActiveWindowX::EventListener.new
+
+# when pressing Ctrl-C
+trap :INT do
+  @listener.destroy
+  exit true
+end
+
+@listener.start do |e|
+  next until e.window
+
+  w = e.window
+  puts <<__OUTPUT__ if e.type == :active_window
+######### change active window  #########
+     id:	#{w.id}
+     title:	#{w.title}
+     name:	#{w.app_name}
+     class:	#{w.app_class}
+     pid:	#{w.pid}
+     command:	#{w.command}
+__OUTPUT__
+  puts <<__OUTPUT__ if e.type == :title
+######### change title #########
+     title:	#{w.title}
+__OUTPUT__
+end

data/sample/simple.rb

@@ -0,0 +1,6 @@
+
+require 'active_window_x'
+
+ActiveWindowX::EventListener.new do |e|
+  puts "#{e.type}:\t#{e.window}"
+end

data/spec/atom_spec.rb

@@ -0,0 +1,27 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'active_window_x'
+
+include ActiveWindowX
+
+describe Atom do
+  before do
+    @raw_display = mock Xlib::Display
+    @display = mock Display
+    @display.stub(:raw){@raw_display}
+    @display.stub(:kind_of?).with(Display).and_return(true)
+    @id = 123
+    @atom = Atom.new @display, @id
+  end
+
+  describe '#name' do
+    before do
+      @name = 'FOOO'
+      @display.should_receive(:atom_name).twice.with(@id).and_return(@name)
+    end
+    it 'should return a String as an atom name' do
+      @atom.name.should == @name
+      @atom.name.should == @name
+    end
+  end
+end

data/spec/display_spec.rb

@@ -0,0 +1,63 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'active_window_x'
+
+include ActiveWindowX
+
+describe Display do
+  before do
+    @display_raw = mock Xlib::Display
+    Xlib.stub(:x_open_display).and_return(@display_raw)
+    @display = Display.new nil
+    @root_id = 9999
+    Xlib.stub(:default_root_window).with(@display_raw).and_return(@root_id)
+    Xlib.stub(:x_select_input).and_return(1)
+  end
+
+  describe '#root_window' do
+    it 'should return the root window' do
+      r = @display.root_window
+      r.id.should == @root_id
+      r.should be_a RootWindow
+    end
+  end
+
+  describe '#next_event' do
+    before do
+      @root = @display.root_window
+      @root.select_input Xlib::PropertyChangeMask
+      @event = mock Xlib::XPropertyEvent
+      @event.stub(:type){@type}
+      @event.stub(:serial){1000}
+      @event.stub(:send_event){0}
+      @event.stub(:time){2000}
+      @event.stub(:state){nil}
+      @window_id = 222
+      @event.stub(:window){@window_id}
+      @atom_id = 333
+      @event.stub(:atom){@atom_id}
+      Xlib.should_receive(:x_next_event).and_return(@event)
+    end
+    context 'with PropertyChangeMask' do
+      before do
+        @type = Xlib::PropertyNotify
+      end
+      it 'should return a PropertyEvent' do
+        ev = @display.next_event
+        ev.type.should == @event.type
+        ev.window.id.should == @event.window
+        ev.atom.id.should == @event.atom
+      end
+    end
+    context 'with other event type' do
+      before do
+        @type = 0
+      end
+      it 'should return a PropertyEvent' do
+        ev = @display.next_event
+        ev.type.should == @event.type
+      end
+    end
+  end
+
+end