termgui 0.0.4

data/src/renderer_print.rb

@@ -0,0 +1,40 @@
+require_relative 'style'
+require_relative 'key'
+
+# takes care of printing renderer buffer in different ways
+module RendererPrint
+  # prints current buffer as string
+  def print
+    s = []
+    @buffer.each_index do |y|
+      @buffer[y].each do |p|
+        s .push p.ch
+      end
+      s .push '\n'
+    end
+    s.join('')
+  end
+
+  def print_rows
+    rows = []
+    @buffer.each_index do |y|
+      line = []
+      @buffer[y].each do |p|
+        line .push p.ch
+      end
+      rows.push(line.join(''))
+    end
+    rows
+  end
+
+  # prints to stdout a representation in ruby string concatenated syntax so its easy for devs copy&paste for test asserts
+  def print_dev_stdout
+    print.split('\\n').each { |line| puts "'#{line}\\n' + " }
+  end
+
+  def print_dev
+    s = "'' + \n"
+    print.split('\\n').each { |line| s = "#{s}#{line}\\n' + \n" }
+    s + "''"
+  end
+end

data/src/screen.rb

@@ -0,0 +1,96 @@
+require_relative 'element'
+require_relative 'renderer'
+require_relative 'input'
+require_relative 'event'
+require_relative 'focus'
+require_relative 'action'
+require_relative 'util'
+require_relative 'screen_element'
+require_relative 'screen_input'
+require_relative 'screen_renderer'
+
+module TermGui
+  # Main user API entry point
+  # Manages instances of Input, Event, Renderer (by default disabling its buffer)
+  # Is a Node so new elements can be append_child
+  # Once `start`is called it will block execution and start an event loop
+  # on each interval user input is read and event listeners are called
+  class Screen < Node
+    include ScreenElement
+    include ScreenInput
+    include ScreenRenderer
+    attr_reader :width, :height, :input_stream, :output_stream, :renderer, :input, :event, :focus, :action
+    attr_accessor :silent
+
+    def initialize(
+      children: [], text: '', attributes: {}, exit_keys: %w[q C-c], no_exit_keys: false,
+      width: nil, height: nil, silent: false
+    )
+      super(name: 'screen', children: children, text: text, attributes: attributes, parent: nil)
+      install(%i[destroy after_destroy start after_start])
+      @width = width == nil ? terminal_width : width
+      @height = height == nil ? terminal_height : height
+      @input_stream = $stdin
+      @silent = silent
+      @exit_keys = exit_keys
+      @output_stream = $stdout
+      @renderer = Renderer.new(@width, @height)
+      @input = Input.new
+      @event = EventManager.new @input
+      @focus = FocusManager.new(root: self, event: @event)
+      @action = ActionManager.new(focus: @focus, event: @event)
+      @renderer.no_buffer = true
+      install_exit_keys unless no_exit_keys
+    end
+
+    def self.new_for_testing(**args)
+      instance = new(args.merge(no_exit_keys: true, silent: true))
+      instance.renderer.no_buffer = false
+      instance
+    end
+
+    def terminal_width
+      $stdout.winsize[1]
+    rescue StandardError
+      80
+    end
+
+    def terminal_height
+      $stdout.winsize[0]
+    rescue StandardError
+      24
+    end
+
+    # start listening for user input. This starts an user input event loop
+    # that ends when screen.destroy is called
+    def start(clean: false)
+      emit :start
+      unless clean
+        clear
+        cursor_hide # TODO: move this to a CursorManager :start listener
+        render
+      end
+      emit :after_start
+      yield if block_given?
+      @input.start
+    end
+
+    def destroy
+      emit :destroy
+      @input.stop
+      cursor_show # TODO: move this to a CursorManager :destroy listener
+      emit :after_destroy
+    end
+
+    # writes directly to @output_stream. Shouldn't be used directly since these changes won't be tracked by the buffer.
+    def write(s)
+      @output_stream.write s unless @silent
+      s
+    end
+
+    def alert
+      puts "\a"
+    end
+  end
+end
+Screen = TermGui::Screen

data/src/screen_element.rb

