termgui 0.0.4

data/src/cursor.rb

@@ -0,0 +1,69 @@
+require_relative 'style'
+module TermGui
+  # minimalist artificial screen cursor. TODO: cursor can be manipulated via ansi escape codes - see npm.org/blessed
+  class Cursor
+    attr_accessor :interval, :x, :y, :enabled, :off, :on
+
+    def initialize(
+      on_interval: 0.3, off_interval: on_interval / 2,
+      x: 0, y: 0, enabled: false,
+      #  by default we render the cursor next to its real x-coordinate
+      x_offset: 1,
+      screen: nil, off: ' ', on: '_',
+      on_style: Style.new(bg: 'white', fg: 'black'), off_style: Style.new(bg: 'black', fg: 'white')
+    )
+      @x = x
+      @y = y
+      @on_interval = on_interval
+      @off_interval = off_interval
+      @enabled = enabled
+      @x_offset = x_offset
+      @screen = screen
+      throw 'screen must be provided' unless @screen
+      @state = 0
+      @off = off
+      @on = on
+      @on_style = on_style
+      @off_style = off_style
+    end
+
+    def enable
+      disable
+      @enabled = true
+      @state = 0
+      tick
+    end
+
+    def draw_off
+      @screen.text(x: @x + @x_offset, y: @y, text: @off, style: @off_style)
+    end
+
+    def draw_on
+      @screen.text(x: @x + @x_offset, y: @y, text: @on, style: @on_style)
+    end
+
+    def disable
+      @enabled = false
+      @screen.clear_timeout @timeout if @timeout
+    end
+
+    protected
+
+    # renders the cursor according to its state, toggling the state and finally schedulling to call it self according to on_interval, off_interval
+    def tick
+      if @state == 0
+        @state = 1
+        draw_on
+      elsif @state == 1
+        @state = 0
+        draw_off
+      else
+        throw 'unknown state ' + @state
+      end
+      @screen.clear_timeout @timeout if @timeout
+      @timeout = @screen.set_timeout(@state == 0 ? @on_interval : @off_interval) { tick } if @enabled
+    end
+  end
+end
+
+Cursor = TermGui::Cursor

data/src/editor/editor_base.rb

@@ -0,0 +1,152 @@
+require_relative '../cursor'
+require_relative '../log'
+require_relative '../key'
+require_relative 'editor_base_handlers'
+
+# See TODO.md section Editor for status and TODOs
+module TermGui
+  class EditorBase
+    include EditorBaseHandlers
+
+    attr_accessor :x, :y, :width, :height
+
+    def initialize(
+      text: '', screen: nil, x: 0, y: 0,
+      width: screen.width, height: screen.height,
+      cursor_x: nil, cursor_y: nil,
+      # if true other party will listen keys and call handle_key - if false it will listen any key by itlself
+      managed: false
+    )
+      @screen = screen || (throw 'screen not given')
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+      @managed = managed
+      @cursor = Cursor.new(screen: @screen)
+      self.text = text
+      @cursor.y = @y + cursor_y if cursor_y
+      @cursor.x = @x + cursor_x if cursor_x
+    end
+
+    def cursor_x
+      @cursor.x - @x
+    end
+
+    def cursor_y
+      @cursor.y - @y
+    end
+
+    def text=(text)
+      @lines = text.split('\n')
+      @cursor.y = @y + @lines.length - 1
+      @cursor.x = @x + current_line.length - 1
+    end
+
+    def value=(v)
+      self.text = v
+    end
+
+    def text
+      @lines.join('\n')
+    end
+
+    def value
+      text
+    end
+
+    def enable(and_render = true)
+      disable
+      @cursor.enable
+      unless @managed
+        @key_listener = @screen.event.add_any_key_listener do |event|
+          handle_key event
+        end
+      end
+      render if and_render
+    end
+
+    def disable
+      @cursor.disable
+      @screen.event.remove_any_key_listener @key_listener if @key_listener
+      @key_listener = nil
+    end
+
+    def enabled
+      @cursor.enabled
+    end
+
+    def render
+      @screen.clear
+      # @screen.rect(x: x, y: y, width: width, height: height, style: Style.new)
+      @screen.render
+      @lines.each_with_index do |line, i|
+        @screen.text(x: @x, y: @y + i, text: line)
+      end
+    end
+
+    # public so keys can be programmatically simlated - useful for tests instead of calling screen.event.handle_keythat emits globally.
+    def handle_key(event)
+      if !enabled
+        return
+      elsif ['down'].include? event.key
+        cursor_down
+      elsif ['up'].include? event.key
+        cursor_up
+      elsif ['right'].include? event.key
+        cursor_right
+      elsif ['left'].include? event.key
+        cursor_left
+      elsif ['enter'].include? event.key
+        handle_enter
+      elsif ['tab'].include? event.key
+        insert_chars('    ') # TODO: hack - adding a tab will break since we assume all chars width is 1 (1 column per char) - it will also fail for unicode chars width>1
+      elsif ['S-tab'].include? event.key
+        # TODO: remove tab line prefix
+      elsif event.key == 'backspace'
+        handle_backspace
+      elsif event.key == 'delete'
+        handle_delete
+      elsif alphanumeric?(event.raw) || %w[space tab].include?(event.key)
+        insert_chars(event.raw)
+      end
+
+      @cursor.off = current_char || @cursor.off
+      @cursor.on = current_char || @cursor.on
+      render
+      @cursor.draw_on
+    end
+
+    protected
+
+    def current_line
+      @lines[current_y] || ''
+    end
+
+    def current_line=(value)
+      @lines[current_y] = value || ''
+    end
+
+    def current_char
+      current_line[[[current_x, current_line.length].min, 0].max] || ' '
+    end
+
+    def current_x
+      @cursor.x - @x
+    end
+
+    def current_x=(x)
+      @cursor.x = @x + x
+    end
+
+    def current_y
+      @cursor.y - @y
+    end
+
+    def current_y=(y)
+      @cursor.y = @y + y
+    end
+  end
+end
+
+EditorBase = TermGui::EditorBase

