curses 1.1.0-x64-mingw32

data/ext/curses/depend

@@ -0,0 +1,5 @@
+$(OBJS): $(HDRS) $(ruby_headers) \
+  $(hdrdir)/ruby/io.h \
+  $(hdrdir)/ruby/encoding.h \
+  $(hdrdir)/ruby/oniguruma.h \
+  $(hdrdir)/ruby/thread.h

data/ext/curses/extconf.rb

@@ -0,0 +1,144 @@
+require 'mkmf'
+
+def have_all(*args)
+  old_libs = $libs.dup
+  old_defs = $defs.dup
+  result = []
+  begin
+    args.each {|arg|
+      r = arg.call(*result)
+      if !r
+        return nil
+      end
+      result << r
+    }
+    result
+  ensure
+    if result.length != args.length
+      $libs = old_libs
+      $defs = old_defs
+    end
+  end
+end
+
+dir_config('curses')
+dir_config('ncurses')
+dir_config('termcap')
+
+have_library("mytinfo", "tgetent") if /bow/ =~ RUBY_PLATFORM
+have_library("tinfo", "tgetent") or have_library("termcap", "tgetent")
+
+header_library = nil
+[
+  ["ncursesw/curses.h", ["ncursesw"]],
+  ["ncurses.h", ["ncursesw", "ncurses"]],
+  ["ncurses/curses.h", ["ncurses"]],
+  ["curses_colr/curses.h", ["cur_colr"]],
+  ["curses.h", ["curses", "pdcurses"]],
+  # ["xcurses.h", ["XCurses"]], # XCurses (PDCurses for X11)
+].each {|hdr, libs|
+  header_library = have_all(
+    lambda { have_header(hdr) && hdr },
+    lambda {|h| libs.find {|lib| have_library(lib, "initscr", h) } })
+  if header_library
+    break;
+  end
+}
+
+if header_library
+  header, library = header_library
+  puts "header: #{header}"
+  puts "library: #{library}"
+
+  curses = [header]
+  if header == 'curses_colr/curses.h'
+    curses.unshift("varargs.h")
+  end
+
+  for f in %w(beep bkgd bkgdset curs_set deleteln doupdate flash
+              getbkgd getnstr init isendwin keyname keypad resizeterm
+              scrl set setscrreg ungetch
+              wattroff wattron wattrset wbkgd wbkgdset wdeleteln wgetnstr
+              wresize wscrl wsetscrreg werase redrawwin
+              def_prog_mode reset_prog_mode timeout wtimeout nodelay
+              init_color wcolor_set use_default_colors newpad
+              unget_wch get_wch wget_wch)
+    have_func(f) || (have_macro(f, curses) && $defs.push(format("-DHAVE_%s", f.upcase)))
+  end
+  flag = "-D_XOPEN_SOURCE_EXTENDED"
+  if try_static_assert("sizeof(char*)>sizeof(int)",
+                       %w[stdio.h stdlib.h]+curses,
+                       flag)
+    $defs << flag
+  end
+  have_var("ESCDELAY", curses)
+  have_var("TABSIZE", curses)
+  have_var("COLORS", curses)
+  have_var("COLOR_PAIRS", curses)
+
+  # SVR4 curses has a (undocumented) variable char *curses_version.
+  # ncurses and PDcurses has a function char *curses_version().
+  # Note that the original BSD curses doesn't provide version information.
+  #
+  # configure option:
+  #   --with-curses-version=function    for SVR4
+  #   --with-curses-version=variable    for ncurses and PDcurses
+  #   (not given)                       automatically determined
+
+  case with_curses_version = with_config("curses-version")
+  when "function"
+    $defs << '-DHAVE_FUNC_CURSES_VERSION'
+  when "variable"
+    $defs << '-DHAVE_VAR_CURSES_VERSION'
+  when nil
+    func_test_program = cpp_include(curses) + <<-"End"
+      int main(int argc, char *argv[])
+      {
+          curses_version();
+          return EXIT_SUCCESS;
+      }
+    End
+    var_test_program = cpp_include(curses) + <<-"End"
+      extern char *curses_version;
+      int main(int argc, char *argv[])
+      {
+          int i = 0;
+          for (i = 0; i < 100; i++) {
+              if (curses_version[i] == 0)
+                  return 0 < i ? EXIT_SUCCESS : EXIT_FAILURE;
+              if (curses_version[i] & 0x80)
+                  return EXIT_FAILURE;
+          }
+          return EXIT_FAILURE;
+      }
+    End
+    try = method(CROSS_COMPILING ? :try_link : :try_run)
+    function_p = checking_for(checking_message('function curses_version', curses)) { try[func_test_program] }
+    variable_p = checking_for(checking_message('variable curses_version', curses)) { try[var_test_program] }
+    if function_p and variable_p
+      if [header, library].grep(/ncurses|pdcurses|xcurses/i)
+        variable_p = false
+      else
+        warn "found curses_version but cannot determine whether it is a"
+        warn "function or a variable, so assume a variable in old SVR4"
+        warn "ncurses."
+        function_p = false
+      end
+    end
+    $defs << '-DHAVE_FUNC_CURSES_VERSION' if function_p
+    $defs << '-DHAVE_VAR_CURSES_VERSION' if variable_p
+  else
+    warn "unexpected value for --with-curses-version: #{with_curses_version}"
+  end
+  
+  if RUBY_VERSION >= '2.1'
+    create_makefile("curses")
+  else
+    # curses is part of ruby-core pre-2.1.0, so this gem is not required. But
+    # make pre-2.1.0 a no-op rather than failing or listing as unsupported, to
+    # aid gems offering multi-version Ruby support.
+    File.open("Makefile", 'w') do |f|
+      f.puts dummy_makefile("curses").join
+    end
+  end
+end

