solutious-stella 0.5.5

data/lib/utils/mathutil.rb

@@ -0,0 +1,15 @@
+
+
+module MathUtil
+  
+  # enforce_limit
+  #
+  # Enforce a minimum and maximum value 
+  def self.enforce_limit(val,min,max)
+    val = min  if val < min
+    val = max  if val > max
+    val
+  end
+  
+end
+

data/lib/utils/stats.rb

@@ -0,0 +1,88 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+# A very simple little class for doing some basic fast statistics sampling.
+# You feed it either samples of numeric data you want measured or you call
+# Stats.tick to get it to add a time delta between the last time you called it.
+# When you're done either call sum, sumsq, n, min, max, mean or sd to get 
+# the information.  The other option is to just call dump and see everything.
+#
+# It does all of this very fast and doesn't take up any memory since the samples
+# are not stored but instead all the values are calculated on the fly.
+
+class Stats
+  attr_reader :sum, :sumsq, :n, :min, :max
+
+  def initialize(name=:unknown)
+    @name = name
+    reset
+  end
+
+  # Resets the internal counters so you can start sampling again.
+  def reset
+    @sum = 0.0
+    @sumsq = 0.0
+    @last_time = Time.new
+    @n = 0.0
+    @min = 0.0
+    @max = 0.0
+  end
+
+  # Adds a sampling to the calculations.
+  def sample(s)
+    @sum += s
+    @sumsq += s * s
+    if @n == 0
+      @min = @max = s
+    else
+      @min = s if @min > s
+      @max = s if @max < s
+    end
+    (@n+=1).to_f
+  end
+
+  # Dump this Stats object with an optional additional message.
+  def dump(msg = "", out=STDERR)
+    out.puts "#{msg}: #{self.to_s}"
+  end
+
+  # Returns a common display (used by dump)
+  def to_s  
+  "[#{@name}]: SUM=%0.4f, SUMSQ=%0.4f, N=%0.4f, MEAN=%0.4f, SD=%0.4f, MIN=%0.4f, MAX=%0.4f" % [@sum, @sumsq, @n, mean, sd, @min, @max]
+  end
+
+
+  # Calculates and returns the mean for the data passed so far.
+  def mean
+    @sum / @n
+  end
+
+  # Calculates the standard deviation of the data so far.
+  def sd
+    # (sqrt( ((s).sumsq - ( (s).sum * (s).sum / (s).n)) / ((s).n-1) ))
+    begin
+      return Math.sqrt( (@sumsq - ( @sum * @sum / @n)) / (@n-1) ).to_f
+    rescue Errno::EDOM
+      return 0.0
+    end
+  end
+
+
+  # Adds a time delta between now and the last time you called this.  This
+  # will give you the average time between two activities.
+  # 
+  # An example is:
+  #
+  #  t = Stats.new("do_stuff")
+  #  10000.times { do_stuff(); t.tick }
+  #  t.dump("time")
+  #
+  def tick
+    now = Time.now
+    sample(now - @last_time)
+    @last_time = now
+  end
+end

data/lib/utils/textgraph.rb

