kaitai-struct-visualizer 0.4 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d14808a034e6e74e58395601dcfdeec2cf874d69
-  data.tar.gz: 75e679c69ed1ee921fe0c9aa2448157bd19dc6e1
+  metadata.gz: '0294e63ea9c355016ef56c48aed683eec1204ee4'
+  data.tar.gz: 49acc6230547d1c10c1978d626cb498a29d2cd0f
 SHA512:
-  metadata.gz: f49dccf89740812c59b12e8eb41067cbe5705ef7ec7e3a210d33087c4c8b2b0863c860db0a43ee38f9dd926ee67e3819ae401e2a4b14f17a8ed160b6699f1415
-  data.tar.gz: 2224037570682309e1ce9db6b9245869f5382b71150705caf3bfd802c7a3727dff7aacfcb1cc196d225795bc60ad5214e07b06dc94169a3f41717c9c8c8e7414
+  metadata.gz: 7962d68bdafde103d6cf56408436ec79299e3fc25ed7b76dee888bde59d06e65bc71231732d4c9fe6ba5dfd3ebb5c727c2f394aa9c081af1123c69f39fb20380
+  data.tar.gz: 07ac40819e35d59ae48e3fcdba3f965df4288ec0c6fe45867f236ec3859f0f06ed62b5e1ea5e6e59fdae80c4a1a7d688fd2ff7658da81767e61fb1b389e41302

data/README.md

@@ -18,9 +18,17 @@ for details on `.ksy` files and general usage patterns.
 
 ## Downloading and installing
 
-### Generic
+### From Ruby Gems repository
 
