termgui 0.0.4 → 0.0.5

data/src/action.rb

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

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

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

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

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