/*

* ncurses-ruby is a ruby module for accessing the FSF's ncurses library

* (C) 2002, 2003, 2004 Tobias Peters <t-peters@berlios.de>

* (C) 2004 Simon Kaczor <skaczor@cox.net>

* (C) 2005 2006 2009 2011 Tobias Herzke

*

* This module is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2 of the License, or (at your option) any later version.

*

* This module is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this module; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

*

* $Id: ncurses_wrap.c,v 1.20 2011-05-30 23:28:23 t-peters Exp $

*

* This file was adapted from the original ncurses header file which

* has the following copyright statements:

*/

/****************************************************************************

* Copyright (c) 1998 Free Software Foundation, Inc. *

* *

* Permission is hereby granted, free of charge, to any person obtaining a *

* copy of this software and associated documentation files (the *

* "Software"), to deal in the Software without restriction, including *

* without limitation the rights to use, copy, modify, merge, publish, *

* distribute, distribute with modifications, sublicense, and/or sell *

* copies of the Software, and to permit persons to whom the Software is *

* furnished to do so, subject to the following conditions: *

* *

* The above copyright notice and this permission notice shall be included *

* in all copies or substantial portions of the Software. *

* *

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *

* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *

* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *

* IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *

* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *

* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *

* THE USE OR OTHER DEALINGS IN THE SOFTWARE. *

* *

* Except as contained in this notice, the name(s) of the above copyright *

* holders shall not be used in advertising or otherwise to promote the *

* sale, use or other dealings in this Software without prior written *

* authorization. *

****************************************************************************/

/****************************************************************************

* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 *

* and: Eric S. Raymond <esr@snark.thyrsus.com> *

****************************************************************************/

/*

NOT IMPLEMENTED:

- terminfo, termcap-functions

- rippoffline

- v*printw functions (but normal printw functions are supported!)

*/

#include "ncurses_wrap.h"

#ifdef HAVE_LOCALE_H

#include <locale.h>

#endif

VALUE mNcurses; /* module Ncurses */

VALUE cWINDOW; /* class Ncurses::WINDOW */

VALUE cSCREEN; /* class Ncurses::SCREEN */

VALUE eNcurses; /* Ncurses::Exception thrown by this extension */

static void Init_ncurses_full(void);

static

void

init_constants_1(void)

{

#ifdef CURSES

rb_define_const(mNcurses, "CURSES", INT2NUM((int)(CURSES)));

#endif

#ifdef CURSES_H

rb_define_const(mNcurses, "CURSES_H", INT2NUM((int)(CURSES_H)));

#endif

#ifdef NCURSES_VERSION_MAJOR

rb_define_const(mNcurses, "NCURSES_VERSION_MAJOR",

INT2NUM((int)(NCURSES_VERSION_MAJOR)));

#endif

#ifdef NCURSES_VERSION_MINOR

rb_define_const(mNcurses, "NCURSES_VERSION_MINOR",

INT2NUM((int)(NCURSES_VERSION_MINOR)));

#endif

#ifdef NCURSES_VERSION_PATCH

rb_define_const(mNcurses, "NCURSES_VERSION_PATCH",

INT2NUM((int)(NCURSES_VERSION_PATCH)));

#endif

#ifdef NCURSES_VERSION

rb_define_const(mNcurses, "NCURSES_VERSION",

rb_str_new2(NCURSES_VERSION));

#endif

/* attributes */

#ifdef WA_ATTRIBUTES

rb_define_const(mNcurses, "WA_ATTRIBUTES", INT2NUM(WA_ATTRIBUTES));

rb_define_const(mNcurses, "WA_NORMAL", INT2NUM(WA_NORMAL));

rb_define_const(mNcurses, "WA_STANDOUT", INT2NUM(WA_STANDOUT));

rb_define_const(mNcurses, "WA_UNDERLINE", INT2NUM(WA_UNDERLINE));

rb_define_const(mNcurses, "WA_REVERSE", INT2NUM(WA_REVERSE));

rb_define_const(mNcurses, "WA_BLINK", INT2NUM(WA_BLINK));

rb_define_const(mNcurses, "WA_DIM", INT2NUM(WA_DIM));

rb_define_const(mNcurses, "WA_BOLD", INT2NUM(WA_BOLD));

rb_define_const(mNcurses, "WA_ALTCHARSET", INT2NUM(WA_ALTCHARSET));

rb_define_const(mNcurses, "WA_INVIS", INT2NUM(WA_INVIS));

rb_define_const(mNcurses, "WA_PROTECT", INT2NUM(WA_PROTECT));

rb_define_const(mNcurses, "WA_HORIZONTAL", INT2NUM(WA_HORIZONTAL));

rb_define_const(mNcurses, "WA_LEFT", INT2NUM(WA_LEFT));

rb_define_const(mNcurses, "WA_LOW", INT2NUM(WA_LOW));

rb_define_const(mNcurses, "WA_RIGHT", INT2NUM(WA_RIGHT));

rb_define_const(mNcurses, "WA_TOP", INT2NUM(WA_TOP));

rb_define_const(mNcurses, "WA_VERTICAL", INT2NUM(WA_VERTICAL));

#endif

/* locale flags */

#ifdef HAVE_LOCALE_H

rb_define_const(mNcurses, "LC_ALL", INT2NUM(LC_ALL));

rb_define_const(mNcurses, "LC_COLLATE", INT2NUM(LC_COLLATE));

rb_define_const(mNcurses, "LC_CTYPE", INT2NUM(LC_CTYPE));

rb_define_const(mNcurses, "LC_MESSAGES", INT2NUM(LC_MESSAGES));

rb_define_const(mNcurses, "LC_MONETARY", INT2NUM(LC_MONETARY));

rb_define_const(mNcurses, "LC_NUMERIC", INT2NUM(LC_NUMERIC));

rb_define_const(mNcurses, "LC_TIME", INT2NUM(LC_TIME));

#endif

}