-KS visualizer is written in Ruby and is available as .gem package. 
+KS visualizer is written in [Ruby](https://www.ruby-lang.org/) and is
+available as
+[.gem package](https://rubygems.org/gems/kaitai-struct-visualizer). Thus,
+you'll need Ruby (RubyGems package manager comes bundled with Ruby
+since v1.9) installed on your box, and then you can just run:
+
+```shell
+gem install kaitai-struct-visualizer
+```
 
 ### Source code
 

data/lib/kaitai/console_ansi.rb

@@ -0,0 +1,119 @@
+# coding: utf-8
+require 'io/console'
+require 'readline'
+
+module Kaitai
+
+class ConsoleANSI
+  attr_reader :cols
+  attr_reader :rows
+
+  def initialize
+    # Normal POSIX way to determine console parameters
+    @cols = `tput cols`.to_i
+    @rows = `tput lines`.to_i
+
+    @seq_clear = `tput clear`
+    @seq_sgr0 = `tput sgr0`
+
+    @seq_fgcolor = []
+    @seq_bgcolor = []
+  end
+
+  def clear
+    print @seq_clear
+  end
+
+  ##
+  # Put the cursor up to screen position (x, y). First line is 0,
+  # first column is 0.
+  def goto(x, y)
+    #print `tput cup #{y} #{x}`
+    printf "\e[%d;%dH", y + 1, x + 1
+  end
+
+  COLORS = {
+    :black => 0,
+    :gray => 7,
+    :gray0 => 232,
+    :gray1 => 233,
+    :gray2 => 234,
+    :gray3 => 235,
+    :gray4 => 236,
+    :gray5 => 237,
+    :gray6 => 238,
+    :gray7 => 239,
+    :gray8 => 240,
+    :gray9 => 241,
+    :gray10 => 242,
+    :gray11 => 243,
+    :gray12 => 244,
+    :gray13 => 245,
+    :gray14 => 246,
+    :gray15 => 247,
+    :gray16 => 248,
+    :gray17 => 249,
+    :gray18 => 250,
+    :gray19 => 251,
+    :gray20 => 252,
+    :gray21 => 253,
+    :gray22 => 254,
+    :gray23 => 255,
+  }
+
+  def fg_color=(col)
+    #print @seq_fgcolor[col] ||= `tput setaf #{col}`
+    code = COLORS[col]
+    raise "Invalid color: #{col}" unless code
+    print "\e[38;5;#{code}m"
+  end
+
+  def bg_color=(col)
+    #print @seq_bgcolor[col] ||= `tput setab #{col}`
+    code = COLORS[col]
+    raise "Invalid color: #{col}" unless code
+    print "\e[48;5;#{code}m"
+  end
+
+  def reset_colors
+    print @seq_sgr0
+  end
+
+  # Reads keypresses from the user including 2 and 3 escape character sequences.
+  def read_char
+    $stdin.echo = false
+    $stdin.raw!
+
+    input = $stdin.getc.chr
+    if input == "\e" then
+      input << $stdin.read_nonblock(3) rescue nil
+      input << $stdin.read_nonblock(2) rescue nil
+    end
+  ensure
+    $stdin.echo = true
+    $stdin.cooked!
+
+    return input
+  end
+
+  def read_char_mapped
+    c = read_char
+    c2 = KEY_MAP[c]
+    c2 ? c2 : c
+  end
+
+  KEY_MAP = {
+    "\t" => :tab,
+    "\r" => :enter,
+    "\e[A" => :up_arrow,
+    "\e[B" => :down_arrow,
+    "\e[C" => :right_arrow,
+    "\e[D" => :left_arrow,
+    "\e[5~" => :pg_up,
+    "\e[6~" => :pg_dn,
+    "\e[H" => :home,
+    "\e[F" => :end,
+  }
+end
+
+end

data/lib/kaitai/console_windows.rb

@@ -0,0 +1,253 @@
+# coding: utf-8
+require 'Win32API'
+require 'readline'
+
+module Kaitai
+
+class ConsoleWindows
+  attr_reader :cols
+  attr_reader :rows
+
+  GET_STD_HANDLE = Win32API.new('kernel32', 'GetStdHandle', 'L', 'L')
+  GET_CONSOLE_SCREEN_BUFFER_INFO = Win32API.new('kernel32', 'GetConsoleScreenBufferInfo', 'LP', 'L')
+
+  FILL_CONSOLE_OUTPUT_ATTRIBUTE = Win32API.new('kernel32', 'FillConsoleOutputAttribute', 'LILLP', 'I')
+  FILL_CONSOLE_OUTPUT_CHARACTER = Win32API.new('kernel32', 'FillConsoleOutputCharacter', 'LILLP', 'I')
+  SET_CONSOLE_CURSOR_POSITION = Win32API.new('kernel32', 'SetConsoleCursorPosition', 'LI', 'I')
+  SET_CONSOLE_TEXT_ATTRIBUTE = Win32API.new('kernel32', 'SetConsoleTextAttribute', 'LL', 'I')
+
+  WRITE_CONSOLE = Win32API.new("kernel32", "WriteConsole", ['l', 'p', 'l', 'p', 'p'], 'l')
+
+  GETCH = Win32API.new("msvcrt", "_getch", [], 'I')
+
+  def initialize
+    @stdin_handle = GET_STD_HANDLE.call(-10)
+    @stdout_handle = GET_STD_HANDLE.call(-11)
+    @fg_color = 7
+    @bg_color = 0
+
+    # typedef struct _CONSOLE_SCREEN_BUFFER_INFO {
+    #   COORD      dwSize;
+    #   COORD      dwCursorPosition;
+    #   WORD       wAttributes;
+    #   SMALL_RECT srWindow;
+    #   COORD      dwMaximumWindowSize;
+    # } CONSOLE_SCREEN_BUFFER_INFO;
+
+    # 4 + 4 + 2 + 4 * 2 + 4 = 22
+       
+    csbi = 'X' * 22
+    
+    GET_CONSOLE_SCREEN_BUFFER_INFO.call(@stdout_handle, csbi)
+    @buf_cols, @buf_rows,
+      cur_x, cur_y, cur_attr,
+      win_left, win_top, win_right, win_bottom,
+      max_win_x, max_win_y = csbi.unpack('vvvvvvvvvvv')
+
+    # Getting size of actual visible portion of Windows console
+    # http://stackoverflow.com/a/12642749/487064
+    @cols = win_right - win_left + 1
+    @rows = win_bottom - win_top + 1
+  end
+
+  def puts(s)
+    Kernel::puts s
+#    num_written = 'XXXX'
+#    reserved = 'XXXX'
+#    WRITE_CONSOLE.call(@stdout_handle, s, s.length, num_written, reserved)
+  end
+  
+  def clear
+    con_size = @buf_cols * @buf_rows
+    num_written = 'XXXX'
+    FILL_CONSOLE_OUTPUT_CHARACTER.call(
+      @stdout_handle,
+      0x20, # ' '
+      con_size,
+      0, # [0, 0] coords
+      num_written
+    )
+    FILL_CONSOLE_OUTPUT_ATTRIBUTE.call(
+      @stdout_handle,
+      current_color_code,
+      con_size,
+      0, # [0, 0] coords
+      num_written
+    )
+    goto(0, 0)
+  end
+
+  ##
+  # Put the cursor up to screen position (x, y). First line is 0,
+  # first column is 0.
+  def goto(x, y)
+    coord = [x, y].pack('vv').unpack('V')[0]
+    SET_CONSOLE_CURSOR_POSITION.call(@stdout_handle, coord)
+  end
+
+  COLORS = {
+    :black => 0,
+    :blue => 1,
+    :green => 2,
+    :aqua => 3,
+    :red => 4,
+    :purple => 5,
+    :yellow => 6,
+    :white => 7,
+    :gray => 8,
+    :light_blue => 9,
+    :light_green => 0xa,
+    :light_aqua => 0xb,
+    :light_red => 0xc,
+    :light_purple => 0xd,
+    :light_yellow => 0xe,
+    :bright_white => 0xf,
+  }
+
+  def fg_color=(col)
+    code = COLORS[col]
+    raise "Invalid color: #{col}" unless code
+    @fg_color = code
+    update_colors
+  end
+
+  def bg_color=(col)
+    code = COLORS[col]
+    raise "Invalid color: #{col}" unless code
+    @bg_color = code
+    update_colors
+  end
+
+  def reset_colors
+    @fg_color = 7
+    @bg_color = 0
+    update_colors
+  end
+
+  ZERO_ESCAPE = 0.chr
+  E0_ESCAPE = 0xe0.chr
+  
+  # Reads keypresses from the user including 2 and 3 escape character sequences.
+  def read_char
+    input = GETCH.call.chr
+    if input == E0_ESCAPE || input == ZERO_ESCAPE
+      input << GETCH.call.chr
+    end
+    return input
+  end
+
+  def read_char_mapped
+    c = read_char
+    c2 = KEY_MAP[c]
+    c2 ? c2 : c
+  end
+
+  KEY_MAP = {
+    "\b" => :backspace,
+    "\t" => :tab,
+    "\r" => :enter,
+
+    # Regular AT keyboard arrows
+    E0_ESCAPE + "H" => :up_arrow,
+    E0_ESCAPE + "P" => :down_arrow,
+    E0_ESCAPE + "K" => :left_arrow,
+    E0_ESCAPE + "M" => :right_arrow,
+    E0_ESCAPE + "I" => :pg_up,
+    E0_ESCAPE + "Q" => :pg_dn,
+    E0_ESCAPE + "G" => :home,
+    E0_ESCAPE + "O" => :end,
+
+    # Keypad
+    ZERO_ESCAPE + "H" => :up_arrow,
+    ZERO_ESCAPE + "P" => :down_arrow,
+    ZERO_ESCAPE + "K" => :left_arrow,
+    ZERO_ESCAPE + "M" => :right_arrow,
+    ZERO_ESCAPE + "I" => :pg_up,
+    ZERO_ESCAPE + "Q" => :pg_dn,
+    ZERO_ESCAPE + "G" => :home,
+    ZERO_ESCAPE + "O" => :end,
+  }
+
+  def message_box_exception(e)
+    message_box("Error while parsing", e.message)
+  end
+
+  SINGLE_CHARSET = '┌┐└┘─│'
+  HEAVY_CHARSET  = '┏┓┗┛━┃'
+  DOUBLE_CHARSET = '╔╗╚╝═║'
+
+  CHAR_TL = 0
+  CHAR_TR = 1
+  CHAR_BL = 2
+  CHAR_BR = 3
+  CHAR_H  = 4
+  CHAR_V  = 5
+
+  def message_box(header, msg)
+    top_y = @rows / 2 - 5
+    draw_rectangle(10, top_y, @cols - 20, 10)
+    goto(@cols / 2 - (header.length / 2) - 1, top_y)
+    print ' ', header, ' '
+    goto(11, top_y + 1)
+    puts msg
+    draw_button(@cols / 2 - 10, top_y + 8, 10, 'OK')
+    loop {
+      c = read_char_mapped
+      return if c == :enter
+    }
+  end
+
+  def input_str(header, msg)
+    top_y = @rows / 2 - 5
+    draw_rectangle(10, top_y, @cols - 20, 10)
+    goto(@cols / 2 - (header.length / 2) - 1, top_y)
+    print ' ', header, ' '
+
+    goto(11, top_y + 1)
+    Readline.readline('', false)
+  end
+
+  def draw_rectangle(x, y, w, h, charset = DOUBLE_CHARSET)
+    goto(x, y)
+    print charset[CHAR_TL]
+    print charset[CHAR_H] * (w - 2)
+    print charset[CHAR_TR]
+
+    ((y + 1)..(y + h - 1)).each { |i|
+      goto(x, i)
+      print charset[CHAR_V]
+      print ' ' * (w - 2)
+      print charset[CHAR_V]
+    }
+
+    goto(x, y + h)
+    print charset[CHAR_BL]
+    print charset[CHAR_H] * (w - 2)
+    print charset[CHAR_BR]
+  end
+
+  def draw_button(x, y, w, caption)
+    goto(x, y)
+    puts "[ #{caption} ]"
+  end
+
+  # Regexp borrowed from
+  # http://stackoverflow.com/questions/170956/how-can-i-find-which-operating-system-my-ruby-program-is-running-on
+  @@is_windows = (RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/) ? true : false
+
+  # Detects if current platform is Windows-based.
+  def self.is_windows?
+    @@is_windows
+  end
+
+  private
+  def current_color_code
+    (@bg_color << 4) | @fg_color
+  end
+  
+  def update_colors
+    SET_CONSOLE_TEXT_ATTRIBUTE.call(@stdout_handle, current_color_code)
+  end
+end
+
+end

data/lib/kaitai/struct/visualizer/hex_viewer.rb

@@ -200,17 +200,9 @@ class HexViewer
     }
   end
 
