uh 0.1.1

data/lib/uh.rb

@@ -0,0 +1,28 @@
+require 'uh.so'
+require 'uh/display'
+require 'uh/drawable'
+require 'uh/events'
+require 'uh/font'
+require 'uh/geo'
+require 'uh/pixmap'
+require 'uh/screen'
+require 'uh/version'
+require 'uh/window'
+
+module Uh
+  Error               = Class.new(StandardError)
+  RuntimeError        = Class.new(RuntimeError)
+  ArgumentError       = Class.new(Error)
+  OtherWMRunningError = Class.new(RuntimeError)
+
+  KEY_MODIFIERS = {
+    shift:  1 << 0,
+    lock:   1 << 1,
+    ctrl:   1 << 2,
+    mod1:   1 << 3,
+    mod2:   1 << 4,
+    mod3:   1 << 5,
+    mod4:   1 << 6,
+    mod5:   1 << 7
+  }.freeze
+end

data/lib/uh/display.rb

@@ -0,0 +1,15 @@
+module Uh
+  class Display
+    def create_subwindow(geo)
+      root.create_sub geo
+    end
+
+    def font
+      @font ||= query_font
+    end
+
+    def pending?
+      pending > 0
+    end
+  end
+end

data/lib/uh/drawable.rb

@@ -0,0 +1,7 @@
+module Uh
+  module Drawable
+    def copy(window)
+      _copy window.id, width, height
+    end
+  end
+end

data/lib/uh/events.rb

@@ -0,0 +1,32 @@
+module Uh
+  module Events
+    # Input Event Masks. Used as event-mask window attribute and as arguments
+    # to Grab requests. Not to be confused with event names.
+    NO_EVENT_MASK               = 0
+    KEY_PRESS_MASK              = 1 <<  0
+    KEY_RELEASE_MASK            = 1 <<  1
+    BUTTON_PRESS_MASK           = 1 <<  2
+    BUTTON_RELEASE_MASK         = 1 <<  3
+    ENTER_WINDOW_MASK           = 1 <<  4
+    LEAVE_WINDOW_MASK           = 1 <<  5
+    POINTER_MOTION_MASK         = 1 <<  6
+    POINTER_MOTION_HINT_MASK    = 1 <<  7
+    BUTTON1_MOTION_MASK         = 1 <<  8
+    BUTTON2_MOTION_MASK         = 1 <<  9
+    BUTTON3_MOTION_MASK         = 1 << 10
+    BUTTON4_MOTION_MASK         = 1 << 11
+    BUTTON5_MOTION_MASK         = 1 << 12
+    BUTTON_MOTION_MASK          = 1 << 13
+    KEYMAP_STATE_MASK           = 1 << 14
+    EXPOSURE_MASK               = 1 << 15
+    VISIBILITY_CHANGE_MASK      = 1 << 16
+    STRUCTURE_NOTIFY_MASK       = 1 << 17
+    RESIZE_REDIRECT_MASK        = 1 << 18
+    SUBSTRUCTURE_NOTIFY_MASK    = 1 << 19
+    SUBSTRUCTURE_REDIRECT_MASK  = 1 << 20
+    FOCUS_CHANGE_MASK           = 1 << 21
+    PROPERTY_CHANGE_MASK        = 1 << 22
+    COLORMAP_CHANGE_MASK        = 1 << 23
+    OWNER_GRAB_BUTTON_MASK      = 1 << 24
+  end
+end

data/lib/uh/font.rb

@@ -0,0 +1,7 @@
+module Uh
+  class Font
+    def height
+      ascent + descent
+    end
+  end
+end

data/lib/uh/geo.rb

@@ -0,0 +1,42 @@
+module Uh
+  class Geo < Struct.new(:x, :y, :width, :height)
+    class << self
+      def format_xgeometry(x, y, width, height)
+        '%sx%s+%s+%s' % [
+          width   ? width.to_s  : ??,
+          height  ? height.to_s : ??,
+          x       ? x.to_s      : ??,
+          y       ? y.to_s      : ??
+        ]
+      end
+    end
+
+    def initialize(*args)
+      super
+      %i[width height].each do |dimension|
+        check_value dimension, send(dimension)
+      end
+    end
+
+    def to_s
+      self.class.format_xgeometry *values
+    end
+
+    def width=(value)
+      check_value :width, value
+      super value
+    end
+
+    def height=(value)
+      check_value :height, value
+      super value
+    end
+
+
+    private
+
+    def check_value(name, value)
+      fail ArgumentError, "invalid #{name.to_s}: #{value}" unless value > 0
+    end
+  end
+end