data/lib/curses.rb

@@ -0,0 +1,22 @@
+pdcurses_path = File.expand_path("../vendor/#{RUBY_PLATFORM}/PDCurses", __dir__)
+pdcurses_bundled = File.directory?(pdcurses_path)
+if pdcurses_bundled
+  path = ENV["PATH"]
+  dir = File::ALT_SEPARATOR ?
+    pdcurses_path.tr("/", File::ALT_SEPARATOR) : dir
+  dirs = path.split(File::PATH_SEPARATOR)
+  if !dirs.include?(dir)
+    ENV["PATH"] = [dir, *dirs].join(File::PATH_SEPARATOR)
+  end
+end
+
+begin
+  major, minor, _ = RUBY_VERSION.split(/\./)
+  require "#{major}.#{minor}/curses.so"
+rescue LoadError
+  require "curses.so"
+end
+
+if pdcurses_bundled
+  Curses.keyboard_encoding = Encoding::UTF_8
+end

data/sample/hello.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require "curses"
+
+def show_message(message)
+  height = 5
+  width  = message.length + 6
+  top    = (Curses.lines - height) / 2
+  left   = (Curses.cols - width) / 2
+  win = Curses::Window.new(height, width, top, left)
+  win.box("|", "-")
+  win.setpos(2, 3)
+  win.addstr(message)
+  win.refresh
+  win.getch
+  win.close
+end
+
+Curses.init_screen
+begin
+  Curses.crmode
+  Curses.setpos((Curses.lines - 1) / 2, (Curses.cols - 11) / 2)
+  Curses.addstr("Hit any key")
+  Curses.refresh
+  Curses.getch
+  show_message("Hello, World!")
+ensure
+  Curses.close_screen
+end