static VALUE rbncurs_COLORS()

{return INT2NUM(COLORS);}

static VALUE rbncurs_COLOR_PAIRS()

{return INT2NUM(COLOR_PAIRS);}

static

void

init_globals_1(void)

{

/* colors */

NCFUNC(COLORS, 0);

NCFUNC(COLOR_PAIRS, 0);

}

static

void

init_constants_2(void)

{

rb_define_const(mNcurses, "COLOR_BLACK", INT2NUM(COLOR_BLACK));

rb_define_const(mNcurses, "COLOR_RED", INT2NUM(COLOR_RED));

rb_define_const(mNcurses, "COLOR_GREEN", INT2NUM(COLOR_GREEN));

rb_define_const(mNcurses, "COLOR_YELLOW", INT2NUM(COLOR_YELLOW));

rb_define_const(mNcurses, "COLOR_BLUE", INT2NUM(COLOR_BLUE));

rb_define_const(mNcurses, "COLOR_MAGENTA", INT2NUM(COLOR_MAGENTA));

rb_define_const(mNcurses, "COLOR_CYAN", INT2NUM(COLOR_CYAN));

rb_define_const(mNcurses, "COLOR_WHITE", INT2NUM(COLOR_WHITE));

rb_define_const(mNcurses, "ERR", INT2NUM(ERR));

rb_define_const(mNcurses, "OK", INT2NUM(OK));

/* values for the _flags member */

#ifdef _SUBWIN

rb_define_const(mNcurses, "SUBWIN", INT2NUM(_SUBWIN));

#endif

#ifdef _ENDLINE

rb_define_const(mNcurses, "ENDLINE", INT2NUM(_ENDLINE));

#endif

#ifdef _FULLWIN

rb_define_const(mNcurses, "FULLWIN", INT2NUM(_FULLWIN));

#endif

#ifdef _SCROLLWIN

rb_define_const(mNcurses, "SCROLLWIN", INT2NUM(_SCROLLWIN));

#endif

#ifdef _ISPAD

rb_define_const(mNcurses, "ISPAD", INT2NUM(_ISPAD));

#endif

#ifdef _HASMOVED

rb_define_const(mNcurses, "HASMOVED", INT2NUM(_HASMOVED));

#endif

#ifdef _WRAPPED

rb_define_const(mNcurses, "WRAPPED", INT2NUM(_WRAPPED));

#endif

#ifdef _NOCHANGE

/*

* this value is used in the firstchar and lastchar fields to mark

* unchanged lines

*/

rb_define_const(mNcurses, "NOCHANGE", INT2NUM(_NOCHANGE));

#endif

#ifdef _NEWINDEX

/*

* this value is used in the oldindex field to mark lines created by

* insertions and scrolls.

*/

rb_define_const(mNcurses, "NEWINDEX", INT2NUM(_NEWINDEX));

#endif

#ifdef CCHARW_MAX

rb_define_const(mNcurses, "CCHARW_MAX", INT2NUM(CCHARW_MAX));

#endif

}

/// Portable (1.8,1.9) determination of array length (calling #length)

long rbncurs_array_length(VALUE array)

{

return NUM2LONG(rb_funcall(array, rb_intern("length"), 0));

}

VALUE wrap_window(WINDOW* window)

{

if (window == 0) return Qnil;

{

VALUE windows_hash = rb_iv_get(mNcurses, "@windows_hash");

VALUE window_adress = INT2NUM((long)(window));

VALUE rb_window = rb_hash_aref(windows_hash, window_adress);

if (rb_window == Qnil) {

rb_window = Data_Wrap_Struct(cWINDOW, 0, 0, window);

rb_iv_set(rb_window, "@destroyed", Qfalse);

rb_hash_aset(windows_hash, window_adress, rb_window);

}

return rb_window;

}

}

WINDOW* get_window(VALUE rb_window)

{

WINDOW* window;

if (rb_window == Qnil) return 0;

if (rb_iv_get(rb_window, "@destroyed") == Qtrue) {

rb_raise(eNcurses, "Attempt to access a destroyed window");

return 0;

}

Data_Get_Struct(rb_window, WINDOW, window);

return window;

}

static VALUE rbncurs_delwin(VALUE dummy, VALUE arg1) {

VALUE windows_hash = rb_iv_get(mNcurses, "@windows_hash");

WINDOW* window = get_window(arg1);

VALUE window_adress = INT2NUM((long)(window));

rb_funcall(windows_hash, rb_intern("delete"), 1, window_adress);

rb_iv_set(arg1, "@destroyed", Qtrue);

return INT2NUM(delwin(window));

}

static VALUE wrap_screen(SCREEN* screen)

{

if (screen == 0) return Qnil;

{

VALUE screens_hash = rb_iv_get(mNcurses, "@screens_hash");

VALUE screen_adress = INT2NUM((long)(screen));

VALUE rb_screen = rb_hash_aref(screens_hash, screen_adress);

if (rb_screen == Qnil) {

rb_screen = Data_Wrap_Struct(cSCREEN, 0, 0, screen);

rb_iv_set(rb_screen, "@destroyed", Qfalse);

rb_hash_aset(screens_hash, screen_adress, rb_screen);

}

return rb_screen;

}

}