data/lib/uh/pixmap.rb

@@ -0,0 +1,5 @@
+module Uh
+  class Pixmap
+    include Drawable
+  end
+end

data/lib/uh/screen.rb

@@ -0,0 +1,7 @@
+module Uh
+  class Screen
+    def geo
+      @geo ||= Geo.new(x, y, width, height)
+    end
+  end
+end

data/lib/uh/version.rb

@@ -0,0 +1,3 @@
+module Uh
+  VERSION = '0.1.1'.freeze
+end

data/lib/uh/window.rb

@@ -0,0 +1,35 @@
+module Uh
+  class Window
+    def to_s
+      id.to_s
+    end
+
+    def ==(other)
+      id == other.id
+    end
+
+    def configure(geo)
+      _configure geo.x, geo.y, geo.width, geo.height
+      self
+    end
+
+    def configure_event(geo)
+      _configure_event geo.x, geo.y, geo.width, geo.height
+      self
+    end
+
+    def create_sub(geo)
+      _create_sub geo.x, geo.y, geo.width, geo.height
+    end
+
+    def moveresize(geo)
+      _moveresize geo.x, geo.y, geo.width, geo.height
+      self
+    end
+
+    def show
+      map
+      self
+    end
+  end
+end

data/lib/uh/wm.rb

@@ -0,0 +1,199 @@
+require 'forwardable'
+require 'logger'
+require 'uh/wm/action_handler'
+require 'uh/wm/client'
+require 'uh/wm/manager'
+require 'uh/wm/workers/base_worker'
+require 'uh/wm/workers/blocking_worker'
+require 'uh/wm/workers/multiplexing_worker'
+
+module Uh
+  class WM
+    include Events
+
+    LOGGER_FORMAT_STR = "%s.%03i %s: %s\n".freeze
+    LOGGER_FORMATER   = proc do |severity, datetime, progname, message|
+      LOGGER_FORMAT_STR % [
+        datetime.strftime('%FT%T'),
+        datetime.usec / 1000,
+        severity[0..0],
+        message
+      ]
+    end
+    LOGGER_LEVEL      = Logger::INFO
+    LOGGER_DEBUG_ENV  = 'UH_DEBUG'.freeze
+
+    WORKERS           = {
+      blocking:     Workers::BlockingWorker,
+      multiplexing: Workers::MultiplexingWorker
+    }.freeze
+
+    DEFAULT_MODIFIER  = :mod1
+    INPUT_MASK        = SUBSTRUCTURE_REDIRECT_MASK
+    ROOT_MASK         = PROPERTY_CHANGE_MASK |
+                        SUBSTRUCTURE_REDIRECT_MASK |
+                        SUBSTRUCTURE_NOTIFY_MASK |
+                        STRUCTURE_NOTIFY_MASK
+
+    extend Forwardable
+    def_delegators :@manager, :on_configure, :on_manage, :on_unmanage, :on_change
+    def_delegator :@logger, :info, :log
+    def_delegator :@logger, :error, :log_error
+
+    def initialize(layout, &block)
+      @layout         = layout
+      @display        = Display.new
+      @logger         = Logger.new($stdout).tap do |o|
+        o.level     = ENV.key?(LOGGER_DEBUG_ENV) ? Logger::DEBUG : LOGGER_LEVEL
+        o.formatter = LOGGER_FORMATER
+      end
+      @manager        = Manager.new(@logger)
+      @action_handler = ActionHandler.new(self, @manager, layout)
+      @keys           = {}
+
+      @manager.on_manage do |client|
+        @display.listen_events client.window, PROPERTY_CHANGE_MASK
+      end
+
+      return unless block_given?
+      if block.arity == 1 then yield self else instance_eval &block end
+    end
+
+    def modifier(mod = nil)
+      return (@modifier or DEFAULT_MODIFIER) unless mod
+      @modifier = mod
+    end
+
+    def key(key, mod = nil, &block)
+      mod_mask = KEY_MODIFIERS[modifier]
+      mod_mask |= KEY_MODIFIERS[mod] if mod
+      @keys[[key, mod_mask]] = block
+    end
+
+    def on_init(&block)
+      @on_init = block
+    end
+
+    def on_expose(&block)
+      @on_expose = block
+    end
+
+    def worker(*args, **options)
+      if args.any?
+        @worker = WORKERS[args.first].new(@display, @logger, options)
+      else
+        @worker ||= Workers::BlockingWorker.new(@display, @logger)
+      end
+    end
+
+    def request_quit!
+      @quit_requested = true
+    end
+
+    def run
+      connect
+      @on_init.call @display
+      grab_keys
+      @display.root.mask = ROOT_MASK
+      worker.setup.each_event do |e|
+        process_event e
+        break if quit_requested?
+      end
+      disconnect
+    end
+
+
+    private
+
+    def modifier_mask(mod)
+      KEY_MODIFIERS[mod]
+    end
+
+    def quit_requested?
+      !!@quit_requested
+    end
+
+    def connect
+      @display.open
+      Display.on_error proc { fail OtherWMRunningError }
+      @display.listen_events INPUT_MASK
+      @display.sync false
+      Display.on_error proc { |*args| handle_error(*args) }
+      @display.sync false
+    end
+
+    def disconnect
+      @display.close
+    end
+
+    def grab_keys
+      @keys.each do |k, v|
+        key, mod = *k
+        key = key.to_s.gsub /\AXK_/, ''
+        @display.grab_key key, mod
+      end
+    end
+
+    def process_event(event)
+      return unless respond_to? handler = event_handler_method(event), true
+      log_event event
+      send handler, event
+    end
+
+    def event_handler_method(event)
+      ('handle_%s' % event.type).to_sym
+    end
+
+    def log_event(event)
+      fmt         = '> Event %s'
+      complement  = case event.type
+      when :destroy_notify, :expose, :key_press, :map_request, :property_notify,
+        :unmap_notify
+        "window: #{event.window}"
+      when :configure_request
+        '%s, above: #%d, detail: #%d, value_mask: #%d' % [
+          Geo.format_xgeometry(event.x, event.y, event.width, event.height),
+          event.above_window_id,
+          event.detail,
+          event.value_mask
+        ]
+      else
+        nil
+      end
+
+      log 'XEvent %s' % [event.type, complement].compact.join(' ')
+    end
+
+    def handle_configure_request(event)
+      @manager.configure event.window
+    end
+
+    def handle_destroy_notify(event)
+      @manager.destroy event.window
+    end
+
+    def handle_expose(event)
+      @on_expose.call event.window if @on_expose
+    end
+
+    def handle_key_press(event)
+      @action_handler.call @keys[["XK_#{event.key}".to_sym, event.modifier_mask]]
+    end
+
+    def handle_map_request(event)
+      @manager.map event.window
+    end
+
+    def handle_property_notify(event)
+      @manager.update_properties event.window
+    end
+
+    def handle_unmap_notify(event)
+      @manager.unmap event.window
+    end
+
+    def handle_error(req, resource_id, msg)
+      @logger.error "XERROR: #{resource_id} #{req} #{msg}"
+    end
+  end
+end