@@ -0,0 +1,59 @@
+require_relative 'geometry'
+
+# so screen emulates an Element. TODO: make Screen < Element and get rid of width and height and all of this...
+module ScreenElement
+  # complies with Element#render and also is capable of rendering given elements
+  def render(element = nil)
+    if element == self || element.nil?
+      children.each { |child| child.render self }
+    elsif !element.nil?
+      element.render self
+    end
+  end
+
+  def abs_x
+    0
+  end
+
+  def abs_y
+    0
+  end
+
+  def abs_width
+    @width
+  end
+
+  def style
+    @style ||= Style.new
+    @style
+  end
+
+  def style=(s)
+    @style = s
+  end
+
+  def final_style
+    style
+  end
+
+  def offset
+    v = get_attribute('offset')
+    unless v
+      v = Offset.new
+      set_attribute('offset', v)
+    end
+    v
+  end
+
+  def offset=(value)
+    set_attribute('offset', value)
+  end
+
+  def abs_height
+    @height
+  end
+
+  def root_screen
+    self
+  end
+end

data/src/screen_input.rb

@@ -0,0 +1,43 @@
+# adds Input related methods to screen
+module ScreenInput
+  attr_accessor :exit_keys
+
+  # Analog to HTML DOM / Node.js setTimeout() using input event loop
+  # @param {Number} seconds
+  def set_timeout(seconds = @input.interval, listener = nil, &block)
+    the_listener = listener == nil ? block : listener
+    throw 'No listener provided' if the_listener == nil
+    @input.set_timeout(seconds, the_listener)
+  end
+
+  def clear_timeout(listener)
+    @input.clear_timeout(listener)
+  end
+
+  # Analog to HTML DOM / Node.js setInterval() using input event loop
+  # @param {Number} seconds
+  def set_interval(seconds = @input.interval, listener = nil, &block)
+    the_listener = listener == nil ? block : listener
+    throw 'No listener provided' if the_listener == nil
+    @input.set_interval(seconds, the_listener)
+  end
+
+  def clear_interval(listener)
+    @input.clear_interval(listener)
+  end
+
+  def install_exit_keys
+    return if @exit_keys_listener
+
+    @exit_keys_listener = @input.subscribe('key') do |e|
+      destroy if @exit_keys.include?(e.key)
+    end
+  end
+
+  def uninstall_exit_keys
+    return unless @exit_keys_listener
+
+    @input.off('key', @exit_keys_listener)
+    @exit_keys_listener = nil
+  end
+end

data/src/screen_renderer.rb

@@ -0,0 +1,53 @@
+# adds rendering related methods to screen
+module ScreenRenderer
+  # renders given text at given position
+  def text(x: 0, y: 0, text: ' ', style: nil)
+    write @renderer.text(x: x, y: y, text: text, style: style)
+  end
+
+  def rect(x: 0, y: 0, width: self.width, height: self.height, ch: Pixel.EMPTY_CH, style: nil)
+    write @renderer.rect(x: x, y: y, width: width, height: height, ch: ch, style: style)
+  end
+
+  def image(x: 0, y: 0, image: nil, ch: Pixel.EMPTY_CH, style: Style.new, fg: false, bg: true, transparent_color: nil, h: height - y, w: width - x)
+    write @renderer.image(x: x, y: y, image: image, ch: ch || Pixel.EMPTY_CH, style: style, fg: fg, bg: bg, transparent_color: transparent_color, h: h, w: w)
+  end
+
+  def circle(x: nil, y: nil, radius: nil, stroke_ch: ' ', stroke: nil, fill: nil, fill_ch: stroke_ch)
+    write @renderer.circle(x: x, y: y, radius: radius, stroke_ch: stroke_ch, stroke: stroke, fill: fill, fill_ch: fill_ch)
+  end
+
+  def clear
+    @renderer.style = Style.new
+    write "#{@renderer.clear}#{@renderer.style.print}"
+  end
+
+  def style=(style)
+    @renderer.style = style
+    write @renderer.style.print
+  end
+
+  def box(x, y, width, height, border_style = :classic, style = nil, content = ' ')
+    self.style = style if style
+    box = draw_box(width: width, height: height, style: border_style, content: content)
+    (box.map.with_index do |line, index|
+      text(x: x, y: y + index, text: line, style: style)
+    end).join('')
+  end
+
+  def print
+    @renderer.print
+  end
+
+  def cursor_move(x, y)
+    write @renderer.move(x, y)
+  end
+
+  def cursor_show
+    write @renderer.cursor_show
+  end
+
+  def cursor_hide
+    write @renderer.cursor_hide
+  end
+end

