ncurses 0.9.1

data/examples/form.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/ruby
+# Copyright (c) 2004 by Simon Kaczor <skaczor@cox.net>
+# Example from the NCurses Programming HOWTO
+# This example uses module functions that are documented in the ncurses man page.
+# For a more rubyish approach that uses Ruby objects see form2.rb
+#
+# The original example contained the following copyright:
+# Copyright (c) 2001 by Pradeep Padala. This document may be distributed 
+# under the terms set forth in the LDP license at linuxdoc.org/COPYRIGHT.html.
+ 
+require 'ncurses.rb'
+
+begin
+  scr = Ncurses.initscr()
+  Ncurses.cbreak()
+  Ncurses.noecho()
+  Ncurses.keypad(scr, true)
+
+  #create some fields
+  fields = Array.new
+  fields.push(Ncurses::Form.new_field(1,10,4,18,0,0))
+  fields.push(Ncurses::Form.new_field(1,10,6,18,0,0))
+  
+  # set field options
+  Ncurses::Form.set_field_back(fields[0], Ncurses::A_UNDERLINE)
+  Ncurses::Form.field_opts_off(fields[0], Ncurses::Form::O_AUTOSKIP)
+
+  Ncurses::Form.set_field_back(fields[1], Ncurses::A_UNDERLINE)
+  Ncurses::Form.field_opts_off(fields[1], Ncurses::Form::O_AUTOSKIP)
+
+
+  # create a form  
+  form = Ncurses::Form.new_form(fields)
+
+  # post the form and refresh the screen
+  Ncurses::Form.post_form(form)
+  scr.refresh()
+
+  Ncurses.mvprintw(4, 10, "Value 1:")
+  Ncurses.mvprintw(6, 10, "Value 2:")
+  scr.refresh()
+
+  # Loop through to get user requests
+  while((ch = scr.getch()) != Ncurses::KEY_F1) do
+    case(ch)
+    when Ncurses::KEY_DOWN
+      # Go to next field
+      Ncurses::Form.form_driver(form, Ncurses::Form::REQ_NEXT_FIELD)
+      # Go to the end of the present buffer
+      # Leaves nicely at the last character
+      Ncurses::Form.form_driver(form, Ncurses::Form::REQ_END_LINE)
+      
+    when Ncurses::KEY_UP
+      #Go to previous field
+      Ncurses::Form.form_driver(form, Ncurses::Form::REQ_PREV_FIELD)
+      Ncurses::Form.form_driver(form, Ncurses::Form::REQ_END_LINE);
+    else                                                                   
+      # If this is a normal character, it gets Printed
+      Ncurses::Form.form_driver(form, ch)
+    end
+  end
+    
+  # unpost and free form
+  Ncurses::Form.unpost_form(form);
+  Ncurses::Form.free_form(form)
+  Ncurses::Form.free_field(fields[0]);
+  Ncurses::Form.free_field(fields[1]);
+
+  
+  #using class methods this time
+#  form = Ncurses::Form::FORM.new(fields)
+#  puts "Created form: #{form.inspect}\n"
+#  form.free()
+
+ensure
+  # put the screen back in its normal state
+  Ncurses.echo()
+  Ncurses.nocbreak()
+  Ncurses.nl()
+  Ncurses.endwin()
+end
+

data/examples/form2.rb

