ffi-ncurses 0.3.3 → 0.4.0

data/examples/newterm.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+require 'ffi-ncurses'
+
+# newterm - how to read STDIN and do ncurses at the same time
+# See ncurses FAQ http://invisible-island.net/ncurses/ncurses.faq.html "Problems with output buffering"
+
+# Call like this:
+#
+#     $ echo hello|ruby newterm.rb
+#
+# or
+#
+#     $ ruby newterm.rb < input.txt
+#
+# otherwise the program will stall.
+
+def log(*a)
+  File.open("ncurses.log", "a") do |file|
+    file.puts(a.inspect)
+  end
+end
+
+module CLib
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  # FILE* open and close
+  typedef :pointer, :FILEP
+  attach_function :fopen, [:string, :string], :FILEP
+  attach_function :fclose, [:FILEP], :int
+end
+
+begin
+  term = CLib.fopen("/dev/tty", "rb+")
+  screen = FFI::NCurses.newterm(nil, term, term)
+  old_screen = FFI::NCurses.set_term(screen)
+  FFI::NCurses.noecho
+  FFI::NCurses.clear
+  FFI::NCurses.move 1, 1
+  FFI::NCurses.addstr("Press any key to continue")
+  FFI::NCurses.move 3, 1
+  FFI::NCurses.addstr(STDIN.read(3))
+  FFI::NCurses.refresh
+  FFI::NCurses.flushinp
+  FFI::NCurses.getch
+  FFI::NCurses.addstr(STDIN.read)
+  FFI::NCurses.move 5, 1
+  FFI::NCurses.addstr("Press any key to continue")
+  FFI::NCurses.refresh
+  FFI::NCurses.flushinp
+  FFI::NCurses.getch
+rescue => e
+  log :e1, e
+ensure
+  begin
+    # Watch the ordering of these calls, i.e. do not call delscreen
+    # before endwin
+    FFI::NCurses.flushinp
+    FFI::NCurses.echo
+    FFI::NCurses.endwin
+    FFI::NCurses.delscreen(screen)
+    CLib.fclose(term)
+  rescue => e
+    log :e2, e
+  end
+end

data/examples/panel_simple.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8; -*-
+require 'ffi-ncurses'
+
+include FFI::NCurses
+
+def main
+  my_wins = []
+  my_panels = []
+  lines = 10
+  cols = 40
+  y = 2
+  x = 4
+
+  begin
+    initscr
+    cbreak
+    noecho
+
+    # Create windows for the panels
+    my_wins[0] = newwin(lines, cols, y, x)
+    my_wins[1] = newwin(lines, cols, y + 1, x + 5)
+    my_wins[2] = newwin(lines, cols, y + 2, x + 10)
+
+
+    # Create borders around the windows so that you can see the effect
+    # of panels
+    my_wins.each_with_index do |win, i|
+      box(win, 0, 0)
+      mvwaddstr(win, 2, 2, "Window #{i}")
+    end
+
+    # Attach a panel to each window      Order is bottom up #
+    my_panels[0] = new_panel(my_wins[0])        # Push 0, order: stdscr-0
+    my_panels[1] = new_panel(my_wins[2])        # Push 1, order: stdscr-0-1
+    my_panels[2] = new_panel(my_wins[1])        # Push 2, order: stdscr-0-1-2
+
+    # Update the stacking order. panel 2 will be on top
+    update_panels
+
+    # Show it on the screen
+    doupdate
+
+    getch
+
+    # bring panel 1 to top
+    top_panel(my_panels[1])
+    update_panels
+    doupdate
+
+    getch
+
+    # hide panel 0
+    hide_panel(my_panels[0])
+    update_panels
+    doupdate
+
+    getch
+
+    # show panel 0 again (on top)
+    show_panel(my_panels[0])
+    update_panels
+    doupdate
+
+    getch
+
+    # put panel 0 back to bottom of stack
+    bottom_panel(my_panels[0])
+    update_panels
+    doupdate
+
+    getch
+
+  rescue => e
+    endwin
+    raise
+  ensure
+    endwin
+  end
+end
+
+main

data/examples/{example-printw-variadic.rb → printw-variadic.rb}

@@ -4,7 +4,7 @@
 # Sean O'Halpin, 2009-02-15
 #
 require 'ffi-ncurses'
-begin	
+begin
   FFI::NCurses.initscr
   FFI::NCurses.clear
   FFI::NCurses.printw("Hello %s! There are %d arguments to this variadic function!", :string, "world", :int, 2)

