snowleopard-ncurses 1.2.4

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,219 @@
+#!/usr/bin/env ruby
+
+# $Id: rain.rb,v 1.6 2005/08/22 21:41:49 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)
+
+  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

data/examples/read_line.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# Emacs: This is -*- ruby -*- code!
+# 
+# Unfinished read_line function
+#
+# Written 2003, 2004 by Tobias Peters
+# No warranties
+# Share and enjoy!
+
+require "ncurses"
+
+# read_line returns an array
+# [string, last_cursor_position_in_string, keycode_of_terminating_enter_key].
+# Complete the "when" clauses before including in your app!
+def read_line(y, x,
+              window     = Ncurses.stdscr,
+              max_len    = (window.getmaxx - x - 1),
+              string     = "",
+              cursor_pos = 0)
+  loop do
+    window.mvaddstr(y,x,string)
+    window.move(y,x+cursor_pos)
+    ch = window.getch
+    case ch
+    when Ncurses::KEY_LEFT
+      cursor_pos = [0, cursor_pos-1].max
+    when Ncurses::KEY_RIGHT
+      # similar, implement yourself !
+    when Ncurses::KEY_ENTER, ?\n, ?\r
+      return string, cursor_pos, ch # Which return key has been used?
+    when Ncurses::KEY_BACKSPACE
+      string = string[0...([0, cursor_pos-1].max)] + string[cursor_pos..-1]
+      cursor_pos = [0, cursor_pos-1].max
+      window.mvaddstr(y, x+string.length, " ")
+    # when etc...
+    when " "[0]..255 # remaining printables
+      if (cursor_pos < max_len)
+        string[cursor_pos,0] = ch.chr
+        cursor_pos += 1
+      else
+        Ncurses.beep
+      end
+    else
+      Ncurses.beep
+    end
+  end    	
+end    
+
+if (__FILE__ == $0) then begin
+  # demo mode
+  Ncurses.initscr
+  Ncurses.cbreak
+  Ncurses.noecho
+
+  # recognize KEY_ENTER, KEY_BACKSPACE  etc
+  Ncurses.keypad(Ncurses.stdscr, true)
+  
+  y = 10
+  x = 2
+  prompt = "Hallo > "
+  Ncurses.mvaddstr(y,x, prompt)
+  s = read_line(y, x + prompt.length)
+  
+ensure
+  Ncurses.endwin
+end end
+p s

data/examples/tclock.rb

