uh-wm 0.0.2.pre → 0.0.2

data/lib/uh/wm/client.rb

@@ -0,0 +1,64 @@
+module Uh
+  module WM
+    class Client
+      attr_reader   :window
+      attr_accessor :geo, :unmap_count
+
+      def initialize window, geo = nil
+        @window       = window
+        @geo          = geo
+        @visible      = false
+        @unmap_count  = 0
+      end
+
+      def to_s
+        "<#{name}> (#{wclass}) #{@geo} win: #{@window}"
+      end
+
+      def visible?
+        @visible
+      end
+
+      def hidden?
+        not visible?
+      end
+
+      def name
+        @wname ||= @window.name
+      end
+
+      def wclass
+        @wclass ||= @window.wclass
+      end
+
+      def configure
+        @window.configure @geo
+        self
+      end
+
+      def moveresize
+        @window.moveresize @geo
+        self
+      end
+
+      def show
+        @window.map
+        @visible = true
+        self
+      end
+
+      def hide
+        @window.unmap
+        @visible = false
+        @unmap_count += 1
+        self
+      end
+
+      def focus
+        @window.raise
+        @window.focus
+        self
+      end
+    end
+  end
+end

data/lib/uh/wm/dispatcher.rb

@@ -16,7 +16,9 @@ module Uh
       end
 
       def emit *key, args: []
-        @hooks[translate_key key].each { |e| e.call *args }
+        value = nil
+        @hooks[translate_key key].each { |e| value = e.call *args }
+        value
       end
 
 

data/lib/uh/wm/env.rb

@@ -3,29 +3,33 @@ module Uh
     class Env
       RC_PATH = '~/.uhwmrc.rb'.freeze
 