data/src/editor/editor_base_handlers.rb

@@ -0,0 +1,116 @@
+require_relative '../cursor'
+require_relative '../log'
+require_relative '../key'
+
+module TermGui
+  module EditorBaseHandlers
+    def handle_enter
+      if current_x >= current_line.length
+        @lines.insert(current_y + 1, '')
+      else
+        line1 = current_x == 0 ? '' : current_line[0..[current_x - 1, 0].max]
+        line2 = current_line[[current_x, current_line.length].min..current_line.length]
+        @lines.delete_at(current_y)
+        @lines.insert(current_y, line1, line2)
+      end
+      self.current_y += 1
+      self.current_x = 0
+    end
+
+    def insert_chars(s)
+      prefix = current_x < 1 ? '' : current_line[0..[current_x - 1, 0].max] || ''
+      postfix = current_line[[current_x, 0].max..current_line.length] || ''
+      self.current_line = prefix + s + postfix
+      self.current_x += s.length
+    end
+
+    def handle_delete
+      if current_x >= current_line.length && current_y >= @lines.length - 1
+        @screen.alert
+      else
+        if current_line.length <= 1
+          self.current_x = 0
+          self.current_line = ''
+        else
+          prefix = current_line[0..[current_x - 1, 0].max]
+          postfix = current_line[[current_x + 1, current_line.length].min..current_line.length] || ''
+          self.current_line = prefix + postfix
+          # TODO: join lines if at the end of line and there's a following
+        end
+      end
+    end
+
+    def cursor_down
+      if self.current_y == @lines.length - 1
+        if current_x > current_line.length
+          @screen.alert
+        else
+          self.current_x = current_line.length
+        end
+      else
+        self.current_y = self.current_y == @lines.length - 1 ? current_y : current_y + 1
+        self.current_x = [current_x, current_line.length].min
+      end
+    end
+
+    def cursor_right
+      if current_x >= current_line.length
+        if current_y < @lines.length - 1
+          self.current_y += 1
+          self.current_x = 0
+        else
+          @screen.alert
+        end
+      else
+        self.current_x += 1
+      end
+    end
+
+    def cursor_left
+      if current_x < 1
+        if current_y > 0
+          self.current_y -= 1
+          self.current_x = current_line.length
+        else
+          @screen.alert
+        end
+      else
+        self.current_x -= 1
+      end
+    end
+
+    def handle_backspace
+      if current_x < 1 && current_y <= 0
+        @screen.alert
+      elsif current_x < 1
+        old_line = (@lines.delete_at(current_y) unless @lines.empty?) || ''
+        self.current_y = [current_y - 1, 0].max
+        self.current_x = current_line.length
+        self.current_line = current_line + old_line
+      elsif current_line.length <= 1
+        self.current_x = 0
+        self.current_line = ''
+      else
+        prefix = current_line[0..[current_x - 2, 0].max]
+        postfix = current_line[[current_x, current_line.length].min..current_line.length] || ''
+        self.current_line = prefix + postfix
+        self.current_x = [current_x - 1, 0].max
+      end
+    end
+
+    def cursor_up
+      if self.current_y == 0
+        if self.current_x == 0
+          @screen.alert
+        else
+          self.current_x = 0
+        end
+      else
+        self.current_y = [current_y - 1, 0].max
+        self.current_x = [current_x, current_line.length - 1].min
+      end
+    end
+  end
+end
+
+EditorBaseHandlers = TermGui::EditorBaseHandlers