static SCREEN* get_screen(VALUE rb_screen)

{

SCREEN* screen;

if (rb_screen == Qnil) return 0;

if (rb_iv_get(rb_screen, "@destroyed") == Qtrue) {

rb_raise(eNcurses, "Attempt to access a destroyed screen");

return 0;

}

Data_Get_Struct(rb_screen, SCREEN, screen);

return screen;

}

#ifdef HAVE_DELSCREEN

static VALUE rbncurs_delscreen(VALUE dummy, VALUE arg1) {

VALUE screens_hash = rb_iv_get(mNcurses, "@screens_hash");

SCREEN* screen = get_screen(arg1);

VALUE screen_adress = INT2NUM((long)(screen));

rb_funcall(screens_hash, rb_intern("delete"), 1, screen_adress);

rb_iv_set(arg1, "@destroyed", Qtrue);

delscreen(screen);

return Qnil;

}

#endif

static VALUE rbncurs_winchnstr(VALUE dummy, VALUE rb_win, VALUE rb_str, VALUE rb_n)

{

if (rb_obj_is_instance_of(rb_str, rb_cArray) != Qtrue) {

rb_raise(rb_eArgError, "2nd argument must be an empty Array");

return Qnil;

}

{

WINDOW * window = get_window(rb_win);

int n = NUM2INT(rb_n);

chtype * str = ALLOC_N(chtype, n + 1);

int return_value;

return_value = winchnstr(window, str, n);

if (return_value != ERR) {

int i;

for (i = 0; i < return_value; ++i) {

rb_ary_push(rb_str, INT2NUM(str[i]));

}

}

xfree(str);

return INT2NUM(return_value);

}

}

static VALUE rbncurs_wgetnstr(VALUE dummy, VALUE rb_win, VALUE rb_chstr, VALUE rb_n)

{

WINDOW * window = get_window(rb_win);

int n = NUM2INT(rb_n);

char * str = ALLOC_N(char, n + 1);

int return_value;

return_value = wgetnstr(window, str, n);

if (return_value != ERR) {

rb_str_cat2(rb_chstr, str);

}

xfree(str);

return INT2NUM(return_value);

}

static VALUE rbncurs_winnstr(VALUE dummy, VALUE rb_win, VALUE rb_chstr, VALUE rb_n)

{

WINDOW * window = get_window(rb_win);

int n = NUM2INT(rb_n);

char* str = ALLOC_N(char, n + 1);

int return_value;

return_value = winnstr(window, str, n);

if (return_value != ERR) {

rb_str_cat(rb_chstr, str, return_value);

}

xfree(str);

return INT2NUM(return_value);

}

#if defined(HAVE_PANEL_H) || defined(HAVE_NCURSESW_PANEL_H)

#include "panel_wrap.h" /* needs access to mNcurses, wrap_window, get_window */

#endif

#if defined(HAVE_FORM_H) || defined(HAVE_NCURSESW_FORM_H)

#include "form_wrap.h" /* needs init_form */

#endif

#if defined(HAVE_MENU_H) || defined(HAVE_NCURSESW_MENU_H)

#include "menu_wrap.h" /* needs init_menu */

#endif

static

void

init_functions_0(void)

{

#ifdef HAVE_DELSCREEN

NCFUNC(delscreen, 1);

#endif

NCFUNC(delwin, 1);

NCFUNC(winchnstr, 3);

NCFUNC(winnstr, 3);

NCFUNC(wgetnstr, 3);

}

static VALUE get_stdscr()

{

VALUE rb_stdscr = rb_iv_get(mNcurses, "@stdscr");

if (rb_stdscr == Qnil) {

rb_stdscr = wrap_window(stdscr);

rb_iv_set(mNcurses, "@stdscr", rb_stdscr);

}

return rb_stdscr;

}

static VALUE get_curscr()

{

VALUE rb_curscr = rb_iv_get(mNcurses, "@curscr");

if (rb_curscr == Qnil) {

rb_curscr = wrap_window(curscr);

rb_iv_set(mNcurses, "@curscr", rb_curscr);

}

return rb_curscr;

}

#ifdef HAVE_NEWSCR

static VALUE get_newscr()

{

VALUE rb_newscr = rb_iv_get(mNcurses, "@newscr");

if (rb_newscr == Qnil) {

rb_newscr = wrap_window(newscr);

rb_iv_set(mNcurses, "@newscr", rb_newscr);

}

return rb_newscr;

}

#endif

static VALUE get_LINES() {return INT2NUM(LINES);}

static VALUE get_COLS() {return INT2NUM(COLS);}

#ifdef HAVE_TABSIZE

static VALUE get_TABSIZE() {return INT2NUM(TABSIZE);}

#endif

#ifdef HAVE_ESCDELAY

/* This global was an undocumented feature under AIX curses. */

/* ESC expire time in milliseconds */

static VALUE get_ESCDELAY(){return INT2NUM(ESCDELAY);}

static VALUE set_ESCDELAY(VALUE dummy, VALUE new_delay)

{

ESCDELAY=NUM2INT(new_delay);

return INT2NUM(ESCDELAY);

}

#endif

/* This global is wrapper-specific. It denotes the interval after which the

terminal is periodically checked for having resized or not. */

/* time in milliseconds */