data/src/style.rb

@@ -0,0 +1,149 @@
+require_relative 'util'
+require_relative 'util/hash_object'
+require_relative 'tco/tco_termgui'
+
+module TermGui
+  # refers to properties directly implemented using ansi escape codes
+  # responsible of printing escape ansi codes for style
+  # Styles are data objects, supporting hash to instantiate, assign, equals, print
+  class BaseStyle
+    include HashObject
+
+    attr_accessor :fg, :bg, :underline, :bold, :blink, :inverse, :fraktur, :framed
+
+    def initialize(fg: nil, bg: nil, bold: nil, blink: nil, inverse: nil, underline: nil, framed: nil, fraktur: nil, bright: nil, wrap: nil, border: nil, padding: nil, style: nil)
+      # TODO: for some reason **args is not working here that's why we have all subclasses props
+      @fg = fg
+      @bg = bg
+      @bold = bold || bright
+      @blink = blink
+      @inverse = inverse
+      @underline = underline
+      @fraktur = fraktur
+      @framed = framed
+    end
+
+    # Prints the style as escape sequences.
+    # This method shouln't be overriden by subclasses since it only makes sense for basic properties defined here.
+    def print(s = nil)
+      if s == nil
+        TermGui.open_style(self)
+      else
+        TermGui.print(s, self)
+      end
+    end
+
+    def self.fast_colouring(value)
+      TermGui.fast_colouring(value)
+    end
+
+    def reset
+      @bg = @fg = @wrap = @border = nil
+    end
+
+    # returns true if self has the same properties of given hash or Style and each property value is equals (comparission using ==)
+    def equals(style)
+      object_equal(self, BaseStyle.from_hash(style))
+    end
+
+    # if a hash is given returns a new Style instance with given properties. If an Style instance if given, returns it.
+    # It also ensures focus, action and enter properties are defined cloning self if not
+    def self.from_hash(obj)
+      if obj == nil
+        return nil
+      elsif obj.instance_of?(Hash)
+        r = merge_hash_into_object obj, new
+      else
+        r = obj
+      end
+
+      if r.is_a? Style
+        r.focus = r.focus || r.clone
+        r.border = Border.from_hash(r.border) if r.border
+        r.action = r.action || r.clone
+        r.enter = r.enter || r.clone
+      end
+      r
+    end
+
+    def pretty_print(delete_nil = true, delete_empty = true)
+      h = to_hash
+      h.keys.each do |k|
+        h.delete k if delete_nil && h[k] == nil
+        if delete_empty && (h[k].respond_to?(:to_hash) || h[k].is_a?(Hash)) && object_variables_to_hash(h[k]).keys.reject { |k| h[k] == nil }.empty?
+          h.delete k
+        end
+      end
+      "{#{h.keys.map { |k| "#{k}: #{pretty_print_value(h[k])}" }.join(', ')}}" .split(/, [^\s]+: \{\}/).join('')
+    end
+
+    def pretty_print_value(v)
+      v.is_a?(String) ? v : v.respond_to?(:pretty_print) ? v.pretty_print : v.to_s
+    end
+
+    def self.from_json(s)
+      r = from_hash(json_parse(s))
+      if r.is_a? Style
+        r.border = from_hash(r.border || new)
+        r.focus = from_hash(r.focus || new)
+        r.enter = from_hash(r.enter || new)
+        r.action = from_hash(r.action || new)
+      end
+      r
+    end
+
+    def bright
+      @bold
+    end
+
+    def bright=(value)
+      @bold = value
+    end
+  end
+
+  # Element style. This is the class of `element.style` - `get_attribute('style')``
+  class Style < BaseStyle
+    attr_accessor :border, :wrap, :padding, :focus, :enter, :action
+
+    def initialize(**args)
+      super
+      @wrap = args[:wrap]
+      # TODO: move this border checking & init to hash_object
+      if args[:border].nil?
+        @border = nil
+      elsif args[:border].instance_of? Border
+        @border = args[:border]
+      elsif args[:border].instance_of? Hash
+        @border = Border.new
+        @border.assign(args[:border])
+      end
+      padding = args[:padding]
+      focus = args[:focus] || clone
+      enter = args[:enter] || clone
+      action = args[:action] || clone
+
+      @padding = padding
+      @focus = focus
+      @enter = enter
+      @action = action
+    end
+  end
+
+  # style for the border
+  class Border < BaseStyle
+    attr_reader :style
+
+    def initialize(**args)
+      super
+      @style = args[:style]&.to_s || 'single'
+    end
+
+    def style=(style)
+      @style = style&.to_s
+    end
+  end
+end
+
+BaseStyle = TermGui::BaseStyle
+Border = TermGui::Border
+Style = TermGui::Style

