termgui 0.0.4

data/src/util/wrap.rb

@@ -0,0 +1,102 @@
+# taken from https://github.com/pazdera/word_wrap/blob/master/lib/word_wrap/wrapper.rb
+#
+# Copyright (c) 2014, 2015  Radek Pazdera
+# Distributed under the MIT License
+#
+# TODO: Refactor similar passages out of the two functions into a common one
+class Wrapper
+  def initialize(text, width)
+    @text = text
+    @width = width
+  end
+
+  def fit
+    lines = []
+    next_line = ''
+    @text.lines do |line|
+      line.chomp! "\n"
+      if line.empty?
+        unless next_line.empty?
+          lines.push next_line
+          next_line = ''
+        end
+        lines.push ''
+      end
+
+      words = line.split ' '
+
+      words.each do |word|
+        word.chomp! "\n"
+
+        if next_line.length + word.length < @width
+          if !next_line.empty?
+            next_line << ' ' << word
+          else
+            next_line = word
+          end
+        else
+          if word.length >= @width
+            lines.push next_line unless next_line == ''
+            lines.push word
+            next_line = ''
+          else
+            lines.push next_line
+            next_line = word
+          end
+        end
+      end
+    end
+
+    lines.push next_line
+    if next_line.length <= 0
+      lines.join("\n")
+    else
+      lines.join("\n") + "\n"
+    end
+  end
+
+  def wrap
+    output = []
+
+    @text.lines do |line|
+      line.chomp! "\n"
+      if line.length > @width
+        new_lines = split_line(line, @width)
+        while new_lines.length > 1 && new_lines[1].length > @width
+          output.push new_lines[0]
+          new_lines = split_line new_lines[1], @width
+        end
+        output += new_lines
+      else
+        output.push line
+      end
+    end
+    output.map(&:rstrip!)
+    output.join("\n") + "\n"
+  end
+
+  def split_line(line, width)
+    at = line.index(/\s/)
+    last_at = at
+
+    while !at.nil? && at < width
+      last_at = at
+      at = line.index(/\s/, last_at + 1)
+    end
+
+    if last_at.nil?
+      [line]
+    else
+      [line[0, last_at], line[last_at + 1, line.length]]
+    end
+  end
+end
+
+def wrap_text(text, width)
+  lines = text.split("\n")
+  a = lines.map do |line|
+    w = Wrapper.new(line, width).wrap
+    w.split("\n")
+  end
+  a.flatten
+end

data/src/util.rb

@@ -0,0 +1,110 @@
+require 'json'
+
+def json_parse(str)
+  JSON.parse(str)
+end
+
+def json_stringify(obj)
+  JSON.generate(obj)
+end
+
+# TODO: why is it so hard in ruby to access an outer local variable from a method ? I needed to create a
+# module and a wrapper for somethig very trivial
+
+module Util
+  @uc = 0
+  def self.unique(s = '')
+    @uc += 1
+    s + @uc.to_s
+  end
+end
+
+def to_array(v)
+  v.is_a?(Array) ? v : [v]
+end
+
+def unique(s = '')
+  Util.unique(s)
+end
+
+# TODO: hack because \n chars are not printed with puts or print:
+def print_string(str)
+  str.split('\n').map { |s| puts s || '' }
+end
+
+def print_ms(t0)
+  "#{((Time.now - t0) * 1000).to_i} ms"
+end
+
+def parse_integer(s, default = nil)
+  Integer(s)
+rescue StandardError
+  default
+end
+
+def parse_float(s, default = nil)
+  Float(s)
+rescue StandardError
+  default
+end
+
+# returns true if given value is between 0.0 and 1.0
+def is_percent(val)
+  val && val > 0 && val < 1
+end
+
+def unquote(s)
+  s[1..s.length - 1]
+end
+
+def next_tick
+  sleep 0.0000001
+end
+
+def random_int(min = 0, max = 10)
+  (min..max).to_a.sample
+end
+
+def random_float(min = 0.0, max = 1.0)
+  rand * (max - min) + min
+end
+
+CHARS = ('a'..'z').to_a.concat(('A'..'Z').to_a).push('_', '-', '@', '!', '#', '$', '%', '^', '&', '*', '=', '+')
+
+def random_char
+  CHARS.sample
+end
+
+def random_color
+  [random_int(0, 255), random_int(0, 255), random_int(0, 255)]
+end
+
+# similar to JS Array.prototype.some
+def some(array, predicate)
+  i = 0
+  value = nil
+  while i < array.length
+    e = array[i]
+    value = predicate.call e
+    if value
+      value = array[i]
+      break
+    else
+      value = nil
+    end
+    i += 1
+  end
+  value
+end
+
+# TODO: this is the same as event.rb Event. Move Event classes to individual - non dependency file
+module TermGui
+  class Event
+    # @return {String}
+    attr_reader :name
+    # @param {String} name
+    def initialize(name)
+      @name = name
+    end
+end
+end