@@ -0,0 +1,267 @@
+# A port of Text::Graph, which generates pretty ascii bar graphs from
+# numeric datasets, like
+# 
+#     aaaa :       (1)
+#       bb :..*    (22)
+#      ccc :...*   (43)
+#   dddddd :.....* (500)
+#       ee :......*(1000)
+#        f :.....* (300)
+#      ghi :...*   (50)
+# 
+# It accepts data in the following forms (see the 'extract' method):
+# 
+# # { label => value, label => value, ... }
+# # { :values => { label => value, ...} }
+# # { :values => [values] }
+# # {:values => { label => value, label => value }, :labels => [...]}
+# # {:values => [values], :labels => [labels]}
+# # [ [label, value], [label, value], ...]
+# # [[values], [labels]]
+# 
+# Numeric parameters:
+# :minval
+# :maxval
+# :maxlen
+# 
+# Boolean parameters:
+# :log   # logarithmic scale
+# :right # label justification
+# 
+# Display parameters:
+# :marker
+# :fill
+# :separator
+# :style # {:bar|:line} - sets default values for marker and fill
+# :showval # numeric value after bar
+
+# Text::Graph
+# Port of Wade Johnson's Text::Graph for perl
+#   http://search.cpan.org/src/GWADEJ/Text-Graph-0.23/Graph.pm
+#  
+# Author: Martin DeMello <martindeme...@gmail.com>
+
+module Enumerable
+  def minmax
+    min = 1.0/0
+    max = -1.0/0
+    each {|i|
+      min = i if i < min
+      max = i if i > max
+    }
+    [min, max]
+  end
+
+  def map_with_index
+    a = []
+    each_with_index {|e, i| a << yield(e,i)}
+    a
+  end
+end
+
+class TextGraph
+  include Math
+
+  def initialize(data, params = {})
+    @data = extract(data)
+    @params = {:style => (params[:style] || :bar)}
+    apply_style(@params[:style])
+    @params.update(params)
+    @params[:separator] ||= " :"
+  end
+
+  def update_params(par)
+    apply_style(par[:style]) if par[:style]
+    @params.update(par)
+  end
+
+  def apply_style(style)
+    if style == :bar
+      @params[:marker] = "*"
+      @params[:fill] = "*"
+    elsif style == :line
+      @params[:marker] = '*'
+      @params[:fill] = ' '
+    else
+      raise "Invalid style #{style}"
+    end
+  end
+
+  def extract(data)
+    if data.is_a? Array
+      if data.length == 2 and data[0].is_a? Array and data[1].is_a? Array
+  # [[values], [labels]]
+  a = {}
+  a[:values] = data[0]
+  a[:labels] = data[1]
+  data = a
+      else
+  # [ [label, value], [label, value], ...]
+  a = {:values => [], :labels => []}
+  data.each {|i,j| a[:labels] << i; a[:values] << j}
+      end
+    end
+
+    if (data.length == 2) and data[:values] and data[:labels]
+      if data[:values].is_a? Array
+  # {:values => [values], :labels => [labels]}
+  # do nothing
+      elsif data[:values].is_a? Hash
+  # {:values => { label => value, label => value }, :labels => [...]}
+  a = data[:labels].map {|i| data[:values][i]}
+  data[:values] = a
+      else
+  raise "Invalid valueset"
+      end
+    elsif (data.length == 1) and data[:values]
+      if data[:values].is_a? Array
+  # { :values => [values] }
+  data[:labels] = data[:values].map {""}
+      elsif data[:values].is_a? Hash
+  # { :values => { label => value, ...} }
+  data[:labels] = data[:values].keys.sort_by {|i| i.to_s}
+  data[:values] = data[:labels].map {|i| data[:values][i]}
+      else
+  raise "Invalid valueset"
+      end
+    else
+      # { label => value, label => value, ... }
+      a = {}
+      a[:labels] = data.keys.sort_by {|i| i.to_s}
+      a[:values] = a[:labels].map {|i| data[i]}
+      data = a
+    end
+    data[:labels].map! {|i| i.to_s}
+    data
+  end
+
+  def make_within(val, min, max)
+    (val < min) ? min : (val > max ? max : val)
+  end
+
+  def makebar(val, m, f)
+    val = (val + 0.5).to_i
+    (val > 0) ? (f*(val - 1) + m) : ""
+  end
+
+  def fmt_labels (right, labels)
+    len = labels.map {|i| i.length}.max
+    just = right ? :rjust : :ljust
+    labels.map {|i| i.send(just, len)}
+  end
+
+  def make_labelled_lines(data)
+    labels = fmt_labels(@params[:right], data[:labels])
+    lines  = histogram(data)
+    lines.zip(labels).map {|line, label| label + @params[:separator] + line}
+  end
+
+  def histogram(data)
+    values = data[:values].dup
+    minval, maxval, maxlen =
+      @params[:minval], @params[:maxval], @params[:maxlen]
+
+    if @params[:log]
+      values.map! {|i| log(i)}
+      minval = log(minval) rescue 1 if minval
+      maxval = log(maxval) rescue 1 if maxval
+    end
+
+    min, max = values.minmax
+    minval ||= min
+    maxval ||= max
+    maxl = maxval - minval + 1
+    maxlen ||= maxl
+    scale = maxlen*1.0/maxl
+    values = values.map {|i|
+      j = make_within(i, minval, maxval) - minval
+      makebar(j*scale, @params[:marker], @params[:fill])
+    }
+
+    if(@params[:showval])
+      values = values.map_with_index {|v, i|
+  v.ljust(maxlen) + "(#{data[:values][i]})"
+      }
+    end
+
+    values
+  end
+
+  def to_s
+    make_labelled_lines(@data).join("\n") + "\n"
+  end
+end
+
+if __FILE__ == $0
+
+  a = TextGraph.new({
+    :values => [100,142,43,54,111,62,52],
+    :labels => %w(aaaa bb ccc dddddd ee f ghi)
+  })
+
+  puts a
+
+  #  aaaa   :
+  #  bb     :*
+  #  ccc    :***
+  #  dddddd :****
+  #  ee     :*********
+  #  f      :**
+  #  ghi    :****
+
+  puts "-------------------------------------------------------------"
+
+  a.update_params(:style => :line, :right => true, :showval => true)
+  puts a
+
+  #    aaaa :          (1)
+  #      bb :*         (2)
+  #     ccc :  *       (4)
+  #  dddddd :   *      (5)
+  #      ee :        * (10)
+  #       f : *        (3)
+  #     ghi :   *      (5)
+
+  puts "-------------------------------------------------------------"
+
+  b = TextGraph.new({ :a=>1, :b=>5, :c=>20, :d=>10, :e=>17 }, {:maxlen => 10})
+  puts b
+
+  #  a :
+  #  b :**
+  #  c :**********
+  #  d :*****
+  #  e :********
+
+  puts "-------------------------------------------------------------"
+
+  c = TextGraph.new({:values => { :a=>1, :b=>5, :c=>20, :d=>10, :e=>17 },
+        :labels => [:a, :c, :d]},
+        {:minval => 0, :maxval => 15, :showval => true})
+  puts c
+
+  #  a :*               (1)
+  #  c :*************** (20)
+  #  d :**********      (10)
+
+  puts "-------------------------------------------------------------"
+
+  d = TextGraph.new([[10,22,43,500,1000,300,50], %w(aaaa bb ccc dddddd ee f ghi)],
+        { :style => :line,
+          :right => true,     # right-justify labels
+          :fill => '.',       # change fill-marker
+          :log => false,       # logarithmic graph
+          :showval => true    # show actual values
+  }
+       )
+       puts d
+
+       #    aaaa :       (1)
+       #      bb :..*    (22)
+       #     ccc :...*   (43)
+       #  dddddd :.....* (500)
+       #      ee :......*(1000)
+       #       f :.....* (300)
+       #     ghi :...*   (50)
+
+end

data/lib/utils/timerutil.rb

@@ -0,0 +1,58 @@
+
+require 'benchmark'
+
+class TimerUtil
+  
+  attr_reader :tstart, :tend, :rstart, :rend
+  attr_reader :time
+  
+  def initialize(label="default")
+    @tstart, @rstart = 0,0
+    @tend, @rend = 0,0
+    @label = label
+    @time = Benchmark::Tms.new
+  end
+  
+  def start
+    @tstart, @rstart = Benchmark.times, Time.now
+  end
+  
+  def stop
+    @tend, @rend = Benchmark.times, Time.now
+    
+    @time = Benchmark::Tms.new(@tend.utime  - @tstart.utime,
+                               @tend.stime  - @tstart.stime,
+                               @tend.cutime - @tstart.cutime,
+                               @tend.cstime - @tstart.cstime,
+                               @rend.to_f - @rstart.to_f,
+                               @label)
+  end
+  
+  def utime
+    @time.utime
+  end
+  def stime
+    @time.stime
+  end
+  def cutime
+    @time.cutime
+  end
+  def cstime
+    @time.cstime
+  end
+  def total
+    @time.total
+  end
+  def real
+    @time.real
+  end
+  def format(formatstr=nil)
+    @time.format(formatstr)
+  end
+  def label
+    @time.label
+  end
+  
+end 
+  
+  

data/lib/win32/Console.rb

