termgui 0.0.5 → 0.0.6

data/src/element_style.rb

@@ -0,0 +1,51 @@
+require_relative 'element_bounds'
+require_relative 'util'
+
+# adds utilities around style
+module ElementStyle
+  def style
+    set_attribute('style', ElementStyle.default_style) if get_attribute('style') == nil
+    get_attribute('style')
+  end
+
+  def style=(style)
+    s = style.instance_of?(Hash) ? Style.from_hash(style) : style
+    set_attribute('style', s)
+    self.dirty = true
+  end
+
+  def style_assign(style)
+    self.style = self.style.assign(style)
+  end
+
+  def get_style(name)
+    s = get_attribute('style')
+    s.get(name)
+  end
+
+  def default_style
+    Style.new
+  end
+
+  # while "normal" style is defined in @style, focused extra style is defined in @style.focus,
+  # so dependently on attributes like `focused` this method performs computation of the "final" style
+  def final_style
+    result = parent && get_attribute('style-cascade') != 'prevent' ? parent.final_style.clone .assign(style) : style.clone
+    result.assign(style.focus) if get_attribute('focused')
+    result.assign(style.enter) if get_attribute('entered')
+    result.assign(style.action) if get_attribute('actioned')
+    result
+  end
+
+  # computes current border style according to style, style.border, style.focus.border, etc in the right order
+  def border_style
+    s = final_style
+    if border
+      s = s.assign(border)
+      s.assign(style.focus&.border) if get_attribute('focused')
+      s.assign(style.enter&.border) if get_attribute('entered')
+      s.assign(style.action&.border) if get_attribute('actioned')
+    end
+    s
+  end
+end

data/src/emitter.rb

@@ -0,0 +1,102 @@
+require_relative 'emitter_state'
+require_relative 'util'
+
+module TermGui
+  # Basic event emitter, similar to Node's Emitter
+  # adapted from https://medium.com/@kopilov.vlad/use-event-emitter-in-ruby-6b289fe2e7b4
+  class Emitter
+    include EmitterState
+
+    # turn on the event
+    # @param {String, Symbol, (String|Symbol)[]} event_names
+    # @return {nil}
+    def install(event_names)
+      to_array(event_names).each do |event_name|
+        events[event_name.to_sym] ||= []
+      end
+    end
+
+    # turn off the event
+    # @param {String, Symbol, (String|Symbol)[]} event_names
+    # @return {nil}
+    def uninstall(event_names)
+      to_array(event_names).each do |event_name|
+        events.delete(event_name.to_sym)
+      end
+    end
+
+    # subscribe to event
+    # @param {String, Symbol, (String|Symbol)[]} event_names
+    # @param handler_proc [Proc]
+    # @return {Proc}
+    def subscribe(event_names, handler_proc = nil, &block)
+      throw 'No block or handler given' if handler_proc == nil && !block_given?
+      handler = handler_proc == nil ? block : handler_proc
+      to_array(event_names).each do |event_name|
+        events[event_name.to_sym]&.push handler
+      end
+      handler
+    end
+
+    alias add_listener subscribe
+    alias on subscribe
+
+    # unsubscribe to event
+    # @param {String, Symbol, (String|Symbol)[]} event_names
+    # @param handler [Proc]
+    # @return {nil}
+    def unsubscribe(event_names, handler)
+      to_array(event_names).each do |event_name|
+        events[event_name.to_sym]&.reject! do |item|
+          item == handler
+        end
+      end
+    end
+
+    alias remove_listener unsubscribe
+    alias off unsubscribe
+
+    # emit the event
+    # @param {String, Symbol} event_name
+    # @param {Event} event
+    # @return {nil}
+    def emit(event_name, event = Event.new(event_name))
+      events[event_name.to_sym]&.each do |h|
+        h.call(event)
+      end
+    end
+
+    alias trigger emit
+
+    # get array of existing events
+    # @return [Array<Symbols>]
+    def all_events
+      events.keys
+    end
+
+    # get array of existing events with stat
+    # @return [Array<Symbols, Fixnum>]
+    def all_events_with_stat
+      events
+        .map { |name, arr| [name, arr.size] }
+        .flatten
+    end
+
+    def once(event_name, handler_proc = nil, &block)
+      throw 'No block or handler given' if handler_proc == nil && !block_given?
+      handler = handler_proc == nil ? block : handler_proc
+      listener = on(event_name) do |event|
+        handler.call(event)
+        off(event_name, listener)
+      end
+    end
+
+    private
+
+    def events
+      @events ||= {}
+    end
+  end
+end
+
+Emitter = TermGui::Emitter