@@ -0,0 +1,184 @@
+#!/usr/bin/ruby
+# Copyright (c) 2004 by Simon Kaczor <skaczor@cox.net>
+# Simple example of a form in action, based on the NCURSES Programming HOWTO:
+# http://www.tldp.org/HOWTO/NCURSES-Programming-HOWTO/
+#
+# All standard field types are created in the form. 
+# Additionnally a custom field is created to illustrate 
+# custom field validation using Ruby Proc objects, as shown in the example.
+#
+# The original example contained the following copyright:
+# Copyright (c) 2001 by Pradeep Padala. This document may be distributed 
+# under the terms set forth in the LDP license at linuxdoc.org/COPYRIGHT.html.
+
+require 'ncurses'
+
+include Ncurses
+include Ncurses::Form
+
+def print_in_middle(win, starty, startx, width, string, color)
+
+  if(win == nil)
+    win = stdscr;
+  end
+  x = Array.new
+  y = Array.new
+  Ncurses.getyx(win, y, x);
+  if(startx != 0)
+    x[0] = startx;
+  end
+  if(starty != 0)
+    y[0] = starty;
+  end
+  if(width == 0)
+    width = 80;
+  end
+  length = string.length;
+  temp = (width - length)/ 2;
+  x[0] = startx + temp.floor;
+  win.attron(color);
+  win.mvprintw(y[0], x[0], "%s", string);
+  win.attroff(color);
+  Ncurses.refresh();
+end
+
+fields = Array.new
+
+states = {"MI" => "Michigan", 
+          "VA" => "Virginia", 
+          "VE" => "Vermont"}
+fieldcheck = proc { |afield| 
+  val = afield.field_buffer(0)
+  val.strip!
+  if (states[val] != nil) 
+    afield.set_field_buffer(0,states[val])
+    return true
+  else
+    return false
+  end
+}
+charcheck = proc { |ch| 
+  if (('A'..'Z').include?(ch))
+    return true
+  else
+    return false
+  end
+}
+
+# Initialize curses
+begin
+  stdscr = Ncurses.initscr();
+  Ncurses.start_color();
+  Ncurses.cbreak();
+  Ncurses.noecho();
+  Ncurses.keypad(stdscr, true);
+
+  # Initialize few color pairs 
+  Ncurses.init_pair(1, COLOR_RED, COLOR_BLACK);
+  Ncurses.init_pair(2, COLOR_BLACK, COLOR_WHITE);
+  Ncurses.init_pair(3, COLOR_BLACK, COLOR_BLUE);
+  stdscr.bkgd(Ncurses.COLOR_PAIR(2));
+
+  # Initialize the fields
+  (1..9).each { |i|
+    field = FIELD.new(1, 10, i*2, 1, 0, 0)
+    field.set_field_back(A_UNDERLINE)
+    fields.push(field)
+  }
+
+  customtype = FIELDTYPE.new(fieldcheck, charcheck);
+
+  fields[1].set_field_type(TYPE_ALNUM, 0);
+  fields[2].set_field_type(TYPE_ALPHA, 0);
+  fields[3].set_field_type(TYPE_INTEGER, 0, 0, 1000);
+  fields[4].set_field_type(TYPE_NUMERIC, 2, 0, 1000);
+  fields[5].set_field_type(TYPE_ENUM, ["one","two","three"], false, false);
+  fields[6].set_field_type(TYPE_REGEXP, "^ *[0-9]* *$");
+  fields[7].set_field_type(TYPE_IPV4);
+  fields[8].set_field_type(customtype);
+
+
+  # Create the form and post it
+  my_form = FORM.new(fields);
+
+  my_form.user_object = "My identifier"
+
+  # Calculate the area required for the form
+  rows = Array.new()
+  cols = Array.new()
+  my_form.scale_form(rows, cols);
+
+  # Create the window to be associated with the form 
+  my_form_win = WINDOW.new(rows[0] + 3, cols[0] + 14, 1, 1);
+  my_form_win.bkgd(Ncurses.COLOR_PAIR(3));
+  my_form_win.keypad(TRUE);
+
+  # Set main window and sub window
+  my_form.set_form_win(my_form_win);
+  my_form.set_form_sub(my_form_win.derwin(rows[0], cols[0], 2, 12));
+
+  # Print a border around the main window and print a title */
+  my_form_win.box(0, 0);
+  print_in_middle(my_form_win, 1, 0, cols[0] + 14, "My Form", Ncurses.COLOR_PAIR(1));
+
+  my_form.post_form();
+
+  # Print field types
+  my_form_win.mvaddstr(4, 2, "No Type")
+  my_form_win.mvaddstr(6, 2, "Alphanum")
+  my_form_win.mvaddstr(8, 2, "Alpha")
+  my_form_win.mvaddstr(10, 2, "Integer")
+  my_form_win.mvaddstr(12, 2, "Numeric")
+  my_form_win.mvaddstr(14, 2, "Enum")
+  my_form_win.mvaddstr(16, 2, "Regexp")
+  my_form_win.mvaddstr(18, 2, "IP")
+  my_form_win.mvaddstr(20, 2, "Custom")
+  
+  my_form_win.wrefresh();
+
+  stdscr.mvprintw(Ncurses.LINES - 2, 28, "Use UP, DOWN arrow keys to switch between fields");
+  stdscr.mvprintw(Ncurses.LINES - 1, 28, "Press F1 to quit");
+  stdscr.refresh();
+
+  # Loop through to get user requests
+  while((ch = my_form_win.getch()) != KEY_F1)
+    case ch
+    when KEY_DOWN
+      # Go to next field */
+      my_form.form_driver(REQ_VALIDATION);
+      my_form.form_driver(REQ_NEXT_FIELD);
+      # Go to the end of the present buffer
+      # Leaves nicely at the last character
+      my_form.form_driver(REQ_END_LINE);
+      
+    when KEY_UP
+      # Go to previous field
+      my_form.form_driver(REQ_VALIDATION);
+      my_form.form_driver(REQ_PREV_FIELD);
+      my_form.form_driver(REQ_END_LINE);
+
+    when KEY_LEFT
+      # Go to previous field
+      my_form.form_driver(REQ_PREV_CHAR);
+
+    when KEY_RIGHT
+      # Go to previous field
+      my_form.form_driver(REQ_NEXT_CHAR);
+
+    when KEY_BACKSPACE
+      my_form.form_driver(REQ_DEL_PREV);
+    else
+      # If this is a normal character, it gets Printed    
+      my_form.form_driver(ch);
+    end
+  end
+  # Un post form and free the memory
+  my_form.unpost_form();
+  my_form.free_form();
+  fields.each {|f| f.free_field()}
+
+
+ensure
+  Ncurses.endwin();
+end
+

