win32console 1.3.0.beta1

data/lib/Win32/Console/ANSI.rb

@@ -0,0 +1,336 @@
+# encoding: utf-8
+
+#
+# Win32::Console::ANSI
+#
+# Copyright 2004 - Gonzalo Garramuno
+# Licensed under GNU General Public License or Perl's Artistic License
+#
+# Based on Perl's Win32::Console::ANSI
+# Copyright (c) 2003 Jean-Louis Morel <jl_morel@bribes.org>
+# Licensed under GNU General Public License or Perl's Artistic License
+#
+require "Win32/Console"
+
+
+module Kernel
+
+  # Kernel#putc is equivalent to $stdout.putc, but
+  # it doesn't use $stdout.putc.  We redefine it to do that
+  # so that it will buffer the escape sequences properly.
+  # See Win32::Console::ANSI::IO#putc
+  remove_method :putc
+  def putc(int)
+    $stdout.putc(int)
+  end
+
+end
+
+module Win32
+  class Console
+    module ANSI
+
+      class IO < IO
+
+        VERSION = '0.05'
+        DEBUG = nil
+
+        require "win32/registry"
+
+        include Win32::Console::Constants
+
+        # @todo: encode is another perl module
+        EncodeOk = false
+
+        # Retrieving the codepages
+        cpANSI = nil
+        Win32::Registry::HKEY_LOCAL_MACHINE.open('SYSTEM\CurrentControlSet\Control\Nls\CodePage' ) { |reg|
+          cpANSI = reg['ACP']
+        }
+
+        STDERR.puts "Unable to read Win codepage #{cpANSI}" if DEBUG && !cpANSI
+
+
+        cpANSI = 'cp'+(cpANSI ? cpANSI : '1252')      # Windows codepage
+        OEM = Win32::Console::OutputCP()
+        cpOEM = 'cp' + OEM.to_s                       # DOS codepage
+        @@cp = cpANSI + cpOEM
+
+        STDERR.puts "EncodeOk=#{EncodeOk} cpANSI=#{cpANSI} "+
+          "cpOEM=#{cpOEM}" if DEBUG
+
+        @@color = { 30 => 0,                                               # black foreground
+              31 => FOREGROUND_RED,                                  # red foreground
+              32 => FOREGROUND_GREEN,                                # green foreground
+              33 => FOREGROUND_RED|FOREGROUND_GREEN,                 # yellow foreground
+              34 => FOREGROUND_BLUE,                                 # blue foreground
+              35 => FOREGROUND_BLUE|FOREGROUND_RED,                  # magenta foreground
+              36 => FOREGROUND_BLUE|FOREGROUND_GREEN,                # cyan foreground
+              37 => FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE, # white foreground
+              40 => 0,                                               # black background
+              41 => BACKGROUND_RED,                                  # red background
+              42 => BACKGROUND_GREEN,                                # green background
+              43 => BACKGROUND_RED|BACKGROUND_GREEN,                 # yellow background
+              44 => BACKGROUND_BLUE,                                 # blue background
+              45 => BACKGROUND_BLUE|BACKGROUND_RED,                  # magenta background
+              46 => BACKGROUND_BLUE|BACKGROUND_GREEN,                # cyan background
+              47 => BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE, # white background
+        }
+
+        def initialize
+          super(1,'w')
+          @Out = Win32::Console.new(STD_OUTPUT_HANDLE)
+          @x = @y = 0           # to save cursor position
+          @foreground = 7
+          @background = 0
+          @bold =
+          @underline =
+          @revideo =
+          @concealed = nil
+          @conv = 1        # char conversion by default
+          @buffer = []
+          STDERR.puts "Console Mode=#{@Out.Mode}" if DEBUG
+        end
+
+        # this redefined #putc buffers escape sequences but passes
+        # other values to #write as normal.
+        def putc(int)
+          if @buffer.empty?
+            unless int == ?\e
+               write(int.chr)
+            else
+              @buffer << int
+            end
+          else
+            @buffer << int
+            case int
+            when ?m, ?J, ?L, ?M, ?@, ?P, ?A, ?B, ?C, ?D,
+                 ?E, ?F, ?G, ?H, ?f, ?s, ?u, ?U, ?K, ?X
+              write(@buffer.pack("c*"))
+              @buffer.clear
+            end
+          end
+        end
+
+        # #write checks if $stdout is going to the console
+        # or if it's being redirected.
+        # When to the console, it passes the string to
+        # _PrintString to be parsed for escape codes.
+        #
+        # When redirected, it passes to WriteFile to allow escape
+        # codes and all to be output.  The application that is
+        # handling the redirected IO should handle coloring.
+        # For Ruby applications, this means requiring Win32Conole again.
+        def write(*s)
+          if redirected?
+            s.each{ |x| @Out.WriteFile(x.dup.to_s) }
+          else
+            s.each{ |x| _PrintString(x) }
+          end
+        end
+
+        # returns true if outputs is being redirected.
+        def redirected?
+          @Out.Mode > 31
+        end
+
+        private
+
+        def _PrintString(t)
+          s = t.dup.to_s
+          while s != ''
+            if s.sub!( /([^\e]*)?\e([\[\(])([0-9\;\=]*)([a-zA-Z@])(.*)/, '\5')
+              @Out.Write((_conv("#$1")))
+              if $2 == '['
+                case $4
+                when 'm'        # ESC[#;#;....;#m Set display attributes
+                  attributs = $3.split(';')
+                  attributs.push(nil) unless attributs  # ESC[m == ESC[;m ==...==ESC[0m
+                  attributs.each do |attr|
+                    atv = attr.to_i
+                    case atv
+                    when 0  # ESC[0m reset
+                      @foreground = 7
+                      @background = 0
+                      @bold =
+                      @underline =
+                      @revideo =
+                      @concealed = nil
+                    when 1
+                      @bold = 1
+                    when 21
+                      @bold = nil
+                    when 4
+                      @underline = 1
+                    when 24
+                      @underline = nil
+                    when 7
+                      @revideo = 1
+                    when 27
+                      @revideo = nil
+                    when 8
+                      @concealed = 1
+                    when 28
+                      @concealed = nil
+                    when 30..37
+                      @foreground = atv - 30
+                    when 40..47
+                      @background = atv - 40
+                    end
+                  end
+
+                  if @revideo
+                    attribut = @@color[40+@foreground] |
+                      @@color[30+@background]
+                  else
+                    attribut = @@color[30+@foreground] |
+                      @@color[40+@background]
+                  end
+                  attribut |= FOREGROUND_INTENSITY if @bold
+                  attribut |= BACKGROUND_INTENSITY if @underline
+                  @Out.Attr(attribut)
+                when 'J'
+                  if !$3 or $3 == ''  # ESC[0J from cursor to end of display
+                    info = @Out.Info()
+                    s = ' ' * ((info[1]-info[3]-1)*info[0]+info[0]-info[2]-1)
+                    @Out.WriteChar(s, info[2], info[3])
+                    @Out.Cursor(info[2], info[3])
+                  elsif $3 == '1' # ESC[1J erase from start to cursor.
+                    info = @Out.Info()
+                    s = ' ' * (info[3]*info[0]+info[2]+1)
+                    @Out.WriteChar(s, 0, 0)
+                    @Out.Cursor(info[2], info[3])
+                  elsif $3 == '2' # ESC[2J Clear screen and home cursor
+                    @Out.Cls()
+                    @Out.Cursor(0, 0)
+                  else
+                    STDERR.print "\e#$2#$3#$4" if DEBUG # if ESC-code not implemented
+                  end
+                when 'K'
+                  info = @Out.Info()
+                  if !$3 or $3 == ''                  # ESC[0K Clear to end of line
+                    s = ' ' * (info[7]-info[2]+1)
+                    @Out.Write(s)
+                    @Out.Cursor(info[2], info[3])
+                  elsif $3=='1'   # ESC[1K Clear from start of line to cursor
+                    s = ' '*(info[2]+1)
+                    @Out.WriteChar(s, 0, info[3])
+                    @Out.Cursor(info[2], info[3])
+                  elsif $3=='2'   # ESC[2K Clear whole line.
+                    s = ' '* info[0]
+                    @Out.WriteChar(s, 0, info[3])
+                    @Out.Cursor(info[2], info[3])
+                  end
+                when 'L'  # ESC[#L Insert # blank lines.
+                  n = $3 == ''? 1 : $3.to_i  # ESC[L == ESC[1L
+                  info = @Out.Info()
+                  @Out.Scroll(0, info[3], info[0]-1, info[1]-1,
+                              0, info[3] + n.to_i,
+                               ' '[0], @Out.Attr(),
+                               0, 0, 10000, 10000)
+                  @Out.Cursor(info[2], info[3])
+                when 'M'   # ESC[#M Delete # line.
+                  n = $3 == ''? 1 : $3.to_i  # ESC[M == ESC[1M
+                  info = @Out.Info();
+                  @Out.Scroll(0, info[3]+n, info[0]-1, info[1]-1,
+                              0, info[3],
+                              ' '[0], @Out.Attr(),
+                              0, 0, 10000, 10000)
+                  @Out.Cursor(info[2], info[3])
+                when 'P'   # ESC[#P Delete # characters.
+                  n = $3 == ''? 1 : $3.to_i  # ESC[P == ESC[1P
+                  info = @Out.Info()
+                  n = info[0]-info[2] if info[2]+n > info[0]-1
+                  @Out.Scroll(info[2]+n, info[3] , info[0]-1, info[3],
+                              info[2], info[3],
+                              ' '[0], @Out.Attr(),
+                              0, 0, 10000, 10000)
+                  s = ' ' * n
+                  @Out.Cursor(info[0]-n, info[3])
+                  @Out.Write(s)
+                  @Out.Cursor(info[2], info[3])
+                when '@'      # ESC[#@ Insert # blank Characters
+                  s = ' ' * $3.to_i
+                  info = @Out.Info()
+                  s << @Out.ReadChar(info[7]-info[2]+1, info[2], info[3])
+                  s = s[0..-($3.to_i)]
+                  @Out.Write(s);
+                  @Out.Cursor(info[2], info[3])
+                when 'A'     # ESC[#A Moves cursor up # lines
+                  (x, y) = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[A == ESC[1A
+                  @Out.Cursor(x, y-n)
+                when 'B'    # ESC[#B Moves cursor down # lines
+                  (x, y) = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[B == ESC[1B
+                  @Out.Cursor(x, y+n)
+                when 'C'    # ESC[#C Moves cursor forward # spaces
+                  (x, y) = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[C == ESC[1C
+                  @Out.Cursor(x+n, y)
+                when 'D'    # ESC[#D Moves cursor back # spaces
+                  (x, y) = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[D == ESC[1D
+                  @Out.Cursor(x-n, y)
+                when 'E'    # ESC[#E Moves cursor down # lines, column 1.
+                  x, y = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[E == ESC[1E
+                  @Out.Cursor(0, y+n)
+                when 'F'    # ESC[#F Moves cursor up # lines, column 1.
+                  x, y = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[F == ESC[1F
+                  @Out.Cursor(0, y-n)
+                when 'G'   # ESC[#G Moves cursor column # in current row.
+                  x, y = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[G == ESC[1G
+                  @Out.Cursor(n-1, y)
+                when 'f' # ESC[#;#f Moves cursor to line #, column #
+                  y, x = $3.split(';')
+                  x = 1 unless x    # ESC[;5H == ESC[1;5H ...etc
+                  y = 1 unless y
+                  @Out.Cursor(x.to_i-1, y.to_i-1) # origin (0,0) in DOS console
+                when 'H' # ESC[#;#H  Moves cursor to line #, column #
+                  y, x = $3.split(';')
+                  x = 1 unless x    # ESC[;5H == ESC[1;5H ...etc
+                  y = 1 unless y
+                  @Out.Cursor(x.to_i-1, y.to_i-1) # origin (0,0) in DOS console
+                when 's'       # ESC[s Saves cursor position for recall later
+                  (@x, @y) = @Out.Cursor()
+                when 'u'       # ESC[u Return to saved cursor position
+                  @Out.Cursor(@x, @y)
+                when 'U'     # ESC(U no mapping
+                  @conv = nil
+                when 'K'     # ESC(K mapping if it exist
+                  @Out.OutputCP(OEM)      # restore original codepage
+                  @conv = 1
+                when 'X'     # ESC(#X codepage **EXPERIMENTAL**
+                  @conv = nil
+                  @Out.OutputCP($3)
+                else
+                  STDERR.puts "\e#$2#$3#$4 not implemented" if DEBUG # ESC-code not implemented
+                end
+              end
+            else
+              @Out.Write(_conv(s))
+              s=''
+            end
+          end
+        end
+
+        def _conv(s)
+          if @concealed
+            s.gsub!( /\S/,' ')
+          end
+          return s
+        end
+
+      end
+
+# end print overloading
+
+    end
+  end
+end
+
+$stdout = Win32::Console::ANSI::IO.new()
+

data/lib/Win32/Console/api.rb

@@ -0,0 +1,342 @@
+
+# The actual api to access windows functions
+module Win32
+  class Console
+    class API
+      require 'Win32API'
+
+      class << self
+
+        def constant(t)
+          begin
+            return Win32::Console::Constants.const_get(t)
+          rescue
+            return nil
+          end
+        end
+
+       def AllocConsole()
+         @AllocConsole ||= Win32API.new( "kernel32", "AllocConsole", [], 'l' )
+         @AllocConsole.call()
+       end
+
+        def CreateConsoleScreenBuffer( dwDesiredAccess, dwShareMode, dwFlags )
+          @CreateConsoleScreenBuffer ||= Win32API.new( "kernel32", "CreateConsoleScreenBuffer", ['l', 'l', 'p', 'l', 'p'], 'l' )
+          @CreateConsoleScreenBuffer.call( dwDesiredAccess, dwShareMode, nil, dwFlags, nil )
+        end
+
+       def FillConsoleOutputAttribute( hConsoleOutput, wAttribute, nLength, col, row )
+         @FillConsoleOutputAttribute ||= Win32API.new( "kernel32", "FillConsoleOutputAttribute", ['l', 'i', 'l', 'l', 'p'], 'l' )
+         dwWriteCoord = (row << 16) + col
+         lpNumberOfAttrsWritten = ' ' * 4
+         @FillConsoleOutputAttribute.call( hConsoleOutput, wAttribute, nLength, dwWriteCoord, lpNumberOfAttrsWritten )
+         return lpNumberOfAttrsWritten.unpack('L')
+       end
+
+       def FillConsoleOutputCharacter( hConsoleOutput, cCharacter, nLength, col, row )
+         @FillConsoleOutputCharacter ||= Win32API.new( "kernel32", "FillConsoleOutputCharacter", ['l', 'i', 'l', 'l', 'p'], 'l' )
+          dwWriteCoord = (row << 16) + col
+          lpNumberOfAttrsWritten = ' ' * 4
+         @FillConsoleOutputCharacter.call( hConsoleOutput, cCharacter, nLength, dwWriteCoord, lpNumberOfAttrsWritten )
+          return lpNumberOfAttrsWritten.unpack('L')
+       end
+
+       def FlushConsoleInputBuffer( hConsoleInput )
+         @FlushConsoleInputBuffer ||= Win32API.new( "kernel32", "FillConsoleInputBuffer", ['l'], 'l' )
+         @FlushConsoleInputBuffer.call( hConsoleInput )
+       end
+
+       def FreeConsole()
+         @FreeConsole ||= Win32API.new( "kernel32", "FreeConsole", [], 'l' )
+         @FreeConsole.call()
+       end
+
+       def GenerateConsoleCtrlEvent( dwCtrlEvent, dwProcessGroupId )
+         @GenerateConsoleCtrlEvent ||= Win32API.new( "kernel32", "GenerateConsoleCtrlEvent", ['l', 'l'], 'l' )
+         @GenerateConsoleCtrlEvent.call( dwCtrlEvent, dwProcessGroupId )
+       end
+
+       def GetConsoleCP()
+         @GetConsoleCP ||= Win32API.new( "kernel32", "GetConsoleCP", [], 'l' )
+         @GetConsoleCP.call()
+       end
+
+       def GetConsoleCursorInfo( hConsoleOutput )
+         @GetConsoleCursorInfo ||= Win32API.new( "kernel32", "GetConsoleCursorInfo", ['l', 'p'], 'l' )
+          lpConsoleCursorInfo = ' ' * 8
+         @GetConsoleCursorInfo.call( hConsoleOutput, lpConsoleCursorInfo )
+          return lpConsoleCursorInfo.unpack('LL')
+       end
+
+        def GetConsoleMode( hConsoleHandle )
+          @GetConsoleMode ||= Win32API.new( "kernel32", "GetConsoleMode", ['l', 'p'], 'l' )
+          lpMode = ' ' * 4
+          @GetConsoleMode.call( hConsoleHandle, lpMode )
+          return lpMode.unpack('L').first
+        end
+
+       def GetConsoleOutputCP()
+         @GetConsoleOutputCP ||= Win32API.new( "kernel32", "GetConsoleOutputCP", [], 'l' )
+         @GetConsoleOutputCP.call()
+       end
+
+       def GetConsoleScreenBufferInfo( hConsoleOutput )
+         @GetConsoleScreenBufferInfo ||= Win32API.new( "kernel32", "GetConsoleScreenBufferInfo", ['l', 'p'], 'l' )
+          lpBuffer = ' ' * 22
+         @GetConsoleScreenBufferInfo.call( hConsoleOutput, lpBuffer )
+          return lpBuffer.unpack('SSSSSssssSS')
+       end
+
+       def GetConsoleTitle()
+          @GetConsoleTitle ||= Win32API.new( "kernel32", "GetConsoleTitle", ['p', 'l'], 'l' )
+          nSize = 120
+          lpConsoleTitle = ' ' * nSize
+          @GetConsoleTitle.call( lpConsoleTitle, nSize )
+          return lpConsoleTitle.strip
+        end
+
+       def GetConsoleWindow()
+         @GetConsoleWindow ||= Win32API.new( "kernel32", "GetConsoleWindow",[], 'l' )
+         @GetConsoleWindow.call()
+       end
+
+        def GetLargestConsoleWindowSize( hConsoleOutput )
+          @GetLargestConsoleWindowSize ||= Win32API.new( "kernel32", "GetLargestConsoleWindowSize", ['l'], 'l' )
+          coord = @GetLargestConsoleWindowSize.call( hConsoleOutput )
+          x = coord >> 16
+          y = coord & 0x0000ffff
+          return [x,y]
+        end
+
+        def GetNumberOfConsoleInputEvents( hConsoleInput )
+          @GetNumberOfConsoleInputEvents ||= Win32API.new( "kernel32", "GetNumberOfConsoleInputEvents", ['l', 'p'], 'l' )
+          lpcNumberOfEvents = 0
+          @GetNumberOfConsoleInputEvents.call( hConsoleInput, lpcNumberOfEvents )
+          return lpcNumberOfEvents
+        end
+
+        def GetNumberOfConsoleMouseButtons( )
+          @GetNumberOfConsoleMouseButtons ||= Win32API.new( "kernel32", "GetNumberOfConsoleMouseButtons", ['p'], 'l' )
+          lpNumberOfMouseButtons = 0
+          @GetNumberOfConsoleMouseButtons.call( lpNumberOfMouseButtons )
+          return lpNumberOfMouseButtons
+        end
+
+       def GetStdHandle( nStdHandle )
+         @GetStdHandle ||= Win32API.new( "kernel32", "GetStdHandle", ['l'], 'l' )
+         @GetStdHandle.call( nStdHandle )
+       end
+
+        # <<HandlerRoutine>> : This is not an actual API function, just a concept description in the SDK.
+
+        def PeekConsoleInput( hConsoleInput )
+          @PeekConsoleInput ||= Win32API.new( "kernel32", "PeekConsoleInput", ['l', 'p', 'l', 'p'], 'l' )
+          lpNumberOfEventsRead = ' ' * 4
+          lpBuffer = ' ' * 20
+          nLength  = 20
+          @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 )
+          @ReadConsole ||= Win32API.new( "kernel32", "ReadConsole", ['l', 'p', 'l', 'p', 'p'], 'l' )
+          lpBuffer = ' ' * nNumberOfCharsToRead unless lpBuffer
+          lpNumberOfCharsRead = ' ' * 4
+          lpReserved = ' ' * 4
+          @ReadConsole.call( hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, lpReserved )
+          return lpNumberOfCharsRead.unpack('L')
+        end
+
+        def ReadConsoleInput( hConsoleInput )
+          @ReadConsoleInput ||= Win32API.new( "kernel32", "ReadConsoleInput", ['l', 'p', 'l', 'p'], 'l' )
+          lpNumberOfEventsRead = ' ' * 4
+          lpBuffer = ' ' * 20
+          nLength  = 20
+          @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 )
+          @ReadConsoleOutput ||= Win32API.new( "kernel32", "ReadConsoleOutput", ['l', 'p', 'l', 'l', 'p'], 'l' )
+          dwBufferSize  = cols * rows * 4
+          lpBuffer = ' ' * dwBufferSize
+          dwBufferCoord = (bufy << 16) + bufx
+          lpReadRegion  = [ left, top, right, bottom ].pack('ssss')
+          @ReadConsoleOutput.call( hConsoleOutput, lpBuffer, dwBufferSize,
+                                     dwBufferCoord, lpReadRegion )
+        end
+
+        def ReadConsoleOutputAttribute( hConsoleOutput, nLength, col, row )
+          @ReadConsoleOutputAttribute ||= Win32API.new( "kernel32", "ReadConsoleOutputAttribute", ['l', 'p', 'l', 'l', 'p'], 'l' )
+          lpAttribute = ' ' * nLength
+          dwReadCoord = (row << 16) + col
+          lpNumberOfAttrsRead = ' ' * 4
+          @ReadConsoleOutputAttribute.call( hConsoleOutput, lpAttribute, nLength, dwReadCoord, lpNumberOfAttrsRead )
+          return lpAttribute
+        end
+
+        def ReadConsoleOutputCharacter( hConsoleOutput, lpCharacter, nLength,  col, row )
+          @ReadConsoleOutputCharacter ||= Win32API.new( "kernel32", "ReadConsoleOutputCharacter", ['l', 'p', 'l', 'l', 'p'], 'l' )
+          dwReadCoord = (row << 16) + col
+          lpNumberOfCharsRead = ' ' * 4
+          @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 )
+          @ScrollConsoleScreenBuffer ||= Win32API.new( "kernel32", "ScrollConsoleScreenBuffer", ['l', 'p', 'p', 'l', 'p'], 'l' )
+          lpScrollRectangle = [left1, top1, right1, bottom1].pack('ssss')
+          lpClipRectangle   = [left2, top2, right2, bottom2].pack('ssss')
+          dwDestinationOrigin = (row << 16) + col
+          lpFill = [char, attr].pack('ss')
+          @ScrollConsoleScreenBuffer.call( hConsoleOutput, lpScrollRectangle, lpClipRectangle, dwDestinationOrigin, lpFill )
+        end
+
+        def SetConsoleActiveScreenBuffer( hConsoleOutput )
+          @SetConsoleActiveScreenBuffer ||= Win32API.new( "kernel32", "SetConsoleActiveScreenBuffer", ['l'], 'l' )
+          @SetConsoleActiveScreenBuffer.call( hConsoleOutput )
+        end
+
+        # <<SetConsoleCtrlHandler>>:  Will probably not be implemented.
+
+        def SetConsoleCP( wCodePageID )
+          @SetConsoleCP ||= Win32API.new( "kernel32", "SetConsoleCP", ['l'], 'l' )
+          @SetConsoleCP.call( wCodePageID )
+        end
+
+        def SetConsoleCursorInfo( hConsoleOutput, col, row )
+          @SetConsoleCursorInfo ||= Win32API.new( "kernel32", "SetConsoleCursorInfo", ['l', 'p'], 'l' )
+          lpConsoleCursorInfo = [size,visi].pack('LL')
+          @SetConsoleCursorInfo.call( hConsoleOutput, lpConsoleCursorInfo )
+        end
+
+        def SetConsoleCursorPosition( hConsoleOutput, col, row )
+          @SetConsoleCursorPosition ||= Win32API.new( "kernel32", "SetConsoleCursorPosition", ['l', 'p'], 'l' )
+          dwCursorPosition = (row << 16) + col
+          @SetConsoleCursorPosition.call( hConsoleOutput, dwCursorPosition )
+        end
+
+        def SetConsoleMode( hConsoleHandle, lpMode )
+          @SetConsoleMode ||= Win32API.new( "kernel32", "SetConsoleMode", ['l', 'p'], 'l' )
+          @SetConsoleMode.call( hConsoleHandle, lpMode )
+        end
+
+        def SetConsoleOutputCP( wCodePageID )
+          @SetConsoleOutputCP ||= Win32API.new( "kernel32", "GetConsoleOutputCP", ['l'], 'l' )
+          @SetConsoleOutputCP.call( wCodePageID )
+        end
+
+        def SetConsoleScreenBufferSize( hConsoleOutput, col, row )
+          @SetConsoleScreenBufferSize ||= Win32API.new( "kernel32", "SetConsoleScreenBufferSize", ['l', 'l'], 'l' )
+          dwSize = (row << 16) + col
+          @SetConsoleScreenBufferSize.call( hConsoleOutput, dwSize )
+        end
+
+        def SetConsoleTextAttribute( hConsoleOutput, wAttributes )
+          @SetConsoleTextAttribute ||= Win32API.new( "kernel32", "SetConsoleTextAttribute", ['l', 'i'], 'l' )
+          @SetConsoleTextAttribute.call( hConsoleOutput, wAttributes )
+        end
+
+        def SetConsoleTitle( lpConsoleTitle )
+          @SetConsoleTitle ||= Win32API.new( "kernel32", "SetConsoleTitle", ['p'], 'l' )
+          @SetConsoleTitle.call( lpConsoleTitle )
+        end
+
+        def SetConsoleWindowInfo( hConsoleOutput, bAbsolute, left, top, right, bottom )
+          @SetConsoleWindowInfo ||= Win32API.new( "kernel32", "SetConsoleWindowInfo", ['l', 'l', 'p'], 'l' )
+          lpConsoleWindow = [ left, top, right, bottom ].pack('ssss')
+          @SetConsoleWindowInfo.call( hConsoleOutput, bAbsolute, lpConsoleWindow )
+        end
+
+        def SetStdHandle( nStdHandle, hHandle )
+          @SetStdHandle ||= Win32API.new( "kernel32", "SetStdHandle", ['l', 'l'], 'l' )
+          @SetStdHandle.call( nStdHandle, hHandle )
+        end
+
+        def WriteConsole( hConsoleOutput, lpBuffer )
+          @WriteConsole ||= Win32API.new( "kernel32", "WriteConsole", ['l', 'p', 'l', 'p', 'p'], 'l' )
+          nNumberOfCharsToWrite = lpBuffer.length()
+          lpNumberOfCharsWritten = ' ' * 4
+          lpReserved = ' ' * 4
+          @WriteConsole.call( hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten,  lpReserved )
+          return lpNumberOfCharsWritten
+        end
+
+        def WriteFile( hConsoleOutput, lpBuffer )
+          @WriteFile ||= Win32API.new( "kernel32", "WriteFile", ['l', 'p', 'l', 'p', 'p'], 'l' )
+          nNumberOfBytesToWrite = lpBuffer.length()
+          lpNumberOfBytesWritten = ' ' * 4
+          lpReserved = nil
+          @WriteFile.call( hConsoleOutput, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten,  lpReserved )
+          return lpNumberOfBytesWritten.unpack('L')
+        end
+
+        def WriteConsoleInput( hConsoleInput, lpBuffer )
+          @WriteConsoleInput ||= Win32API.new( "kernel32", "WriteConsoleInput", ['l', 'p', 'l', 'p'], 'l' )
+          @WriteConsoleInput.call( hConsoleInput, lpBuffer, nLength,  lpNumberOfEventsWritten )
+        end
+
+        # @@ Todo: Test this
+        def WriteConsoleOutput( hConsoleOutput, buffer, cols, rows, bufx, bufy, left, top, right, bottom )
+          @WriteConsoleOutput ||= Win32API.new( "kernel32", "WriteConsoleOutput", ['l', 'p', 'l', 'l', 'p'], 'l' )
+          lpBuffer = buffer.flatten.pack('ss' * buffer.length() * 2)
+          dwBufferSize = (buffer.length() << 16) + 2
+          dwBufferCoord = (row << 16) + col
+          lpWriteRegion = [ left, top, right, bottom ].pack('ssss')
+          @WriteConsoleOutput.call( hConsoleOutput, lpBuffer, dwBufferSize, dwBufferCoord, lpWriteRegion )
+        end
+
+        def WriteConsoleOutputAttribute( hConsoleOutput, lpAttribute, col, row )
+          @WriteConsoleOutputAttribute ||= Win32API.new( "kernel32", "WriteConsoleOutputAttribute", ['l', 'p', 'l', 'l', 'p'], 'l' )
+          nLength = lpAttribute.length()
+          dwWriteCoord = (row << 16) + col
+          lpNumberOfAttrsWritten = ' ' * 4
+          @WriteConsoleOutputAttribute.call( hConsoleOutput, lpAttribute, nLength, dwWriteCoord, lpNumberOfAttrsWritten )
+          return lpNumberOfAttrsWritten.unpack('L')
+        end
+
+        def WriteConsoleOutputCharacter( hConsoleOutput, lpCharacter, col, row )
+          @WriteConsoleOutputCharacter ||= Win32API.new( "kernel32", "WriteConsoleOutputCharacter", ['l', 'p', 'l', 'l', 'p'], 'l' )
+          nLength = lpCharacter.length()
+          dwWriteCoord = (row << 16) + col
+          lpNumberOfCharsWritten = ' ' * 4
+          @WriteConsoleOutputCharacter.call( hConsoleOutput, lpCharacter, nLength, dwWriteCoord, lpNumberOfCharsWritten )
+          return lpNumberOfCharsWritten.unpack('L')
+        end
+
+      end
+    end
+  end
+
+end