data/sample/mouse.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require "curses"
+include Curses
+
+def show_message(*msgs)
+  message = msgs.join
+  height, width = 5, message.length + 6
+  top, left = (lines - height) / 2, (cols - width) / 2
+  win = Window.new(height, width, top, left)
+  win.keypad = true
+  win.attron(color_pair(COLOR_RED)) do
+    win.box("|", "-", "+")
+  end
+  win.setpos(2, 3)
+  win.addstr(message)
+  win.refresh
+  win.getch
+  win.close
+end
+
+init_screen
+start_color
+init_pair(COLOR_BLUE, COLOR_BLUE, COLOR_WHITE)
+init_pair(COLOR_RED, COLOR_RED, COLOR_WHITE)
+crmode
+noecho
+stdscr.keypad(true)
+
+begin
+  mousemask(BUTTON1_CLICKED|BUTTON2_CLICKED|BUTTON3_CLICKED|BUTTON4_CLICKED)
+  setpos((lines - 1) / 2, (cols - 5) / 2)
+  attron(color_pair(COLOR_BLUE)|A_BOLD) do
+    addstr("click")
+  end
+  refresh
+  loop do
+    c = getch
+    case c
+    when KEY_MOUSE
+      m = getmouse
+      if m
+        show_message("getch = #{c.inspect}, ",
+                     "mouse event = #{'0x%x' % m.bstate}, ",
+                     "axis = (#{m.x},#{m.y},#{m.z})")
+      end
+      break
+    end
+  end
+  refresh
+ensure
+  close_screen
+end

data/sample/rain.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require "curses"
+
+def onsig(signal)
+  Curses.close_screen
+  exit signal
+end
+
+def place_string(y, x, string)
+  Curses.setpos(y, x)
+  Curses.addstr(string)
+end
+
+def cycle_index(index)
+  (index + 1) % 5
+end
+
+%w[HUP INT QUIT TERM].each do |sig|
+  unless trap(sig, "IGNORE") == "IGNORE"  # previous handler
+    trap(sig) {|s| onsig(s) }
+  end
+end
+
+Curses.init_screen
+Curses.nl
+Curses.noecho
+Curses.curs_set 0
+srand
+
+xpos, ypos = {}, {}
+x_range = 2..(Curses.cols - 3)
+y_range = 2..(Curses.lines - 3)
+(0..4).each do |i|
+  xpos[i], ypos[i] = rand(x_range), rand(y_range)
+end
+
+i = 0
+loop do
+  x, y = rand(x_range), rand(y_range)
+
+  place_string(y, x, ".")
+
+  place_string(ypos[i], xpos[i], "o")
+
+  i = cycle_index(i)
+  place_string(ypos[i], xpos[i], "O")
+
+  i = cycle_index(i)
+  place_string(ypos[i] - 1, xpos[i],      "-")
+  place_string(ypos[i],     xpos[i] - 1, "|.|")
+  place_string(ypos[i] + 1, xpos[i],      "-")
+
+  i = cycle_index(i)
+  place_string(ypos[i] - 2, xpos[i],       "-")
+  place_string(ypos[i] - 1, xpos[i] - 1,  "/ \\")
+  place_string(ypos[i],     xpos[i] - 2, "| O |")
+  place_string(ypos[i] + 1, xpos[i] - 1, "\\ /")
+  place_string(ypos[i] + 2, xpos[i],       "-")
+
+  i = cycle_index(i)
+  place_string(ypos[i] - 2, xpos[i],       " ")
+  place_string(ypos[i] - 1, xpos[i] - 1,  "   ")
+  place_string(ypos[i],     xpos[i] - 2, "     ")
+  place_string(ypos[i] + 1, xpos[i] - 1,  "   ")
+  place_string(ypos[i] + 2, xpos[i],       " ")
+
+  xpos[i], ypos[i] = x, y
+
+  Curses.refresh
+  sleep(0.5)
+end

data/sample/view.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+require "curses"
+include Curses
+
+unless ARGV.size == 1
+  puts "usage: #{$0} file"
+  exit
+end
+
+begin
+  data_lines = File.readlines(ARGV[0])
+rescue
+  raise "cannot open file: #{ARGV[0]}"
+end
+
+init_screen
+#keypad(stdscr, true)
+nonl
+cbreak
+noecho
+#scrollok(stdscr, true)
+
+lptr = 0
+loop do
+  lines.times do |i|
+    setpos(i, 0)
+    #clrtoeol
+    addstr(data_lines[lptr + i] || "")
+  end
+  refresh
+
+  explicit = false
+  n = 0
+  c = nil
+  loop do
+    c = getch
+    if c =~ /[0-9]/
+      n = 10 * n + c.to_i
+      explicit = true
+    else
+      break
+    end
+  end
+
+  n = 1 if !explicit && n == 0
+
+  case c
+  when "n"  #when KEY_DOWN
+    i = 0
+    n.times do
+      if lptr + lines < data_lines.size
+        lptr += 1
+      else
+        break
+      end
+      i += 1
+    end
+    #wscrl(i)
+  when "p"  #when KEY_UP
+    i = 0
+    n.times do
+      if lptr > 0
+        lptr -= 1
+      else
+        break
+      end
+      i += 1
+    end
+    #wscrl(-i)
+  when "q"
+    break
+  end
+end
+
+close_screen