data/src/emitter_state.rb

@@ -0,0 +1,19 @@
+# adds save/restore event listeners state to Emitter
+module EmitterState
+  # saves current emitter listeners state under given name
+  def emitter_save(name)
+    @emitter_state ||= {}
+    @emitter_state[name.to_sym] = @events
+  end
+
+  # loads a previously saved emitter state with given name.
+  # After this call this emitter will notify a different set of listeners
+  def emitter_load(name)
+    @emitter_state ||= {}
+    @events = @emitter_state[name.to_sym] || @events
+  end
+
+  def emitter_reset
+    @events = {}
+  end
+end

data/src/enterable.rb

@@ -0,0 +1,93 @@
+require_relative 'event'
+
+module TermGui
+  class InputEvent < NodeEvent
+    attr_accessor :value
+    def initialize(target, value = target.value, original_event = nil)
+      super 'input', target, original_event
+      @value = value
+    end
+  end
+
+  class ChangeEvent < NodeEvent
+    attr_accessor :value
+    def initialize(target, value = target.value, original_event = nil)
+      super 'change', target, original_event
+      @value = value
+    end
+  end
+
+  class EscapeEvent < NodeEvent
+    def initialize(target, original_event = nil)
+      super 'escape', target, original_event
+    end
+  end
+
+  class EnterEvent < NodeEvent
+    def initialize(target, original_event = nil)
+      super 'enter', target, original_event
+    end
+  end
+
+  module Enterable
+    def initialize(**args)
+      super
+      self.value = args[:value] || ''
+      @key_listener = nil
+      set_attribute(:focusable, true)
+      set_attribute(:enterable, true)
+      set_attribute(:actionable, true)
+      install(%i[input action enter change escape focus blur])
+      on(:action) do |event|
+        return unless root_screen && get_attribute('entered')
+        set_attribute('entered', true)
+        @key_listener = proc { |e| handle_key e }
+        root_screen.event.add_any_key_listener @key_listener
+        on('change', args[:change]) if args[:change]
+        on('input', args[:input]) if args[:input]
+        on('escape', args[:escape]) if args[:escape]
+        trigger('enter', EnterEvent.new(self, event))
+      end
+      on(%i[blur escape change]) do
+        return unless root_screen
+        set_attribute('entered', false)
+      end
+    end
+
+    def handle_key(event)
+      return unless root_screen
+      if !get_attribute('focused')
+        trigger('change', ChangeEvent.new(self, value, event))
+        root_screen.event.remove_any_key_listener @key_listener
+        true
+      elsif to_array(get_attribute('escape-keys') || 'escape').include? event.key
+        trigger('escape', EscapeEvent.new(self, event))
+        root_screen.event.remove_any_key_listener @key_listener
+        true
+      else
+        false
+      end
+    end
+
+    def value=(_value)
+      throw 'subclass must implementation'
+    end
+
+    def value
+      throw 'subclass must implementation'
+    end
+
+    protected
+
+    def on_input(value, event = nil)
+      return unless root_screen
+      self.value = value
+      trigger('input', InputEvent.new(self, value, event))
+    end
+  end
+end
+
+Enterable = TermGui::Enterable
+InputEvent = TermGui::InputEvent
+ChangeEvent = TermGui::ChangeEvent
+EscapeEvent = TermGui::EscapeEvent

data/src/event.rb