data/src/element.rb

@@ -0,0 +1,61 @@
+require_relative 'node'
+require_relative 'style'
+require_relative 'renderer'
+require_relative 'element_bounds'
+require_relative 'element_box'
+require_relative 'element_render'
+require_relative 'element_style'
+
+module TermGui
+  # Node responsible of
+  #  * x, y, width, height, abs_x, abs_y
+  #  * rendering text, wrap (TODO)
+  #  * border, margin & padding & abs_* update (TODO)
+  #  * scroll
+  # TODO: separate each responsibility on its module or subclass
+  class Element < Node
+    include ElementBounds
+    include ElementBox
+    include ElementRender
+    include ElementStyle
+
+    def initialize(**args)
+      super
+      install(%i[focus blur action enter escape])
+      args[:attributes] = { x: args[:x] || 0, y: args[:y] || 0, width: args[:width] || 0, height: args[:height] || 0 } if args[:attributes] == nil
+      a = {}.merge(args, args[:attributes] || {})
+      a[:style] = default_style.assign(Style.from_hash(a[:attributes][:style])).assign(Style.from_hash(a[:style]))
+      self.attributes = a
+      self.style = a[:style]
+      on(%i[focus blur action enter escape]) do |e|
+        s = root_screen
+        if s
+          if e.name == 'action'
+            set_attribute('actioned', true)
+            render s
+            s.set_timeout(get_attribute('actioned-interval') || 0.2) do
+              set_attribute('actioned', false)
+              render s
+            end
+          else
+            render s
+          end
+        end
+      end
+    end
+
+    def focus
+      if get_attribute('focusable')
+        root_screen&.focus&.focused = self
+        trigger :bounds_change
+      end
+    end
+
+    def text=(v)
+      @text = v
+      trigger :bounds_change
+    end
+  end
+end
+
+Element = TermGui::Element

data/src/element_bounds.rb

@@ -0,0 +1,111 @@
+require_relative 'util'
+require_relative 'geometry'
+
+# Adds support for Element's x, y, abs_x, abs_y, width, height, abs_width, abs_height, offset (scroll viewport)
+module ElementBounds
+  def initialize(**args)
+    super
+    install(:bounds_change)
+  end
+
+  def x=(x)
+    set_attribute('x', x)
+    trigger :bounds_change
+  end
+
+  def x
+    get_attribute('x') || 0
+  end
+
+  def abs_x
+    val = if is_percent x
+            ((@parent ? @parent.abs_x : 0) + x * (@parent ? @parent.abs_width : abs_width)).truncate
+          else
+            ((@parent ? @parent.abs_x : 0) + x).truncate
+          end
+    o = @parent && parent.offset
+    val -= o.left if o
+    # val -= 1 if border
+    val
+  end
+
+  def offset
+    v = get_attribute('offset')
+    set_attribute('offset', v = Offset.new) unless v
+    v
+  end
+
+  def offset=(value)
+    set_attribute('offset', value)
+    trigger :bounds_change
+  end
+
+  def abs_x=(value)
+    # TODO: parent offset
+    self.x = value - (@parent ? @parent.abs_x : 0).truncate
+  end
+
+  def y=(y)
+    set_attribute('y', y)
+    trigger :bounds_change
+  end
+
+  def y
+    get_attribute('y') || 0
+  end
+
+  def abs_y
+    val = if is_percent y
+            ((@parent ? @parent.abs_y : 0) + y * (@parent ? @parent.abs_height : abs_height)).truncate
+          else
+            ((@parent ? @parent.abs_y : 0) + y).truncate
+          end
+    o = @parent && parent.offset
+    val -= o.top if o
+    # val += 1 if border
+    val
+  end
+
+  def abs_y=(value)
+    # TODO: parent offset
+    self.y = value - (@parent ? @parent.abs_y : 0).truncate
+  end
+
+  def width=(width)
+    set_attribute('width', width)
+    trigger :bounds_change
+  end
+
+  def width
+    get_attribute('width') || 0
+  end
+
+  def abs_width
+    val = if (is_percent width) && @parent
+            (@parent.abs_width * width).truncate
+          else
+            width.truncate
+    end
+    val += 2 if border
+    val
+  end
+
+  def height=(height)
+    set_attribute('height', height)
+    trigger :bounds_change
+  end
+
+  def height
+    get_attribute('height') || 0
+  end
+
+  def abs_height
+    val = if is_percent height
+            (@parent ? @parent.abs_height * height : 0).truncate
+          else
+            height.truncate
+    end
+    val += 2 if border&.style
+    val
+  end
+end

data/src/element_box.rb

