termgui 0.0.5 → 0.0.6

data/src/action.rb

@@ -0,0 +1,58 @@
+require_relative 'event'
+require_relative 'emitter'
+require_relative 'util'
+
+module TermGui
+  # action manager - it notifies focused elements on user input
+  # WIP
+  # defines action concept semantics like "action", "input"
+  # "focus": user press tab and it set focus on the next focusable element
+  # "enter": user focus a button and press enter or space. The button will receive an "action" event.
+  # "input": user focus a textarea, press enter ("action") and this enters in the "edit" mode
+  # meaning all user input now it's being notified ONLY to the textarea. Nor even the focus manager or
+  # others will be notified.
+  # "escape": when in a textarea "edit" mode, user press ESCAPE to exit it, meaning now user input will
+  # be notified to all listeners. Example: when in edit mode, pressing TAB will just print a tab in the
+  # textarea and it won't change focus as usual. For that to happen user presses escape to exit the "edit" mode.
+  # Attributes enabling each action:
+  # "enterable"
+  # "focusable"
+  # in the case of scape it will be enabled iff enterable is true
+  # For example a Label is not focusable or enterable. A Button is focusable but not enterable. A textatra is focusable and enterable.
+  class ActionManager < Emitter
+    attr_accessor :keys
+
+    def initialize(event: nil, focus: nil)
+      super()
+      @event = event
+      @focus = focus
+      @event.add_any_key_listener { |e| handle_key e }
+      install(:action)
+      @keys = ['enter']
+    end
+
+    def handle_key(e)
+      focused = @focus.focused
+      return unless focused && !focused.get_attribute('entered')
+
+      action_keys = to_array(focused.get_attribute('action-keys') || keys)
+      if action_keys.include?(e.key) && focused.get_attribute('focusable')
+        event = ActionEvent.new focused, e
+        focused_action = focused.get_attribute('action')
+        focused_action&.call(event)
+        trigger event.name, event
+        focused.trigger event.name, event
+      end
+    end
+  end
+
+  # An event representing an action, like a button "clicked"
+  class ActionEvent < NodeEvent
+    def initialize(target, original_event = nil)
+      super 'action', target, original_event
+    end
+  end
+end
+
+ActionEvent = TermGui::ActionEvent
+ActionManager = TermGui::ActionManager

data/src/box.rb

@@ -0,0 +1,90 @@
+BOXES = {
+  single: {
+    topLeft: '┌',
+    topRight: '┐',
+    bottomRight: '┘',
+    bottomLeft: '└',
+    vertical: '│',
+    horizontal: '─'
+  },
+  double: {
+    topLeft: '╔',
+    topRight: '╗',
+    bottomRight: '╝',
+    bottomLeft: '╚',
+    vertical: '║',
+    horizontal: '═'
+  },
+  round: {
+    topLeft: '╭',
+    topRight: '╮',
+    bottomRight: '╯',
+    bottomLeft: '╰',
+    vertical: '│',
+    horizontal: '─'
+  },
+  bold: {
+    topLeft: '┏',
+    topRight: '┓',
+    bottomRight: '┛',
+    bottomLeft: '┗',
+    vertical: '┃',
+    horizontal: '━'
+  },
+  single_double: {
+    topLeft: '╓',
+    topRight: '╖',
+    bottomRight: '╜',
+    bottomLeft: '╙',
+    vertical: '║',
+    horizontal: '─'
+  },
+  double_single: {
+    topLeft: '╒',
+    topRight: '╕',
+    bottomRight: '╛',
+    bottomLeft: '╘',
+    vertical: '│',
+    horizontal: '═'
+  },
+  classic: {
+    topLeft: '+',
+    topRight: '+',
+    bottomRight: '+',
+    bottomLeft: '+',
+    vertical: '|',
+    horizontal: '-'
+  }
+}.freeze
+
+def boxes
+  BOXES
+end
+
+def draw_box(width: 0, height: 0, style: :single, content: ' ')
+  box = BOXES[style ? style.to_sym : :single]
+  lines = []
+
+  (0..height - 1).each do |y|
+    line = []
+    (0..width - 1).each do |x|
+      line .push(if y.zero? && x.zero?
+                   box[:topLeft]
+                 elsif y == height - 1 && x.zero?
+                   box[:bottomLeft]
+                 elsif y.zero? && x == width - 1
+                   box[:topRight]
+                 elsif y == height - 1 && x == width - 1
+                   box[:bottomRight]
+                 elsif y == height - 1 || y.zero?
+                   box[:horizontal]
+                 elsif x == width - 1 || x.zero?
+                   box[:vertical]
+                 else
+                   content
+              end)
+    end
+    lines.push(line.join(''))
+  end
+  lines
+end

data/src/color.rb