@@ -0,0 +1,92 @@
+require_relative 'input'
+require_relative 'util'
+
+module TermGui
+  # # Base event class. Independent of Element.
+  # class Event
+  #   attr_reader :name
+
+  #   def initialize(name)
+  #     @name = name
+  #   end
+  # end
+
+  # Event related with a Node (`target`) and a native event (`original_event`).
+  class NodeEvent < Event
+    attr_reader :target, :original_event
+
+    def initialize(name, target, original_event = nil)
+      super name
+      @target = target
+      @original_event = original_event
+    end
+  end
+
+  # Represents a keyboard event. Independent of Element.
+  class KeyEvent < Event
+    attr_reader :key, :raw
+
+    def initialize(key, raw = name_to_char(key))
+      super 'key'
+      @key = key
+      @raw = raw
+    end
+
+    def to_s
+      "KeyEvent#{{ name: @name, key: @key, raw: @raw }}"
+    end
+  end
+
+  # responsible of observe/emit user input events (KeyEvent)
+  class EventManager
+    def initialize(input = Input.new)
+      @key_listeners = {}
+      @any_key_listener = []
+      input.add_listener('key') { |e| handle_key e }
+    end
+
+    def add_key_listener(keys, listener = nil, &block)
+      the_listener = listener == nil ? block : listener
+      throw 'No listener provided' if the_listener == nil
+      keys = (keys.is_a? String) ? [keys] : keys
+      keys.each do |key|
+        @key_listeners[key] = @key_listeners[key] || []
+        @key_listeners[key].push the_listener
+      end
+      the_listener
+    end
+
+    def remove_key_listener(key, listener)
+      @key_listeners[key] = @key_listeners[key] || []
+      @key_listeners[key].delete listener
+    end
+
+    def add_any_key_listener(listener = nil, &block)
+      the_listener = listener == nil ? block : listener
+      throw 'No listener provided' if the_listener == nil
+      @any_key_listener.push the_listener
+      the_listener
+    end
+
+    def remove_any_key_listener(listener)
+      @any_key_listener.delete listener
+    end
+
+    # can be used to programmatically simulate keypressed (useful for tests)
+    def handle_key(e)
+      key = e.key
+      @key_listeners[key] = @key_listeners[key] || []
+      @key_listeners[key].each do |listener|
+        listener.call(e)
+      end
+      @any_key_listener.each do |listener|
+        listener.call(e)
+      end
+    end
+  end
+end
+
+Event = TermGui::Event
+NodeEvent = TermGui::NodeEvent
+KeyEvent = TermGui::KeyEvent
+EventManager = TermGui::EventManager

data/src/focus.rb

@@ -0,0 +1,102 @@
+require_relative 'emitter'
+require_relative 'element'
+require_relative 'log'
+require_relative 'event'
+
+module TermGui
+  # provides support for focused, focusable attributes management and emit focus-related events
+  # TODO: make events extend NodeEvent
+  class FocusManager < Emitter
+    attr_reader :keys, :focused
+
+    def initialize(
+      root: nil, # the root element inside of which to look up for focusables
+      event: nil, # EventManager instance - needed for subscribe to key events
+      keys: { next: ['tab'], prev: ['S-tab'] }, # the keys for focusing the next and previous focusable
+      focus_first: true # if true will set focus (attribute focused == true) on the first focusable automatically
+    )
+      throw 'root Element and Event EventManager are required' unless root && event
+      install(:focus)
+      @root = root
+      @keys = keys
+      @event = event
+      @focus_first = focus_first
+      init
+      @event.add_any_key_listener { |e| handle_key e }
+      @root.on(:after_start) do
+        init
+      end
+    end
+
+    def init
+      focusables.each { |n| n.set_attribute(:focused, false) }
+      if @focus_first
+        self.focused = focusables.first
+        @focused&.render if @focused6.is_a? Element
+      end
+    end
+
+    def focusables
+      @root.query_by_attribute(:focusable, true)
+    end
+
+    # focus next focusable node
+    def focus_next
+      i = focusables.index(@focused) || 0
+      new_i = i == focusables.length - 1 ? 0 : i + 1
+      self.focused = focusables[new_i] if focusables[new_i]
+    end
+
+    # focus previous focusable node
+    def focus_prev
+      i = focusables.index(@focused) || 0
+      new_i = i.zero? ? focusables.length - 1 : i - 1
+      self.focused = focusables[new_i] if focusables[new_i]
+    end
+
+    def focused=(focused)
+      previous = @focused
+      @focused&.set_attribute(:focused, false)
+      @focused = focused
+      @focused&.set_attribute(:focused, true)
+      emit :focus, focused: @focused, previous: previous
+      previous&.emit :blur, BlurEvent.new(previous, @focused)
+      focus_event = FocusEvent.new(@focused, previous)
+      @focused&.emit :focus, focus_event
+      if @focused&.get_attribute('action-on-focus')
+        event = ActionEvent.new @focused, focus_event
+        @focused.get_attribute('action')&.call(event)
+        @focused.trigger event.name, event
+      end
+    end
+
+    protected
+
+    def handle_key(e)
+      return if @focused&.get_attribute('entered') && !@focused&.get_attribute('escape-on-blur')
+      if @keys[:next].include? e.key
+        focus_next
+      elsif @keys[:prev].include? e.key
+        focus_prev
+      end
+    end
+  end
+
+  class BlurEvent < NodeEvent
+    attr_accessor :focused
+    def initialize(target, focused, original_event = nil)
+      super 'blur', target, original_event
+      @focused = focused
+    end
+  end
+
+  class FocusEvent < NodeEvent
+    attr_accessor :previous
+    def initialize(target, previous, original_event = nil)
+      super 'focus', target, original_event
+      @previous = previous
+    end
+  end
+end
+
+FocusManager = TermGui::FocusManager