class AnsiSys::Terminal

Constants

CODE_LETTERS

Escape sequence codes processed in this Class

Public Class Methods

new(csis = ["\x1b["]) click to toggle source

csis is an Array of Code Sequence Introducers which can be e[, x9B, or both

# File lib/ansisys.rb, line 590
def initialize(csis = ["\x1b["])
        @lexer = Lexer.new(csis)
        @stream = Array.new
end

Public Instance Methods

apply_code!(letter, *pars) click to toggle source

applies self an escape sequence code that ends with letter as String and with some pars as Integers

# File lib/ansisys.rb, line 631
def apply_code!(letter, *pars)
        case letter
        when 'J'
                cur_col = @cursor.cur_col
                cur_row = @cursor.cur_row
                lines = @screens[-1].lines
                if pars.empty? or 0 == pars[0]
                        rs = lines.keys.select{|r| r > cur_row}
                        cs = lines[cur_row].keys.select{|c| c >= cur_col}
                elsif 1 == pars[0]
                        rs = lines.keys.select{|r| r < cur_row}
                        cs = lines[cur_row].keys.select{|c| c <= cur_col}
                elsif 2 == pars[0]
                        rs = lines.keys
                        cs = []
                        @cursor.apply_code!('H', 1, 1)
                end
                rs.each do |r|
                        lines.delete(r)
                end
                cs.each do |c|
                        lines[cur_row].delete(c)
                end
        when 'K'
                cur_col = @cursor.cur_col
                cur_row = @cursor.cur_row
                line = @screens[-1].lines[cur_row]
                if pars.empty? or 0 == pars[0]
                        cs = line.keys.select{|c| c >= cur_col}
                elsif 1 == pars[0]
                        cs = line.keys.select{|c| c <= cur_col}
                elsif 2 == pars[0]
                        cs = line.keys
                end
                cs.each do |c|
                        line.delete(c)
                end
        when 'S'
                lines = @screens[-1].lines
                n = pars.empty? ? 1 : pars[0]
                n.times do |l|
                        lines.delete(l)
                end
                rs = lines.keys.sort
                rs.each do |r|
                        lines[r-n] = lines[r]
                        lines.delete(r)
                end
                @cursor.apply_code!('H', rs[-1] - n + 1, 1)
        when 'T'
                lines = @screens[-1].lines
                n = pars.empty? ? 1 : pars[0]
                rs = lines.keys.sort_by{|a| -a}     # sort.reverse
                rs.each do |r|
                        lines[r+n] = lines[r]
                        lines.delete(r)
                end
                @cursor.apply_code!('H', rs[-1] - n + 1, 1)
        when 's'
                @stored_cursor = @cursor.dup
        when 'u'
                @cursor = @stored_cursor.dup if @stored_cursor
        end

        return self
end
css_style(format = :html, max_col = 80, max_row = nil, colors = Screen.default_css_colors) click to toggle source

CSS stylelet to be used in <head>

# File lib/ansisys.rb, line 604
def css_style(format = :html, max_col = 80, max_row = nil, colors = Screen.default_css_colors)
        case format
        when :html
                Screen.css_style(colors, max_col, max_row)
        when :text
                ''
        end
end
echo(data) click to toggle source

echoes data, a String of characters or escape sequences to the Terminal. This method actually just buffers the echoed data.

# File lib/ansisys.rb, line 598
def echo(data)
        @lexer.push(data)
        return self
end
render(format = :html, max_col = 80, max_row = nil, colors = Screen.default_css_colors, css_class = nil, css_style = nil, kcode = nil) click to toggle source

renders the echoed data as format of :html or :text. max_col, max_row can be specified as Integer. colors can be Screen.default_css_colors(inverted, bright).

# File lib/ansisys.rb, line 616
def render(format = :html, max_col = 80, max_row = nil, colors = Screen.default_css_colors, css_class = nil, css_style = nil, kcode = nil)
        css_class ||= 'screen'
        kcode ||= Guess.kcode(@lexer.buffer)
        screens = populate(format, max_col, max_row, colors, kcode)
        separator = case format
        when :html
                "\n"
        when :text
                "\n---\n"
        end
        return screens.map{|screen| screen.render(format, css_class, css_style)}.join(separator)
end

Private Instance Methods

populate(format = :html, max_col = 80, max_row = nil, colors = Screen.default_css_colors, kcode = nil) click to toggle source
# File lib/ansisys.rb, line 699
def populate(format = :html, max_col = 80, max_row = nil, colors = Screen.default_css_colors, kcode = nil)
        @cursor = Cursor.new(1, 1, max_col, max_row)
        @stored_cursor = nil
        @screens = [Screen.new(colors, max_col, max_row)]
        @sgr = SGR.new
        @stream += @lexer.lex!
        @stream.each do |type, payload|
                case type
                when :string
                        Characters.new(payload, @sgr).echo_on(@screens[-1], @cursor, kcode)
                when :code
                        unless Lexer::PARAMETER_AND_LETTER =~ payload
                                raise AnsiSysError, "Invalid code: #{payload.inspect}"
                        end
                        letter = $2
                        pars = $1.split(/;/).map{|i| i.to_i}
                        applied = false
                        [@sgr, @cursor, @screens[-1], self].each do |recv|
                                if recv.class.const_get(:CODE_LETTERS).include?(letter)
                                        recv.apply_code!(letter, *pars)
                                        applied = true
                                end
                        end
                        raise AnsiSysError, "Invalid code or not implemented: #{payload.inspect}" unless applied
                end
        end
        return @screens
end