data/examples/ripoffline.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+require 'ffi-ncurses'
+
+# how to use ripoffline
+
+def log(*a)
+  File.open("ncurses.log", "a") do |file|
+    file.puts(a.inspect)
+  end
+end
+
+# this works
+# module FFI
+#   module NCurses
+#     callback :ripoffline_callback, [:pointer, :int], :int
+#     attach_function :ripoffline, [:int, :ripoffline_callback], :int
+#   end
+# end
+
+# works
+$ripoffwin = nil
+ripoffCallback = Proc.new do |win, cols|
+  $ripoffwin = win
+  FFI::NCurses.wbkgd(win, FFI::NCurses::A_REVERSE)
+  FFI::NCurses.werase(win)
+
+  FFI::NCurses.wmove(win, 0, 0)
+  FFI::NCurses.waddstr(win, "ripoff: window %s, %d columns %s" % [win.to_s, cols, Time.now])
+  FFI::NCurses.wnoutrefresh(win)
+  Thread.start do
+    # FFI::NCurses.immedok(win)
+    loop do
+      FFI::NCurses.wmove(win, 0, 0)
+      FFI::NCurses.waddstr(win, "ripoff: window %s, %d columns %s" % [win.to_s, cols, Time.now])
+      FFI::NCurses.wnoutrefresh(win)
+      sleep 1
+    end
+  end
+  FFI::NCurses::OK
+end
+
+callback = FFI::Function.new(:int, [:pointer, :int], &ripoffCallback)
+
+def get_cmd
+  while (ch = FFI::NCurses.getch) == FFI::NCurses::ERR
+    sleep(0.1) # this has better performance than using halfdelay
+    FFI::NCurses.wrefresh($ripoffwin)
+  end
+  ch
+end
+
+begin
+  #FFI::NCurses.ripoffline(-1, RipoffCallback) # works
+  FFI::NCurses.ripoffline(1, callback)  # rip line off top
+  FFI::NCurses.ripoffline(-1, callback) # rip line off bottom
+  FFI::NCurses.initscr
+  # FFI::NCurses.halfdelay(1)
+  FFI::NCurses.nodelay(FFI::NCurses.stdscr, true) # v. expensive in CPU (unless we sleep as above)
+  FFI::NCurses.noecho
+  FFI::NCurses.clear
+  FFI::NCurses.border(*([0]*8))
+  FFI::NCurses.move(4, 4)
+  FFI::NCurses.addstr("Hello")
+  FFI::NCurses.refresh
+  # FFI::NCurses.getch
+  get_cmd
+  FFI::NCurses.flushinp
+  FFI::NCurses.addstr("World")
+  FFI::NCurses.refresh
+  get_cmd
+  #FFI::NCurses.getch
+rescue => e
+  FFI::NCurses.flushinp
+  FFI::NCurses.echo
+  FFI::NCurses.endwin
+  log :e1, e
+  raise
+ensure
+  begin
+    FFI::NCurses.flushinp
+    FFI::NCurses.echo
+    FFI::NCurses.endwin
+  rescue => e
+    log :e2, e
+  end
+end

data/examples/run-all.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+for p in *.rb; do
+  if [ "$p" = "newterm.rb" ]; then
+    echo Not running $p
+  elif [ "$p" = "multiterm.rb" ]; then
+    echo Not running $p
+  elif [ "$p" = "viewer.rb" ]; then
+    echo $p
+    ruby $p $p
+  else
+    echo $p
+    ruby $p
+  fi
+done

data/examples/{example-stdscr.rb → stdscr.rb}

@@ -6,7 +6,8 @@ require 'ffi-ncurses'
 begin
   scr = FFI::NCurses.initscr
   FFI::NCurses.box(FFI::NCurses.stdscr, 0, 0)
-  FFI::NCurses.mvaddstr 1, 1, "#{[scr, FFI::NCurses.stdscr].inspect}"
+  FFI::NCurses.mvaddstr 1, 1, "initscr: #{scr.inspect}"
+  FFI::NCurses.mvaddstr 2, 1, "stdscr:  #{FFI::NCurses.stdscr.inspect}"
   FFI::NCurses.refresh
   FFI::NCurses.getch
 

