conio 1.0 → 1.1.0

data/LICENSE

@@ -1,5 +1,5 @@
 
-= Ruby Conio 1.0
+= Ruby Conio 1.1.0
 
 LICENSE
 

data/README

@@ -1,18 +1,19 @@
-= Ruby Conio 1.0
+= Ruby Conio 1.1.0
 
 Author: Gabriele Secci
 
 * http://rubyforge.org/projects/conio
+* http://rubygems.org/gems/conio
 * http://google.code.com/p/rubyconio
 
 == DESCRIPTION
 
-Ruby Conio 1.0 is a wrapper for Turbo C conio, used to create text user interfaces developed by Gabriele Secci.
+Ruby Conio 1.1.0 is a wrapper for Turbo C conio, used to create text user interfaces developed by Gabriele Secci.
 
 The functions of "libconio.so" are implemented in C ANSI using the "libconio.a" library and "conio.h" header, available from the site: "http://conio.sourceforge.net".
-Module "libconio.so" are compiled with mingw32-gcc from RDK (Ruby Development Kit).
+Module "libconio.so" is compiled with mingw32-gcc.
 
-For the bug or various problem, or source "libconio.c", please send me E-mail at:</i> mailto:ragnettosoftware@gmail.com
+For the bug or various problem, please send me E-mail at:</i> mailto:ragnettosoftware@gmail.com
 
 == INSTALL
 
@@ -22,43 +23,60 @@ GEM File:
 EXE File:
   * Double click in the exe file and follow the installation instruction.
 
-ZIP File:
-  * Extract the content from zip file and copy it in the gems folder of your Ruby interpreter.
-
 == EXAMPLE
 
 This is a simple example of conio module.
 
-  require "conio"
-
-  # Set the console title
-  settitle("Ruby Conio example...")
-
-  # Set the text color
-  textcolor(RED)
-
-  # Hide cursor
-  setcursortype(HIDE)
-
-  # Print message
-  print("Press ENTER key\n\n")
-
-  # Stop program while users press ENTER...
-  while getch() != 13
-    # nil
-  end
-
-  # Print message
-  print("OK! You are pressed ENTER key")
-
-  # Exit before 2 seconds
-  delay(2000)
+    require "conio"
+    
+    # Set the console title
+    Conio.settitle("Ruby Conio 1.1.0 [test.rb]")
+    
+    # Set the console window and buffer size
+    Conio.resize(80, 30)
+    
+    # Hide cursor
+    Conio.setcursortype(Conio::CURSOR_HIDE)
+    
+    # Put name module
+    Conio.write("Ruby Conio 1.1.0", 1, 0)
+    
+    # Put name script
+    Conio.write("test.rb", 72, 0)
+    
+    # Select cursor position
+    Conio.gotoxy(20, 29)
+    
+    # Put copyright
+    print("Copyright \xa9 2010 RAGNETTO \xb8 Software")
+    
+    # Put text attribute
+    Conio.fillattr(Conio::COLOR_WHITE, Conio::COLOR_RED, 80, 0, 0)
+    Conio.fillattr(Conio::COLOR_WHITE, Conio::COLOR_RED, 80, 0, 29)
+    
+    # Print message
+    Conio.write("Press F1 to exit...", 1, 3)
+    
+    # Stop program while users press F1...
+    while Conio.getkey() != Conio::KEY_F1
+      # nil
+      Conio.getkey()
+    end
+    
+    # Count exit time
+    for index in (-4..-1) do
+      # Print message
+      Conio.write("Program exit in 4 seconds: #{index}", 1, 27)
+      
+      # Exit before 4 seconds
+      Conio.sleep(1)
+    end
   
-For other examples see the "test" folder.
+Show this code in test folder [test.rb]
 
 == DEVELOPER
 
-* Author: Gabriele Secci
+* Author: Gabriele Secci - RAGNETTO Software
 * Web: http://www.ragnetto.altervista.org
 * E-mail: mailto:ragnettosoftware@gmail.com
 

data/Rakefile

