Windows Console I/O in Ruby


#1

Is there a Ruby equivalent to the WConio Python Module or similar conio
type support for windows?
(http://newcenturycomputers.net/projects/wconio.html)

If not, does anyone have some pointers or documention about porting
this module from Python to Ruby that might help me take a stab at it?

I appreciate any help.

–Matt


#2

seems like Ncurses does most of the same things as wconio.
http://ncurses-ruby.berlios.de/

I needed to compile PDCurses on windows to get ncurses to work:
http://pdcurses.sourceforge.net/

-Adam


#3

this may be of use,
http://rubyforge.org/projects/win32console/

and here’s the top of one of its rdoc files:
(there also are ANSI color options and escape-sequence options)

= NAME

Win32::Console - Win32 Console and Character Mode Functions

= DESCRIPTION

This module implements the Win32 console and character mode

functions. They give you full control on the console input and

output,

including: support of off-screen console buffers (eg. multiple screen

pages)

- reading and writing of characters, attributes and whole portions

of

the screen

- complete processing of keyboard and mouse events

- some very funny additional features :slight_smile:

Those functions should also make possible a port of the Unix’s curses

library; if there is anyone interested (and/or willing to contribute)

to this project, e-mail me. Thank you.

= REFERENCE

== Methods

- Alloc

Allocates a new console for the process. Returns C on errors,

a

nonzero value on success. A process cannot be associated with more

than one console, so this method will fail if there is already an

allocated console. Use Free to detach the process from the

console,

and then call Alloc to create a new console. See also: C

Example:

Win32::Console::Alloc()

- Attr [attr]

Gets or sets the current console attribute. This attribute is used

by

the Write method.

Example:

attr = console.Attr()

console.Attr(FG_YELLOW | BG_BLUE)

- Close

Closes a shortcut object. Note that it is not “strictly” required

to

close the objects you created, since the Win32::Shortcut objects

are

automatically closed when the program ends (or when you elsehow

destroy such an object).

Example:

link.Close()

- Cls [attr]

Clear the console, with the specified I if given, or using

ATTR_NORMAL otherwise.

Example:

console.Cls()

console.Cls(FG_WHITE | BG_GREEN)

- Cursor [x, y, size, visible]

Gets or sets cursor position and appearance. Returns C on

errors, or a 4-element list containing: I, I, I,

I. I and I are the current cursor position; …

Example:

x, y, size, visible = console.Cursor()

# Get position only

x, y = console.Cursor()

console.Cursor(40, 13, 50, 1)

# Set position only

console.Cursor(40, 13)

# Set size and visibility without affecting position

console.Cursor(-1, -1, 50, 1)

- Display

Displays the specified console on the screen. Returns C on

errors,

a nonzero value on success.

Example:

console.Display()

- FillAttr [attribute, number, col, row]

Fills the specified number of consecutive attributes, beginning at

I, I, with the value specified in I. Returns

the

number of attributes filled, or C on errors. See also:

C.

Example:

console.FillAttr(FG_BLACK | BG_BLACK, 80*25, 0, 0)

- FillChar char, number, col, row

Fills the specified number of consecutive characters, beginning at

I, I, with the character specified in I. Returns

the

number of characters filled, or C on errors. See also:

C.

Example:

console.FillChar(“X”, 80*25, 0, 0)

- Flush

Flushes the console input buffer. All the events in the buffer are

discarded. Returns C on errors, a nonzero value on success.

Example:

console.Flush()

- Free

Detaches the process from the console. Returns C on errors, a

nonzero value on success. See also: C.

Example:

Win32::Console::Free()

- GenerateCtrlEvent [type, processgroup]

Sends a break signal of the specified I to the specified

I. I can be one of the following constants:

CTRL_BREAK_EVENT

CTRL_C_EVENT

they signal, respectively, the pressing of Control + Break and of

Control + C; if not specified, it defaults to CTRL_C_EVENT.

I is the pid of a process sharing the same console.

If

omitted, it defaults to 0 (the current process), which is also the

only meaningful value that you can pass to this function. Returns

C on errors, a nonzero value on success.

Example:

# break this script now

Win32::Console::GenerateCtrlEvent()

- GetEvents

Returns the number of unread input events in the console’s input

buffer, or C on errors. See also: C, C,

C, C.

Example:

events = console.GetEvents()

- Info

Returns an array of informations about the console (or C on

errors), which contains:

* columns (X size) of the console buffer.

* rows (Y size) of the console buffer.

* current column (X position) of the cursor.

* current row (Y position) of the cursor.

* current attribute used for C.

* left column (X of the starting point) of the current console

window.

* top row (Y of the starting point) of the current console

window.

* right column (X of the final point) of the current console

window.

* bottom row (Y of the final point) of the current console

window.

* maximum number of columns for the console window, given the

current

buffer size, font and the screen size.

* maximum number of rows for the console window, given the

current

buffer size, font and the screen size.

See also: Attr, Cursor, Size, Window,

MaxWindow.

Example:

info = console.Info()

puts “Cursor at #{info[3]}, #{info[4]}.”

- Input

Reads an event from the input buffer. Returns an array of values,

which

depending on the event’s nature are:

- keyboard event

The array will contain:

* event type: 1 for keyboard

* key down: TRUE if the key is being pressed, FALSE if the key

is being released

* repeat count: the number of times the key is being held down

* virtual keycode: the virtual key code of the key

* virtual scancode: the virtual scan code of the key

* char: the ASCII code of the character (if the key is a

character key, 0 otherwise)

* control key state: the state of the control keys (SHIFTs,

CTRLs, ALTs, etc.)

- mouse event

The array will contain:

* event type: 2 for mouse

* mouse pos. X: X coordinate (column) of the mouse location

* mouse pos. Y: Y coordinate (row) of the mouse location

* button state: the mouse button(s) which are pressed

* control key state: the state of the control keys (SHIFTs,

CTRLs, ALTs, etc.)

* event flags: the type of the mouse event

This method will return nil on errors. Note that the events

returned are depending on the input Mode of the console; for

example,

mouse events are not intercepted unless ENABLE_MOUSE_INPUT is

specified. See also: GetEvents, InputChar,

Mode,

PeekInput, WriteInput.

Example:

event = console.Input()

- InputChar number

Reads and returns I characters from the console input

buffer,

or nil on errors. See also: Input, Mode.

Example:

key = console.InputChar(1)

- InputCP [codepage]

Gets or sets the input code page used by the console. Note that

this

doesn’t apply to a console object, but to the standard input

console. This attribute is used by the Write method. See also:

OutputCP.

Example:

codepage = Win32::Console::InputCP()

Win32::Console::InputCP(437)

- MaxWindow

Returns the size of the largest possible console window, based on

the

current font and the size of the display. The result is nil

on

errors, otherwise a 2-element list containing col, row.

Example:

maxCol, maxRow = console.MaxWindow()

- Mode [flags]

Gets or sets the input or output mode of a console. I can

be a

combination of the following constants:

ENABLE_LINE_INPUT

ENABLE_ECHO_INPUT

ENABLE_PROCESSED_INPUT

ENABLE_WINDOW_INPUT

ENABLE_MOUSE_INPUT

ENABLE_PROCESSED_OUTPUT

ENABLE_WRAP_AT_EOL_OUTPUT

For more informations on the meaning of those flags, please refer

to

the L<“Microsoft’s Documentation”>.

Example:

mode = console.Mode()

console.Mode(ENABLE_MOUSE_INPUT | ENABLE_PROCESSED_INPUT)

- MouseButtons

Returns the number of the buttons on your mouse, or nil on

errors.

Example:

puts “Your mouse has #{Win32::Console::MouseButtons()} buttons.”

- Win32::Console.new standard_handle

- Win32::Console.new [accessmode, sharemode]

Creates a new console object. The first form creates a handle to a

standard channel, I<standard_handle> can be one of the following:

STD_OUTPUT_HANDLE

STD_ERROR_HANDLE

STD_INPUT_HANDLE

The second form, instead, creates a console screen buffer in

memory,

which you can access for reading and writing as a normal console,

and

then redirect on the standard output (the screen) with

Display. In

this case, you can specify one or both of the following values for

I:

GENERIC_READ

GENERIC_WRITE

which are the permissions you will have on the created buffer, and

one

or both of the following values for I:

FILE_SHARE_READ

FILE_SHARE_WRITE

which affect the way the console can be shared. If you don’t

specify

any of those parameters, all 4 flags will be used.

Example:

stdout = Win32::Console.new(STD_OUTPUT_HANDLE)

stderr = Win32::Console.new(STD_ERROR_HANDLE)

stdin = Win32::Console.new(STD_INPUT_HANDLE)

buffer = Win32::Console.new()

buffer = Win32::Console.new(GENERIC_READ | GENERIC_WRITE)

[snip]