-  HIGHLIGHT_COLOR = [
-    :gray14,
-    :gray11,
-    :gray8,
-    :gray5,
-    :gray2,
-  ]
-
   def highlight_show
     each_highlight_region { |i, p1, p2|
-      @ui.bg_color = HIGHLIGHT_COLOR[i]
+      @ui.bg_color = @ui.highlight_colors[i]
       @ui.fg_color = :black
       highlight_draw(p1, p2)
     }

data/lib/kaitai/struct/visualizer/node.rb

@@ -12,6 +12,7 @@ class Node
   attr_reader :pos2
   attr_reader :children
   attr_accessor :parent
+  attr_accessor :type
 
   def initialize(tree, value, level, value_method = nil, pos1 = nil, pos2 = nil)
     @tree = tree
@@ -41,6 +42,7 @@ class Node
     not (
       @value.is_a?(Fixnum) or
       @value.is_a?(Bignum) or
+      @value.is_a?(Float) or
       @value.is_a?(String) or
       @value.is_a?(Symbol) or
       @value === true or
@@ -59,7 +61,7 @@ class Node
       open
     end
   end
-  
+
   def open
     return unless openable?
     explore
@@ -85,36 +87,40 @@ class Node
 
     pos = 2 * level + 4 + @id.length
 
-    if @value.is_a?(Fixnum) or @value.is_a?(Bignum)
-      print " = #{@value}"
-    elsif @value.is_a?(Symbol)
-      print " = #{@value}"
-    elsif @value.is_a?(String)
-      print ' = '
-      pos += 3
-      @str_mode = detect_str_mode unless @str_mode
-      max_len = @tree.tree_width - pos
-      case @str_mode
-      when :str
-        v = @value.encode('UTF-8')
-        s = v[0, max_len]
-      when :str_esc
-        v = @value.encode('UTF-8')
-        s = v.inspect[0, max_len]
-      when :hex
-        s = first_n_bytes_dump(@value, max_len / 3 + 1)
-      else
-        raise "Invalid str_mode: #{@str_mode.inspect}"
-      end
-      if s.length > max_len
-        s = s[0, max_len - 1]
-        s += '…'
+    if open? or not openable?
+      if @value.is_a?(Fixnum) or @value.is_a?(Bignum) or @value.is_a?(Float)
+        print " = #{@value}"
+      elsif @value.is_a?(Symbol)
+        print " = #{@value}"
+      elsif @value.is_a?(String)
+        print ' = '
+        pos += 3
+        @str_mode = detect_str_mode unless @str_mode
+        max_len = @tree.tree_width - pos
+        case @str_mode
+        when :str
+          v = @value.encode('UTF-8')
+          s = v[0, max_len]
+        when :str_esc
+          v = @value.encode('UTF-8')
+          s = v.inspect[0, max_len]
+        when :hex
+          s = first_n_bytes_dump(@value, max_len / 3 + 1)
+        else
+          raise "Invalid str_mode: #{@str_mode.inspect}"
+        end
+        if s.length > max_len
+          s = s[0, max_len - 1]
+          s += '…'
+        end
+        print s
+      elsif @value === true or @value === false
+        print " = #{@value}"
+      elsif @value.nil?
+        print " = null"
+      elsif @value.is_a?(Array)
+        printf ' (%d = 0x%x entries)', @value.size, @value.size
       end
-      print s
-    elsif @value === true or @value === false
-      print " = #{@value}"
-    elsif @value.is_a?(Array)
-      printf ' (%d = 0x%x entries)', @value.size, @value.size
     end
 
     puts
@@ -162,8 +168,23 @@ class Node
       @value = @parent.value.send(@value_method)
     end
 
-    if @value.is_a?(Fixnum) or @value.is_a?(Bignum) or @value.is_a?(String) or @value.is_a?(Symbol)
-      # do nothing else
+    @explored = true
+
+    if @value.is_a?(Fixnum) or
+       @value.is_a?(Bignum) or
+       @value.is_a?(Float) or
+       @value.is_a?(String) or
+       @value == true or
+       @value == false or
+       @value.nil? or
+       @value.is_a?(Symbol)
+      clean_id = @id[0] == '@' ? @id[1..-1] : @id
+      debug_el = @parent.value._debug[clean_id]
+      #raise "Unable to get debugging aid for: #{@parent.value._debug.inspect} using ID '#{clean_id}'" unless debug_el
+      if debug_el
+        @pos1 = debug_el[:start]
+        @pos2 = debug_el[:end]
+      end
     elsif @value.is_a?(Array)
       clean_id = @id[0] == '@' ? @id[1..-1] : @id
       debug_el = @parent.value._debug[clean_id]
@@ -175,18 +196,16 @@ class Node
       fmt = "%#{max_val_digits}d"
 
       @value.each_with_index { |el, i|
-        n = Node.new(@tree, el, level + 1, nil, aid[i][:start], aid[i][:end])
+        aid_el = aid[i] || {}
+        n = Node.new(@tree, el, level + 1, nil, aid_el[:start], aid_el[:end])
         n.id = sprintf(fmt, i)
         add(n)
       }
     else
       # Gather seq attributes
-      attrs = Set.new
-      @value.instance_variables.each { |k|
-        k = k.to_s
-        next if k =~ /^@_/
-        el = @value.instance_eval(k)
-        aid = @value._debug[k[1..-1]]
+      @value.class::SEQ_FIELDS.each { |k|
+        el = @value.instance_eval("@#{k}")
+        aid = @value._debug[k]
         if aid
           aid_s = aid[:start]
           aid_e = aid[:end]
@@ -195,12 +214,16 @@ class Node
           aid_s = nil
           aid_e = nil
         end
-        n = Node.new(@tree, el, level + 1, nil, aid_s, aid_e)
-        n.id = k
-        add(n)
-        attrs << k.gsub(/^@/, '')
+        unless el.nil?
+          n = Node.new(@tree, el, level + 1, nil, aid_s, aid_e)
+          n.id = k
+          n.type = :seq
+          add(n)
+        end
       }
 
+      attrs = Set.new(@value.class::SEQ_FIELDS)
+
       # Gather instances
       common_meths = Set.new
       @value.class.ancestors.each { |cl|
@@ -213,10 +236,10 @@ class Node
         next if k =~ /^_/ or attrs.include?(k)
         n = Node.new(@tree, nil, level + 1, meth)
         n.id = k
+        n.type = :instance
         add(n)
       }
     end
-    @explored = true
   end
 
   ##

data/lib/kaitai/struct/visualizer/version.rb

@@ -1,7 +1,7 @@
 module Kaitai
   module Struct
     module Visualizer
-      VERSION = '0.4'
+      VERSION = '0.5'
     end
   end
 end

data/lib/kaitai/struct/visualizer/visualizer_main.rb

@@ -1,5 +1,6 @@
 require 'kaitai/struct/visualizer/version'
 require 'kaitai/struct/visualizer/visualizer'
+require 'kaitai/tui'
 
 module Kaitai::Struct::Visualizer
 
@@ -7,13 +8,30 @@ class ExternalCompilerVisualizer < Visualizer
   def compile_format(fn)
     main_class_name = nil
     Dir.mktmpdir { |code_dir|
-      system("ksc -- --debug -t ruby '#{fn}' -d '#{code_dir}'")
-      exit $?.exitstatus if $?.exitstatus != 0
+      args = ['--debug', '-t', 'ruby', fn, '-d', code_dir]
+
+      # UNIX-based systems run ksc via a shell wrapper that requires
+      # extra '--' in invocation to disambiguate our '-d' from java runner
+      # '-d' (which allows to pass defines to JVM). Windows-based systems
+      # do not need and do not support this extra '--', so we don't add it
+      # on Windows.
+      args.unshift('--') unless Kaitai::TUI::is_windows?
+
+      system('kaitai-struct-compiler', *args)
+      if $?.exitstatus != 0
+        st = $?.exitstatus
+        $stderr.puts("ksv: unable to find and execute kaitai-struct-compiler in your PATH") if st == 127
+        exit st
+      end
+
+      puts "Compilation OK"
 
       compiled_path = Dir.glob("#{code_dir}/*.rb")[0]
 
       require compiled_path
 
+      puts "Class loaded OK"
+
       main_class_name = File.readlines(compiled_path).grep(/^class /)[0].strip.gsub(/^class /, '').gsub(/ <.*$/, '')
     }
 

data/lib/kaitai/tui.rb

@@ -1,118 +1,38 @@
 # coding: utf-8
-require 'io/console'
-require 'readline'
+require 'forwardable'
 
 module Kaitai
 
 class TUI
-  attr_reader :cols
-  attr_reader :rows
+  extend Forwardable
+  def_delegators :@console, :rows, :cols, :goto, :clear, :fg_color=, :bg_color=, :reset_colors, :read_char_mapped
 
-  def initialize
-    @cols = `tput cols`.to_i
-    @rows = `tput lines`.to_i
-
-    @seq_clear = `tput clear`
-    @seq_sgr0 = `tput sgr0`
-    @seq_fgcolor = []
-    @seq_bgcolor = []
-  end
-
-  def clear
-    print @seq_clear
-  end
-
-  ##
-  # Put the cursor up to screen position (x, y). First line is 0,
-  # first column is 0.
-  def goto(x, y)
-    #print `tput cup #{y} #{x}`
-    printf "\e[%d;%dH", y + 1, x + 1
-  end
-
-  COLORS = {
-    :black => 0,
-    :gray => 7,
-    :gray0 => 232,
-    :gray1 => 233,
-    :gray2 => 234,
-    :gray3 => 235,
-    :gray4 => 236,
-    :gray5 => 237,
-    :gray6 => 238,
-    :gray7 => 239,
-    :gray8 => 240,
-    :gray9 => 241,
-    :gray10 => 242,
-    :gray11 => 243,
-    :gray12 => 244,
-    :gray13 => 245,
-    :gray14 => 246,
-    :gray15 => 247,
-    :gray16 => 248,
-    :gray17 => 249,
-    :gray18 => 250,
-    :gray19 => 251,
-    :gray20 => 252,
-    :gray21 => 253,
-    :gray22 => 254,
-    :gray23 => 255,
-  }
-
-  def fg_color=(col)
-    #print @seq_fgcolor[col] ||= `tput setaf #{col}`
-    code = COLORS[col]
-    raise "Invalid color: #{col}" unless code
-    print "\e[38;5;#{code}m"
-  end
+  attr_reader :highlight_colors
 
-  def bg_color=(col)
-    #print @seq_bgcolor[col] ||= `tput setab #{col}`
-    code = COLORS[col]
-    raise "Invalid color: #{col}" unless code
-    print "\e[48;5;#{code}m"
-  end
-
-  def reset_colors
-    print @seq_sgr0
-  end
-
-  # Reads keypresses from the user including 2 and 3 escape character sequences.
-  def read_char
-    $stdin.echo = false
-    $stdin.raw!
-
-    input = $stdin.getc.chr
-    if input == "\e" then
-      input << $stdin.read_nonblock(3) rescue nil
-      input << $stdin.read_nonblock(2) rescue nil
+  def initialize
+    if TUI::is_windows?
+      require 'kaitai/console_windows'
+      @console = ConsoleWindows.new
+      @highlight_colors = [
+        :white,
+        :aqua,
+        :blue,
+        :green,
+        :white,
+      ]
+    else
+      require 'kaitai/console_ansi'
+      @console = ConsoleANSI.new
+      @highlight_colors = [
+        :gray14,
+        :gray11,
+        :gray8,
+        :gray5,
+        :gray2,
+      ]
     end
-  ensure
-    $stdin.echo = true
-    $stdin.cooked!
-
-    return input
-  end
-
-  def read_char_mapped
-    c = read_char
-    c2 = KEY_MAP[c]
-    c2 ? c2 : c
   end
 
-  KEY_MAP = {
-    "\t" => :tab,
-    "\r" => :enter,
-    "\e[A" => :up_arrow,
-    "\e[B" => :down_arrow,
-    "\e[C" => :right_arrow,
-    "\e[D" => :left_arrow,
-    "\e[5~" => :pg_up,
-    "\e[6~" => :pg_dn,
-    "\e[H" => :home,
-    "\e[F" => :end,
-  }
-
   def message_box_exception(e)
     message_box("Error while parsing", e.message)
   end
@@ -129,23 +49,23 @@ class TUI
   CHAR_V  = 5
 
   def message_box(header, msg)
-    top_y = @rows / 2 - 5
-    draw_rectangle(10, top_y, @cols - 20, 10)
-    goto(@cols / 2 - (header.length / 2) - 1, top_y)
+    top_y = @console.rows / 2 - 5
+    draw_rectangle(10, top_y, @console.cols - 20, 10)
+    @console.goto(@console.cols / 2 - (header.length / 2) - 1, top_y)
     print ' ', header, ' '
-    goto(11, top_y + 1)
+    @console.goto(11, top_y + 1)
     puts msg
-    draw_button(@cols / 2 - 10, top_y + 8, 10, 'OK')
+    draw_button(@console.cols / 2 - 10, top_y + 8, 10, 'OK')
     loop {
-      c = read_char_mapped
+      c = @console.read_char_mapped
       return if c == :enter
     }
   end
 
   def input_str(header, msg)
-    top_y = @rows / 2 - 5
-    draw_rectangle(10, top_y, @cols - 20, 10)
-    goto(@cols / 2 - (header.length / 2) - 1, top_y)
+    top_y = @console.rows / 2 - 5
+    draw_rectangle(10, top_y, @console.cols - 20, 10)
+    goto(@console.cols / 2 - (header.length / 2) - 1, top_y)
     print ' ', header, ' '
 
     goto(11, top_y + 1)
@@ -175,6 +95,15 @@ class TUI
     goto(x, y)
     puts "[ #{caption} ]"
   end
+
+  # Regexp borrowed from
+  # http://stackoverflow.com/questions/170956/how-can-i-find-which-operating-system-my-ruby-program-is-running-on
+  @@is_windows = (RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/) ? true : false
+
+  # Detects if current platform is Windows-based.
+  def self.is_windows?
+    @@is_windows
+  end
 end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kaitai-struct-visualizer
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: '0.5'
 platform: ruby
 authors:
 - Mikhail Yakshin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-09 00:00:00.000000000 Z
+date: 2016-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,6 +68,8 @@ files:
 - README.md
 - bin/ksv
 - kaitai-struct-visualizer.gemspec
+- lib/kaitai/console_ansi.rb
+- lib/kaitai/console_windows.rb
 - lib/kaitai/struct/visualizer.rb
 - lib/kaitai/struct/visualizer/hex_viewer.rb
 - lib/kaitai/struct/visualizer/node.rb