static VALUE get_RESIZEDELAY(){return rb_iv_get(mNcurses, "@resize_delay");}

static VALUE set_RESIZEDELAY(VALUE dummy, VALUE rb_new_delay)

{

int c_new_delay = NUM2INT(rb_new_delay);

if (c_new_delay <= 0)

rb_raise(rb_eArgError, "delay must be > 0");

rb_new_delay = INT2NUM(c_new_delay);

rb_iv_set(mNcurses, "@resize_delay", rb_new_delay);

return rb_new_delay ;

}

static

void

init_globals_2(void)

{

rb_iv_set(mNcurses, "@stdscr", Qnil);

rb_iv_set(mNcurses, "@curscr", Qnil);

rb_iv_set(mNcurses, "@newscr", Qnil);

rb_define_module_function(mNcurses, "stdscr",

(&get_stdscr), 0);

rb_define_module_function(mNcurses, "curscr",

(&get_curscr), 0);

#ifdef HAVE_NEWSCR

rb_define_module_function(mNcurses, "newscr",

(&get_newscr), 0);

#endif

rb_define_module_function(mNcurses, "LINES",

(&get_LINES), 0);

rb_define_module_function(mNcurses, "COLS",

(&get_COLS), 0);

#ifdef HAVE_TABSIZE

rb_define_module_function(mNcurses, "TABSIZE",

(&get_TABSIZE),0);

#endif

#ifdef HAVE_ESCDELAY

rb_define_module_function(mNcurses, "ESCDELAY",

(&get_ESCDELAY),0);

rb_define_module_function(mNcurses, "ESCDELAY=",

(&set_ESCDELAY),1);

#endif

/* The maximum delay before screen resize is detected, in milliseconds */

rb_iv_set(mNcurses, "@resize_delay", INT2FIX(333));

rb_define_module_function(mNcurses, "RESIZEDELAY",

(&get_RESIZEDELAY),0);

rb_define_module_function(mNcurses, "RESIZEDELAY=",

(&set_RESIZEDELAY),1);

}

#ifdef HAVE_KEYBOUND

static VALUE rbncurs_keybound(VALUE dummy, VALUE keycode, VALUE count)

{

char * str = keybound(NUM2INT(keycode), NUM2INT(count));

VALUE rb_str = Qnil;

if (str) {

rb_str = rb_str_new2(str);

free(str);

}

return rb_str;

}

#endif

#ifdef HAVE_CURSES_VERSION

static VALUE rbncurs_curses_version(){return rb_str_new2(curses_version());}

#endif

#ifdef HAVE_DEFINE_KEY

static VALUE rbncurs_define_key(VALUE dummy, VALUE definition, VALUE keycode)

{

return INT2NUM(define_key((definition != Qnil)

? StringValuePtr(definition)

: (char*)(NULL),

NUM2INT(keycode)));

}

#endif

#ifdef HAVE_KEYOK

static VALUE rbncurs_keyok(VALUE dummy, VALUE keycode, VALUE enable)

{

return INT2NUM(keyok(NUM2INT(keycode), RTEST(enable)));

}

#endif

#ifdef HAVE_RESIZETERM

static VALUE rbncurs_resizeterm(VALUE dummy, VALUE lines, VALUE columns)

{

return INT2NUM(resizeterm(NUM2INT(lines), NUM2INT(columns)));

}

#endif

#ifdef HAVE_USE_DEFAULT_COLORS

static VALUE rbncurs_use_default_colors()

{

return INT2NUM(use_default_colors());

}

#endif

#ifdef HAVE_USE_EXTENDED_NAMES

static VALUE rbncurs_use_extended_names(VALUE dummy, VALUE boolean)

{return INT2NUM(use_extended_names(RTEST(boolean)));}

#endif

#ifdef HAVE_WRESIZE

static VALUE rbncurs_wresize(VALUE dummy, VALUE win, VALUE lines, VALUE columns)

{

return INT2NUM(wresize(get_window(win), NUM2INT(lines), NUM2INT(columns)));

}

#endif

static

void

init_functions_1(void)

{

#ifdef HAVE_KEYBOUND

NCFUNC(keybound, 2);

#endif

#ifdef HAVE_CURSES_VERSION

NCFUNC(curses_version, 0);

#endif

#ifdef HAVE_DEFINE_KEY

NCFUNC(define_key, 2);

#endif

#ifdef HAVE_KEYOK

NCFUNC(keyok, 2);

#endif

#ifdef HAVE_RESIZETERM

NCFUNC(resizeterm, 2);

#endif

#ifdef HAVE_USE_DEFAULT_COLORS

NCFUNC(use_default_colors, 0);

#endif

#ifdef HAVE_USE_EXTENDED_NAMES

NCFUNC(use_extended_names, 1);

#endif

#ifdef HAVE_WRESIZE

NCFUNC(wresize, 3);

#endif

}

/* FIXME: what's this? */

/* extern char ttytype[]; */ /* needed for backward compatibility */

/* copy a chstr from ruby to c */

static chtype * RB2CHSTR(VALUE array)

{

if (rb_obj_is_instance_of(array, rb_cArray) != Qtrue) {

rb_raise(rb_eArgError,

"chtype string argument must be an empty Array");

return NULL;

}

{

size_t string_length =

NUM2ULONG(rb_funcall(array, rb_intern("size"), 0));

size_t vector_length =

string_length + 1; /* for terminating 0 */

chtype * chstr = ALLOC_N(chtype, vector_length);

unsigned long i;

for (i = 0; i < string_length; ++i) {

chstr[i] = NUM2ULONG(rb_ary_entry(array, i));

}

chstr[string_length] = 0;

return chstr;

}

}