-      MODIFIER = :mod1
-      KEYBINDS = {
-        q: proc { quit }
+      MODIFIER  = :mod1
+      KEYBINDS  = {
+        [:q, :shift] => proc { quit }
       }.freeze
+      WORKER    = :block
 
       LOGGER_LEVEL          = Logger::WARN
       LOGGER_LEVEL_VERBOSE  = Logger::INFO
       LOGGER_LEVEL_DEBUG    = Logger::DEBUG
-      LOGGER_LEVEL_STRINGS  = %w[DEBUG INFO WARN ERROR FATAL UNKNOWN]
+      LOGGER_LEVEL_STRINGS  = %w[DEBUG INFO WARN ERROR FATAL UNKNOWN].freeze
 
       extend Forwardable
-      def_delegator :logger, :info, :log
-      def_delegator :logger, :debug, :log_debug
-      def_delegator :@output, :print
+      def_delegator   :logger, :info,   :log
+      def_delegator   :logger, :error,  :log_error
+      def_delegator   :logger, :debug,  :log_debug
+      def_delegators  :@output, :print, :puts
 
       attr_reader   :output, :keybinds
-      attr_accessor :verbose, :debug, :rc_path, :layout_class, :modifier
+      attr_accessor :verbose, :debug, :rc_path, :layout_class, :modifier,
+                    :worker
 
       def initialize output
         @output   = output
         @rc_path  = RC_PATH
         @modifier = MODIFIER
         @keybinds = KEYBINDS.dup
+        @worker   = :block
       end
 
       def verbose?
@@ -48,7 +52,9 @@ module Uh
       def logger
         @logger ||= Logger.new(@output).tap do |o|
           o.level = debug? ? LOGGER_LEVEL_DEBUG :
-            verbose? ? LOGGER_LEVEL_VERBOSE : LOGGER_LEVEL
+            verbose? ? LOGGER_LEVEL_VERBOSE :
+            LOGGER_LEVEL
+          o.formatter = LoggerFormatter.new
         end
       end
 

data/lib/uh/wm/env_logging.rb

@@ -0,0 +1,8 @@
+module Uh
+  module WM
+    module EnvLogging
+      extend Forwardable
+      def_delegators :@env, :log, :log_error, :log_debug
+    end
+  end
+end

data/lib/uh/wm/logger_formatter.rb

@@ -0,0 +1,16 @@
+module Uh
+  module WM
+    class LoggerFormatter
+      FORMAT_STR = "%s.%03i %s: %s\n".freeze
+
+      def call severity, datetime, progname, message
+        FORMAT_STR % [
+          datetime.strftime('%FT%T'),
+          datetime.usec / 1000,
+          severity[0..0],
+          message
+        ]
+      end
+    end
+  end
+end

data/lib/uh/wm/manager.rb

@@ -1,25 +1,43 @@
 module Uh
   module WM
     class Manager
-      INPUT_MASK = Events::SUBSTRUCTURE_REDIRECT_MASK
+      INPUT_MASK  = Events::SUBSTRUCTURE_REDIRECT_MASK
+      ROOT_MASK   = Events::PROPERTY_CHANGE_MASK |
+                    Events::SUBSTRUCTURE_REDIRECT_MASK |
+                    Events::SUBSTRUCTURE_NOTIFY_MASK |
+                    Events::STRUCTURE_NOTIFY_MASK
+      DEFAULT_GEO = Geo.new(0, 0, 320, 240).freeze
 
-      attr_reader :modifier, :display
+      attr_reader :modifier, :display, :clients
 
       def initialize events, modifier, display = Display.new
         @events   = events
         @modifier = modifier
         @display  = display
+        @clients  = []
+      end
+
+      def to_io
+        IO.new(@display.fileno)
       end
 
       def connect
         @events.emit :connecting, args: @display
         @display.open
-        Display.on_error { fail OtherWMRunningError }
-        @display.listen_events INPUT_MASK
-        @display.sync false
+        check_other_wm!
         Display.on_error { |*args| handle_error *args }
         @display.sync false
         @events.emit :connected, args: @display
+        @display.root.mask = ROOT_MASK
+      end
+
+      def disconnect
+        @display.close
+        @events.emit :disconnected
+      end
+
+      def flush
+        @display.flush
       end
 
       def grab_key keysym, mod = nil
@@ -28,25 +46,89 @@ module Uh
         @display.grab_key keysym.to_s, mod_mask
       end
 
+      def configure window
+        if client = client_for(window)
+          client.configure
+        else
+          geo = @events.emit :configure, args: window
+          window.configure_event geo ? geo : DEFAULT_GEO
+        end
+      end
+
+      def map window
+        return if window.override_redirect? || client_for(window)
+        @clients << client = Client.new(window)
+        @events.emit :manage, args: client
+      end
+
+      def unmap window
+        return unless client = client_for(window)
+        if client.unmap_count > 0
+          client.unmap_count -= 1
+        else
+          @clients.delete client
+          @events.emit :unmanage, args: client
+        end
+      end
+
+      def destroy window
+        return unless client = client_for(window)
+        @clients.delete client
+        @events.emit :unmanage, args: client
+      end
+
+      def handle_next_event
+        handle @display.next_event
+      end
+
       def handle_pending_events
-        handle @display.next_event while @display.pending?
+        handle_next_event while @display.pending?
       end
 
       def handle event
-        case event.type
-        when :key_press
-          key_selector = event.modifier_mask & KEY_MODIFIERS[:shift] == 1 ?
-            [event.key.to_sym, :shift] :
-            event.key.to_sym
-          @events.emit :key, *key_selector
-        end
+        @events.emit :xevent, args: event
+        return unless respond_to? handler = "handle_#{event.type}".to_sym, true
+        send handler, event
       end
 
 
       private
 
       def handle_error *args
-        @dispatcher.emit :error, args: args
+        @events.emit :xerror, args: args
+      end
+
+      def handle_key_press event
+        key_selector = event.modifier_mask & KEY_MODIFIERS[:shift] == 1 ?
+          [event.key.to_sym, :shift] :
+          event.key.to_sym
+        @events.emit :key, *key_selector
+      end
+
+      def handle_configure_request event
+        configure event.window
+      end
+
+      def handle_destroy_notify event
+        destroy event.window
+      end
+
+      def handle_map_request event
+        map event.window
+      end
+
+      def handle_unmap_notify event
+        unmap event.window
+      end
+
+      def client_for window
+        @clients.find { |e| e.window == window }
+      end
+
+      def check_other_wm!
+        Display.on_error { fail OtherWMRunningError }
+        @display.listen_events INPUT_MASK
+        @display.sync false
       end
     end
   end

data/lib/uh/wm/run_control.rb

@@ -28,14 +28,19 @@ module Uh
         @env.modifier = mod
       end
 
-      def key keysym, &block
-        @env.keybinds[translate_keysym keysym] = block
+      def key *keysyms, &block
+        @env.keybinds[translate_keysym *keysyms] = block
+      end
+
+      def worker type, **options
+        @env.worker = [type, options]
       end
 
 
       private
 
-      def translate_keysym keysym
+      def translate_keysym keysym, modifier = nil
+        return [translate_keysym(keysym)[0].to_sym, modifier] if modifier
         translate_key = keysym.to_s.downcase.to_sym
         translated_keysym = KEYSYM_TRANSLATIONS.key?(translate_key) ?
           KEYSYM_TRANSLATIONS[translate_key] :

data/lib/uh/wm/runner.rb

@@ -1,6 +1,8 @@
 module Uh
   module WM
     class Runner
+      include EnvLogging
+
       class << self
         def run env, **options
           runner = new env, **options
@@ -8,6 +10,7 @@ module Uh
           runner.register_event_hooks
           runner.connect_manager
           runner.run_until { runner.stopped? }
+          runner.terminate
         end
       end
 
@@ -41,10 +44,9 @@ module Uh
       end
 
       def register_event_hooks
-        register_runner_hooks
-        register_manager_hooks
-        register_layout_event_hooks
-        register_key_bindings_hooks
+        %w[runner manager layout keybinds]
+          .map  { |e| "register_#{e}_hooks".to_sym }
+          .each { |e| send e }
       end
 
       def connect_manager
@@ -54,8 +56,31 @@ module Uh
         end
       end
 
+      def worker
+        @worker ||= Workers.build(*(@env.worker)).tap do |w|
+          w.on_read do
+            @manager.handle_pending_events
+          end
+          w.on_read_next do
+            @manager.handle_next_event
+          end
+          w.on_timeout do |*args|
+            log_debug "Worker timeout: #{args.inspect}"
+            log_debug 'Flushing X output buffer'
+            @manager.flush
+          end
+        end
+      end
+
       def run_until &block
-        manager.handle_pending_events until block.call
+        worker.watch @manager
+        log "Working events with `#{worker.class}'"
+        worker.work_events until block.call
+      end
+
+      def terminate
+        log "Terminating..."
+        manager.disconnect
       end
 
 
@@ -66,25 +91,68 @@ module Uh
       end
 
       def register_manager_hooks
-        @events.on(:connecting) do |display|
-          @env.log_debug "Connecting to X server on `#{display}'"
+        @events.on :connecting do |display|
+          log_debug "Connecting to X server on `#{display}'"
         end
-        @events.on(:connected) do |display|
-          @env.log "Connected to X server on `#{display}'"
+        @events.on :connected do |display|
+          log "Connected to X server on `#{display}'"
         end
+        @events.on(:disconnected) { log "Disconnected from X server" }
+        @events.on(:xevent) { |event| XEventLogger.new(env).log_event event }
+        @events.on(:xerror) { |*error| XEventLogger.new(env).log_xerror *error }
       end
 
-      def register_layout_event_hooks
-        @events.on(:connected) do |display|
+      def register_layout_hooks
+        @events.on :connected do |display|
+          log "Registering layout `#{layout.class}'"
           layout.register display
         end
+        @events.on :configure do |window|
+          log "Configuring window: #{window}"
+          layout.suggest_geo
+        end
+        @events.on :manage do |client|
+          log "Managing client #{client}"
+          layout << client
+        end
+        @events.on :unmanage do |client|
+          log "Unmanaging client #{client}"
+          layout.remove client
+        end
       end
 
-      def register_key_bindings_hooks
+      def register_keybinds_hooks
         @env.keybinds.each do |keysym, code|
-          @events.on :key, *keysym do
-            @actions.evaluate code
+          @events.on(:key, *keysym) { @actions.evaluate code }
+        end
+      end
+
+
+      class XEventLogger
+        include EnvLogging
+
+        def initialize env
+          @env = env
+        end
+
+        def log_event xev
+          complement = case xev.type
+          when :key_press
+            "window: #{xev.window} key: #{xev.key} mask: #{xev.modifier_mask}"
+          when :map_request
+            "window: #{xev.window}"
           end
+
+          log_debug [
+            'XEvent',
+            xev.type,
+            xev.send_event ? 'SENT' : nil,
+            complement
+          ].compact.join ' '
+        end
+
+        def log_xerror req, resource_id, msg
+          log_error "XERROR: #{resource_id} #{req} #{msg}"
         end
       end
     end