@@ -0,0 +1,970 @@
+# Win32::Console:  an object implementing the Win32 API Console functions
+# Copyright (C) 2003 Gonzalo Garramuno (ggarramuno@aol.com)
+#
+# Original Win32API_Console was:
+# Copyright (C) 2001 Michael L. Semon (mlsemon@sega.net)
+
+begin
+  # If Console.so is available, use that.  Otherwise, we define
+  # equivalent functions in ruby (a tad slower)
+  # That dll should define everything in an identical interface
+  # to all the ruby code that the rescue below defines.
+  require "Console.so"
+  STDERR.print "Using faster, DLL Console.so\n" if $DEBUG
+
+rescue Exception
+
+  STDERR.print "Using slower, non-DLL Console.rb\n" if $DEBUG
+
+  module Win32
+    class Console
+    end
+  end
+
+  # The WINDOWS constants
+  module Win32::Console::Constants
+    STD_INPUT_HANDLE          = 0xFFFFFFF6
+    STD_OUTPUT_HANDLE         = 0xFFFFFFF5
+    STD_ERROR_HANDLE          = 0xFFFFFFF4
+    INVALID_HANDLE_VALUE      = 0xFFFFFFFF
+    GENERIC_READ              = 0x80000000
+    GENERIC_WRITE             = 0x40000000
+    FILE_SHARE_READ           = 0x00000001
+    FILE_SHARE_WRITE          = 0x00000002
+    CONSOLE_TEXTMODE_BUFFER   = 0x00000001
+
+    FOREGROUND_BLUE           = 0x0001
+    FOREGROUND_GREEN          = 0x0002
+    FOREGROUND_RED            = 0x0004
+    FOREGROUND_INTENSITY      = 0x0008
+    BACKGROUND_BLUE           = 0x0010
+    BACKGROUND_GREEN          = 0x0020
+    BACKGROUND_RED            = 0x0040
+    BACKGROUND_INTENSITY      = 0x0080
+
+    ENABLE_PROCESSED_INPUT    = 0x0001
+    ENABLE_LINE_INPUT         = 0x0002
+    ENABLE_ECHO_INPUT         = 0x0004
+    ENABLE_WINDOW_INPUT       = 0x0008
+    ENABLE_MOUSE_INPUT        = 0x0010
+    ENABLE_PROCESSED_OUTPUT   = 0x0001
+    ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
+
+    KEY_EVENT                 = 0x0001
+    MOUSE_EVENT               = 0x0002
+    WINDOW_BUFFER_SIZE_EVENT  = 0x0004
+    MENU_EVENT                = 0x0008
+    FOCUS_EVENT               = 0x0010
+
+    CAPSLOCK_ON               = 0x0080
+    ENHANCED_KEY              = 0x0100
+    NUMLOCK_ON                = 0x0020
+    SHIFT_PRESSED             = 0x0010
+    LEFT_CTRL_PRESSED         = 0x0008
+    RIGHT_CTRL_PRESSED        = 0x0004
+    LEFT_ALT_PRESSED          = 0x0002
+    RIGHT_ALT_PRESSED         = 0x0001
+    SCROLLLOCK_ON             = 0x0040
+
+    MOUSE_WHEELED             = 0x0004
+    DOUBLE_CLICK              = 0x0002
+    MOUSE_MOVED               = 0x0001
+
+    FROM_LEFT_1ST_BUTTON_PRESSED    = 0x0001
+    FROM_LEFT_2ND_BUTTON_PRESSED    = 0x0004
+    FROM_LEFT_3RD_BUTTON_PRESSED    = 0x0008
+    FROM_LEFT_4TH_BUTTON_PRESSED    = 0x0010
+    RIGHTMOST_BUTTON_PRESSED        = 0x0002
+
+    CTRL_C_EVENT              = 0x0000
+    CTRL_BREAK_EVENT          = 0x0001
+    CTRL_CLOSE_EVENT          = 0x0002
+    CTRL_LOGOFF_EVENT         = 0x0005
+    CTRL_SHUTDOWN_EVENT       = 0x0006
+  end
+
+  # The actual api to access windows functions
+  class Win32::Console::API
+    require 'Win32API'
+
+    private
+    # This is a class-wide cache that will hold Win32API objects.  As each 
+    # Win32API object is about 920 bytes, I didn't want to initialize all of 
+    # them at one time.  That would waste about 42 kB for this object because 
+    # it has 47 functions.  However, to not have a cache at all would reduce 
+    # the speed of this object by 164%.
+    @@m_AllocConsole = nil
+    @@m_CreateConsoleScreenBuffer = nil
+    @@m_FillConsoleOutputAttribute = nil
+    @@m_FillConsoleOutputCharacter = nil
+    @@m_FlushConsoleInputBuffer = nil
+    @@m_FreeConsole = nil
+    @@m_GenerateConsoleCtrlEvent = nil
+    @@m_GetConsoleCP = nil
+    @@m_GetConsoleCursorInfo = nil
+    @@m_GetConsoleMode = nil
+    @@m_GetConsoleOutputCP = nil
+    @@m_GetConsoleScreenBufferInfo = nil
+    @@m_GetConsoleTitle = nil
+    @@m_GetConsoleWindow = nil
+    @@m_GetLargestConsoleWindowSize = nil
+    @@m_GetNumberOfConsoleInputEvents = nil
+    @@m_GetNumberOfConsoleMouseButtons = nil
+    @@m_GetStdHandle = nil
+    @@m_PeekConsoleInput = nil
+    @@m_ReadConsole = nil
+    @@m_ReadConsoleInput = nil
+    @@m_ReadConsoleOutput = nil
+    @@m_ReadConsoleOutputAttribute = nil
+    @@m_ReadConsoleOutputCharacter = nil
+    @@m_ScrollConsoleScreenBuffer = nil
+    @@m_SetConsoleActiveScreenBuffer = nil
+    @@m_SetConsoleCP = nil
+    @@m_SetConsoleCursorInfo = nil
+    @@m_SetConsoleCursorPosition = nil
+    @@m_SetConsoleMode = nil
+    @@m_SetConsoleOutputCP = nil
+    @@m_SetConsoleScreenBufferSize = nil
+    @@m_SetConsoleTextAttribute = nil
+    @@m_SetConsoleTitle = nil
+    @@m_SetConsoleWindowInfo = nil
+    @@m_SetStdHandle = nil
+    @@m_WriteConsole = nil
+    @@m_WriteConsoleInput = nil
+    @@m_WriteConsoleOutput = nil
+    @@m_WriteConsoleOutputAttribute = nil
+    @@m_WriteConsoleOutputCharacter = nil
+
+    public
+
+    class << self
+
+    
+      def constant(t)
+	begin
+	  eval "return Win32::Console::Constants::#{t}"
+	rescue
+	  return nil
+	end
+      end
+
+
+     def AllocConsole()
+       if @@m_AllocConsole == nil
+	  @@m_AllocConsole = Win32API.new( "kernel32", "AllocConsole", 
+					  [], 'l' )
+       end
+       @@m_AllocConsole.call()
+     end
+
+      def CreateConsoleScreenBuffer( dwDesiredAccess, dwShareMode, dwFlags )
+        if @@m_CreateConsoleScreenBuffer == nil
+	  @@m_CreateConsoleScreenBuffer = Win32API.new( "kernel32", "CreateConsoleScreenBuffer", ['l', 'l', 'p', 'l', 'p'], 'l' )
+        end
+        @@m_CreateConsoleScreenBuffer.call( dwDesiredAccess, dwShareMode, 
+					    nil, dwFlags, nil )
+      end
+
+
+
+     def FillConsoleOutputAttribute( hConsoleOutput, wAttribute, nLength, 
+				      col, row )
+       if @@m_FillConsoleOutputAttribute == nil
+	  @@m_FillConsoleOutputAttribute = Win32API.new( "kernel32", "FillConsoleOutputAttribute", ['l', 'i', 'l', 'l', 'p'], 'l' )
+       end
+	dwWriteCoord = (row << 16) + col
+	lpNumberOfAttrsWritten = ' ' * 4
+       @@m_FillConsoleOutputAttribute.call( hConsoleOutput, wAttribute, 
+					    nLength, dwWriteCoord, 
+					    lpNumberOfAttrsWritten )
+	return lpNumberOfAttrsWritten.unpack('L')
+     end
+
+
+
+     def FillConsoleOutputCharacter( hConsoleOutput, cCharacter, nLength, 
+				      col, row )
+       if @@m_FillConsoleOutputCharacter == nil
+	  @@m_FillConsoleOutputCharacter = Win32API.new( "kernel32", "FillConsoleOutputCharacter", ['l', 'i', 'l', 'l', 'p'], 'l' )
+       end
+	dwWriteCoord = (row << 16) + col
+	lpNumberOfAttrsWritten = ' ' * 4
+       @@m_FillConsoleOutputCharacter.call( hConsoleOutput, cCharacter, 
+					    nLength, dwWriteCoord, 
+					    lpNumberOfAttrsWritten )
+	return lpNumberOfAttrsWritten.unpack('L')
+     end
+
+
+      def FlushConsoleInputBuffer( hConsoleInput )
+        if @@m_FlushConsoleInputBuffer == nil
+	  @@m_FlushConsoleInputBuffer = Win32API.new( "kernel32", 
+						     "FillConsoleInputBuffer",
+						     ['l'], 'l' )
+        end
+        @@m_FlushConsoleInputBuffer.call( hConsoleInput )
+      end
+
+
+      def FreeConsole()
+        if @@m_FreeConsole == nil
+	  @@m_FreeConsole = Win32API.new( "kernel32", "FreeConsole", [], 'l' )
+        end
+        @@m_FreeConsole.call()
+      end
+
+
+      def GenerateConsoleCtrlEvent( dwCtrlEvent, dwProcessGroupId )
+        if @@m_GenerateConsoleCtrlEvent == nil
+	  @@m_GenerateConsoleCtrlEvent = Win32API.new( "kernel32", "GenerateConsoleCtrlEvent", ['l', 'l'], 'l' )
+        end
+        @@m_GenerateConsoleCtrlEvent.call( dwCtrlEvent, dwProcessGroupId )
+      end
+
+     def GetConsoleCP()
+       if @@m_GetConsoleCP == nil
+	  @@m_GetConsoleCP = Win32API.new( "kernel32", "GetConsoleCP", 
+					  [], 'l' )
+       end
+       @@m_GetConsoleCP.call()
+     end
+
+     def GetConsoleCursorInfo( hConsoleOutput )
+       if @@m_GetConsoleCursorInfo == nil
+	  @@m_GetConsoleCursorInfo = Win32API.new( "kernel32", 
+						  "GetConsoleCursorInfo", 
+						  ['l', 'p'], 'l' )
+       end
+	lpConsoleCursorInfo = ' ' * 8
+       @@m_GetConsoleCursorInfo.call( hConsoleOutput, lpConsoleCursorInfo )
+	return lpConsoleCursorInfo.unpack('LL')
+     end
+
+      def GetConsoleMode( hConsoleHandle )
+        if @@m_GetConsoleMode == nil
+	  @@m_GetConsoleMode = Win32API.new( "kernel32", "GetConsoleMode", 
+					    ['l', 'p'], 'l' )
+        end
+	lpMode = ' ' * 4
+        @@m_GetConsoleMode.call( hConsoleHandle, lpMode )
+	return lpMode.unpack('L')
+      end
+
+     def GetConsoleOutputCP()
+       if @@m_GetConsoleOutputCP == nil
+	  @@m_GetConsoleOutputCP = Win32API.new( "kernel32", 
+						"GetConsoleOutputCP", [], 'l' )
+       end
+       @@m_GetConsoleOutputCP.call()
+     end
+
+     def GetConsoleScreenBufferInfo( hConsoleOutput )
+       if @@m_GetConsoleScreenBufferInfo == nil
+	  @@m_GetConsoleScreenBufferInfo = Win32API.new( "kernel32", "GetConsoleScreenBufferInfo", ['l', 'p'], 'l' )
+       end
+	lpBuffer = ' ' * 22
+       @@m_GetConsoleScreenBufferInfo.call( hConsoleOutput, lpBuffer )
+	return lpBuffer.unpack('SSSSSssssSS')
+     end
+
+     def GetConsoleTitle()
+        if @@m_GetConsoleTitle == nil
+	  @@m_GetConsoleTitle = Win32API.new( "kernel32", "GetConsoleTitle", 
+					     ['p', 'l'], 'l' )
+        end
+	nSize = 120
+	lpConsoleTitle = ' ' * nSize
+        @@m_GetConsoleTitle.call( lpConsoleTitle, nSize )
+	return lpConsoleTitle.strip
+      end
+
+     def GetConsoleWindow()
+       if @@m_GetConsoleWindow == nil
+	  @@m_GetConsoleWindow = Win32API.new( "kernel32", "GetConsoleWindow",
+					      [], 'l' )
+       end
+       @@m_GetConsoleWindow.call()
+     end
+
+      def GetLargestConsoleWindowSize( hConsoleOutput )
+        if @@m_GetLargestConsoleWindowSize == nil
+	  @@m_GetLargestConsoleWindowSize = Win32API.new( "kernel32", "GetLargestConsoleWindowSize", ['l'], 'l' )
+        end
+        coord = @@m_GetLargestConsoleWindowSize.call( hConsoleOutput )
+	x = coord >> 16
+	y = coord & 0x0000ffff
+	return [x,y]
+      end
+
+      def GetNumberOfConsoleInputEvents( hConsoleInput )
+        if @@m_GetNumberOfConsoleInputEvents == nil
+	  @@m_GetNumberOfConsoleInputEvents = Win32API.new( "kernel32", "GetNumberOfConsoleInputEvents", ['l', 'p'], 'l' )
+        end
+	lpcNumberOfEvents = 0
+        @@m_GetNumberOfConsoleInputEvents.call( hConsoleInput, 
+					       lpcNumberOfEvents )
+	return lpcNumberOfEvents
+      end
+
+      def GetNumberOfConsoleMouseButtons( )
+        if @@m_GetNumberOfConsoleMouseButtons == nil
+	  @@m_GetNumberOfConsoleMouseButtons = Win32API.new( "kernel32", "GetNumberOfConsoleMouseButtons", ['p'], 'l' )
+        end
+	lpNumberOfMouseButtons = 0
+        @@m_GetNumberOfConsoleMouseButtons.call( lpNumberOfMouseButtons )
+	return lpNumberOfMouseButtons
+      end
+
+     def GetStdHandle( nStdHandle )
+       if @@m_GetStdHandle == nil
+	  @@m_GetStdHandle = Win32API.new( "kernel32", "GetStdHandle", 
+					  ['l'], 'l' )
+       end
+       @@m_GetStdHandle.call( nStdHandle )
+     end
+
+      # <<HandlerRoutine>> : This is not an actual API function, just a concept description in the SDK.
+
+      def PeekConsoleInput( hConsoleInput )
+        if @@m_PeekConsoleInput == nil
+	  @@m_PeekConsoleInput = Win32API.new( "kernel32", "PeekConsoleInput",
+					      ['l', 'p', 'l', 'p'], 'l' )
+        end
+	lpNumberOfEventsRead = ' ' * 4
+	lpBuffer = ' ' * 20
+	nLength  = 20
+        @@m_PeekConsoleInput.call( hConsoleInput, lpBuffer, nLength, 
+				   lpNumberOfEventsRead )
+	type = lpBuffer.unpack('s')[0]
+
+	case type
+	when KEY_EVENT
+	  return lpBuffer.unpack('sSSSSCS') 
+	when MOUSE_EVENT
+	  return lpBuffer.unpack('sSSSS')
+	when WINDOW_BUFFER_SIZE_EVENT
+	  return lpBuffer.unpack('sS') 
+	when MENU_EVENT
+	  return lpBuffer.unpack('sS') 
+	when FOCUS_EVENT
+	  return lpBuffer.unpack('sS')
+	else
+	  return []
+	end
+      end
+
+      def ReadConsole( hConsoleInput, lpBuffer, nNumberOfCharsToRead )
+        if @@m_ReadConsole == nil
+	  @@m_ReadConsole = Win32API.new( "kernel32", "ReadConsole", 
+					 ['l', 'p', 'l', 'p', 'p'], 'l' )
+        end
+	lpBuffer = ' ' * nNumberOfCharsToRead unless lpBuffer
+	lpNumberOfCharsRead = ' ' * 4
+	lpReserved = ' ' * 4
+        @@m_ReadConsole.call( hConsoleInput, lpBuffer, nNumberOfCharsToRead, 
+			     lpNumberOfCharsRead, lpReserved )
+	return lpNumberOfCharsRead.unpack('L')
+      end
+
+      def ReadConsoleInput( hConsoleInput )
+        if @@m_ReadConsoleInput == nil
+	  @@m_ReadConsoleInput = Win32API.new( "kernel32", "ReadConsoleInput",
+					      ['l', 'p', 'l', 'p'], 'l' )
+        end
+	lpNumberOfEventsRead = ' ' * 4
+	lpBuffer = ' ' * 20
+	nLength  = 20
+        @@m_ReadConsoleInput.call( hConsoleInput, lpBuffer, nLength, 
+				  lpNumberOfEventsRead )
+	type = lpBuffer.unpack('s')[0] 
+
+	case type
+	when KEY_EVENT
+	  return lpBuffer.unpack('sSSSSCS') 
+	when MOUSE_EVENT
+	  return lpBuffer.unpack('sSSSS')
+	when WINDOW_BUFFER_SIZE_EVENT
+	  return lpBuffer.unpack('sS') 
+	when MENU_EVENT
+	  return lpBuffer.unpack('sS') 
+	when FOCUS_EVENT
+	  return lpBuffer.unpack('sS')
+	else
+	  return []
+	end
+      end
+
+      def ReadConsoleOutput( hConsoleOutput, lpBuffer, cols, rows,
+			    bufx, bufy, left, top, right, bottom )
+        if @@m_ReadConsoleOutput == nil
+	  @@m_ReadConsoleOutput = Win32API.new( "kernel32", 
+					       "ReadConsoleOutput", 
+					       ['l', 'p', 'l', 'l', 'p'], 'l' )
+        end
+	dwBufferSize  = cols * rows * 4
+	lpBuffer = ' ' * dwBufferSize
+	dwBufferCoord = (bufy << 16) + bufx
+	lpReadRegion  = [ left, top, right, bottom ].pack('ssss')
+        @@m_ReadConsoleOutput.call( hConsoleOutput, lpBuffer, dwBufferSize, 
+				   dwBufferCoord, lpReadRegion )
+      end
+
+      def ReadConsoleOutputAttribute( hConsoleOutput, nLength, col, row )
+        if @@m_ReadConsoleOutputAttribute == nil
+	  @@m_ReadConsoleOutputAttribute = Win32API.new( "kernel32", "ReadConsoleOutputAttribute", ['l', 'p', 'l', 'l', 'p'], 'l' )
+        end
+	lpAttribute = ' ' * nLength
+	dwReadCoord = (row << 16) + col
+	lpNumberOfAttrsRead = ' ' * 4
+        @@m_ReadConsoleOutputAttribute.call( hConsoleOutput, lpAttribute, 
+					    nLength, dwReadCoord, 
+					    lpNumberOfAttrsRead )
+	return lpAttribute
+      end
+
+      def ReadConsoleOutputCharacter( hConsoleOutput, lpCharacter, nLength, 
+				      col, row )
+        if @@m_ReadConsoleOutputCharacter == nil
+	  @@m_ReadConsoleOutputCharacter = Win32API.new( "kernel32", "ReadConsoleOutputCharacter", ['l', 'p', 'l', 'l', 'p'], 'l' )
+        end
+	dwReadCoord = (row << 16) + col
+	lpNumberOfCharsRead = ' ' * 4
+        @@m_ReadConsoleOutputCharacter.call( hConsoleOutput, lpCharacter, 
+					    nLength, dwReadCoord, 
+					    lpNumberOfCharsRead )
+	return lpNumberOfCharsRead.unpack('L')
+      end
+
+     def ScrollConsoleScreenBuffer( hConsoleOutput, 
+				    left1, top1, right1, bottom1,
+				    col, row, char, attr,
+				    left2, top2, right2, bottom2 )
+       if @@m_ScrollConsoleScreenBuffer == nil
+	  @@m_ScrollConsoleScreenBuffer = Win32API.new( "kernel32", "ScrollConsoleScreenBuffer", ['l', 'p', 'p', 'l', 'p'], 'l' )
+       end
+	lpScrollRectangle = [left1, top1, right1, bottom1].pack('ssss')
+	lpClipRectangle   = [left2, top2, right2, bottom2].pack('ssss')
+	dwDestinationOrigin = (row << 16) + col
+	lpFill = [char, attr].pack('ss')
+       @@m_ScrollConsoleScreenBuffer.call( hConsoleOutput, lpScrollRectangle,
+					   lpClipRectangle, 
+					   dwDestinationOrigin, lpFill )
+     end
+
+     def SetConsoleActiveScreenBuffer( hConsoleOutput )
+       if @@m_SetConsoleActiveScreenBuffer == nil
+	  @@m_SetConsoleActiveScreenBuffer = Win32API.new( "kernel32", "SetConsoleActiveScreenBuffer", ['l'], 'l' )
+       end
+       @@m_SetConsoleActiveScreenBuffer.call( hConsoleOutput )
+     end
+
+      # <<SetConsoleCtrlHandler>>:  Will probably not be implemented.
+
+     def SetConsoleCP( wCodePageID )
+       if @@m_SetConsoleCP == nil
+	  @@m_SetConsoleCP = Win32API.new( "kernel32", "SetConsoleCP", 
+					  ['l'], 'l' )
+       end
+       @@m_SetConsoleCP.call( wCodePageID )
+     end
+
+     def SetConsoleCursorInfo( hConsoleOutput, col, row )
+       if @@m_SetConsoleCursorInfo == nil
+	  @@m_SetConsoleCursorInfo = Win32API.new( "kernel32", 
+						  "SetConsoleCursorInfo", 
+						  ['l', 'p'], 'l' )
+       end
+	lpConsoleCursorInfo = [size,visi].pack('LL')
+       @@m_SetConsoleCursorInfo.call( hConsoleOutput, lpConsoleCursorInfo )
+     end
+
+     def SetConsoleCursorPosition( hConsoleOutput, col, row )
+       if @@m_SetConsoleCursorPosition == nil
+	  @@m_SetConsoleCursorPosition = Win32API.new( "kernel32", "SetConsoleCursorPosition", ['l', 'p'], 'l' )
+       end
+	dwCursorPosition = (row << 16) + col
+       @@m_SetConsoleCursorPosition.call( hConsoleOutput, dwCursorPosition )
+     end
+
+     def SetConsoleMode( hConsoleHandle, lpMode )
+       if @@m_SetConsoleMode == nil
+	  @@m_SetConsoleMode = Win32API.new( "kernel32", "SetConsoleMode", 
+					    ['l', 'p'], 'l' )
+       end
+       @@m_SetConsoleMode.call( hConsoleHandle, lpMode )
+     end
+
+     def SetConsoleOutputCP( wCodePageID )
+       if @@m_SetConsoleOutputCP == nil
+	  @@m_SetConsoleOutputCP = Win32API.new( "kernel32", 
+						"GetConsoleOutputCP", 
+						['l'], 'l' )
+       end
+       @@m_SetConsoleOutputCP.call( wCodePageID )
+     end
+
+      def SetConsoleScreenBufferSize( hConsoleOutput, col, row )
+        if @@m_SetConsoleScreenBufferSize == nil
+	  @@m_SetConsoleScreenBufferSize = Win32API.new( "kernel32", "SetConsoleScreenBufferSize", ['l', 'l'], 'l' )
+        end
+	dwSize = (row << 16) + col
+        @@m_SetConsoleScreenBufferSize.call( hConsoleOutput, dwSize )
+      end
+
+     def SetConsoleTextAttribute( hConsoleOutput, wAttributes )
+       if @@m_SetConsoleTextAttribute == nil
+	  @@m_SetConsoleTextAttribute = Win32API.new( "kernel32", "SetConsoleTextAttribute", ['l', 'i'], 'l' )
+       end
+       @@m_SetConsoleTextAttribute.call( hConsoleOutput, wAttributes )
+     end
+
+      def SetConsoleTitle( lpConsoleTitle )
+        if @@m_SetConsoleTitle == nil
+	  @@m_SetConsoleTitle = Win32API.new( "kernel32", "SetConsoleTitle", 
+					     ['p'], 'l' )
+        end
+        @@m_SetConsoleTitle.call( lpConsoleTitle )
+      end
+
+      def SetConsoleWindowInfo( hConsoleOutput, bAbsolute, 
+			        left, top, right, bottom )
+        if @@m_SetConsoleWindowInfo == nil
+	  @@m_SetConsoleWindowInfo = Win32API.new( "kernel32", 
+						  "SetConsoleWindowInfo", 
+						  ['l', 'l', 'p'], 'l' )
+        end
+	lpConsoleWindow = [ left, top, right, bottom ].pack('ssss')
+        @@m_SetConsoleWindowInfo.call( hConsoleOutput, bAbsolute, 
+				      lpConsoleWindow )
+      end
+
+      def SetStdHandle( nStdHandle, hHandle )
+        if @@m_SetStdHandle == nil
+	  @@m_SetStdHandle = Win32API.new( "kernel32", "SetStdHandle",
+					  ['l', 'l'], 'l' )
+        end
+        @@m_SetStdHandle.call( nStdHandle, hHandle )
+      end
+
+     def WriteConsole( hConsoleOutput, lpBuffer )
+       if @@m_WriteConsole == nil
+	  @@m_WriteConsole = Win32API.new( "kernel32", "WriteConsole",
+					  ['l', 'p', 'l', 'p', 'p'], 'l' )
+       end
+	nNumberOfCharsToWrite = lpBuffer.length()
+	lpNumberOfCharsWritten = ' ' * 4
+	lpReserved = ' ' * 4
+       @@m_WriteConsole.call( hConsoleOutput, lpBuffer, nNumberOfCharsToWrite,
+			      lpNumberOfCharsWritten,  lpReserved )
+	return lpNumberOfCharsWritten
+     end
+
+      def WriteConsoleInput( hConsoleInput, lpBuffer )
+        if @@m_WriteConsoleInput == nil
+	  @@m_WriteConsoleInput = Win32API.new( "kernel32", "WriteConsoleInput", ['l', 'p', 'l', 'p'], 'l' )
+        end
+        @@m_WriteConsoleInput.call( hConsoleInput, lpBuffer, nLength, 
+				   lpNumberOfEventsWritten )
+      end
+
+      # @@ Todo: Test this
+      def WriteConsoleOutput( hConsoleOutput, buffer, cols, rows,
+			     bufx, bufy, left, top, right, bottom )
+        if @@m_WriteConsoleOutput == nil
+	  @@m_WriteConsoleOutput = Win32API.new( "kernel32", "WriteConsoleOutput", ['l', 'p', 'l', 'l', 'p'], 'l' )
+        end
+	lpBuffer = buffer.flatten.pack('ss' * buffer.length() * 2)
+	dwBufferSize = (buffer.length() << 16) + 2
+	dwBufferCoord = (row << 16) + col 
+	lpWriteRegion = [ left, top, right, bottom ].pack('ssss')
+        @@m_WriteConsoleOutput.call( hConsoleOutput, lpBuffer, dwBufferSize,
+				    dwBufferCoord, lpWriteRegion )
+      end
+
+      def WriteConsoleOutputAttribute( hConsoleOutput, lpAttribute, col, row )
+        if @@m_WriteConsoleOutputAttribute == nil
+	  @@m_WriteConsoleOutputAttribute = Win32API.new( "kernel32", "WriteConsoleOutputAttribute", ['l', 'p', 'l', 'l', 'p'], 'l' )
+        end
+	nLength = lpAttribute.length()
+	dwWriteCoord = (row << 16) + col
+	lpNumberOfAttrsWritten = ' ' * 4
+        @@m_WriteConsoleOutputAttribute.call( hConsoleOutput, lpAttribute, 
+					     nLength, dwWriteCoord, 
+					     lpNumberOfAttrsWritten )
+	return lpNumberOfAttrsWritten.unpack('L')
+      end
+
+      def WriteConsoleOutputCharacter( hConsoleOutput, lpCharacter, col, row )
+        if @@m_WriteConsoleOutputCharacter == nil
+	  @@m_WriteConsoleOutputCharacter = Win32API.new( "kernel32", "WriteConsoleOutputCharacter", ['l', 'p', 'l', 'l', 'p'], 'l' )
+        end
+	nLength = lpCharacter.length()
+	dwWriteCoord = (row << 16) + col
+	lpNumberOfCharsWritten = ' ' * 4
+        @@m_WriteConsoleOutputCharacter.call( hConsoleOutput, lpCharacter, 
+					     nLength, dwWriteCoord, 
+					     lpNumberOfCharsWritten )
+	return lpNumberOfCharsWritten.unpack('L')
+      end
+
+    end
+  end
+
+end  # rescue
+
+
+
+module Win32
+  class Console
+
+    VERSION = '1.0'
+
+    include Win32::Console::Constants
+
+    def initialize( t = nil )
+      if t and ( t == STD_INPUT_HANDLE or t == STD_OUTPUT_HANDLE or
+		 t == STD_ERROR_HANDLE )
+	@handle = API.GetStdHandle( t )
+      else
+	param1 = GENERIC_READ    | GENERIC_WRITE
+	param2 = FILE_SHARE_READ | FILE_SHARE_WRITE
+	@handle = API.CreateConsoleScreenBuffer( param1, param2, 
+						 CONSOLE_TEXTMODE_BUFFER )
+      end
+    end
+
+
+    def Display
+      return API.SetConsoleActiveScreenBuffer(@handle)
+    end
+
+    def Select(type)
+      return API.SetStdHandle(type,@handle)
+    end
+
+    def Title(title = nil)
+      if title
+	return API.SetConsoleTitle(title)
+      else
+	return API.GetConsoleTitle()
+      end
+    end
+
+    def WriteChar(s, col, row)
+      API.WriteConsoleOutputCharacter( @handle, s, col, row )
+    end
+
+    def ReadChar(size, col, row)
+      buffer = ' ' * size
+      if API.ReadConsoleOutputCharacter( @handle, buffer, size, col, row )
+	return buffer
+      else
+	return nil
+      end
+    end
+
+    def WriteAttr(attr, col, row)
+      API.WriteConsoleOutputAttribute( @handle, attr, col, row )
+    end
+
+    def ReadAttr(size, col, row)
+      x = API.ReadConsoleOutputAttribute( @handle, size, col, row )
+      return x.unpack('c'*size)
+    end
+
+
+    def Cursor(*t)
+      col, row, size, visi = t
+      if col
+	row = -1 if !row
+	if col < 0 or row < 0
+	  curr_col, curr_row = API.GetConsoleScreenBufferInfo(@handle)
+	  col = curr_col if col < 0
+	  row = curr_row if row < 0
+	end
+	API.SetConsoleCursorPosition( @handle, col, row )
+	if size and visi
+	  curr_size, curr_visi = API.GetConsoleCursorInfo( @handle )
+	  size = curr_size if size < 0
+	  visi = curr_visi if visi < 0
+	  size = 1 if size < 1
+	  size = 99 if size > 99
+	  API.SetConsoleCursorInfo( @handle, size, visi )
+	end
+      else
+	d, d, curr_col, curr_row = API.GetConsoleScreenBufferInfo(@handle)
+	curr_size, curr_visi = API.GetConsoleCursorInfo( @handle )
+        return [ curr_col, curr_row, curr_size, curr_visi ]
+      end
+    end
+
+    def Write(s)
+      API.WriteConsole( @handle, s )
+    end
+
+    def ReadRect( left, top, right, bottom )
+      col = right  - left + 1
+      row = bottom - top  + 1
+      size = col * row
+      buffer = ' ' * size * 4
+      if API.ReadConsoleOutput( @handle, buffer, col, row, 0, 0, 
+			       left, top, right, bottom )
+	#return buffer.unpack('US'*size)  # for unicode
+	return buffer.unpack('axS'*size)  # for ascii
+      else
+	return nil
+      end
+    end
+
+    def WriteRect( buffer, left, top, right, bottom )
+      col = right  - left + 1
+      row = bottom - top  + 1
+      API.WriteConsoleOutput( @handle, buffer, col, row, 0, 0, 
+			     left, top, right, bottom )
+    end
+
+
+
+    def Scroll( left1, top1, right1, bottom1,
+	       col, row, char, attr,
+	       left2, top2, right2, bottom2 )
+      API.ScrollConsoleScreenBuffer(@handle, left1, top1, right1, bottom1,
+				    col, row, char, attr,
+				    left2, top2, right2, bottom2)
+    end
+
+
+    def MaxWindow(flag = nil)
+      if !flag
+	info = API.GetConsoleScreenBufferInfo(@handle)
+        return info[9], info[10]
+      else
+        return API.GetLargestConsoleWindowSize(@handle)
+      end
+    end
+
+
+    def Info()
+      return API.GetConsoleScreenBufferInfo( @handle )
+    end
+
+
+    def GetEvents()
+      return API.GetNumberOfConsoleInputEvents(@handle)
+    end
+
+
+    def Flush()
+      return API.FlushConsoleInputBuffer(@handle)
+    end
+
+    def InputChar(number = nil)
+      number = 1 unless number
+      buffer = ' ' * number
+      if API.ReadConsole(@handle, buffer, number) == number
+	return buffer
+      else
+	return nil
+      end
+    end
+
+
+    def Input()
+      API.ReadConsoleInput(@handle)
+    end
+
+
+    def PeekInput()
+      API.PeekConsoleInput(@handle)
+    end
+
+
+    def Mode(mode = nil)
+      if mode
+	mode = mode.pack('L') if mode === Array
+	API.SetConsoleMode(@handle, mode)
+      else
+	return API.GetConsoleMode(@handle)
+      end
+    end
+
+    def WriteInput(*t)
+      API.WriteConsoleInput(@handle, *t)
+    end
+
+    def Attr(*attr)
+      if attr.size > 0
+	API.SetConsoleTextAttribute( @handle, attr[0] )
+      else
+	info = API.GetConsoleScreenBufferInfo( @handle )
+	return info[4]
+      end
+    end
+
+
+    def Size(*t)
+      if t.size == 0
+	col, row = API.GetConsoleScreenBufferInfo(@handle )
+        return [col, row]
+      else
+	row = -1 if !t[1]
+	col = -1 if !t[0]
+	if col < 0 or row < 0
+	  curr_col, curr_row = Size()
+	  col = curr_col if col < 0
+	  row = curr_row if row < 0
+	end
+	API.SetConsoleScreenBufferSize(@handle, row, col)
+      end
+    end
+
+    def Window(*t)
+      if t.size != 5
+	info = API.GetConsoleScreenBufferInfo( @handle )
+	return info[5..8]
+      else
+	API.SetConsoleWindowInfo(@handle, t[0], t[1], t[2], t[3], t[4])
+      end
+    end
+
+    def FillAttr(attr, number = 1, col = -1, row = -1)
+      if col < 0 or row < 0
+	d, d, curr_col, curr_row = API.GetConsoleScreenBufferInfo(@handle)
+        col = curr_col if col < 0
+        row = curr_row if row < 0
+      end
+      API.FillConsoleOutputAttribute(@handle, attr, number, col, row)
+    end
+
+    def FillChar(char, number, col = -1, row = -1)
+      if col < 0 or row < 0
+	d, d, curr_col, curr_row = API.GetConsoleScreenBufferInfo(@handle)
+        col = curr_col if col < 0
+        row = curr_row if row < 0
+      end
+      API.FillConsoleOutputCharacter(@handle, char[0], number, col, row)
+    end
+
+    def Cls()
+      attr = ATTR_NORMAL
+      x, y = Size()
+      left, top, right , bottom = Window()
+      vx = right  - left
+      vy = bottom - top
+      FillChar(' ', x*y, 0, 0)
+      FillAttr(attr, x*y, 0, 0)
+      Cursor(0,0)
+      Window(1,0,0,vx,vy)
+    end
+
+    def Console.Free()
+      API.FreeConsole()
+    end
+
+    def Console.Alloc()
+      API.AllocConsole()
+    end
+
+    def Console.MouseButtons()
+      API.GetNumberOfConsoleMouseButtons()
+    end
+
+    def Console.InputCP(codepage=nil)
+      if codepage
+	API.SetConsoleCP(codepage)
+      else
+	return API.GetConsoleCP()
+      end
+    end
+
+    def Console.OutputCP(codepage=nil)
+      if codepage
+	API.SetConsoleOutputCP(codepage)
+      else
+	return API.GetConsoleOutputCP()
+      end
+    end
+
+    def Console.GenerateCtrlEvent( type=nil, pid=nil )
+      type = API.constant('CTRL_C_EVENT') if type == nil
+      pid  = 0 if pid == nil
+      API.GenerateConsoleCtrlEvent(type, pid)
+    end
+
+  end
+end
+
+
+
+
+
+FG_BLACK        = 0
+FG_BLUE         = Win32::Console::API.constant("FOREGROUND_BLUE")
+FG_LIGHTBLUE    = Win32::Console::API.constant("FOREGROUND_BLUE")|
+                  Win32::Console::API.constant("FOREGROUND_INTENSITY")
+FG_RED          = Win32::Console::API.constant("FOREGROUND_RED")
+FG_LIGHTRED     = Win32::Console::API.constant("FOREGROUND_RED")|
+                  Win32::Console::API.constant("FOREGROUND_INTENSITY")
+FG_GREEN        = Win32::Console::API.constant("FOREGROUND_GREEN")
+FG_LIGHTGREEN   = Win32::Console::API.constant("FOREGROUND_GREEN")|
+                  Win32::Console::API.constant("FOREGROUND_INTENSITY")
+FG_MAGENTA      = Win32::Console::API.constant("FOREGROUND_RED")|
+                  Win32::Console::API.constant("FOREGROUND_BLUE")
+FG_LIGHTMAGENTA = Win32::Console::API.constant("FOREGROUND_RED")|
+                  Win32::Console::API.constant("FOREGROUND_BLUE")|
+                  Win32::Console::API.constant("FOREGROUND_INTENSITY")
+FG_CYAN         = Win32::Console::API.constant("FOREGROUND_GREEN")|
+                  Win32::Console::API.constant("FOREGROUND_BLUE")
+FG_LIGHTCYAN    = Win32::Console::API.constant("FOREGROUND_GREEN")|
+                  Win32::Console::API.constant("FOREGROUND_BLUE")|
+                  Win32::Console::API.constant("FOREGROUND_INTENSITY")
+FG_BROWN        = Win32::Console::API.constant("FOREGROUND_RED")|
+                  Win32::Console::API.constant("FOREGROUND_GREEN")
+FG_YELLOW       = Win32::Console::API.constant("FOREGROUND_RED")|
+                  Win32::Console::API.constant("FOREGROUND_GREEN")|
+                  Win32::Console::API.constant("FOREGROUND_INTENSITY")
+FG_GRAY         = Win32::Console::API.constant("FOREGROUND_RED")|
+                  Win32::Console::API.constant("FOREGROUND_GREEN")|
+                  Win32::Console::API.constant("FOREGROUND_BLUE")
+FG_WHITE        = Win32::Console::API.constant("FOREGROUND_RED")|
+                  Win32::Console::API.constant("FOREGROUND_GREEN")|
+                  Win32::Console::API.constant("FOREGROUND_BLUE")|
+                  Win32::Console::API.constant("FOREGROUND_INTENSITY")
+
+BG_BLACK        = 0
+BG_BLUE         = Win32::Console::API.constant("BACKGROUND_BLUE")
+BG_LIGHTBLUE    = Win32::Console::API.constant("BACKGROUND_BLUE")|
+                  Win32::Console::API.constant("BACKGROUND_INTENSITY")
+BG_RED          = Win32::Console::API.constant("BACKGROUND_RED")
+BG_LIGHTRED     = Win32::Console::API.constant("BACKGROUND_RED")|
+                  Win32::Console::API.constant("BACKGROUND_INTENSITY")
+BG_GREEN        = Win32::Console::API.constant("BACKGROUND_GREEN")
+BG_LIGHTGREEN   = Win32::Console::API.constant("BACKGROUND_GREEN")|
+                  Win32::Console::API.constant("BACKGROUND_INTENSITY")
+BG_MAGENTA      = Win32::Console::API.constant("BACKGROUND_RED")|
+                  Win32::Console::API.constant("BACKGROUND_BLUE")
+BG_LIGHTMAGENTA = Win32::Console::API.constant("BACKGROUND_RED")|
+                  Win32::Console::API.constant("BACKGROUND_BLUE")|
+                  Win32::Console::API.constant("BACKGROUND_INTENSITY")
+BG_CYAN         = Win32::Console::API.constant("BACKGROUND_GREEN")|
+                  Win32::Console::API.constant("BACKGROUND_BLUE")
+BG_LIGHTCYAN    = Win32::Console::API.constant("BACKGROUND_GREEN")|
+                  Win32::Console::API.constant("BACKGROUND_BLUE")|
+                  Win32::Console::API.constant("BACKGROUND_INTENSITY")
+BG_BROWN        = Win32::Console::API.constant("BACKGROUND_RED")|
+                  Win32::Console::API.constant("BACKGROUND_GREEN")
+BG_YELLOW       = Win32::Console::API.constant("BACKGROUND_RED")|
+                  Win32::Console::API.constant("BACKGROUND_GREEN")|
+                  Win32::Console::API.constant("BACKGROUND_INTENSITY")
+BG_GRAY         = Win32::Console::API.constant("BACKGROUND_RED")|
+                  Win32::Console::API.constant("BACKGROUND_GREEN")|
+                  Win32::Console::API.constant("BACKGROUND_BLUE")
+BG_WHITE        = Win32::Console::API.constant("BACKGROUND_RED")|
+                  Win32::Console::API.constant("BACKGROUND_GREEN")|
+                  Win32::Console::API.constant("BACKGROUND_BLUE")|
+                  Win32::Console::API.constant("BACKGROUND_INTENSITY")
+
+ATTR_NORMAL  = FG_GRAY  | BG_BLACK
+ATTR_INVERSE = FG_BLACK | BG_GRAY
+
+include Win32::Console::Constants