data/examples/temp_leave.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+require 'ffi-ncurses'
+
+include FFI::NCurses
+
+module CLib
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  # FILE* open and close
+  typedef :pointer, :FILEP
+  attach_function :fdopen, [:int, :string], :FILEP
+  attach_function :fopen, [:string, :string], :FILEP
+  attach_function :fclose, [:FILEP], :int
+end
+
+# This is the version from NCURSES HOWTO
+def do_cmd(cmd)
+  def_prog_mode              # Save the tty modes
+  endwin                     # End curses mode temporarily
+  system(cmd)                # Do whatever you like in cooked mode
+  reset_prog_mode            # Return to the previous tty mode
+  refresh                    # Do refresh() to restore the
+                             # Screen contents
+                             # stored by def_prog_mode()
+end
+
+# This is the version from ncurses examples filter.c
+def do_cmdx(cmd)
+  reset_shell_mode           # Restore terminal mode
+  STDOUT.flush
+  system(cmd)                # Do whatever you like in cooked mode
+  reset_prog_mode            # Return to the previous tty mode
+  touchwin(stdscr)
+  # erase
+  refresh
+end
+
+def show_text_window(win, title, text)
+  text_width = text.lines.map{ |x| x.size }.max
+  text_height = text.lines.to_a.size
+
+  width = text_width + 4
+  height = text_height + 4
+
+  rows, cols = getmaxyx(win)
+
+  col = (cols - width)/2
+  row = (rows - height)/2
+
+  frame = newwin(height, width, row, col)
+  keypad frame, true
+  box(frame, 0, 0)
+
+  title = "[ #{title} ]"
+  wmove(frame, 0, (width - title.size)/2)
+  waddstr(frame, title)
+
+  win = derwin(frame, text_height, text_width, 2, 2)
+  wmove(win, 0, 0)
+  waddstr(win, text)
+  wnoutrefresh(win)
+  wgetch(frame)
+  flushinp
+  delwin(win)
+  delwin(frame)
+end
+
+def main
+  begin
+    # input = CLib.fdopen(STDIN.fileno, "rb+")
+    # output = CLib.fdopen(STDOUT.fileno, "rb+")
+    # screen = newterm(nil, output, input)
+    # set_term(screen)
+
+    initscr
+    keypad stdscr, true
+    noecho
+
+    addstr("Hello from ncurses\n")
+    refresh
+    addstr("Press any key to enter shell\n")
+    getch
+    addstr("Now entering shell - enter 'exit' or press Ctrl-D to exit\n")
+    refresh
+    sleep 0.2
+
+    cmd = ARGV[0] || "/bin/sh"
+    do_cmd(cmd)
+    flushinp
+    show_text_window(stdscr, "Message", "Back to ncurses\nPress any key to quit")
+    refresh
+  ensure
+    flushinp
+    endwin
+    # delscreen(screen)
+  end
+end
+
+main

data/examples/viewer.rb

