termgui 0.0.4

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

data/src/geometry.rb

@@ -0,0 +1,53 @@
+module TermGui
+  # represents a scroll viewport offset
+  class Offset
+    attr_accessor :left, :top
+
+    def initialize(left: 0, top: 0)
+      @left = left
+      @top = top
+    end
+  end
+
+  # Represents a rectangle in the form of {top, left, bottom, top}
+  class Bounds < Offset
+    attr_accessor :right, :bottom
+
+    def initialize(left: 0, right: 0, top: 0, bottom: 0)
+      super(left: left, top: top)
+      @right = right
+      @bottom = bottom
+    end
+
+    def self.from_hash(hash)
+      merge_hash_into_object hash, Bounds.new
+    end
+  end
+
+  class Point
+    attr_accessor :x, :y
+    def initialize(x: 0, y: 0)
+      @x = x
+      @y = y
+    end
+  end
+
+  class Rectangle < Point
+    attr_accessor :width, :height
+
+    def initialize(x: 0,  y: 0, width: 0, height: 0)
+      super(x: x, y: y)
+      @width = width
+      @height = height
+    end
+
+    def self.from_hash(hash)
+      merge_hash_into_object hash, Rectangle.new
+    end
+  end
+end
+
+Offset = TermGui::Offset
+Bounds = TermGui::Bounds
+Point = TermGui::Point
+Rectangle = TermGui::Rectangle

data/src/image.rb

@@ -0,0 +1,60 @@
+require 'chunky_png'
+require 'fileutils'
+require_relative 'util/imagemagick'
+# small facade for image decoding and processing
+# Right now only supports reading png thanks to chunky_png
+module TermGui
+  class Image
+    attr_reader :path
+
+    def initialize(image = nil, path = image.is_a?(String) ? image : 'unknown.png')
+      if image.is_a?(String)
+        if File.extname(image).capitalize != '.png'
+          if !image_magick_available
+            throw 'Cannot create image from non PNG file without imagemagick available'
+          else
+            image = convert(image)
+          end
+        end
+      end
+      @image = image.is_a?(String) ? ChunkyPNG::Image.from_file(image) : image
+      @path = path
+    end
+
+    def rgb(x = 0, y = 0, transparent_color = nil)
+      p = @image[x, y]
+      if transparent_color
+        bg = ChunkyPNG::Color.rgb(transparent_color[0], transparent_color[1], transparent_color[2])
+        p = ChunkyPNG::Color. interpolate_quick(p, bg,  ChunkyPNG::Color.a(p))
+      end
+      [ChunkyPNG::Color.r(p), ChunkyPNG::Color.g(p), ChunkyPNG::Color.b(p)]
+    end
+
+    def rgba(x = 0, y = 0)
+      p = @image[x, y]
+      [ChunkyPNG::Color.r(p), ChunkyPNG::Color.g(p), ChunkyPNG::Color.b(p), ChunkyPNG::Color.a(p)]
+    end
+
+    def width
+      @image.width
+    end
+
+    def height
+      @image.height
+    end
+
+    # returns a new image which is the result of scaling this image to given dimentions
+    def scale(width: @image.width, height: @image.height,
+              algorithm: 'bilineal') # bilinear, nearest_neighbor
+      if algorithm == 'nearest_neighbor'
+        Image.new(@image.resample_nearest_neighbor(width, height), path)
+      else
+        Image.new(@image.resample_bilinear(width, height), path)
+      end
+    end
+
+    def crop(x: 0, y: 0, width: @image.width, height: @image.height)
+      Image.new(@image.crop(x, y, width, height), path)
+    end
+  end
+end

data/src/input.rb

@@ -0,0 +1,85 @@
+require_relative 'emitter'
+require_relative 'log'
+require_relative 'event'
+require_relative 'input_time'
+require_relative 'input_grab'
+require 'io/console'
+require 'io/wait'
+require_relative 'key'
+
+module TermGui
+  # responsible of listening stdin and event loop
+  class Input < Emitter
+    include InputTime
+    include InputGrab
+
+    attr_reader :interval, :stdin, :stopped
+
+    def initialize(stdin = $stdin, interval = 0.0000001)
+      super
+      @interval = interval
+      @stdin = stdin
+      @stopped = true
+      install(:key)
+    end
+
+    def stop
+      @stopped = true
+    end
+
+    # starts listening for user input. Implemented like an event loop reading from @input_stream each @interval
+    def start
+      return self unless @stopped
+
+      @stdin.raw do |io|
+        @io = io
+        @stopped = false
+        loop do
+          tick
+          break if @stopped
+        end
+      end
+    end
+
+    # Once it `start`s this method is called on the loop to read input. Calls update_status which update timers (timeout - interval).
+    # Could be useful for applications with their own event loops or time long blocking tasks to notify input/timeouts
+    def tick
+      char = get_char_or_sequence
+      if char
+        key = char.inspect
+        key = key[1..key.length - 2]
+        key = char_to_name(key) || char
+        emit_key char, key
+      else
+        sleep @interval
+      end
+      update_status
+    end
+
+    def emit_key(char, key = char)
+      event = KeyEvent.new key, char
+      emit 'key', event
+    end
+
+    def write(s)
+      @stdin.write s
+    end
+
+    protected
+
+    def get_char_or_sequence(io = @io)
+      if io.ready?
+        result = io.sysread(1)
+        while (CSI.start_with?(result) ||
+               (result.start_with?(CSI) &&
+                !result.codepoints[-1].between?(64, 126))) &&
+              (next_char = get_char_or_sequence(io))
+          result << next_char
+        end
+        result
+      end
+    end
+  end
+end
+
+Input = TermGui::Input

data/src/input_grab.rb

@@ -0,0 +1,17 @@
+require_relative 'util'
+
+# Add Input support for grab, this is stop notifying listeners and notify others. Based on EmitterState
+module InputGrab
+  def grab(block = nil, &b)
+    the_block = block == nil ? b : block
+    throw 'Block not given' unless the_block
+    emitter_save('grab')
+    emitter_reset
+    install(:key)
+    subscribe(:key, the_block)
+  end
+
+  def ungrab
+    emitter_load('grab')
+  end
+end