@@ -0,0 +1,64 @@
+require_relative 'geometry'
+require_relative 'element_bounds'
+require_relative 'util/hash_object'
+
+# Adds html-like box-model support for Element: margin, padding, border
+module ElementBox
+  include ElementBounds
+
+  def abs_content_x
+    abs_x + abs_padding.left + (border ? 1 : 0)
+  end
+
+  def abs_content_y
+    abs_y + abs_padding.top + (border ? 1 : 0)
+  end
+
+  def abs_content_width
+    m = abs_padding
+    abs_width - m.left - m.right - (border ? 2 : 0)
+  end
+
+  def abs_content_height
+    m = abs_padding
+    abs_height - m.top - m.bottom - (border ? 2 : 0)
+  end
+
+  def abs_content_bounds
+    y = abs_content_y
+    x = abs_content_x
+    Bounds.new(left: x, right: x + abs_content_width, top: y, bottom: y + abs_content_height)
+  end
+
+  def abs_content_box
+    Rectangle.new(x: abs_content_x, y: abs_content_y, width: abs_content_width, height: abs_content - abs_content_height)
+  end
+
+  # returns padding as Offset instance
+  def padding
+    padding = get_style('padding')
+    if !padding
+      Bounds.new
+    elsif padding.instance_of? Hash
+      Offset.from_hash(padding)
+    else
+      padding
+    end
+  end
+
+  def padding=(padding)
+    set_style('padding', padding)
+    trigger :bounds_change
+  end
+
+  # computes absolute padding transforming padding percents to absolute pixel amounts.
+  def abs_padding
+    p = padding
+    Bounds.new(
+      top: is_percent(p.top) ? (p.top * abs_height).truncate : p.top,
+      bottom: is_percent(p.bottom) ? (p.bottom * abs_height).truncate : p.bottom,
+      left: is_percent(p.left) ? (p.left * abs_width).truncate : p.left,
+      right: is_percent(p.right) ? (p.right * abs_width).truncate : p.right
+    )
+  end
+end

data/src/element_render.rb

@@ -0,0 +1,102 @@
+require_relative 'element_box'
+require_relative 'element_style'
+require_relative 'util'
+require_relative 'util/wrap'
+require_relative 'log'
+require_relative 'box'
+
+# implements element rendering (self, border, child, text) for which it depends on ElementBox
+module ElementRender
+  include ElementBox
+  include ElementStyle
+
+  attr_accessor :dirty
+
+  def initialize(**args)
+    super
+    @render_cache = args[:render_cache] || false
+    @dirty = true
+    @render_cache_data = nil
+    on(:bounds_change) do
+      @dirty = true
+    end
+  end
+
+  def border
+    style&.border
+  end
+
+  def render(screen = root_screen, force = false)
+    self.dirty = true if force
+    return '' unless screen
+
+    trigger(:before_render)
+
+    layout
+    if @render_cache && !dirty && @render_cache_data
+      screen.write @render_cache_data
+    else
+      @render_cache_data = [
+        render_border(screen),
+        render_self(screen),
+        render_text(screen)
+      ].join('')
+    end
+    trigger(:after_render)
+    self.dirty = false if @render_cache
+    [@render_cache_data, render_children(screen)].join('')
+  end
+
+  def root_screen
+    @parent&.root_screen
+  end
+
+  def clear
+    root_screen.rect(x: abs_x, y: abs_y, width: abs_width, height: abs_height, style: parent.final_style) if parent && root_screen
+  end
+
+  protected
+
+  def render_self(screen)
+    screen.rect(
+      x: abs_x + (border ? 1 : 0),
+      y: abs_y + (border ? 1 : 0),
+      width: abs_width - (border ? 2 : 0),
+      height: abs_height - (border ? 2 : 0),
+      ch: get_attribute('ch'),
+      style: final_style
+    )
+  end
+
+  # IMPORTANT: border is rendered in a +2 bigger rectangle that sourounds actual element bounds (abs_* methods)
+  def render_border(screen)
+    border ? screen.box(abs_x, abs_y, abs_width, abs_height, border.style, border_style) : ''
+  end
+
+  def render_text(screen)
+    (render_text_lines.map.with_index do |line, i|
+      screen.text(x: abs_content_x, y: abs_content_y + i, text: line, style: final_style)
+    end).join('')
+  end
+
+  def render_children(screen)
+    (@children.map do |c|
+      c.render(screen)
+    end).join('')
+  end
+
+  def render_text_lines(text = @text || '')
+    text&.length ? (style.wrap ? wrap_text(text, abs_content_width) : text.split('\n')) : []
+  end
+
+  # can be used by text widgets like labels or buttons to automatically set preffered size according to its text
+  def render_text_size(text = @text)
+    lines = render_text_lines(text)
+    width = lines.map(&:length).max
+    height = lines.length
+    { width: width, height: height }
+  end
+
+  def layout
+  end
+end