data/src/tco/colouring.rb

@@ -0,0 +1,248 @@
+# rubocop:disable Layout/EndAlignment
+
+# adapted from tco
+# tco - terminal colouring application and library
+# Copyright (c) 2013, 2014 Radek Pazdera
+
+require_relative 'palette'
+
+module Tco
+  class Colouring
+    ANSI_FG_BASE = 30
+    ANSI_BG_BASE = 40
+
+    attr_reader :palette
+
+    def initialize(configuration)
+      @palette = Palette.new configuration.options['palette']
+      @output_type = configuration.options['output']
+      @disabled = configuration.options['disabled']
+
+      configuration.colour_values.each do |id, value|
+        @palette.set_colour_value(parse_colour_id(id), parse_rgb_value(value))
+      end
+
+      @names = {}
+      configuration.names.each do |name, colour_def|
+        @names[name] = resolve_colour_def colour_def
+      end
+
+      @styles = {}
+      configuration.styles.each do |name, style|
+        @styles[name] = Style.new(resolve_colour_def(style[:fg]),
+                                  resolve_colour_def(style[:bg]),
+                                  style[:bright], style[:underline])
+      end
+    end
+
+    # Decorate a string according to the style passed. The input string
+    # is processed line-by-line (the escape sequences are added to each
+    # line). This is due to some problems I've been having with some
+    # terminal emulators not handling multi-line coloured sequences well.
+    def decorate(string, style)
+      # (fg, bg, bright, underline)
+      # fg = style.fg
+      # bg = style.bg
+      # bright = style.bright
+      # underline = style.underline
+      return string if !STDOUT.isatty || @output_type == :raw || @disabled
+
+      fg = get_colour_instance style.fg
+      bg = get_colour_instance style.bg
+
+      output = []
+      lines = string.lines.map(&:chomp)
+      lines = [''] if lines.length.zero?
+      lines.each do |line|
+        unless line.length < 0
+          line = case @palette.type
+                 when 'ansi' then colour_ansi line, fg, bg
+                 when 'extended' then colour_extended line, fg, bg
+                 else raise "Unknown palette '#{@palette.type}'."
+                 end
+
+          line = e(1) + line if style.bright
+          line = e(4) + line if style.underline
+          line = e(5) + line if style.blink
+          line = e(7) + line if style.inverse
+          line = e(20) + line if style.fraktur
+          line = e(51) + line if style.framed
+
+          if (style.bright || style.underline || style.blink || style.inverse || style.fraktur || style.framed) && (fg == nil) && (bg == nil)
+            line << e(0)
+          end
+        end
+
+        output.push line
+      end
+
+      output << '' if string =~ /\n$/
+      output.join "\n"
+    end
+
+    def get_style(name)
+      raise "Style '#{name}' not found." unless @styles.key? name
+
+      @styles[name]
+    end
+
+    def set_output(output_type)
+      raise "Output '#{output_type}' not supported." unless %i[term raw].include? output_type
+
+      @output_type = output_type
+    end
+
+    def get_best_font_colour(background)
+      black = Tco::Colour.new([0, 0, 0])
+      white = Tco::Colour.new([255, 255, 255])
+
+      if background.is_a?(Colour) &&
+         (background - black).abs < (background - white).abs
+        return white
+      end
+
+      black
+    end
+
+    def get_colour_instance(value)
+      if value.is_a?(String)
+        resolve_colour_def value
+      elsif value.is_a?(Symbol)
+        resolve_colour_def value.to_s
+      elsif value.is_a?(Array)
+        Colour.new value
+      elsif value.is_a?(Colour) || value.is_a?(Unknown)
+        value
+      elsif value == nil
+        nil
+      else
+        raise "Colour value type '#{value.class}' not supported."
+      end
+    end
+
+    private
+
+    def e(seq)
+      if @output_type == :raw
+        "\\033[#{seq}m"
+      else
+        "\033[#{seq}m"
+      end
+    end
+
+    def colour_ansi(string, fg = nil, bg = nil)
+      unless fg == nil
+        colour_id = if fg.is_a? Unknown
+                      fg.id
+                    else
+                      @palette.match_colour(fg)
+        end
+        string = e(colour_id + 30) + string
+      end
+
+      unless bg == nil
+        colour_id = if bg.is_a? Unknown
+                      bg.id
+                    else
+                      @palette.match_colour(bg)
+        end
+        string = e(colour_id + 40) + string
+      end
+
+      string << e(0) unless (fg == nil) && (bg == nil)
+
+      string
+    end
+
+    def colour_extended(string, fg = nil, bg = nil)
+      unless fg == nil
+        colour_id = if fg.is_a? Unknown
+                      fg.id
+                    else
+                      @palette.match_colour(fg)
+        end
+        string = e("38;5;#{colour_id}") + string
+      end
+
+      unless bg == nil
+        colour_id = if bg.is_a? Unknown
+                      bg.id
+                    else
+                      @palette.match_colour(bg)
+        end
+        string = e("48;5;#{colour_id}") + string
+      end
+
+      string << e(0) unless (fg == nil) && (bg == nil)
+
+      string
+    end
+
+    def parse_colour_id(id_in_string)
+      id = String.new(id_in_string)
+      if id[0] == '@'
+        id[0] = ''
+        return id.to_i
+      end
+
+      raise "Invalid colour id #{id_in_string}."
+    end
+
+    def parse_rgb_value(rgb_value_in_string)
+      error_msg = "Invalid RGB value '#{rgb_value_in_string}'."
+      rgb_value = String.new rgb_value_in_string
+      if rgb_value[0] == '#'
+        rgb_value[0] = ''
+      elsif rgb_value[0..1] == '0x'
+        rgb_value[0..1] = ''
+      else
+        raise error_msg
+      end
+
+      raise error_msg unless rgb_value =~ /^[0-9a-fA-F]+$/
+
+      case rgb_value.length
+      when 3
+        rgb_value.scan(/./).map { |c| c.to_i 16 }
+      when 6
+        rgb_value.scan(/../).map { |c| c.to_i 16 }
+      else
+        raise error_msg
+      end
+    end
+
+    def resolve_colour_name(name)
+      raise "Name '#{name}' not found." unless @names.key? name
+
+      @names[name]
+    end
+
+    def resolve_colour_def(colour_def)
+      return nil if colour_def == '' || colour_def == 'default'
+
+      begin
+        id = parse_colour_id colour_def
+        if @palette.is_known? id
+          Colour.new @palette.get_colour_value id
+        else
+          Unknown.new id
+        end
+      rescue RuntimeError
+        begin
+          Colour.new parse_rgb_value colour_def
+        rescue RuntimeError
+          begin
+            colour_def = resolve_colour_name colour_def
+            if colour_def.is_a? String
+              resolve_colour_def colour_def
+            else
+              colour_def
+            end
+          rescue RuntimeError
+            raise "Invalid colour definition '#{colour_def}'."
+          end
+        end
+      end
+    end
+  end
+end