static VALUE rbncurs_addch(VALUE dummy, VALUE arg1) {

return INT2NUM(addch(NUM2ULONG(arg1)));

}

static VALUE rbncurs_addchnstr(VALUE dummy, VALUE arg1, VALUE arg2) {

chtype * chstr = RB2CHSTR(arg1);

VALUE return_value = INT2NUM(addchnstr(chstr, NUM2INT(arg2)));

xfree(chstr);

return return_value;

}

static VALUE rbncurs_addchstr(VALUE dummy, VALUE arg1) {

chtype * chstr = RB2CHSTR(arg1);

VALUE return_value = INT2NUM(addchstr(chstr));

xfree(chstr);

return return_value;

}

static VALUE rbncurs_addnstr(VALUE dummy, VALUE arg1, VALUE arg2) {

return INT2NUM(addnstr(StringValuePtr(arg1), NUM2INT(arg2)));

}

static VALUE rbncurs_addstr(VALUE dummy, VALUE arg1) {

return INT2NUM(addstr(StringValuePtr(arg1)));

}

static VALUE rbncurs_attroff(VALUE dummy, VALUE arg1) {

return INT2NUM(attroff(NUM2ULONG(arg1)));

}

static VALUE rbncurs_attron(VALUE dummy, VALUE arg1) {

return INT2NUM(attron(NUM2ULONG(arg1)));

}

static VALUE rbncurs_attrset(VALUE dummy, VALUE arg1) {

return INT2NUM(attrset(NUM2ULONG(arg1)));

}

#if defined(NCURSES_VERSION_MAJOR) && NCURSES_VERSION_MAJOR > 4

#ifdef HAVE_ATTR_OFF

static VALUE rbncurs_attr_off(VALUE dummy, VALUE arg1, VALUE arg2) {

return INT2NUM(attr_off(NUM2ULONG(arg1), ((void)(arg2),NULL)));

}

#endif

#ifdef HAVE_ATTR_ON

static VALUE rbncurs_attr_on(VALUE dummy, VALUE arg1, VALUE arg2) {

return INT2NUM(attr_on(NUM2ULONG(arg1), ((void)(arg2),NULL)));

}

#endif

#ifdef HAVE_ATTR_SET

static VALUE rbncurs_attr_set(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3) {

return INT2NUM(attr_set(NUM2ULONG(arg1), NUM2INT(arg2), ((void)(arg3),NULL)));

}

#endif

#if defined(HAVE_SLK_ATTR_OFF) || defined(slk_attr_off)

static VALUE rbncurs_slk_attr_off(VALUE dummy, VALUE arg1, VALUE arg2) {

return INT2NUM(slk_attr_off(NUM2ULONG(arg1), ((void)(arg2),NULL)));

}

#endif

#if defined(HAVE_SLK_ATTR_ON) || defined(slk_attr_on)

static VALUE rbncurs_slk_attr_on(VALUE dummy, VALUE arg1, VALUE arg2) {

return INT2NUM(slk_attr_on(NUM2ULONG(arg1), ((void)(arg2),NULL)));

}

#endif

#ifdef HAVE_SLK_ATTR_SET

static VALUE rbncurs_slk_attr_set(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3) {

return INT2NUM(slk_attr_set(NUM2ULONG(arg1), NUM2INT(arg2), ((void)(arg3),NULL)));

}

#endif

#ifdef HAVE_WATTR_ON

static VALUE rbncurs_wattr_on(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3) {

return INT2NUM(wattr_on(get_window(arg1), NUM2ULONG(arg2), ((void)(arg3),NULL)));

}

#endif

#ifdef HAVE_WATTR_OFF

static VALUE rbncurs_wattr_off(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3) {

return INT2NUM(wattr_off(get_window(arg1), NUM2ULONG(arg2), ((void)(arg3),NULL)));

}

#endif

#ifdef HAVE_WATTR_SET

static VALUE rbncurs_wattr_set(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4) {

return INT2NUM(wattr_set(get_window(arg1), NUM2ULONG(arg2), NUM2INT(arg3), ((void)(arg4),NULL)));

}

#endif

#if defined(HAVE_VID_ATTR) || defined(vid_attr)

static VALUE rbncurs_vid_attr(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3) {

return INT2NUM(vid_attr(NUM2ULONG(arg1), NUM2INT(arg2), ((void)(arg3),NULL)));

}

#endif

#ifdef HAVE_ATTR_GET

static VALUE rbncurs_attr_get(VALUE dummy, VALUE rb_attrs, VALUE rb_pair,

VALUE dummy2)

{

if ((rb_obj_is_instance_of(rb_attrs, rb_cArray) != Qtrue)

|| (rb_obj_is_instance_of(rb_pair, rb_cArray) != Qtrue)) {

rb_raise(rb_eArgError,

"attrs and pair arguments must be empty Arrays");

return Qnil;

}

{

attr_t attrs = 0;

short pair = 0;

int return_value = attr_get(&attrs, &pair, 0);

rb_ary_push(rb_attrs, INT2NUM(attrs));

rb_ary_push(rb_pair, INT2NUM(pair));

return INT2NUM(return_value);

}

}

static VALUE rbncurs_wattr_get(VALUE dummy,VALUE win, VALUE rb_attrs, VALUE rb_pair,

VALUE dummy2)

