termgui 0.0.4 → 0.0.5

data/src/editor/editor_base_handlers.rb

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

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

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

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

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