path: root/ext/tk/sample/tktextio.rb

#!/usr/bin/env ruby
#
#  TkTextIO class :: handling I/O stream on a TkText widget
#                             by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
#
#  NOTE: TkTextIO supports 'character' (not 'byte') access only. 
#        So, for example, TkTextIO#getc returns a character, TkTextIO#pos 
#        means the character position, TkTextIO#read(size) counts by 
#        characters, and so on.
#        Of course, it is available to make TkTextIO class to suuport 
#        'byte' access. However, it may break multi-byte characters. 
#        and then, displayed string on the text widget may be garbled.
#        I think that it is not good on the supposed situation of using 
#        TkTextIO. 
#
require 'tk'
require 'tk/text'
require 'tk/textmark'
require 'thread'

class TkTextIO < TkText
  # keep safe level
  @@create_queues = proc{ [Queue.new, Mutex.new, Queue.new, Mutex.new] }

  OPT_DEFAULTS = {
    'mode'       => nil,
    'overwrite'  => false, 
    'text'       => nil, 
    'show'       => :pos, 
    'wrap'       => 'char', 
    'sync'       => true, 
    'prompt'     => nil, 
    'prompt_cmd' => nil, 
    'hist_size'  => 1000, 
  }

  def create_self(keys)
    opts = _get_io_params((keys.kind_of?(Hash))? keys: {})

    super(keys)

    @count_var = TkVariable.new

    @write_buffer = ''
    @read_buffer  = ''
    @buf_size = 0
    @buf_max = 1024

    @write_buf_queue, @write_buf_mutex, 
    @read_buf_queue,  @read_buf_mutex  = @@create_queues.call

    @idle_flush  = TkTimer.new(:idle, 1, proc{ @flusher.run rescue nil })
    @timer_flush = TkTimer.new(250, -1, proc{ @flusher.run rescue nil })

    @flusher = Thread.new{ loop { Thread.stop; flush() } }

    @receiver = Thread.new{
      begin
        loop {
          str = @write_buf_queue.deq
          @write_buf_mutex.synchronize { @write_buffer << str }
          @idle_flush.start
        }
      ensure
        @flusher.kill
      end
    }

    @timer_flush.start

    _setup_io(opts)
  end
  private :create_self

  def destroy
    @flusher.kill rescue nil

    @idle_flush.stop rescue nil
    @timer_flush.stop rescue nil

    @receiver.kill rescue nil

    super()
  end

  ####################################

  def _get_io_params(keys)
    opts = {}
    self.class.const_get(:OPT_DEFAULTS).each{|k, v| 
      if keys.has_key?(k)
        opts[k] = keys.delete(k)
      else
        opts[k] = v
      end
    }
    opts
  end

  def _setup_io(opts)
    unless defined? @txtpos
      @txtpos = TkTextMark.new(self, '1.0')
    else
      @txtpos.set('1.0')
    end
    @txtpos.gravity = :left

    @lineno = 0
    @line_offset = 0

    @hist_max = opts['hist_size']
    @hist_index = 0
    @history = Array.new(@hist_max)
    @history[0] = ''

    self['wrap'] = wrap

    self.show_mode = opts['show']

    self.value = opts['text'] if opts['text']

    @overwrite = (opts['overwrite'])? true: false

    @sync = opts['sync']

    @prompt = opts['prompt']
    @prompt_cmd = opts['prompt_cmd']

    @open  = {:r => true,  :w => true}  # default is 'r+'

    @console_mode = false
    @end_of_stream = false
    @console_buffer = nil

    case opts['mode']
    when nil
      # do nothing

    when :console, 'console'
      @console_mode = true
      # @console_buffer = TkTextIO.new(:mode=>'r')
      @console_buffer = self.class.new(:mode=>'r')
      self.show_mode = :insert

    when 'r', 'rb'
      @open[:r] = true; @open[:w] = nil

    when 'r+', 'rb+', 'r+b'
      @open[:r] = true; @open[:w] = true

    when 'w', 'wb'
      @open[:r] = nil;  @open[:w] = true
      self.value=''

    when 'w+', 'wb+', 'w+b'
      @open[:r] = true; @open[:w] = true
      self.value=''

    when 'a', 'ab'
      @open[:r] = nil;  @open[:w] = true
      @txtpos.set('end - 1 char')
      @txtpos.gravity = :right

    when 'a+', 'ab+', 'a+b'
      @open[:r] = true;  @open[:w] = true
      @txtpos.set('end - 1 char')
      @txtpos.gravity = :right

    else
      fail ArgumentError, "unknown mode `#{opts['mode']}'"
    end

    unless defined? @ins_head
      @ins_head = TkTextMark.new(self, 'insert')
      @ins_head.gravity = :left
    end

    unless defined? @ins_tail
      @ins_tail = TkTextMark.new(self, 'insert')
      @ins_tail.gravity = :right
    end

    unless defined? @tmp_mark
      @tmp_mark = TkTextMark.new(self, 'insert')
      @tmp_mark.gravity = :left
    end

    if @console_mode
      _set_console_line
      _setup_console_bindings
    end
  end
  private :_get_io_params, :_setup_io

  def _set_console_line
    @tmp_mark.set(@ins_tail)

    mark_set('insert', 'end')

    prompt = ''
    prompt << @prompt_cmd.call if @prompt_cmd
    prompt << @prompt if @prompt
    insert(@tmp_mark, prompt)

    @ins_head.set(@ins_tail)
    @ins_tail.set('insert')

    @txtpos.set(@tmp_mark)

    _see_pos
  end

  def _replace_console_line(str)
    self.delete(@ins_head, @ins_tail)
    self.insert(@ins_head, str)
  end

  def _get_console_line
    @tmp_mark.set(@ins_tail)
    s = self.get(@ins_head, @tmp_mark)
    _set_console_line
    s
  end
  private :_set_console_line, :_replace_console_line, :_get_console_line

  def _cb_up
    @history[@hist_index].replace(self.get(@ins_head, @ins_tail))
    @hist_index += 1
    @hist_index -= 1 if @hist_index >= @hist_max || !@history[@hist_index]
    _replace_console_line(@history[@hist_index]) if @history[@hist_index]
    Tk.callback_break
  end
  def _cb_down
    @history[@hist_index].replace(self.get(@ins_head, @ins_tail))
    @hist_index -= 1
    @hist_index = 0 if @hist_index < 0
    _replace_console_line(@history[@hist_index]) if @history[@hist_index]
    Tk.callback_break
  end
  def _cb_left
    if @console_mode && compare('insert', '<=', @ins_head)
      mark_set('insert', @ins_head)
      Tk.callback_break
    end
  end
  def _cb_backspace
    if @console_mode && compare('insert', '<=', @ins_head)
      Tk.callback_break
    end
  end
  def _cb_ctrl_a
    if @console_mode
      mark_set('insert', @ins_head)
      Tk.callback_break
    end
  end
  private :_cb_up, :_cb_down, :_cb_left, :_cb_backspace, :_cb_ctrl_a

  def _setup_console_bindings
    @bindtag = TkBindTag.new

    tags = self.bindtags
    tags[tags.index(self)+1, 0] = @bindtag
    self.bindtags = tags

    @bindtag.bind('Return'){
      insert('end - 1 char', "\n")
      if (str = _get_console_line)
        @read_buf_queue.push(str)

        @history[0].replace(str.chomp)
        @history.pop
        @history.unshift('')
        @hist_index = 0
      end

      Tk.update
      Tk.callback_break
    }
    @bindtag.bind('Alt-Return'){
      Tk.callback_continue
    }

    @bindtag.bind('FocusIn'){
      if @console_mode
        mark_set('insert', @ins_tail)
        Tk.callback_break
      end
    }

    ins_mark = TkTextMark.new(self, 'insert')

    @bindtag.bind('ButtonPress'){
      if @console_mode
        ins_mark.set('insert')
      end
    }

    @bindtag.bind('ButtonRelease-1'){
      if @console_mode && compare('insert', '<=', @ins_head)
        mark_set('insert', ins_mark)
        Tk.callback_break
      end
    }

    @bindtag.bind('ButtonRelease-2', '%x %y'){|x, y|
      if @console_mode
        # paste a text at 'insert' only
        x1, y1, x2, y2 =  bbox(ins_mark)
        unless x == x1 && y == y1
          Tk.event_generate(self, 'ButtonRelease-2', :x=>x1, :y=>y1)
          Tk.callback_break
        end
      end
    }

    @bindtag.bind('Up'){ _cb_up }
    @bindtag.bind('Control-p'){ _cb_up }

    @bindtag.bind('Down'){ _cb_down }
    @bindtag.bind('Control-n'){ _cb_down }

    @bindtag.bind('Left'){ _cb_left }
    @bindtag.bind('Control-b'){ _cb_left }

    @bindtag.bind('BackSpace'){ _cb_backspace }
    @bindtag.bind('Control-h'){ _cb_backspace }

    @bindtag.bind('Home'){ _cb_ctrl_a }
    @bindtag.bind('Control-a'){ _cb_ctrl_a }
  end
  private :_setup_console_bindings

  def _block_read(size = nil, ret = '', block_mode = true)
    return '' if size == 0
    return nil if ! @read_buf_queue && @read_buffer.empty?
    ret = '' unless ret.kind_of?(String)
    ret.replace('') unless ret.empty?

    if block_mode == nil # partial
      if @read_buffer.empty?
        ret << @read_buffer.slice!(0..-1)
        return ret
      end
    end

    if size.kind_of?(Numeric)
      loop{
        @read_buf_mutex.synchronize {
          buf_len = @read_buffer.length
          if buf_len >= size
            ret << @read_buffer.slice!(0, size)
            return ret
          else
            ret << @read_buffer.slice!(0..-1)
            size -= buf_len
            return ret unless @read_buf_queue
          end
        }
        @read_buffer << @read_buf_queue.pop
      }
    else # readline
      rs = (size)? size: $/
      rs = rs.to_s if rs.kind_of?(Regexp)
      loop{
        @read_buf_mutex.synchronize {
          if (str = @read_buffer.slice!(/\A(.*)(#{rs})/m))
            ret << str
            return ret
          else
            ret << @read_buffer.slice!(0..-1)
            return ret unless @read_buf_queue
          end
        }
        @read_buffer << @read_buf_queue.pop
      }
    end
  end

  def _block_write
    ###### currently, not support
  end
  private :_block_read, :_block_write

  ####################################

  def <<(obj)
    _write(obj)
    self
  end

  def binmode
    self
  end

  def clone
    fail NotImplementedError, 'cannot clone TkTextIO'
  end
  def dup
    fail NotImplementedError, 'cannot duplicate TkTextIO'
  end

  def close
    close_read
    close_write
    nil
  end
  def close_read
    @open[:r] = false if @open[:r]
    nil
  end
  def close_write
    @open[:w] = false if @opne[:w]
    nil
  end

  def closed?(dir=nil)
    case dir
    when :r, 'r'
      !@open[:r]
    when :w, 'w'
      !@open[:w]
    else
      !@open[:r] && !@open[:w]
    end
  end

  def _check_readable
    fail IOError, "not opened for reading" if @open[:r].nil?
    fail IOError, "closed stream" if !@open[:r]
  end
  def _check_writable
    fail IOError, "not opened for writing" if @open[:w].nil?
    fail IOError, "closed stream" if !@open[:w]
  end
  private :_check_readable, :_check_writable

  def each_line(rs = $/)
    _check_readable
    while(s = self.gets(rs))
      yield(s)
    end
    self
  end
  alias each each_line

  def each_char
    _check_readable
    while(c = self.getc)
      yield(c)
    end
    self
  end
  alias each_byte each_char

  def eof?
    compare(@txtpos, '==', 'end - 1 char')
  end
  alias eof eof?

  def fcntl(*args)
    fail NotImplementedError, "fcntl is not implemented on #{self.class}"
  end

  def fsync
    0
  end

  def fileno
    nil
  end

  def flush
    Thread.pass
    if @open[:w] || ! @write_buffer.empty?
      @write_buf_mutex.synchronize {
        _sync_write_buf(@write_buffer) 
        @write_buffer[0..-1] = ''
      }
    end
    self
  end

  def getc
    return _block_read(1) if @console_mode

    _check_readable
    return nil if eof?
    c = get(@txtpos)
    @txtpos.set(@txtpos + '1 char')
    _see_pos
    c
  end

  def gets(rs = $/)
    return _block_read(rs) if @console_mode

    _check_readable
    return nil if eof?
    _readline(rs)
  end

  def ioctrl(*args)
    fail NotImplementedError, 'iocntl is not implemented on TkTextIO'
  end

  def isatty
    false
  end
  def tty?
    false
  end

  def lineno
    @lineno + @line_offset
  end

  def lineno=(num)
    @line_offset = num - @lineno
    num
  end

  def overwrite?
    @overwrite
  end

  def overwrite=(ovwt)
    @overwrite = (ovwt)? true: false
  end

  def pid
    nil
  end

  def index_pos
    index(@txtpos)
  end
  alias tell_index index_pos

  def index_pos=(idx)
    @txtpos.set(idx)
    @txtpos.set('end - 1 char') if compare(@txtpos, '>=', :end)
    _see_pos
    idx
  end

  def pos
    s = get('1.0', @txtpos)
    number(tk_call('string', 'length', s))
  end
  alias tell pos

  def pos=(idx)
    seek(idx, IO::SEEK_SET)
    idx
  end

  def pos_gravity
    @txtpos.gravity
  end

  def pos_gravity=(side)
    @txtpos.gravity = side
    side
  end

  def print(arg=$_, *args)
    _check_writable
    args.unshift(arg)
    args.map!{|val| (val == nil)? 'nil': val.to_s }
    str = args.join($,)
    str << $\ if $\
    _write(str)
    nil
  end
  def printf(*args)
    _check_writable
    _write(sprintf(*args))
    nil
  end

  def putc(c)
    _check_writable
    c = c.chr if c.kind_of?(Fixnum)
    _write(c)
    c
  end

  def puts(*args)
    _check_writable
    if args.empty?
      _write("\n")
      return nil
    end
    args.each{|arg|
      if arg == nil
        _write("nil\n")
      elsif arg.kind_of?(Array)
        puts(*arg)
      elsif arg.kind_of?(String)
        _write(arg.chomp)
        _write("\n")
      else
        begin
          arg = arg.to_ary
          puts(*arg)
        rescue
          puts(arg.to_s)
        end
      end
    }
    nil
  end

  def _read(len)
    epos = @txtpos + "#{len} char"
    s = get(@txtpos, epos)
    @txtpos.set(epos)
    @txtpos.set('end - 1 char') if compare(@txtpos, '>=', :end)
    _see_pos
    s
  end
  private :_read

  def read(len=nil, buf=nil)
    return _block_read(len, buf) if @console_mode

    _check_readable
    if len
      return "" if len == 0
      return nil if eof?
      s = _read(len)
    else
      s = get(@txtpos, 'end - 1 char')
      @txtpos.set('end - 1 char')
      _see_pos
    end
    buf.replace(s) if buf.kind_of?(String)
    s
  end

  def readchar
    return _block_read(1) if @console_mode

    _check_readable
    fail EOFError if eof?
    c = get(@txtpos)
    @txtpos.set(@txtpos + '1 char')
    _see_pos
    c
  end

  def _readline(rs = $/)
    if rs == nil
      s = get(@txtpos, 'end - 1 char')
      @txtpos.set('end - 1 char')
    elsif rs == ''
      @count_var.value  # make it global
      idx = tksearch_with_count([:regexp], @count_var, 
                                   "\n(\n)+", @txtpos, 'end - 1 char')
      if idx
        s = get(@txtpos, idx) << "\n"
        @txtpos.set("#{idx} + #{@count_var.value} char")
        @txtpos.set('end - 1 char') if compare(@txtpos, '>=', :end)
      else
        s = get(@txtpos, 'end - 1 char')
        @txtpos.set('end - 1 char')
      end
    else
      @count_var.value  # make it global
      idx = tksearch_with_count(@count_var, rs, @txtpos, 'end - 1 char')
      if idx
        s = get(@txtpos, "#{idx} + #{@count_var.value} char")
        @txtpos.set("#{idx} + #{@count_var.value} char")
        @txtpos.set('end - 1 char') if compare(@txtpos, '>=', :end)
      else
        s = get(@txtpos, 'end - 1 char')
        @txtpos.set('end - 1 char')
      end
    end

    _see_pos
    @lineno += 1
    $_ = s
  end
  private :_readline

  def readline(rs = $/)
    return _block_readline(rs) if @console_mode

    _check_readable
    fail EOFError if eof?
    _readline(rs)
  end

  def readlines(rs = $/)
    if @console_mode
      lines = []
      while (line = _block_readline(rs))
        lines << line
      end
      return lines
    end

    _check_readable
    lines = []
    until(eof?)
      lines << _readline(rs)
    end
    $_ = nil
    lines
  end

  def readpartial(maxlen, buf=nil)
    #return @console_buffer.readpartial(maxlen, buf) if @console_mode
    return _block_read(maxlen, buf, nil) if @console_mode

    _check_readable
    fail EOFError if eof?
    s = _read(maxlen)
    buf.replace(s) if buf.kind_of?(String)
    s
  end

  def reopen(*args)
    fail NotImplementedError, 'reopen is not implemented on TkTextIO'
  end

  def rewind
    @txtpos.set('1.0')
    _see_pos
    @lineno = 0
    @line_offset = 0
    self
  end

  def seek(offset, whence=IO::SEEK_SET)
    case whence
    when IO::SEEK_SET
      offset = "1.0 + #{offset} char" if offset.kind_of?(Numeric)
      @txtpos.set(offset)

    when IO::SEEK_CUR
      offset = "#{offset} char" if offset.kind_of?(Numeric)
      @txtpos.set(@txtpos + offset)

    when IO::SEEK_END
      offset = "#{offset} char" if offset.kind_of?(Numeric)
      @txtpos.set("end - 1 char + #{offset}")

    else
      fail Errno::EINVAL, 'invalid whence argument'
    end

    @txtpos.set('end - 1 char') if compare(@txtpos, '>=', :end)
    _see_pos

    0
  end
  alias sysseek seek

  def _see_pos
    see(@show) if @show
  end
  private :_see_pos

  def show_mode
    (@show == @txtpos)? :pos : @show
  end

  def show_mode=(mode)
    # define show mode  when file position is changed. 
    #  mode == :pos or "pos" or true :: see current file position. 
    #  mode == :insert or "insert"   :: see insert cursor position. 
    #  mode == nil or false          :: do nothing
    #  else see 'mode' position ('mode' should be text index or mark)
    case mode
    when :pos, 'pos', true
      @show = @txtpos
    when :insert, 'insert'
      @show = :insert
    when nil, false
      @show = false
    else
      begin
        index(mode)
      rescue
        fail ArgumentError, 'invalid show-position'
      end
      @show = mode
    end

    _see_pos

    mode
  end

  def stat
    fail NotImplementedError, 'stat is not implemented on TkTextIO'
  end

  def sync
    @sync
  end

  def sync=(mode)
    @sync = mode
  end

  def sysread(len, buf=nil)
    return _block_read(len, buf) if @console_mode

    _check_readable
    fail EOFError if eof?
    s = _read(len)
    buf.replace(s) if buf.kind_of?(String)
    s
  end

  def syswrite(obj)
    _write(obj)
  end

  def to_io
    self
  end

  def trancate(len)
    delete("1.0 + #{len} char", :end)
    0
  end

  def ungetc(c)
    if @console_mode
      @read_buf_mutex.synchronize {
        @read_buffer[0,0] = c.chr
      }
      return nil
    end

    _check_readable
    c = c.chr if c.kind_of?(Fixnum)
    if compare(@txtpos, '>', '1.0')
      @txtpos.set(@txtpos - '1 char')
      delete(@txtpos)
      insert(@txtpos, tk_call('string', 'range', c, 0, 1))
      @txtpos.set(@txtpos - '1 char') if @txtpos.gravity == 'right'
      _see_pos
    else
      fail IOError, 'cannot ungetc at head of stream'
    end
    nil
  end

=begin
  def _write(obj)
    #s = _get_eval_string(obj)
    s = (obj.kind_of?(String))? obj: obj.to_s
    n = number(tk_call('string', 'length', s))
    delete(@txtpos, @txtpos + "#{n} char") if @overwrite
    self.insert(@txtpos, s)
    @txtpos.set(@txtpos + "#{n} char")
    @txtpos.set('end - 1 char') if compare(@txtpos, '>=', :end)
    _see_pos
    Tk.update if @sync
    n
  end
  private :_write
=end
#=begin
  def _sync_write_buf(s)
    if (n = number(tk_call('string', 'length', s))) > 0
      delete(@txtpos, @txtpos + "#{n} char") if @overwrite
      self.insert(@txtpos, s)
      #Tk.update

      @txtpos.set(@txtpos + "#{n} char")
      @txtpos.set('end - 1 char') if compare(@txtpos, '>=', :end)

      @ins_head.set(@txtpos) if compare(@txtpos, '>', @ins_head)

      _see_pos
    end
    self
  end
  private :_sync_write_buf

  def _write(obj)
    s = (obj.kind_of?(String))? obj: obj.to_s
    n = number(tk_call('string', 'length', s))
    @write_buf_queue.enq(s)
    if @sync
      Thread.pass
      Tk.update
    end
    n
  end
  private :_write
#=end

  def write(obj)
    _check_writable
    _write(obj)
  end
end

####################
#  TEST
####################
if __FILE__ == $0
  ev_loop = Thread.new{Tk.mainloop}

  f = TkFrame.new.pack
  #tio = TkTextIO.new(f, :show=>:nil, 
  #tio = TkTextIO.new(f, :show=>:pos, 
  tio = TkTextIO.new(f, :show=>:insert, 
                     :text=>">>> This is an initial text line. <<<\n\n"){
#    yscrollbar(TkScrollbar.new(f).pack(:side=>:right, :fill=>:y))
    pack(:side=>:left, :fill=>:both, :expand=>true)
  }

  Tk.update

  $stdin  = tio
  $stdout = tio
  $stderr = tio

  STDOUT.print("\n========= TkTextIO#gets for inital text ========\n\n")

  while(s = gets)
    STDOUT.print(s)
  end

  STDOUT.print("\n============ put strings to TkTextIO ===========\n\n")

  puts "On this sample, a text widget works as if it is a I/O stream."
  puts "Please see the code."
  puts
  printf("printf message: %d %X\n", 123456, 255)
  puts
  printf("(output by 'p' method) This TkTextIO object is ...\n")
  p tio
  print(" [ Current wrap mode of this object is 'char'. ]\n")
  puts
  warn("This is a warning message generated by 'warn' method.")
  puts
  puts "current show_mode is #{tio.show_mode}."
  if tio.show_mode == :pos
    puts "So, you can see the current file position on this text widget."
  else
    puts "So, you can see the position '#{tio.show_mode}' on this text widget."
  end
  print("Please scroll up this text widget to see the head of lines.\n")
  print("---------------------------------------------------------\n")

  STDOUT.print("\n=============== TkTextIO#readlines =============\n\n")

  tio.seek(0)
  lines = readlines
  STDOUT.puts(lines.inspect)

  STDOUT.print("\n================== TkTextIO#each ===============\n\n")

  tio.rewind
  tio.each{|line| STDOUT.printf("%2d: %s\n", tio.lineno, line.chomp)}

  STDOUT.print("\n================================================\n\n")

  STDOUT.print("\n========= reverse order (seek by lines) ========\n\n")

  tio.seek(-1, IO::SEEK_END)
  begin
    begin
      tio.seek(:linestart, IO::SEEK_CUR)
    rescue
      # maybe use old version of tk/textmark.rb
      tio.seek('0 char linestart', IO::SEEK_CUR)
    end
    STDOUT.print(gets)
    tio.seek('-1 char linestart -1 char', IO::SEEK_CUR)
  end while(tio.pos > 0)

  STDOUT.print("\n================================================\n\n")

  tio.seek(0, IO::SEEK_END)

  STDOUT.print("tio.sync ==  #{tio.sync}\n")
#  tio.sync = false
#  STDOUT.print("tio.sync ==  #{tio.sync}\n")

  (0..10).each{|i|
    STDOUT.print("#{i}\n")
    s = ''
    (0..1000).each{ s << '*' }
    print(s)
  }
  print("\n")
  print("\n=========================================================\n\n")

  s = ''
  timer = TkTimer.new(:idle, -1, proc{
                        #STDOUT.print("idle call\n")
                        unless s.empty?
                          print(s)
                          s = ''
                        end
                      }).start
  (0..10).each{|i|
    STDOUT.print("#{i}\n")
    (0..1000).each{ s << '*' }
  }
#  timer.stop
  until s.empty?
    sleep 0.1
  end
  timer.stop

=begin
  tio.sync = false
  print("\n")
  #(0..10000).each{ putc('*') }
  (0..10).each{|i|
    STDOUT.print("#{i}\n")
    (0..1000).each{ putc('*') }
  }

  (0..10).each{|i|
    STDOUT.print("#{i}\n")
    s = ''
    (0..1000).each{ s << '*' }
    print(s)
  }
=end

  num = 0
#  io = TkTextIO.new(:mode=>:console, :prompt=>'').pack
#=begin
  io = TkTextIO.new(:mode=>:console, 
                    :prompt_cmd=>proc{
                      s = "[#{num}]"
                      num += 1
                      s
                    }, 
                    :prompt=>'-> ').pack
#=end
  Thread.new{loop{sleep 2; io.puts 'hoge'}}
  Thread.new{loop{p io.gets}}

  ev_loop.join
end