@@ -1,40 +1,40 @@
-# Require ruby module
-require "rubygems"
-require "rake"
-require "rake/clean"
-require "rake/gempackagetask"
-require "rake/rdoctask"
-require "rake/testtask"
-
-spec = Gem::Specification.new do |s|
-  s.name = "conio"
-  s.version = "1.0"
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "LICENSE"]
-  s.summary = "Ruby Conio 1.0 is wrapper for Turbo C conio, used to create text user interfaces developed by Gabriele Secci."
-  s.description = "Library Console I/O for Ruby"
-  s.author = "Gabriele Secci"
-  s.email = "ragnettosoftware@gmail.com"
-  s.files = %w(LICENSE README Rakefile) + Dir.glob("{lib,test}/**/*")
-  s.require_path = "lib"
-  s.bindir = "bin"
-end
-
-Rake::GemPackageTask.new(spec) do |p|
-  p.gem_spec = spec
-  p.need_tar = false
-  p.need_zip = true
-end
-
-Rake::RDocTask.new do |rdoc|
-  files =["README", "LICENSE", "lib/conio.rb"]
-  rdoc.rdoc_files.add(files)
-  rdoc.main = "README"
-  rdoc.title = "Ruby Conio"
-  rdoc.rdoc_dir = "rdoc"
-  rdoc.options << "--line-numbers"
-end
-
-Rake::TestTask.new do |t|
-  t.test_files = FileList["test/test.rb"]
-end
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'conio'
+  s.version = '1.1.0'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README', 'LICENSE', 'ext/libconio.c']
+  s.summary = 'Ruby Conio is a wrapper for Turbo C conio.'
+  s.description = s.summary
+  s.author = 'Gabriele Secci'
+  s.email = 'ragnettosoftware@gmail.com'
+  # s.executables = ['your_executable_here']
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{ext,lib,test}/**/*")
+  s.require_path = "lib"
+  # s.bindir = "bin"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/conio.rb', 'ext/libconio.c']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README"
+  rdoc.title = "Ruby Conio 1.1.0"
+  rdoc.rdoc_dir = 'doc'
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/test.rb']
+end

data/ext/libconio.c