{

if ((rb_obj_is_instance_of(rb_attrs, rb_cArray) != Qtrue)

|| (rb_obj_is_instance_of(rb_pair, rb_cArray) != Qtrue)) {

rb_raise(rb_eArgError,

"attrs and pair arguments must be empty Arrays");

return Qnil;

}

{

attr_t attrs = 0;

short pair = 0;

int return_value = wattr_get(get_window(win), &attrs, &pair, 0);

rb_ary_push(rb_attrs, INT2NUM(attrs));

rb_ary_push(rb_pair, INT2NUM(pair));

return INT2NUM(return_value);

}

}

#endif /* HAVE_ATTR_GET */

#endif

static VALUE rbncurs_baudrate(VALUE dummy) {

return INT2NUM(baudrate());

}

static VALUE rbncurs_beep(VALUE dummy) {

return INT2NUM(beep());

}

static VALUE rbncurs_bkgd(VALUE dummy, VALUE arg1) {

return INT2NUM(bkgd(NUM2ULONG(arg1)));

}

static VALUE rbncurs_bkgdset(VALUE dummy, VALUE arg1) {

return ((bkgdset(NUM2ULONG(arg1))),Qnil);

}

static VALUE rbncurs_border(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, VALUE arg8) {

return INT2NUM(border(NUM2ULONG(arg1), NUM2ULONG(arg2), NUM2ULONG(arg3), NUM2ULONG(arg4), NUM2ULONG(arg5), NUM2ULONG(arg6), NUM2ULONG(arg7), NUM2ULONG(arg8)));

}

static VALUE rbncurs_box(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3) {

return INT2NUM(box(get_window(arg1), NUM2ULONG(arg2), NUM2ULONG(arg3)));

}

static VALUE rbncurs_can_change_color(VALUE dummy) {

return (can_change_color()) ? Qtrue : Qfalse;

}

static int rbncurshelper_halfdelay_cbreak(int tenths, int break_chars)

{

int status = break_chars ? cbreak() : nocbreak();

if (status != ERR) {

rb_iv_set(mNcurses, "@halfdelay", INT2NUM(tenths));

rb_iv_set(mNcurses, "@cbreak", break_chars ? Qtrue : Qfalse);

}

return status;

}

static void rbncurshelper_halfdelay_cbreak_restore()

{

if (RTEST(rb_iv_get(mNcurses, "@cbreak")))

cbreak();

else

nocbreak();

}

static VALUE rbncurs_cbreak(VALUE dummy) {

return INT2NUM(rbncurshelper_halfdelay_cbreak(0, 1));

}

#ifdef HAVE_CHGAT

static VALUE rbncurs_chgat(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4) {

return INT2NUM(chgat(NUM2INT(arg1), NUM2ULONG(arg2), NUM2INT(arg3),

((void)(arg4),NULL)));

}

#endif

static VALUE rbncurs_clear(VALUE dummy) {

return INT2NUM(clear());

}

static VALUE rbncurs_clearok(VALUE dummy, VALUE arg1, VALUE arg2) {

return INT2NUM(clearok(get_window(arg1), RTEST(arg2)));

}

static VALUE rbncurs_clrtobot(VALUE dummy) {

return INT2NUM(clrtobot());

}

static VALUE rbncurs_clrtoeol(VALUE dummy) {

return INT2NUM(clrtoeol());

}

#ifdef HAVE_COLOR_SET

static VALUE rbncurs_color_set(VALUE dummy, VALUE arg1, VALUE arg2) {

return INT2NUM(color_set(NUM2INT(arg1), ((void)(arg2),NULL)));

}

#endif

static VALUE rbncurs_COLOR_PAIR(VALUE dummy, VALUE arg1) {

return INT2NUM(COLOR_PAIR(NUM2INT(arg1)));

}

static VALUE rbncurs_copywin(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, VALUE arg8, VALUE arg9) {

return INT2NUM(copywin(get_window(arg1), get_window(arg2), NUM2INT(arg3), NUM2INT(arg4), NUM2INT(arg5), NUM2INT(arg6), NUM2INT(arg7), NUM2INT(arg8), NUM2INT(arg9)));

}

static VALUE rbncurs_curs_set(VALUE dummy, VALUE arg1) {

return INT2NUM(curs_set(NUM2INT(arg1)));

}

static VALUE rbncurs_def_prog_mode(VALUE dummy) {

return INT2NUM(def_prog_mode());

}

static VALUE rbncurs_def_shell_mode(VALUE dummy) {

return INT2NUM(def_shell_mode());

}

static VALUE rbncurs_delay_output(VALUE dummy, VALUE arg1) {

return INT2NUM(delay_output(NUM2INT(arg1)));

}

static VALUE rbncurs_delch(VALUE dummy) {

return INT2NUM(delch());

}

static VALUE rbncurs_deleteln(VALUE dummy) {

return INT2NUM(deleteln());

}

static VALUE rbncurs_derwin(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5) {

return wrap_window(derwin(get_window(arg1), NUM2INT(arg2), NUM2INT(arg3), NUM2INT(arg4), NUM2INT(arg5)));

}

static VALUE rbncurs_doupdate(VALUE dummy) {

return INT2NUM(doupdate());

}

static VALUE rbncurs_dupwin(VALUE dummy, VALUE arg1) {

return wrap_window(dupwin(get_window(arg1)));

}

static VALUE rbncurs_echo(VALUE dummy) {

return INT2NUM(echo());

}