@@ -0,0 +1,174 @@
+# # # fast acceptable color comparision by myself
+# # def color_distance1(c1, c2)
+# #   sum = 0
+# #   c1.each_index do |i|
+# #     sum += (c1[i].abs2 - c2[i].abs2).abs
+# #   end
+# #   sum
+# # end
+
+# def color_distance3(c1, c2)
+#   sum = 0
+#   coef = [1, 1, 1]
+#   c1.each_index do |i|
+#     sum += ((c1[i] - c2[i]) * coef[i]).abs2
+#   end
+#   sum
+# end
+
+# # // As it happens, comparing how similar two colors are is really hard. Here is
+# # // one of the simplest solutions, which doesn't require conversion to another
+# # // color space, posted on stackoverflow[1]. Maybe someone better at math can
+# # // propose a superior solution.
+# # // [1] http://stackoverflow.com/questions/1633828
+# def color_distance2(c1, c2)
+#   # function colorDistance(r1, g1, b1, r2, g2, b2) {
+#   #   return Math.pow(30 * (r1 - r2), 2)
+#   #     + Math.pow(59 * (g1 - g2), 2)
+#   #     + Math.pow(11 * (b1 - b2), 2);
+#   # }
+#   (30 * (c1[0] - c2[0])).abs2 + (59 * (c1[1] - c2[1])).abs2 + (11 * (c1[2] - c2[2])).abs2
+# end
+
+# # // This might work well enough for a terminal's colors: treat RGB as XYZ in a
+# # // 3-dimensional space and go midway between the two points.
+# # exports.mixColors = function(c1, c2, alpha) {
+# #   // if (c1 === 0x1ff) return c1;
+# #   // if (c2 === 0x1ff) return c1;
+# #   if (c1 === 0x1ff) c1 = 0;
+# #   if (c2 === 0x1ff) c2 = 0;
+# #   if (alpha == null) alpha = 0.5;
+
+# #   c1 = exports.vcolors[c1];
+# #   var r1 = c1[0];
+# #   var g1 = c1[1];
+# #   var b1 = c1[2];
+
+# #   c2 = exports.vcolors[c2];
+# #   var r2 = c2[0];
+# #   var g2 = c2[1];
+# #   var b2 = c2[2];
+
+# #   r1 += (r2 - r1) * alpha | 0;
+# #   g1 += (g2 - g1) * alpha | 0;
+# #   b1 += (b2 - b1) * alpha | 0;
+
+# #   return exports.match([r1, g1, b1]);
+# # };
+
+# # the rest is obsoleted by src/tco
+
+# # color enumerations and utilities. See http://ascii-table.com/ansi-escape-sequences.phpsss
+# require_relative 'key'
+
+# # obsolete
+# COLORS = {
+#   black: 0,
+#   red: 1,
+#   green: 2,
+#   yellow: 3,
+#   blue: 4,
+#   magenta: 5,
+#   cyan: 6,
+#   white: 7
+# }.freeze
+
+# # obsolete
+# def color_names
+#   %w[black red green yellow blue magenta cyan white]
+# end
+
+# # obsolete
+# def random_color
+#   color_names.sample
+# end
+
+# # obsolete
+# def color_text(content, fg = nil, bg = nil)
+#   colored = color(fg, bg)
+#   colored << content
+#   colored << "#{CSI}0m"
+# end
+
+# # obsolete
+# def color(fg = nil, bg = nil)
+#   colored = ''
+#   colored << color_to_escape(fg, 30) if fg
+#   colored << color_to_escape(bg, 40) if bg
+# end
+
+# # obsolete
+# def color_to_escape(name, layer)
+#   short_name = name.to_s.sub(/\Abright_/, '')
+#   color = COLORS.fetch(short_name.to_sym)
+#   escape = "#{CSI}#{layer + color}"
+#   escape << ';1' if short_name.size < name.size
+#   escape << 'm'
+#   escape
+# end
+
+# # # https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters
+# # ATTRIBUTES = {
+# #   normal: 0,
+
+# #   bold: 1,
+# #   boldOff: 22,
+
+# #   faint: 2,
+# #   faintOff: 22,
+
+# #   italic: 3,
+# #   italicOff: 23,
+
+# #   underline: 4,
+# #   underlineOff: 24,
+
+# #   blink: 5,
+# #   slowBlink: 5,
+# #   rapidBlink: 6,
+# #   blinkOff: 25,
+# #   slowBlinkOff: 25,
+# #   rapidBlinkOff: 25,
+
+# #   inverse: 7,
+# #   inverseOff: 27,
+
+# #   defaultForeground: 39,
+# #   defaultBackground: 49,
+
+# #   invisible: 8,
+# #   invisibleOff: 28,
+
+# #   fraktur: 20,
+# #   frakturOff: 23,
+
+# #   framed: 51,
+# #   encircled: 52,
+# #   overlined: 53,
+
+# #   framedOff: 54,
+# #   encircledOff: 54
+# # }.freeze
+
+# # # Usage: screen.write attributes(blink: true).
+# # # Attributes supported: bold, inverse, blink, slowBlink, rapidBlink, invisible, fraktur, framed, encircled, normal,
+# # # italic, underline, faint
+# # #
+# # # Esc[Value;...;Valuem  Set Graphics Mode:
+# # # Calls the graphics functions specified by the following values.
+# # # These specified functions remain active until the next occurrence of this escape sequence. Graphics mode changes the
+# # # colors and attributes of text (such as bold and underline) displayed on the screen
+# # def attributes(**args)
+# #   output = []
+# #   args.keys.each do |key|
+# #     if args[key] == true
+# #       output.push ATTRIBUTES[key].to_s
+# #     elsif args[key] == false
+# #       output.push ATTRIBUTES[:blinkOff].to_s if key == :blink
+# #       output.push "#{CSI}#{ATTRIBUTES[:boldOff]}" if key == :bold
+# #       # TODO: the rest
+# #     end
+# #   end
+# #   # p output
+# #   !output.empty? ? "#{CSI}#{output.join(';')}m" : ''
+# # end

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