data/examples/hello_ncurses.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+# $Id: hello_ncurses.rb,v 1.3 2002/02/28 13:50:03 t-peters Exp $
+
+# this ncurses-ruby program follows an ancient tradition of example
+# computer programs: When invoked, it prints a friendly greeting on the
+# screen and exits.
+#
+# Copyright (C) 2002 Tobias Peters <t-peters@users.berlios.de>
+#
+# You may use, modify, and redistribute this file without restriction.
+
+
+
+# First, we have to tell Ruby to use the Ncurses extension module:
+
+require "ncurses"
+
+
+
+# Second, every program using ncurses must initialize the ncurses library
+# before the first call to any ncurses function:
+
+Ncurses.initscr
+
+
+
+# Now the program can use ncurses facilities for screen output. It will print
+# a greeting to the 5th line on the screen, starting at column 20
+
+Ncurses.mvaddstr(4, 19, "Hello, world!");
+
+# Note that ncurses counts lines and columns starting from 0, and that it
+# expects the line number first and the column number second every time it
+# expects a coordinate pair.
+
+
+
+# The previous function call did not alter the screen at all. Ncurses makes
+# all changes first to an internal buffer. The contents of this buffer is
+# copied to the screen with the following function call:
+
+Ncurses.refresh
+
+
+# Now pause for a short while, enough time for the program user to read the
+# greeting and greet back.
+
+sleep(2.5)
+
+
+# The program has almost finished its task. It only needs to put the screen
+# back to its normal state:
+
+Ncurses.endwin
+
+

data/examples/rain.rb