data/src/widget/button.rb

@@ -0,0 +1,33 @@
+require_relative 'label'
+
+module TermGui
+  module Widget
+    # A button widget. Usage:
+    # Button.new(text: 'click me', style: {bg: 'blue'}, action: proc {|e| p 'actioned!'})
+    class Button < Label
+      def initialize(**args, &block)
+        super
+        @name = 'button'
+        install(:action)
+        set_attribute(:focusable, true)
+      end
+
+      def default_style
+        s = super
+        s.border = Border.new(fg: '#779966')
+        s.bg = '#336688'
+        s.fg = '#111111'
+        s.focus&.fg = 'red'
+        s.focus.bold = true
+        s.focus.underline = true
+        s.focus&.bg = 'grey'
+        s.focus&.border = Border.new(fg: 'green')
+        s.action&.bg = 'red'
+        s.action&.border = Border.new(fg: 'magenta', bold: true, bg: 'white')
+        s
+      end
+    end
+  end
+end
+
+Button = TermGui::Widget::Button

data/src/widget/checkbox.rb

@@ -0,0 +1,47 @@
+require_relative 'button'
+require_relative '../log'
+require_relative '../util'
+require_relative '../screen'
+
+module TermGui
+  module Widget
+    # Similar to HTMLInputElement type="checkbox"
+    class CheckBox < Button
+      def initialize(**args)
+        super
+        @name = 'checkbox'
+        set_attribute('action-keys', %w[enter space])
+        set_attribute('label', text || get_attribute('label') || unique('Option'))
+        update_text get_attribute('value') || get_attribute('checked') || args[:value] || args[:checked] || false
+        on(:action) do |e|
+          update_text !get_attribute('value')
+          render
+          trigger(:input, TermGui::InputEvent.new(self, value, e))
+          trigger(:change, TermGui::ChangeEvent.new(self, value, e))
+        end
+      end
+
+      def value
+        get_attribute('value')
+      end
+
+      def value=(v)
+        update_text v
+      end
+
+      def update_text(v = nil)
+        set_attribute('value', v) unless v == nil
+        self.text = "#{get_attribute('value') ? '[x]' : '[ ]'} #{get_attribute('label')}"
+      end
+
+      def default_style
+        s = super
+        s.border = nil
+        s.action = nil
+        s
+      end
+    end
+  end
+end
+
+CheckBox = TermGui::Widget::CheckBox

data/src/widget/col.rb

@@ -0,0 +1,30 @@
+require_relative '../element'
+module TermGui
+  module Widget
+    # Column container. A column child is rendered at the bottom of the previous child - all of them in one column.
+    # By default it will have height==0.999
+    class Col < Element
+      attr_accessor :gap
+      def initialize(**args)
+        # p(({height: 0.99999}.merge(args))[:height])
+        super({ height: 0.9999999 }.merge(args))
+        # p height, abs_height
+        @name = 'col'
+        @gap = args[:gap]||0
+      end
+
+      def layout
+        # init_y = abs_content_y
+        last_y = abs_content_y
+        @children.each do |c|
+          # last_y += 1 if c.style.border
+          c.abs_y = last_y
+          last_y += c.abs_height + @gap
+          # last_y += 1 if c.style.border
+        end
+      end
+    end
+  end
+end
+
+Col = TermGui::Widget::Col

data/src/widget/image.rb