data/lib/uh/wm/action_handler.rb

@@ -0,0 +1,59 @@
+module Uh
+  class WM
+    class ActionHandler
+      def initialize(wm, manager, layout)
+        @wm, @manager, @layout = wm, manager, layout
+      end
+
+      def call(action)
+        instance_exec &action
+      end
+
+      def quit
+        @wm.log 'Exiting...'
+        @wm.request_quit!
+      end
+
+      def execute(command)
+        @wm.log "Spawn `#{command}`"
+        pid = spawn command, pgroup: true
+        Process.detach pid
+      rescue Errno::ENOENT => e
+        @wm.log_error "Spawn: #{e}"
+      end
+
+      def log_layout
+        @wm.log "Layout:\n#{@layout.to_s.lines.map { |e| "  #{e}" }.join.chomp}"
+      end
+
+      def log_clients
+        @wm.log "Clients:\n#{@manager.to_s.lines.map { |e| "  #{e}" }.join.chomp}"
+      end
+
+      def log_separator
+        @wm.log '- ' * 24
+      end
+
+      def method_missing(m, *args, &block)
+        if respond_to? m
+          meth = layout_method m
+          @wm.log "#{@layout.class.name}##{meth} #{args.inspect}"
+          @layout.send(meth, *args)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(m, *)
+        m.to_s =~ /\Alayout_/ || super
+      end
+
+
+      private
+
+      def layout_method(m)
+        m.to_s.gsub(/\Alayout_/, 'handle_').to_sym
+      end
+    end
+  end
+end