static VALUE rbncurs_echochar(VALUE dummy, VALUE arg1) {

return INT2NUM(echochar(NUM2ULONG(arg1)));

}

static VALUE rbncurs_endwin(VALUE dummy) {

return INT2NUM(endwin());

}

static VALUE rbncurs_erasechar(VALUE dummy) {

return INT2NUM(erasechar());

}

#ifdef HAVE_FILTER

static VALUE rbncurs_filter(VALUE dummy) {

return ((filter()),Qnil);

}

#endif

static VALUE rbncurs_flash(VALUE dummy) {

return INT2NUM(flash());

}

static VALUE rbncurs_flushinp(VALUE dummy) {

return INT2NUM(flushinp());

}

static VALUE rbncurs_getbkgd(VALUE dummy, VALUE arg1) {

return INT2NUM(getbkgd(get_window(arg1)));

}

static int rbncurshelper_nonblocking_wgetch(WINDOW *c_win) {

/* nonblocking wgetch only implemented for Ncurses */

int halfdelay = NUM2INT(rb_iv_get(mNcurses, "@halfdelay"));

int infd = NUM2INT(rb_iv_get(mNcurses, "@infd"));

double screen_delay = halfdelay * 0.1;

#ifdef NCURSES_VERSION

int windelay = c_win->_delay;

#else

int windelay = 0;

#endif

double window_delay = (windelay >= 0) ? 0.001 * windelay : (1e200*1e200);

/* FIXME: ^ Infinity ^*/

double delay = (screen_delay > 0) ? screen_delay : window_delay;

int result;

struct timeval tv;

struct timezone tz = {0,0};

double starttime, nowtime, finishtime;

double resize_delay = NUM2INT(get_RESIZEDELAY()) / 1000.0;

fd_set in_fds;

gettimeofday(&tv, &tz);

starttime = tv.tv_sec + tv.tv_usec * 1e-6;

finishtime = starttime + delay;

#ifdef NCURSES_VERSION

c_win->_delay = 0;

#endif

while (doupdate() /* detects resize */, (result = wgetch(c_win)) == ERR) {

gettimeofday(&tv, &tz);

nowtime = tv.tv_sec + tv.tv_usec * 1e-6;

delay = finishtime - nowtime;

if (delay <= 0) break;

/* Check for terminal size change every resize_delay seconds */

if (resize_delay > delay) resize_delay = delay;

tv.tv_sec = (time_t)resize_delay;

tv.tv_usec = (unsigned)( (resize_delay - tv.tv_sec) * 1e6 );

/* sleep on infd until input is available or tv reaches timeout */

FD_ZERO(&in_fds);

FD_SET(infd, &in_fds);

rb_thread_select(infd + 1, &in_fds, NULL, NULL, &tv);

}

#ifdef NCURSES_VERSION

c_win->_delay = windelay;

#endif

return result;

}

static VALUE rbncurs_getch(VALUE dummy) {

return INT2NUM(rbncurshelper_nonblocking_wgetch(stdscr));

}

static VALUE rbncurs_halfdelay(VALUE dummy, VALUE arg1) {

return INT2NUM(rbncurshelper_halfdelay_cbreak(NUM2INT(arg1), 1));

}

static VALUE rbncurs_has_colors(VALUE dummy) {

return (has_colors()) ? Qtrue : Qfalse;

}

static VALUE rbncurs_has_ic(VALUE dummy) {

return (has_ic()) ? Qtrue : Qfalse;

}

static VALUE rbncurs_has_il(VALUE dummy) {

return (has_il()) ? Qtrue : Qfalse;

}

static VALUE rbncurs_hline(VALUE dummy, VALUE arg1, VALUE arg2) {

return INT2NUM(hline(NUM2ULONG(arg1), NUM2INT(arg2)));

}

static VALUE rbncurs_idcok(VALUE dummy, VALUE arg1, VALUE arg2) {

return ((idcok(get_window(arg1), RTEST(arg2))),Qnil);

}

static VALUE rbncurs_idlok(VALUE dummy, VALUE arg1, VALUE arg2) {

return INT2NUM(idlok(get_window(arg1), RTEST(arg2)));

}

static VALUE rbncurs_immedok(VALUE dummy, VALUE arg1, VALUE arg2) {

return ((immedok(get_window(arg1), RTEST(arg2))),Qnil);

}

static VALUE rbncurs_inch(VALUE dummy) {

return INT2NUM(inch());

}