@@ -0,0 +1,1009 @@
+/*
+ *******************************************************
+ *                        Conio                        *
+ *******************************************************
+ *            Library Console I/O for Ruby             *
+ *******************************************************
+ * Title: Conio                                        *
+ * Version: 1.0                                        *
+ * Language: C                                         *
+ * Source: libconio.c                                  *
+ *******************************************************
+ * Author: Gabriele Secci                              *
+ * Company: RAGNETTO (R) Software                      *
+ * E-mail: ragnettosoftware@gmail.com                  *
+ * Web: www.ragnetto.altervista.org                    *
+ *******************************************************
+ *         Copyright (C) 2010 RAGNETTO Software        *
+ *******************************************************
+*/
+
+// C Headers
+#include <conio.h>
+#include <stdio.h>
+
+// Ruby headers
+#include "ruby.h"
+
+// declaration of Libconio Library
+VALUE Libconio = Qnil;
+
+// ***************************
+// * Conio Library Functions *
+// ***************************
+
+/*
+* call-seq:
+*   clreol()  -> nil
+*
+* Clears all characters from the cursor position to the end of the
+* line within the string length, in the location string.
+*/
+VALUE method_clreol(VALUE self)
+{
+	// Native function clreol()
+	clreol();
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   clrscr()  -> nil
+*
+* Clears the current text window and places the cursor in the
+* upper left hand corner at position 1, 1.
+*/
+VALUE method_clrscr(VALUE self)
+{
+	// Native function clrscr()
+	clrscr();
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   cputs(text)  -> string
+*
+* Writes the null-terminated string text to the current text window.
+*/
+VALUE method_cputs(VALUE self, VALUE string_text)
+{
+	// Ruby conversion string
+	const char * text = StringValuePtr(string_text);
+
+	// Native function cputs()
+	cputs(text);
+
+	// Return value text
+	return rb_str_new2(text);
+}
+
+/*
+* call-seq:
+*   crop()  -> nil
+*
+* Crop the window console buffer size.
+*/
+VALUE method_crop(VALUE self)
+{
+	// Native function crop()
+	con_crop();
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   delay(milliseconds)  -> nil
+*
+* The time interval for which execution is to be suspended, in milliseconds.
+*/
+VALUE method_delay(VALUE self, VALUE int_milliseconds)
+{
+	// Ruby conversion long
+	int milliseconds = NUM2LONG(int_milliseconds);
+
+	// Native function delay()
+	delay(milliseconds);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   delline()  -> nil
+*
+* Deletes the line containing the cursor and moves all lines below it a line up.
+*/
+VALUE method_delline(VALUE self)
+{
+	// Native function delline()
+	delline();
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   fill(character, forecolor, backcolor, number, x, y)  -> nil
+*
+* Write the specified number of consecutive characters, beginning at
+* X and Y coordinates, with the value specified attribute.
+*/
+VALUE method_fill(VALUE self, VALUE int_character, VALUE int_forecolor, VALUE int_backcolor, VALUE int_number, VALUE int_x, VALUE int_y)
+{
+	// Ruby conversion integer
+	int character = NUM2INT(int_character);
+	int forecolor = NUM2INT(int_forecolor);
+	int backcolor = NUM2INT(int_backcolor);
+	int number = NUM2INT(int_number);
+	int x = NUM2INT(int_x);
+	int y = NUM2INT(int_y);
+
+	// Native function fill()
+	con_fill(character, forecolor, backcolor, number, x, y);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   fillattr(forecolor, backcolor, number, x, y)  -> nil
+*
+* Fills the specified number of consecutive attributes, beginning at
+* X and Y coordinates, with the value specified attribute.
+*/
+VALUE method_fillattr(VALUE self, VALUE int_forecolor, VALUE int_backcolor, VALUE int_number, VALUE int_x, VALUE int_y)
+{
+	// Ruby conversion integer
+	int forecolor = NUM2INT(int_forecolor);
+	int backcolor = NUM2INT(int_backcolor);
+	int number = NUM2INT(int_number);
+	int x = NUM2INT(int_x);
+	int y = NUM2INT(int_y);
+
+	// Native function fillattr()
+	con_fillattr(forecolor, backcolor, number, x, y);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   fillchar(character, number, x, y)  -> nil
+*
+* Write the specified number of consecutive characters, beginning at X and Y coordinates.
+*/
+VALUE method_fillchar(VALUE self, VALUE int_character, VALUE int_number, VALUE int_x, VALUE int_y)
+{
+	// Ruby conversion integer
+	int character = NUM2INT(int_character);
+	int number = NUM2INT(int_number);
+	int x = NUM2INT(int_x);
+	int y = NUM2INT(int_y);
+
+	// Native function fillchar()
+	con_fillchar(character, number, x, y);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   fillcr(character, number, x, y)  -> nil
+*
+* Write the specified number of consecutive characters, beginning at X and Y coordinates.
+*/
+VALUE method_fillcr(VALUE self, VALUE int_character, VALUE int_number, VALUE int_x, VALUE int_y)
+{
+	// Ruby conversion integer
+	int character = NUM2INT(int_character);
+	int number = NUM2INT(int_number);
+	int x = NUM2INT(int_x);
+	int y = NUM2INT(int_y);
+
+	// Native function fillcr()
+	con_fillcr(character, number, x, y);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   get(left, top, right, bottom, buffer)  -> nil
+*
+* Get the contents with attributes of the memory area source out to the
+* onscreen rectangle defined by left, top, right and bottom.
+*/
+VALUE method_get(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom, VALUE int_buffer)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+	int buffer = NUM2INT(int_buffer);
+
+	// Declare variable dimension
+	int dimension[buffer];
+
+	// Native function get()
+	con_get(left, top, right, bottom, dimension);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   getattrs(left, top, right, bottom, buffer)  -> nil
+*
+* Get the attributes of the memory area source out to the onscreen
+* rectangle defined by left, top, right and bottom.
+*/
+VALUE method_getattrs(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom, VALUE int_buffer)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+	int buffer = NUM2INT(int_buffer);
+
+	// Declare variable dimension
+	int dimension[buffer];
+
+	// Native function getattrs()
+	con_getattrs(left, top, right, bottom, dimension);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   getch()  -> number
+*
+* Reads a single character directly from the keyboard, without echoing to the screen.
+*/
+VALUE method_getch(VALUE self)
+{
+	// Native function getch()
+	int character = getch();
+
+	// Return value character
+	return INT2NUM(character);
+}
+
+/*
+* call-seq:
+*   getchars(left, top, right, bottom, buffer)  -> nil
+*
+* Get the contents of the memory area source out to the onscreen rectangle defined by left, top, right and bottom.
+*/
+VALUE method_getchars(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom, VALUE int_buffer)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+	int buffer = NUM2INT(int_buffer);
+
+	// Declare variable dimension
+	char dimension[buffer];
+
+	// Native function getchars()
+	con_getchars(left, top, right, bottom, dimension);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   getche()  -> number
+*
+* Reads a single character from the keyboard and echoes it to the current text windows.
+*/
+VALUE method_getche(VALUE self)
+{
+	// Native function getche()
+	int character = getche();
+
+	// Return value character
+	return INT2NUM(character);
+}
+
+/*
+* call-seq:
+*   getinfo()  -> array
+*
+* Gets console information.
+*/
+VALUE method_getinfo(VALUE self)
+{
+	// Declare struct info
+	con_info info;
+
+	// Native function getinfo()
+	con_getinfo(& info);
+
+	// Set value info
+	int attr = info.attr;
+	int cx = info.cx;
+	int cy = info.cy;
+	int top = info.top;
+	int left = info.left;
+	int right = info.right;
+	int bottom = info.bottom;
+	int width = info.width;
+	int height = info.height;
+	int maxwidth = info.maxwidth;
+	int maxheight = info.maxheight;
+	int totalwidth = info.totalwidth;
+	int totalheight = info.totalheight;
+
+	// Create new Ruby hash
+	VALUE array = rb_ary_new();
+
+	// Populate Ruby hash
+	rb_ary_push(array, INT2NUM(attr));
+	rb_ary_push(array, INT2NUM(cx));
+	rb_ary_push(array, INT2NUM(cy));
+	rb_ary_push(array, INT2NUM(top));
+	rb_ary_push(array, INT2NUM(left));
+	rb_ary_push(array, INT2NUM(right));
+	rb_ary_push(array, INT2NUM(bottom));
+	rb_ary_push(array, INT2NUM(width));
+	rb_ary_push(array, INT2NUM(height));
+	rb_ary_push(array, INT2NUM(maxwidth));
+	rb_ary_push(array, INT2NUM(maxheight));
+	rb_ary_push(array, INT2NUM(totalwidth));
+	rb_ary_push(array, INT2NUM(totalheight));
+
+	// Return value hash
+	return array;
+}
+
+/*
+* call-seq:
+*   gettext(left, top, right, bottom, buffer)  -> nil
+*
+* Get the text of the memory area source out to the onscreen rectangle
+* defined by left, top, right and bottom.
+*/
+VALUE method_gettext(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom, VALUE int_buffer)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+	int buffer = NUM2INT(int_buffer);
+
+	// Declare variable dimension
+	char dimension[buffer];
+
+	// Native function gettext()
+	gettext(left, top, right, bottom, dimension);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   gettextinfo()  -> array
+*
+* Gets text mode video information.
+*/
+VALUE method_gettextinfo(VALUE self)
+{
+	// Declare struct info
+	text_info info;
+
+	// Native function gettextinfo()
+	gettextinfo(& info);
+
+	// Set value info
+	int attribute = info.attribute;
+	int normattr = info.normattr;
+	int currmode = info.currmode;
+	int curx = info.curx;
+	int cury = info.cury;
+	int screenwidth = info.screenwidth;
+	int screenheight = info.screenheight;
+	int winleft = info.winleft;
+	int wintop = info.wintop;
+	int winright = info.winright;
+	int winbottom = info.winbottom;
+
+	// Create new Ruby hash
+	VALUE array = rb_ary_new();
+
+	// Populate Ruby hash
+	rb_ary_push(array, INT2NUM(attribute));
+	rb_ary_push(array, INT2NUM(normattr));
+	rb_ary_push(array, INT2NUM(currmode));
+	rb_ary_push(array, INT2NUM(curx));
+	rb_ary_push(array, INT2NUM(cury));
+	rb_ary_push(array, INT2NUM(screenwidth));
+	rb_ary_push(array, INT2NUM(screenheight));
+	rb_ary_push(array, INT2NUM(winleft));
+	rb_ary_push(array, INT2NUM(wintop));
+	rb_ary_push(array, INT2NUM(winright));
+	rb_ary_push(array, INT2NUM(winbottom));
+
+	// Return value hash
+	return array;
+}
+
+/*
+* call-seq:
+*   gotoxy(x, y)  -> nil
+*
+* Moves the cursor to the given position in the current text window.
+*/
+VALUE method_gotoxy(VALUE self, VALUE int_x, VALUE int_y)
+{
+	// Ruby conversion integer
+	int x = NUM2INT(int_x);
+	int y = NUM2INT(int_y);
+
+	// Native function gotoxy()
+	gotoxy(x + 1, y + 1);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   insline()  -> nil
+*
+* Inserts an empty line in the text window at the cursor
+* position using the current text background color.
+*/
+VALUE method_insline(VALUE self)
+{
+	// Native function insline()
+	insline();
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   kbhit()  -> number
+*
+* Checks to see if a keystroke is currently available.
+*/
+VALUE method_kbhit(VALUE self)
+{
+	// Native function kbhit()
+	int key = kbhit();
+
+	// Return value key
+	return INT2NUM(key);
+}
+
+/*
+* call-seq:
+*   movetext(left, top, right, bottom, newleft, newtop)  -> nil
+*
+* Copies the contents of the onscreen rectangle defined by left, top, right, and bottom
+* to a new rectangle of the same dimensions.
+*/
+VALUE method_movetext(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom, VALUE int_newleft, VALUE int_newtop)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+	int newleft = NUM2INT(int_newleft);
+	int newtop = NUM2INT(int_newtop);
+
+	// Native function movetext()
+	movetext(left, top, right, bottom, newleft, newtop);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   put(left, top, right, bottom, buffer)  -> nil
+*
+* Put the contents with attributes of the memory area source out to the onscreen
+* rectangle defined by left, top, right and bottom.
+*/
+VALUE method_put(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom, VALUE int_buffer)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+	int buffer = NUM2INT(int_buffer);
+
+	// Declare variable dimension
+	int dimension[buffer];
+
+	// Native function put()
+	con_put(left, top, right, bottom, dimension);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   putattrs(left, top, right, bottom, buffer)  -> nil
+*
+* Put the attributes of the memory area source out to the onscreen
+* rectangle defined by left, top, right and bottom.
+*/
+VALUE method_putattrs(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom, VALUE int_buffer)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+	int buffer = NUM2INT(int_buffer);
+
+	// Declare variable dimension
+	int dimension[buffer];
+
+	// Native function putattrs()
+	con_putattrs(left, top, right, bottom, dimension);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   putch(character)  -> number
+*
+* Outputs the character c to the current text window.
+* It is a text-mode function that performs direct video output to the console.
+*/
+VALUE method_putch(VALUE self, VALUE int_character)
+{
+	// Ruby conversion integer
+	int character = NUM2INT(int_character);
+
+	// Native function putch()
+	int value = putchar(character);
+
+	// Return value character
+	return INT2NUM(value);
+}
+
+/*
+* call-seq:
+*   putchars(left, top, right, bottom, buffer)  -> nil
+*
+* Put the contents of the memory area source out to the onscreen
+* rectangle defined by left, top, right and bottom.
+*/
+VALUE method_putchars(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom, VALUE int_buffer)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+	int buffer = NUM2INT(int_buffer);
+
+	// Declare variable dimension
+	char dimension[buffer];
+
+	// Native function getattrs()
+	con_putchars(left, top, right, bottom, dimension);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   puttext(left, top, right, bottom, buffer)  -> nil
+*
+* Put the text of the memory area source out to the onscreen
+* rectangle defined by left, top, right and bottom.
+*/
+VALUE method_puttext(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom, VALUE int_buffer)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+	int buffer = NUM2INT(int_buffer);
+
+	// Declare variable dimension
+	char dimension[buffer];
+
+	// Native function puttext()
+	puttext(left, top, right, bottom, dimension);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   resize(width, height)  -> nil
+*
+* Resize buffer and window size.
+*/
+VALUE method_resize(VALUE self, VALUE int_width, VALUE int_height)
+{
+	// Ruby conversion integer
+	int width = NUM2INT(int_width);
+	int height = NUM2INT(int_height);
+
+	// Native function resize()
+	con_resize(width, height);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   scroll(left, top, right, bottom, newleft, newtop)  -> nil
+*
+* The console window displays a portion of the active screen buffer.
+*/
+VALUE method_scroll(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom, VALUE int_newleft, VALUE int_newtop)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+	int newleft = NUM2INT(int_newleft);
+	int newtop = NUM2INT(int_newtop);
+
+	// Native function scroll()
+	con_scroll(left, top, right, bottom, newleft, newtop);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   scrollup(left, top, right, bottom)  -> nil
+*
+* Scroll up the text in current window text.
+*/
+VALUE method_scrollup(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+
+	// Native function scrollup()
+	con_scrollup(left, top, right, bottom);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   scrolldown(left, top, right, bottom)  -> nil
+*
+* Scroll down the text in current window text.
+*/
+VALUE method_scrolldown(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+
+	// Native function scrolldown()
+	con_scrolldown(left, top, right, bottom);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   scrollleft(left, top, right, bottom)  -> nil
+*
+* Scroll left the text in current window text.
+*/
+VALUE method_scrollleft(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+
+	// Native function scrollleft()
+	con_scrollleft(left, top, right, bottom);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   scrollright(left, top, right, bottom)  -> nil
+*
+* Scroll right the text in current window text.
+*/
+VALUE method_scrollright(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+
+	// Native function scrollright()
+	con_scrollright(left, top, right, bottom);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   setbuffer(width, height)  -> nil
+*
+* Define a window buffer size.
+*/
+VALUE method_setbuffer(VALUE self, VALUE int_width, VALUE int_height)
+{
+	// Ruby conversion integer
+	int width = NUM2INT(int_width);
+	int height = NUM2INT(int_height);
+
+	// Native function setbuffer()
+	con_setbuffer(width, height);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   setcursortype(cursor)  -> nil
+*
+* Sets the cursor type in range 0 (hide cursor) to 100 (solid block cursor).
+*/
+VALUE method_setcursortype(VALUE self, VALUE int_cursor)
+{
+	// Ruby conversion integer
+	int cursor = NUM2INT(int_cursor);
+
+	// Native function setcursortype()
+	_setcursortype(cursor);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   settitle(title)  -> nil
+*
+* Change the console window title.
+*/
+VALUE method_settitle(VALUE self, VALUE string_title)
+{
+	// Ruby conversion string
+	const char * title = StringValuePtr(string_title);
+
+	// Native function settitle()
+	con_settitle(title);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   setwindow(left, top, right, bottom)  -> nil
+*
+* Defines a text window onscreen. If the coordinates are in
+* any way invalid, the call to window is ignored.
+*/
+VALUE method_setwindow(VALUE self, VALUE int_left, VALUE int_top, VALUE int_right, VALUE int_bottom)
+{
+	// Ruby conversion integer
+	int left = NUM2INT(int_left);
+	int top = NUM2INT(int_top);
+	int right = NUM2INT(int_right);
+	int bottom = NUM2INT(int_bottom);
+
+	// Native function setwindow()
+	con_setwindow(left, top, right, bottom);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   sleep(seconds)  -> nil
+*
+* The time interval for which execution is to be suspended, in seconds.
+*/
+VALUE method_sleep(VALUE self, VALUE int_seconds)
+{
+	// Ruby conversion integer
+	int seconds = NUM2INT(int_seconds);
+
+	// Native function sleep()
+	sleep(seconds);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   textbackground(color)  -> nil
+*
+* Selects the background character color.
+*/
+VALUE method_textbackground(VALUE self, VALUE int_color)
+{
+	// Ruby conversion integer
+	int color = NUM2INT(int_color);
+
+	// Native function textbackground()
+	textbackground(color);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   textcolor(color)  -> nil
+*
+* Selects the foreground character color.
+*/
+VALUE method_textcolor(VALUE self, VALUE int_color)
+{
+	// Ruby conversion integer
+	int color = NUM2INT(int_color);
+
+	// Native function textcolor()
+	textcolor(color);
+
+	// Return NULL value
+	return Qnil;
+}
+
+/*
+* call-seq:
+*   ungetch(character)  -> number
+*
+* Pushes the character ch back to the console, causing ch to be the next character read.
+*/
+VALUE method_ungetch(VALUE self, VALUE int_character)
+{
+	// Ruby conversion integer
+	int character = NUM2INT(int_character);
+
+	// Native function ungetch()
+	int value = ungetch(character);
+
+	// Return value character
+	return INT2NUM(value);
+}
+
+/*
+* call-seq:
+*   wherex()  -> number
+*
+* Gets the X coordinate of the current cursor position (within the current text window).
+*/
+VALUE method_wherex(VALUE self)
+{
+
+	// Native function wherex()
+	int position = wherex() - 1;
+
+	// Return NULL value
+	return INT2NUM(position);
+}
+
+/*
+* call-seq:
+*   wherey()  -> number
+*
+* Gets the Y coordinate of the current cursor position (within the current text window).
+*/
+VALUE method_wherey(VALUE self)
+{
+
+	// Native function wherex()
+	int position = wherey() - 1;
+
+	// Return NULL value
+	return INT2NUM(position);
+}
+
+// *************************
+// * Conio Library Methods *
+// *************************
+
+void Init_libconio()
+{
+	// Libconio Library
+	Libconio = rb_define_module("Libconio");
+
+	// Libconio Methods
+	rb_define_method(Libconio, "clreol", method_clreol, 0);
+	rb_define_method(Libconio, "clrscr", method_clrscr, 0);
+	rb_define_method(Libconio, "cputs", method_cputs, 1);
+	rb_define_method(Libconio, "crop", method_crop, 0);
+	rb_define_method(Libconio, "delay", method_delay, 1);
+	rb_define_method(Libconio, "delline", method_delline, 0);
+	rb_define_method(Libconio, "fill", method_fill, 6);
+	rb_define_method(Libconio, "fillattr", method_fillattr, 5);
+	rb_define_method(Libconio, "fillchar", method_fillchar, 4);
+	rb_define_method(Libconio, "fillcr", method_fillcr, 4);
+	rb_define_method(Libconio, "get", method_get, 5);
+	rb_define_method(Libconio, "getattrs", method_getattrs, 5);
+	rb_define_method(Libconio, "getch", method_getch, 0);
+	rb_define_method(Libconio, "getchars", method_getchars, 5);
+	rb_define_method(Libconio, "getche", method_getche, 0);
+	rb_define_method(Libconio, "getinfo", method_getinfo, 0);
+	rb_define_method(Libconio, "gettext", method_gettext, 5);
+	rb_define_method(Libconio, "gettextinfo", method_gettextinfo, 0);
+	rb_define_method(Libconio, "gotoxy", method_gotoxy, 2);
+	rb_define_method(Libconio, "insline", method_insline, 0);
+	rb_define_method(Libconio, "movetext", method_movetext, 6);
+	rb_define_method(Libconio, "put", method_put, 5);
+	rb_define_method(Libconio, "putattrs", method_putattrs, 5);
+	rb_define_method(Libconio, "putch", method_putch, 1);
+	rb_define_method(Libconio, "putchars", method_putchars, 5);
+	rb_define_method(Libconio, "puttext", method_puttext, 5);
+	rb_define_method(Libconio, "resize", method_resize, 2);
+	rb_define_method(Libconio, "scroll", method_scroll, 6);
+	rb_define_method(Libconio, "scrollup", method_scrollup, 4);
+	rb_define_method(Libconio, "scrolldown", method_scrolldown, 4);
+	rb_define_method(Libconio, "scrollleft", method_scrollleft, 4);
+	rb_define_method(Libconio, "scrollright", method_scrollright, 4);
+	rb_define_method(Libconio, "setbuffer", method_setbuffer, 2);
+	rb_define_method(Libconio, "setcursortype", method_setcursortype, 1);
+	rb_define_method(Libconio, "settitle", method_settitle, 1);
+	rb_define_method(Libconio, "setwindow", method_setwindow, 4);
+	rb_define_method(Libconio, "sleep", method_sleep, 1);
+	rb_define_method(Libconio, "textbackground", method_textbackground, 1);
+	rb_define_method(Libconio, "textcolor", method_textcolor, 1);
+	rb_define_method(Libconio, "ungetch", method_ungetch, 1);
+	rb_define_method(Libconio, "wherex", method_wherex, 0);
+	rb_define_method(Libconio, "wherey", method_wherey, 0);
+}