@@ -0,0 +1,106 @@
+require_relative '../termgui'
+
+module TermGui
+  module Widget
+    # analog to HTMLImageElement. Note that the image will be loaded only on render. Also it will be resized according to abs_content
+    # Properties:
+    # src: file path or TermGui::Image ot load
+    # transparent_color color to blend transparent pixels, by default style.bg
+    # ignore_alpha. if true alpha channel is ignored (could be faster)
+    # use_bg (true by default) will paint pixels using style.bg
+    # use_fg (false by default) will paint using style.fg
+    class Image < Element
+      attr_accessor :pan_x, :pan_y, :zoom
+      def initialize(**args)
+        super
+        @name = 'image'
+        @src = args[:src]
+        @use_bg = args[:use_bg] == nil ? true : args[:use_bg]
+        @use_fg = args[:use_fg] == nil ? false : args[:use_fg]
+        @transparent_color = args[:transparent_color]
+        @ignore_alpha = args[:ignore_alpha]
+        @zoom = args[:zoom] || 1.0
+        @pan_x = args[:pan_x] || 0.0
+        @pan_y = args[:pan_y] || 0.0
+        @chs = args[:chs] || [get_attribute('ch') || ' ']
+        @x_factor = args[:x_factor] || 2.0 # to improve non squared terminal "pixels"
+        @y_factor = args[:y_factor] || 1.2
+      end
+
+      def image
+        if !@image && @src
+          @image = @src.is_a?(String) ? TermGui::Image.new(@src) : @src
+        end
+        factor = (@image.width * 2.0 - abs_content_width) < (@image.height - abs_content_height) ?
+        @zoom * @x_factor * @image.width.to_f / abs_content_width.to_f :
+          @zoom * @y_factor * @image.height.to_f / abs_content_height.to_f
+
+        @resized_image = @image.scale(
+          width: (@image.width.to_f * @x_factor / factor).to_i,
+          height: (@image.height.to_f * @y_factor / factor).to_i
+        )
+        # root_screen.text(text: " #{[factor, @image.height, @image.width, @resized_image.width, @resized_image.height, abs_content_width,abs_content_height, abs_content_x, abs_content_y]}", y: 3, x: 55)
+        if @pan_x + @pan_y > 0
+          @resized_image = @resized_image.crop(
+            x: (@resized_image.width.to_f * @pan_x).to_i,
+            y: (@resized_image.height.to_f * @pan_y).to_i,
+            width: (@resized_image.width.to_f - @resized_image.width.to_f * @pan_x).to_i,
+            height: (@resized_image.height.to_f - @resized_image.height.to_f * @pan_y).to_i
+          )
+        end
+        @image
+      end
+
+      def chs=(v)
+        if @chs.join != v.join
+          @chs = v
+          self.dirty = true
+        end
+      end
+
+      def original_image
+        @image
+      end
+
+      def current_image
+        @resized_image
+      end
+
+      def render_self(screen)
+        [
+          super,
+          image ? screen.image(
+            x: abs_content_x,
+            y: abs_content_y,
+            w: abs_content_width,
+            h: abs_content_height,
+            transparent_color: !@ignore_alpha ? TermGui.to_rgb(@transparent_color || final_style.bg || '#000000') : nil,
+            image: @resized_image,
+            bg: @use_bg,
+            fg:  @use_fg,
+            style: final_style,
+            ch: @chs
+          ) : ''
+        ].join('')
+      end
+
+      def src=(v)
+        @src = v
+        @image = nil
+        refresh
+      end
+
+      def refresh(force_render = false)
+        @resized_image = nil
+        image
+        if force_render
+          self.dirty = true
+          clear
+          render
+        end
+      end
+    end
+  end
+end
+
+Image = TermGui::Widget::Image

data/src/widget/inline.rb

@@ -0,0 +1,40 @@
+require_relative '../element'
+module TermGui
+  module Widget
+    # an inline layout - similar to HTML display: inline - so I can add arbitrary elements. 
+    # it will break when there is no more space and resize itself.
+    # TODO: almost there...
+    class Inline < Element
+      attr_accessor :horizontal_gap, :vertical_gap
+      def initialize(**args)
+        super({ width: 0.9999999 }.merge(args))
+        @name = 'inline'
+        @horizontal_gap = args[:horizontal_gap]||0
+        @vertical_gap = args[:vertical_gap]||0
+      end
+
+      def layout
+        last_y = abs_content_y
+        row_max_height = 1+ @vertical_gap
+        last_x = abs_content_x
+        total_height=0
+        @children.each do |c|
+          c.abs_x = last_x
+          c.abs_y = last_y
+          row_max_height = [row_max_height, c.abs_height].max
+          last_x += c.abs_width + @horizontal_gap
+          if last_x + @horizontal_gap+c.abs_width > abs_content_y + abs_content_width
+            last_x = abs_content_x
+            last_y += row_max_height + @vertical_gap
+            total_height+=row_max_height+@vertical_gap
+            row_max_height = 1+ @vertical_gap
+          end
+        end
+        self.height = [total_height + abs_padding.top + abs_padding.bottom + row_max_height, self.abs_height].max ##TODO borders
+      end
+    end
+  end
+end
+
+Inline = TermGui::Widget::Inline
+

data/src/widget/input_number.rb