static VALUE rbncurs_initscr(VALUE dummy) {

VALUE v = wrap_window(initscr());

if (!RTEST(v))

return v;

Init_ncurses_full();

/* Some constants defined by the initscr call. */

/* line graphics */

/* VT100 symbols begin here */

rb_define_const(mNcurses, "ACS_ULCORNER", INT2NUM(ACS_ULCORNER));

rb_define_const(mNcurses, "ACS_LLCORNER", INT2NUM(ACS_LLCORNER));

rb_define_const(mNcurses, "ACS_URCORNER", INT2NUM(ACS_URCORNER));

rb_define_const(mNcurses, "ACS_LRCORNER", INT2NUM(ACS_LRCORNER));

rb_define_const(mNcurses, "ACS_LTEE", INT2NUM(ACS_LTEE));

rb_define_const(mNcurses, "ACS_RTEE", INT2NUM(ACS_RTEE));

rb_define_const(mNcurses, "ACS_BTEE", INT2NUM(ACS_BTEE));

rb_define_const(mNcurses, "ACS_TTEE", INT2NUM(ACS_TTEE));

rb_define_const(mNcurses, "ACS_HLINE", INT2NUM(ACS_HLINE));

rb_define_const(mNcurses, "ACS_VLINE", INT2NUM(ACS_VLINE));

rb_define_const(mNcurses, "ACS_PLUS", INT2NUM(ACS_PLUS));

rb_define_const(mNcurses, "ACS_S1", INT2NUM(ACS_S1));

rb_define_const(mNcurses, "ACS_S9", INT2NUM(ACS_S9));

rb_define_const(mNcurses, "ACS_DIAMOND", INT2NUM(ACS_DIAMOND));

rb_define_const(mNcurses, "ACS_CKBOARD", INT2NUM(ACS_CKBOARD));

rb_define_const(mNcurses, "ACS_DEGREE", INT2NUM(ACS_DEGREE));

rb_define_const(mNcurses, "ACS_PLMINUS", INT2NUM(ACS_PLMINUS));

rb_define_const(mNcurses, "ACS_BULLET", INT2NUM(ACS_BULLET));

/* Teletype 5410v1 symbols begin here */

rb_define_const(mNcurses, "ACS_LARROW", INT2NUM(ACS_LARROW));

rb_define_const(mNcurses, "ACS_RARROW", INT2NUM(ACS_RARROW));

rb_define_const(mNcurses, "ACS_DARROW", INT2NUM(ACS_DARROW));

rb_define_const(mNcurses, "ACS_UARROW", INT2NUM(ACS_UARROW));

rb_define_const(mNcurses, "ACS_BOARD", INT2NUM(ACS_BOARD));

rb_define_const(mNcurses, "ACS_LANTERN", INT2NUM(ACS_LANTERN));

rb_define_const(mNcurses, "ACS_BLOCK", INT2NUM(ACS_BLOCK));

/*

* These aren't documented, but a lot of System Vs have them anyway

* (you can spot pprryyzz{{||}} in a lot of AT&T terminfo strings).

* The ACS_names may not match AT&T's, our source didn't know them.

*/

#ifdef ACS_S3

rb_define_const(mNcurses, "ACS_S3", INT2NUM(ACS_S3));

#endif

#ifdef ACS_S7

rb_define_const(mNcurses, "ACS_S7", INT2NUM(ACS_S7));

#endif

#ifdef ACS_LEQUAL

rb_define_const(mNcurses, "ACS_LEQUAL", INT2NUM(ACS_LEQUAL));

#endif

#ifdef ACS_LEQUAL

rb_define_const(mNcurses, "ACS_GEQUAL", INT2NUM(ACS_GEQUAL));

#endif

#ifdef ACS_PI

rb_define_const(mNcurses, "ACS_PI", INT2NUM(ACS_PI));

#endif

#ifdef ACS_NEQUAL

rb_define_const(mNcurses, "ACS_NEQUAL", INT2NUM(ACS_NEQUAL));

#endif

#ifdef ACS_STERLING

rb_define_const(mNcurses, "ACS_STERLING", INT2NUM(ACS_STERLING));

#endif

/*

* Line drawing ACS names are of the form ACS_trbl, where t is the top, r

* is the right, b is the bottom, and l is the left. t, r, b, and l might

* be B (blank), S (single), D (double), or T (thick). The subset defined

* here only uses B and S.

*/

#ifdef ACS_BSSB

rb_define_const(mNcurses, "ACS_BSSB", INT2NUM(ACS_BSSB));

#endif

#ifdef ACS_SSBB

rb_define_const(mNcurses, "ACS_SSBB", INT2NUM(ACS_SSBB));

#endif

#ifdef ACS_BBSS

rb_define_const(mNcurses, "ACS_BBSS", INT2NUM(ACS_BBSS));

#endif

#ifdef ACS_SBBS

rb_define_const(mNcurses, "ACS_SBBS", INT2NUM(ACS_SBBS));

#endif

#ifdef ACS_SBSS

rb_define_const(mNcurses, "ACS_SBSS", INT2NUM(ACS_SBSS));

#endif

#ifdef ACS_SSSB

rb_define_const(mNcurses, "ACS_SSSB", INT2NUM(ACS_SSSB));

#endif

#ifdef ACS_SSBS

rb_define_const(mNcurses, "ACS_SSBS", INT2NUM(ACS_SSBS));

#endif

#ifdef ACS_BSSS

rb_define_const(mNcurses, "ACS_BSSS", INT2NUM(ACS_BSSS));

#endif

#ifdef ACS_BSBS

rb_define_const(mNcurses, "ACS_BSBS", INT2NUM(ACS_BSBS));

#endif

#ifdef ACS_SBSB

rb_define_const(mNcurses, "ACS_SBSB", INT2NUM(ACS_SBSB));

#endif

#ifdef ACS_SSSS

rb_define_const(mNcurses, "ACS_SSSS", INT2NUM(ACS_SSSS));

#endif

rbncurshelper_halfdelay_cbreak_restore();

rb_iv_set(mNcurses, "@infd", INT2FIX(0));

rb_iv_set(mNcurses, "@halfdelay", INT2FIX(0));

rb_iv_set(mNcurses, "@cbreak", Qfalse);

return v;

}

static VALUE rbncurs_init_color(VALUE dummy, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4) {

return INT2NUM(init_color(NUM2INT(arg1), NUM2INT(arg2), NUM2INT(arg3), NUM2INT(arg4)));

}