termgui 0.0.4 → 0.0.5

data/src/element_style.rb

@@ -1,51 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,19 +0,0 @@
-# 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

@@ -1,93 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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