@@ -0,0 +1,227 @@
+#!/usr/bin/env ruby
+
+# $Id: tclock.rb,v 1.6 2002/02/28 13:50:10 t-peters Exp $
+
+# tclock - analog/digital clock for curses, translated to ruby
+# Copyright (C) 2002 Tobias Peters <t-peters@users.berlios.de>
+# This file was adapted from the C program tclock.c from the ncurses
+# distribution, which bears the following copyright statement:
+
+#  tclock - analog/digital clock for curses.
+#  If it gives you joy, then
+#  (a) I'm glad
+#  (b) you need to get out more :-)
+#
+#  This program is copyright Howard Jones, September 1994
+#  (ha.jones@ic.ac.uk). It may be freely distributed as
+#  long as this copyright message remains intact, and any
+#  modifications are clearly marked as such. [In fact, if
+#  you modify it, I wouldn't mind the modifications back,
+#  especially if they add any nice features. A good one
+#  would be a precalc table for the 60 hand positions, so
+#  that the floating point stuff can be ditched. As I said,
+#  it was a 20 hackup minute job.]
+#
+#  COMING SOON: tfishtank. Be the envy of your mac-owning
+#  colleagues.
+
+###########################################################################
+# The translation of this program to ruby is a modification and is hereby #
+# clearly marked as such.                                                 #
+###########################################################################
+
+require "ncurses"
+PI = Math::PI
+
+def sign(_x)
+  (_x<0?-1:1)
+end
+
+ASPECT = 2.2
+
+def a2x(angle,radius)
+  (ASPECT * radius * Math::sin(angle)).round
+end
+def a2y(angle,radius)
+  (radius * Math::cos(angle)).round
+end
+
+# Plot a point
+def plot(x, y, c)
+  Ncurses.mvaddch(y, x, c[0])
+end
+
+# Draw a diagonal(arbitrary) line using Bresenham's alogrithm.
+def dline(pair, from_x, from_y, x2, y2, ch)
+  if (Ncurses.has_colors?)
+    Ncurses.attrset(Ncurses.COLOR_PAIR(pair))
+  end
+  
+  dx = x2 - from_x;
+  dy = y2 - from_y;
+  
+  ax = (dx * 2).abs
+  ay = (dy * 2).abs
+  
+  sx = sign(dx);
+  sy = sign(dy);
+  
+  x = from_x;
+  y = from_y;
+  
+  if (ax > ay) 
+    d = ay - (ax / 2);
+    
+    while (1)
+      plot(x, y, ch);
+      if (x == x2)
+	return nil
+      end
+      if (d >= 0) 
+	y += sy;
+	d -= ax;
+      end
+      x += sx;
+      d += ay;
+    end
+  else 
+    d = ax - (ay / 2);
+    
+    while (1) 
+      plot(x, y, ch);
+      if (y == y2)
+	return nil;
+      end
+      if (d >= 0) 
+	x += sx;
+	d -= ay;
+      end
+      y += sy;
+      d += ax;
+    end
+  end
+end
+
+begin
+  #    int i, cx, cy;
+  #    double mradius, hradius, mangle, hangle;
+  #    double sangle, sradius, hours;
+  #    int hdx, hdy;
+  #    int mdx, mdy;
+  #    int sdx, sdy;
+  #    int ch;
+    
+
+  lastbeep = -1;
+  my_bg = Ncurses::COLOR_BLACK;
+  
+  Ncurses::initscr();
+  Ncurses::noecho();
+  Ncurses::cbreak();
+  Ncurses::nodelay(Ncurses::stdscr, TRUE);
+  Ncurses::curs_set(0);
+  
+  if (Ncurses::has_colors?())
+    Ncurses::start_color();
+    
+    Ncurses::init_pair(1, Ncurses::COLOR_RED, my_bg);
+    Ncurses::init_pair(2, Ncurses::COLOR_MAGENTA, my_bg);
+    Ncurses::init_pair(3, Ncurses::COLOR_GREEN, my_bg);
+  end
+  Ncurses::keypad(Ncurses::stdscr, TRUE);
+
+  while (:restart)
+    cx = (Ncurses.COLS - 1) / 2;	#/* 39 */
+    cy = Ncurses.LINES / 2;		#/* 12 */
+    ch = (cx > cy) ? cy : cx;	#/* usually cy */
+    mradius = ((3 * cy) / 4).to_f;	#/* 9 */
+    hradius = (cy / 2).to_f;		#/* 6 */
+    sradius = ((2 * cy) / 3).to_f;	#/* 8 */
+
+    for i in (0...12)
+      sangle = (i + 1) * (2.0 * PI) / 12.0;
+      sradius = ((5 * cy) / 6).to_f;	#/* 10 */
+      sdx = a2x(sangle, sradius);
+      sdy = a2y(sangle, sradius);
+      szChar = sprintf("%d", i + 1);
+
+      Ncurses::mvaddstr(cy - sdy, cx + sdx, szChar);
+    end
+    
+    Ncurses::mvaddstr(0, 0,
+		      "ASCII Clock by Howard Jones (ha.jones@ic.ac.uk),1994");
+    
+    sradius -=2
+    sradius = 1 if sradius < 1
+    window_size_changed = false
+    while (window_size_changed == false)
+      sleep(0.100);
+      
+      hours = Time.now.hour + Time.now.min / 60.0;
+      if (hours > 12.0)
+	hours -= 12.0;
+      end
+      
+      mangle = Time.now.min * (2 * PI) / 60.0;
+      mdx = a2x(mangle, mradius);
+      mdy = a2y(mangle, mradius);
+      
+      hangle = ((hours) * (2.0 * PI) / 12.0);
+      hdx = a2x(hangle, hradius);
+      hdy = a2y(hangle, hradius);
+      
+      sangle = ((Time.now.sec) * (2.0 * PI) / 60.0);
+      sdx = a2x(sangle, sradius);
+      sdy = a2y(sangle, sradius);
+      
+      dline(3, cx, cy, cx + mdx, cy - mdy, '#');
+      
+      Ncurses::attrset(Ncurses::A_REVERSE);
+      dline(2, cx, cy, cx + hdx, cy - hdy, '.');
+      Ncurses::attroff(Ncurses::A_REVERSE);
+      
+      if (Ncurses::has_colors?())
+	Ncurses::attrset(Ncurses::COLOR_PAIR(1));
+      end
+      plot(cx + sdx, cy - sdy, 'O');
+      
+      if (Ncurses::has_colors?())
+	Ncurses::attrset(Ncurses::COLOR_PAIR(0));
+      end
+      Ncurses::mvaddstr(Ncurses.LINES - 2, 0, Time.now.to_s);
+      Ncurses::refresh();
+      if ((Time.now.sec % 5) == 0 &&
+	  Time.now.sec != lastbeep) 
+	lastbeep = Time.now.sec;
+	Ncurses::beep();
+      end
+      
+      if ((ch = Ncurses::getch()) != Ncurses::ERR)
+	if (ch == Ncurses::KEY_RESIZE) 
+	  Ncurses::erase();
+	  window_size_changed = true;
+	else
+	  break;
+	end
+      end
+      
+      plot(cx + sdx, cy - sdy, ' ');
+      dline(0, cx, cy, cx + hdx, cy - hdy, ' ');
+      dline(0, cx, cy, cx + mdx, cy - mdy, ' ');
+      
+    end
+    
+    if ! window_size_changed
+      $stderr.puts "! window_size_changed"
+      break
+    end
+  end
+ensure
+  Ncurses::curs_set(1);
+  Ncurses::endwin();
+end
+  
+
+
+
+