@@ -0,0 +1,220 @@
+#!/usr/bin/env ruby
+
+# $Id: rain.rb,v 1.5 2002/11/16 21:16:32 t-peters Exp $
+
+# This program is a translation of the popular rain.c demo program from the
+# ncurses library distribution.
+#
+# Copyright (C) 2002 Tobias Peters <t-peters@users.berlios.de>
+#
+# I do not impose any additional restrictions over the copyright of the
+# ncurses library distribution. It has the following Copyright notice
+
+#/****************************************************************************
+# * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+# *                                                                          *
+# * Permission is hereby granted, free of charge, to any person obtaining a  *
+# * copy of this software and associated documentation files (the            *
+# * "Software"), to deal in the Software without restriction, including      *
+# * without limitation the rights to use, copy, modify, merge, publish,      *
+# * distribute, distribute with modifications, sublicense, and/or sell       *
+# * copies of the Software, and to permit persons to whom the Software is    *
+# * furnished to do so, subject to the following conditions:                 *
+# *                                                                          *
+# * The above copyright notice and this permission notice shall be included  *
+# * in all copies or substantial portions of the Software.                   *
+# *                                                                          *
+# * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+# * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+# * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+# * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+# * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+# * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+# * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+# *                                                                          *
+# * Except as contained in this notice, the name(s) of the above copyright   *
+# * holders shall not be used in advertising or otherwise to promote the     *
+# * sale, use or other dealings in this Software without prior written       *
+# * authorization.                                                           *
+# ****************************************************************************/
+
+
+
+require "ncurses"
+
+
+# A class responsible for raindrop drawing
+class Raindrop
+  def initialize (window, color_pair = nil)
+    @window = window
+    @color_pair = color_pair
+    lines   = []
+    columns = []
+    window.getmaxyx(lines,columns)
+    lines = (lines[0] <= 4) ? 1 : (lines[0] - 4)
+    columns = (columns[0] <= 4) ? 1 : (columns[0] - 4)
+    @current_phase = 0
+    @x = rand(columns)+2
+    @y = rand(lines)+2
+  end
+
+  # draw_next_phase draws the next phase of a raindrop. If this was the last
+  # phase, returns 0, otherwise returns the raindrop.
+  def draw_next_phase
+    if (@color_pair)
+      if Ncurses.respond_to?(:color_set)
+        @window.color_set(@color_pair, nil)
+      else
+        @window.attrset(Ncurses.COLOR_PAIR(@color_pair))
+      end
+    end
+    if (DRAWING_PROCS[@current_phase].call(@window,@y,@x))
+      @current_phase += 1
+      self
+    end
+  end
+
+  DRAWING_PROCS = [
+    Proc.new{|window,y,x|
+      window.mvaddstr(y,x, ".")
+    },
+    Proc.new{|window,y,x|
+      window.mvaddstr(y, x, "o")
+    },
+    Proc.new{|window,y,x|
+      window.mvaddstr(y, x, "O")
+    },
+    Proc.new{|window,y,x|
+      window.mvaddstr(y-1, x,    "-")
+      window.mvaddstr(y,   x-1, "|.|")
+      window.mvaddstr(y+1, x,    "-")
+    },
+    Proc.new{|window,y,x|
+      window.mvaddstr(y-2, x,     "-")
+      window.mvaddstr(y-1, x-1,  "/ \\")
+      window.mvaddstr(y,   x-2,  "| O |")
+      window.mvaddstr(y+1, x-1,  "\\ /")
+      window.mvaddstr(y+2, x,     "-")
+    },
+    Proc.new{|window,y,x|
+      window.mvaddstr(y-2, x,     " ")
+      window.mvaddstr(y-1, x-1,  "   ")
+      window.mvaddstr(y,   x-2, "     ")
+      window.mvaddstr(y+1, x-1,  "   ")
+      window.mvaddstr(y+2, x,     " ")
+      nil   # signal the last raindrop phase
+    }
+  ]
+  NUMBER_OF_PHASES = DRAWING_PROCS.size - 1
+end
+
+
+# This class creates raindrops and tells them to draw on the screen
+class Rain
+  AVERAGE_RAINDROP_SPACE = 475.1  # 4 simultaneous raindrops in a 80x24 Window
+
+  def Rain.sigwinch_handler(sig = nil)
+    ObjectSpace.each_object(Rain){|rain|
+      rain.window_size_changed = true
+    }
+  end
+
+  attr_writer :window_size_changed
+
+  def initialize(window)
+    @window = window
+    @window_size_changed = true
+    @raindrops = []
+    @has_colors = Ncurses.has_colors?
+    if (@has_colors)
+      @current_color = 1
+    end
+  end
+
+  def fall_for_a_moment
+    adjust_to_new_window_size if (@window_size_changed)
+
+    current_number_of_new_raindrops.times{
+      if (@has_colors)
+	@raindrops.push(Raindrop.new(@window, @current_color))
+	@current_color = 3 - @current_color  # alternate between 1 and 2
+      else
+	@raindrops.push(Raindrop.new(@window))
+      end
+    }
+
+    @raindrops = @raindrops.collect{|raindrop|
+      raindrop.draw_next_phase
+    }.compact # erase raindrops that have expired from the list
+  end
+
+  def adjust_to_new_window_size
+    @window_size_changed = false
+    window_size = @window.getmaxx * @window.getmaxy
+    average_number_of_raindrops = window_size / AVERAGE_RAINDROP_SPACE
+    @average_number_of_new_raindrops =
+      average_number_of_raindrops / Raindrop::NUMBER_OF_PHASES
+  end
+
+  def current_number_of_new_raindrops
+    num_floor = @average_number_of_new_raindrops.floor
+    num_ceil  = @average_number_of_new_raindrops.ceil
+    chance = @average_number_of_new_raindrops - num_floor
+    if (rand > chance)
+        num_floor
+    else
+      num_ceil
+    end
+  end
+    
+  def fall(pause = 0.1)
+    begin
+      fall_for_a_moment
+      @window.refresh
+      sleep(pause)
+    end while (true)
+  end
+end
+
+Ncurses.initscr
+begin
+  if (Ncurses.has_colors?)
+    bg = Ncurses::COLOR_BLACK
+    Ncurses.start_color
+    if (Ncurses.respond_to?("use_default_colors"))
+      if (Ncurses.use_default_colors == Ncurses::OK)
+        bg = -1
+      end
+    end
+    Ncurses.init_pair(1, Ncurses::COLOR_BLUE, bg);
+    Ncurses.init_pair(2, Ncurses::COLOR_CYAN, bg);
+  end
+  Ncurses.nl()
+  Ncurses.noecho()
+  Ncurses.curs_set(0)
+  Ncurses.stdscr.nodelay(true)
+  Ncurses.timeout(0)
+
+  rain = Rain.new(Ncurses.stdscr)
+
+  begin
+    case(Ncurses.getch())
+    when 'q'[0], 'Q'[0]
+      Ncurses.curs_set(1)
+      Ncurses.endwin()
+      exit
+    when 's'[0]
+      Ncurses.stdscr.nodelay(false)
+    when ' '[0]
+      Ncurses.stdscr.nodelay(true)
+    when Ncurses::KEY_RESIZE
+      Rain.sigwinch_handler
+    end
+    sleep(0.050)
+    rain.fall_for_a_moment
+    Ncurses.refresh
+  end while true
+ensure
+  Ncurses.curs_set(1)
+  Ncurses.endwin()
+end