@@ -0,0 +1,73 @@
+require_relative 'button'
+require_relative '../enterable'
+require_relative '../util'
+require_relative '../screen'
+
+module TermGui
+  module Widget
+    # analog to HTMLInputElement type="number"
+    class InputNumber < Button
+      include Enterable
+      def initialize(**args)
+        super
+        @name = 'input-number'
+        set_attribute('escape-on-blur', get_attribute('escape-on-blur') == nil ? true : get_attribute('escape-on-blur'))
+        set_attribute('action-on-focus', get_attribute('action-on-focus') == nil ? true : get_attribute('action-on-focus'))
+      end
+
+      def value
+        v = parse_float(text)
+        v == nil ? v : (v.to_i - v == 0 ? v.to_i : v)
+      end
+
+      def value=(v)
+        self.text = v.to_s
+      end
+
+      def handle_key(event)
+        if !super(event)
+          if event.key == 'up'
+            on_input value + 1, event
+            true
+          elsif event.key == 'down'
+            on_input value - 1, event
+            true
+          elsif numeric? event.key
+            self.text = text + event.key
+            if parse_float(text) == nil
+              render
+            else
+              on_input value, event
+            end
+            true
+          elsif event.key == 'backspace'
+            self.text = text.slice(0, [text.length - 1, 0].max)
+            if parse_float(text) == nil
+              render
+            else
+              on_input value, event
+            end
+            true
+          end
+        else
+          true
+        end
+      end
+    end
+  end
+end
+
+InputNumber = TermGui::Widget::InputNumber
+
+# # p parse_float('9.')
+
+# sb = nil
+# s = Screen.new(children: [
+#                  Button.new(text: 'hello', x: 0.7, y: 0.6, action: proc { |e|
+#                    e.target.text = sb.value.to_s
+#                    e.target.render
+#                  }),
+#                  (sb = InputNumber.new(x: 2, y: 1, width: 0.5, height: 0.5, value: 12))
+#                ])
+
+# s.start

data/src/widget/inputbox.rb

@@ -0,0 +1,85 @@
+require_relative 'button'
+require_relative '../enterable'
+require_relative '../log'
+require_relative '../cursor'
+
+module TermGui
+  module Widget
+    # One line text input box, analog to HTMLInputElement
+    class InputBox < Button
+      include Enterable
+      def initialize(**args)
+        super({height: 1, text: args[:value]||args[:text] }.merge(args))
+        # super
+        @name = 'input'
+        if args[:dynamic_width]
+          on(:input) do |e|
+            update_width(e.value)
+            cursor.x = abs_content_x + e.value.length - 2
+          end
+        end
+        # set_attribute('escape-on-blur', get_attribute('escape-on-blur') == nil ? true : get_attribute('escape-on-blur'))
+        # set_attribute('action-on-focus', get_attribute('action-on-focus') == nil ? true : get_attribute('action-on-focus'))
+        on(:enter) do
+          cursor.enable
+        end
+        on(:escape) do
+          cursor.disable
+          args[:change]&.call(value)
+        end
+      end
+
+      def cursor
+        @cursor ||= Cursor.new(x: abs_content_x + value.length - 2, y: abs_content_y, enabled: false, screen: root_screen)
+        @cursor
+      end
+
+      def value=(value)
+        @text = value
+      end
+
+      def value
+        text
+      end
+
+      def between(v, min, max)
+        [[v, min].max, max].min
+      end
+
+      def current_x
+        cursor.x - abs_content_x
+      end
+
+      def handle_key(event)
+        if !super(event)
+          if event.key == 'backspace'
+            on_input value[0..between(current_x - 1, 0, value.length - 1)] + value[between(current_x + 1, 0, value.length - 1)..(value.length - 1)], event
+            cursor.x = [cursor.x - 1, abs_content_x - 1].max
+            render
+            true
+          elsif alphanumeric? event.key
+            on_input value[0..between(current_x, 0, value.length - 1)] + event.key + value[between(current_x + 1, 0, value.length - 1)..(value.length - 1)], event
+            cursor.x = cursor.x + 1
+            render
+            true
+          elsif ['right'].include? event.key
+            cursor.x = [cursor.x + 1, abs_content_x + value.length - 1].min
+            render
+            true
+          elsif ['left'].include? event.key
+            cursor.x = [cursor.x - 1, abs_content_x - 1].max
+            render
+            true
+          else
+            false
+          end
+        else
+          true
+        end
+      end
+    end
+  end
+end
+
+InputBox = TermGui::Widget::InputBox
+

data/src/widget/label.rb

@@ -0,0 +1,33 @@
+require_relative '../element'
+module TermGui
+  module Widget
+    # A label widget. It's size, if not given, will be computed according to its text.
+    class Label < Element
+      def initialize(**args)
+        super
+        @name = 'label'
+        # sets width and height according to size rendering:
+        w = args[:width] || 0
+        update_width if !w || w.zero?
+        h = args[:height] || 0
+        update_height if !h || h.zero?
+      end
+
+      def text=(t)
+        super
+        update_width
+        update_height
+      end
+
+      def update_width(text = @text)
+        self.width = render_text_size(text)[:width]
+      end
+
+      def update_height(text = @text)
+        self.height = render_text_size(text)[:height]
+      end
+    end
+  end
+end
+
+Label = TermGui::Widget::Label