@@ -0,0 +1,350 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+#
+# A simple file viewer.
+#
+# Sean O'Halpin, 2011-09-16
+#
+# Possible features to add:
+# - search
+# - hex view
+#
+require 'ffi-ncurses'
+
+include FFI::NCurses
+
+# some helper methods for working with stdlib FILE pointers
+module CLib
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  typedef :pointer, :FILEP
+  # FILE* open, close and eof
+  attach_function :fopen, [:string, :string], :FILEP
+  attach_function :fclose, [:FILEP], :int
+  attach_function :feof, [:FILEP], :int
+  attach_function :fflush, [:FILEP], :int
+  attach_function :fputs, [:string, :FILEP], :int
+end
+
+$APP_DEBUG = ARGV.delete("--debug")
+def log(*a)
+  STDERR.puts a.inspect if $APP_DEBUG
+end
+
+def redraw_background_frame
+  clear
+  touchwin(stdscr)
+  box(stdscr, 0, 0)
+  title = "[ F1 or ? for help ]"
+  wmove(stdscr, 0, (COLS() - title.size)/2)
+  waddstr(stdscr, title)
+  wnoutrefresh(stdscr)
+end
+
+def std_colors
+  init_pair(0,  Color::BLACK,   Color::BLACK)
+  init_pair(1,  Color::RED,     Color::BLACK)
+  init_pair(2,  Color::GREEN,   Color::BLACK)
+  init_pair(3,  Color::YELLOW,  Color::BLACK)
+  init_pair(4,  Color::BLUE,    Color::BLACK)
+  init_pair(5,  Color::MAGENTA, Color::BLACK)
+  init_pair(6,  Color::CYAN,    Color::BLACK)
+  init_pair(7,  Color::WHITE,   Color::BLACK)
+
+  init_pair(8,  Color::BLACK,   Color::BLACK)
+  init_pair(9,  Color::BLACK,   Color::RED)
+  init_pair(10, Color::BLACK,   Color::GREEN)
+  init_pair(11, Color::BLACK,   Color::YELLOW)
+  init_pair(12, Color::BLACK,   Color::BLUE)
+  init_pair(13, Color::BLACK,   Color::MAGENTA)
+  init_pair(14, Color::BLACK,   Color::CYAN)
+  init_pair(15, Color::BLACK,   Color::WHITE)
+end
+
+def show_text_window(win, title, text)
+  text_width = text.lines.map{ |x| x.size }.max
+  text_height = text.lines.to_a.size
+
+  width = text_width + 4
+  height = text_height + 4
+
+  rows, cols = getmaxyx(win)
+
+  col = (cols - width)/2
+  row = (rows - height)/2
+
+  frame = newwin(height, width, row, col)
+  keypad frame, true
+  box(frame, 0, 0)
+
+  title = "[ #{title} ]"
+  wmove(frame, 0, (width - title.size)/2)
+  waddstr(frame, title)
+
+  win = derwin(frame, text_height, text_width, 2, 2)
+  wmove(win, 0, 0)
+  waddstr(win, text)
+  wnoutrefresh(win)
+  wgetch(frame)
+  flushinp
+  delwin(win)
+  delwin(frame)
+end
+
+def update_row_col(left_border, row, col)
+  move(0, left_border)
+  addstr("%03d:%003d" % [row + 1, col + 1])
+  wnoutrefresh(stdscr)
+end
+
+@maximized = false
+def toggle_maximize(term)
+  # Maximize terminal window (xterm only).
+  #
+  # You can do the same with Alt-F10 in Gnome (and it seems more
+  # reliable).
+  CLib.fflush(term)
+
+  # maximize
+  CLib.fputs("\e[9;#{@maximized ? 0 : 1}t", term)
+  CLib.fflush(term)
+
+  @maximized = !@maximized
+end
+
+# Helper function to match charcodes or (single character) strings
+# against keycodes returned by ncursesw.
+#
+# Note that this won't work for characters outside Latin-1 as they overlap numerically with
+# ncurses's KEY_ codes. Should return new class for KEY_ codes.
+#
+def KEY(s)
+  case s
+  when String
+    s.unpack("U")[0]
+  else
+    s
+  end
+end
+
+def resize_terminal_window(rows, cols)
+  print("\e[8;#{rows};#{cols};t") # set window size to rows x cols
+  resizeterm(rows, cols)              # note: you need to tell ncurses that you've resized the terminal
+end
+
+def page_height
+  LINES() - total_tb_border
+end
+
+def page_width
+  COLS() - total_lr_border
+end
+
+def total_lr_border
+  @left_border + @right_border
+end
+
+def total_tb_border
+  @top_border + @bottom_border
+end
+
+def view(text, arg_rows = nil, arg_cols = nil)
+  @top_border = @bottom_border = 1
+  @left_border = @right_border = 1
+  # set_escdelay(10) if respond_to?(:set_escdelay) # Centos 5.1 :S
+  lines = text.lines.to_a
+  maxx = lines.map{|x| x.size }.max + total_lr_border
+  maxy = lines.size + total_tb_border
+
+  # We need to open /dev/tty so we can read from STDIN without borking
+  # ncurses
+  term = CLib.fopen("/dev/tty", "rb+")
+  screen = newterm(nil, term, term)
+  old_screen = set_term(screen)
+
+  # save original window size
+  orig_rows, orig_cols = getmaxyx(stdscr)
+  if arg_rows.nil?
+    arg_rows = orig_rows
+  end
+  if arg_cols.nil?
+    arg_cols = orig_cols
+  end
+  if arg_rows != orig_rows || arg_cols != orig_cols
+    resize_terminal_window(arg_rows, arg_cols)
+  end
+
+  help_text = <<EOT
+F1, ?       - Help
+Home        - Beginning of file
+End         - End of file
+PgDn, space - Scroll down one page
+PgUp        - Scroll up one page
+Down arrow  - Scroll down one line
+Up arrow    - Scroll up one line
+Right arrow - Scroll right one column
+Left arrow  - Scroll left one column
++/-         - Increase/decrease window size
+^q, q, Esc  - Quit
+EOT
+
+  saved_exception = nil
+  begin
+    raw
+    noecho
+    curs_set 0
+    pad = newpad(maxy, maxx)
+    if has_colors
+      start_color
+      std_colors
+    end
+    keypad pad, true
+
+    # just a bit of fun - format RDoc headers, comments and org-mode
+    # header lines
+    flag = false
+    bg_flag = false
+    attribute = 0
+    lines.each do |line|
+      if line =~ /^\s*[=*#]+/
+        case line
+        when /^\s*#/
+          attribute = COLOR_PAIR(4)
+        when /^\s*=+/
+          # attribute = A_UNDERLINE
+          wbkgdset(pad, A_REVERSE)
+          wclrtoeol(pad)
+          bg_flag = true
+        when /^\s*\*/
+          attribute = COLOR_PAIR(1)
+        end
+        # wchgat(pad, -1, A_REVERSE, COLOR_WHITE, nil)
+        flag = true
+        # wattron(pad, A_BOLD)
+        wattron(pad, attribute)
+      end
+      rv = waddstr(pad, line)
+      if flag
+        flag = false
+        wattroff(pad, attribute)
+        if bg_flag
+          wbkgdset(pad, A_NORMAL)
+          wattroff(pad, A_BOLD)
+        end
+      end
+      log :adding, line, :rv, rv
+    end
+
+    current_line = 0
+    current_col  = 0
+
+    redraw_background_frame
+    update_row_col(@left_border, current_line, current_col)
+
+    rv = pnoutrefresh(pad, current_line, current_col, @top_border, @left_border, page_height, page_width)
+    log :prefresh1, :rv, rv
+    doupdate
+
+    # main loop
+    while ch = wgetch(pad)
+      log :ch, ch
+      case ch
+      when KEY_HOME
+        current_line = 0
+        current_col  = 0
+      when KEY_END
+        current_line = maxy - LINES() + total_lr_border
+        current_col  = 0
+      when KEY_NPAGE, KEY(' ')
+        current_line = [current_line + page_height, [maxy - page_height, 0].max].min
+      when KEY_PPAGE
+        current_line = [current_line - page_height, 0].max
+      when KEY_DOWN
+        current_line = [current_line + 1, [maxy - page_height, 0].max].min
+      when KEY_UP
+        current_line = [current_line - 1, 0].max
+      when KEY_RIGHT
+        current_col = [current_col + 1, [maxx - page_width, 0].max].min
+      when KEY_LEFT
+        current_col = [current_col - 1, 0].max
+      when KEY_F1, KEY('?')
+        # Help
+        show_text_window stdscr, "Help", help_text
+        redraw_background_frame
+      when KEY('f')
+        toggle_maximize(term)
+      when KEY('+')
+        rows, cols = getmaxyx(stdscr)
+        rows += 1
+        cols += 1
+        resize_terminal_window(rows, cols)
+        redraw_background_frame
+      when KEY('-')
+        rows, cols = getmaxyx(stdscr)
+        rows -= 1
+        cols -= 1
+        resize_terminal_window(rows, cols)
+        redraw_background_frame
+      when KEY_CTRL_Q, 'q'[0].ord, 27 # 27 == Esc
+        # Quit
+        delwin(pad)
+        break
+      when KEY_CTRL_C
+        # for JRuby - Ctrl-C in cbreak mode is not trapped in rescue
+        # below for some reason and so leaves the terminal in raw mode
+        raise Interrupt
+      when KEY_RESIZE, KEY_CTRL_L
+        log :redraw2
+        redraw_background_frame
+      end
+
+      update_row_col(@left_border, current_line, current_col)
+      rv = pnoutrefresh(pad, current_line, current_col, @top_border, @left_border, page_height, page_width)
+      log :prefresh2, :rv, rv, :line, current_line, :col, current_col
+      doupdate
+      flushinp
+    end
+  rescue Object => saved_exception
+  ensure
+    CLib.fclose(term) if !CLib.feof(term)
+    flushinp
+    end_rows, end_cols = getmaxyx(stdscr)
+    endwin
+    delscreen(screen)
+
+    # restore terminal size at launch
+    if end_rows != orig_rows || end_cols != orig_cols
+      resizeterm(orig_rows, orig_cols)
+      File.open("/dev/tty", "wb+") do |file|
+        file.print("\e[8;#{orig_rows};#{orig_cols};t") # restore window
+      end
+    end
+  end
+  if saved_exception
+    raise saved_exception
+  end
+end
+
+def main
+  require 'ostruct'
+  require 'optparse'
+
+  options = OpenStruct.new
+
+  xopts = OptionParser.new do |opts|
+    opts.on("-c", "--c COLS", Integer, "Resize screen to COLS width") do |cols|
+      options.columns = cols
+    end
+    opts.on("-r", "--r ROWS", Integer, "Resize screen to ROWS height") do |rows|
+      options.rows = rows
+    end
+  end
+
+  xopts.parse!(ARGV)
+  view(ARGF.read, options.rows, options.columns) # simplistic but works for demo
+
+end
+
+if __FILE__ == $0
+  main
+end