data/sample/view2.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+
+require "curses"
+
+
+# A curses based file viewer.
+class FileViewer
+
+  # Create a new FileViewer and view the file.
+  def initialize(filename)
+    @data_lines = []
+    @screen = nil
+    @top = nil
+    init_curses
+    load_file(filename)
+    interact
+  end
+
+  # Perform the curses setup.
+  def init_curses
+    Curses.init_screen
+    Curses.nonl
+    Curses.cbreak
+    Curses.noecho
+
+    @screen = Curses.stdscr
+
+    @screen.scrollok(true)
+    #@screen.keypad(true)
+  end
+
+  # Load the file into memory and
+  # put the first part on the curses display.
+  def load_file(filename)
+    @data_lines = File.readlines(filename).map(&:chomp)
+    @top = 0
+    @data_lines[0..@screen.maxy-1].each_with_index do |line, idx|
+      @screen.setpos(idx, 0)
+      @screen.addstr(line)
+    end
+    @screen.setpos(0, 0)
+    @screen.refresh
+  rescue
+    raise "cannot open file '#{filename}' for reading"
+  end
+
+
+  # Scroll the display up by one line.
+  def scroll_up
+    if @top > 0
+      @screen.scrl(-1)
+      @top -= 1
+      str = @data_lines[@top]
+      if str
+        @screen.setpos(0, 0)
+        @screen.addstr(str)
+      end
+      return true
+    else
+      return false
+    end
+  end
+
+  # Scroll the display down by one line.
+  def scroll_down
+    if @top + @screen.maxy < @data_lines.length
+      @screen.scrl(1)
+      @top += 1
+      str = @data_lines[@top + @screen.maxy - 1]
+      if str
+        @screen.setpos(@screen.maxy - 1, 0)
+        @screen.addstr(str)
+      end
+      return true
+    else
+      return false
+    end
+  end
+
+  # Allow the user to interact with the display.
+  # This uses Emacs-like keybindings, and also
+  # vi-like keybindings as well, except that left
+  # and right move to the beginning and end of the
+  # file, respectively.
+  def interact
+    loop do
+      result = true
+      c = Curses.getch
+      case c
+      when Curses::KEY_DOWN, Curses::KEY_CTRL_N, "j"
+        result = scroll_down
+      when Curses::KEY_UP, Curses::KEY_CTRL_P, "k"
+        result = scroll_up
+      when Curses::KEY_NPAGE, " "
+        (@screen.maxy - 1).times do |i|
+          if !scroll_down && i == 0
+            result = false
+            break
+          end
+        end
+      when Curses::KEY_PPAGE
+        (@screen.maxy - 1).times do |i|
+          if !scroll_up && i == 0
+            result = false
+            break
+          end
+        end
+      when Curses::KEY_LEFT, Curses::KEY_CTRL_T, "h"
+        while scroll_up
+        end
+      when Curses::KEY_RIGHT, Curses::KEY_CTRL_B, "l"
+        while scroll_down
+        end
+      when "q"
+        break
+      else
+        @screen.setpos(0, 0)
+        @screen.addstr("[unknown key `#{Curses.keyname(c)}'=#{c}] ")
+      end
+      if !result
+        Curses.beep
+      end
+      @screen.setpos(0, 0)
+    end
+    Curses.close_screen
+  end
+end
+
+
+# If we are being run as a main program...
+if __FILE__ == $0
+  unless ARGV.size == 1
+    puts "usage: #{$0} file"
+    exit
+  end
+
+  viewer = FileViewer.new(ARGV[0])
+end