scsh-conservatory
/
scsh-ncurses
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
scsh-ncurses/c/ncurses.c

2320 lines
53 KiB
C
Raw Normal View History

first commit
2004-09-07 05:13:21 -04:00
#include <curses.h>
Renamed init function
2004-09-07 10:30:27 -04:00
#include "scheme48.h"
first commit
2004-09-07 05:13:21 -04:00
#include <stdlib.h>
added bindings to ioctl() with TIOCGWINSZ and TIOCSWINSZ
2005-05-27 03:04:24 -04:00
#include <sys/ioctl.h>
first commit
2004-09-07 05:13:21 -04:00
//Makros zum Ein- und Auspacken von Zeigern
#define curses_enter_window(w) s48_enter_integer((long) w)
#define curses_extract_window(w) (WINDOW*) s48_extract_integer(w)
#define curses_enter_screen(s) s48_enter_integer((long) s)
#define curses_extract_screen(s) (SCREEN*) s48_extract_integer(s)
#define curses_extract_file(f) (FILE*) fdopen(s48_extract_integer(f),"rw")
#define curses_enter_chtype(c) s48_enter_char((short) c)
#define curses_extract_chtype(c) (chtype) s48_extract_char(c)
//*********************************************************************
//Bibliotheks-Funktionen
//*********************************************************************
//ALLGEMEINE:
//Initialisierung
s48_value scsh_initscr(void)
{
s48_value res;
WINDOW *stdscr;
stdscr = initscr();
if (stdscr==NULL)
return S48_FALSE;
else
{
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res=curses_enter_window (stdscr);
S48_GC_UNPROTECT();
return res;
}
}
s48_value scsh_newterm(s48_value type, s48_value outfd,
s48_value infd)
{
SCREEN *screen;
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(type, outfd, infd, res);
screen = newterm (s48_extract_string (type),
curses_extract_file (outfd),
curses_extract_file (infd));
if(screen==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res = curses_enter_screen(screen);
S48_GC_UNPROTECT();
return res;
}
}
//Beenden
s48_value scsh_endwin(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (endwin());
S48_GC_UNPROTECT();
}
s48_value scsh_isendwin(void)
{
return S48_ENTER_BOOLEAN (isendwin());
}
s48_value scsh_delscreen(s48_value s)
{
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(s);
(void) delscreen(curses_extract_screen(s));
S48_GC_UNPROTECT();
return S48_UNSPECIFIC;
}
//Hilfsfunktionen
s48_value scsh_unctrl(s48_value c)
{
char *res_c;
s48_value res_s;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(c, res_s);
res_c = (char*) unctrl(curses_extract_chtype(c));
if (res_c==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res_s = s48_enter_string (res_c);
S48_GC_UNPROTECT();
return res_s;
}
}
s48_value scsh_keyname(s48_value c)
{
char *key;
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(c, res);
key = (char*) keyname((int) s48_extract_integer(c));
if (key==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res = s48_enter_string(key);
S48_GC_UNPROTECT();
return res;
}
}
s48_value scsh_filter(void)
{
(void) filter();
return S48_UNSPECIFIC;
}
s48_value scsh_use_env(s48_value f)
{
(void) use_env( S48_EXTRACT_BOOLEAN(f));
return S48_UNSPECIFIC;
}
s48_value scsh_putwin(s48_value win, s48_value file)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win,file,res);
res = s48_enter_integer (putwin
(curses_extract_window(win),
curses_extract_file(file)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_getwin(s48_value file)
{
WINDOW *win;
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(file, res);
win = getwin(curses_extract_file(file));
if(win==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res = curses_enter_window(win);
S48_GC_UNPROTECT();
return res;
}
}
s48_value scsh_delay_output(s48_value ms)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(ms, res);
res = s48_enter_integer(delay_output (s48_extract_integer(ms)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_flushinp(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(flushinp());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_curses_version(void)
{
s48_value res_s;
char *res = (char*) curses_version();
if (res==NULL)
return S48_FALSE;
else
{
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res_s);
res_s = s48_enter_string (res);
S48_GC_UNPROTECT();
return res_s;
}
}
//Einstellungen
s48_value scsh_use_default_colors(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer((int)use_default_colors);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_assume_default_colors(s48_value fg, s48_value bg)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(assume_default_colors
(s48_extract_integer(fg),
s48_extract_integer(bg)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_define_key(s48_value def, s48_value keyc)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (define_key (s48_extract_string (def),
s48_extract_integer (keyc)));
S48_GC_UNPROTECT();
return res;
}
//***************************************************************************
//TERMINAL
//Eigenschaften
s48_value scsh_baudrate(void)
{
int res=baudrate();
if (res==ERR)
return S48_FALSE;
else
{
s48_value res_s;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res_s);
res_s = s48_enter_integer(res);
S48_GC_UNPROTECT();
return res_s;
}
}
s48_value scsh_erasechar(void)
{
return s48_enter_char((unsigned char) erasechar());
}
s48_value scsh_has_ic(void)
{
return S48_ENTER_BOOLEAN((int)has_ic());
}
s48_value scsh_has_il(void)
{
return S48_ENTER_BOOLEAN((int) has_il());
}
s48_value scsh_killchar(void)
{
return s48_enter_char((unsigned char) killchar());
}
s48_value scsh_longname(void)
{
char *name = longname();
if (name==NULL)
return S48_FALSE;
else
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_string(name);
S48_GC_UNPROTECT();
return res;
}
}
s48_value scsh_termname(void)
{
char *name = termname();
if (name==NULL)
return S48_FALSE;
else
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_string(name);
S48_GC_UNPROTECT();
return res;
}
}
s48_value scsh_has_key(s48_value ch)
{
s48_value res_s;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(ch, res_s);
int res_c=has_key(s48_extract_integer(ch));
if (res_c==ERR)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res_s = s48_extract_integer(res_c);
S48_GC_UNPROTECT();
return res_s;
}
}
//Farbe
s48_value scsh_start_color()
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer((int) start_color());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_init_pair(s48_value pair, s48_value f,
s48_value b)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(pair, f, b, res);
res = s48_enter_integer((int) init_pair((short) s48_extract_integer(pair),
(short) s48_extract_integer(f),
(short) s48_extract_integer(b)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_init_color(s48_value color, s48_value r,
s48_value g, s48_value b)
{
s48_value res;
S48_DECLARE_GC_PROTECT(5);
S48_GC_PROTECT_5(color, r, g, b, res);
res = s48_enter_integer(init_color ((short) s48_extract_integer(color),
(short) s48_extract_integer(r),
(short) s48_extract_integer(g),
(short) s48_extract_integer(b)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_has_colors(void)
{
return S48_ENTER_BOOLEAN((int)has_colors());
}
s48_value scsh_can_change_colors(void)
{
return S48_ENTER_BOOLEAN((int) can_change_color());
}
s48_value scsh_color_pair (s48_value num)
{
s48_value res;
S48_DECLARE_GC_PROTECT(12);
S48_GC_PROTECT_2(num, res);
res = s48_enter_integer( COLOR_PAIR(s48_extract_integer(num)));
S48_GC_UNPROTECT();
return res;
}
//Eingabe:
s48_value scsh_cbreak(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(cbreak());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_no_cbreak(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(nocbreak());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_echo(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(echo());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_noecho(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(noecho());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_halfdelay(s48_value tenth)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(tenth, res);
res = s48_enter_integer(halfdelay(s48_extract_integer(tenth)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_intrflush(s48_value win, s48_value bf)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, bf, res);
res = s48_enter_integer(intrflush (curses_extract_window(win),
S48_EXTRACT_BOOLEAN(bf)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_keypad(s48_value win, s48_value bf)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, bf, res);
res = s48_enter_integer(keypad (curses_extract_window(win),
S48_EXTRACT_BOOLEAN(bf)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_meta(s48_value win, s48_value bf)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, bf, res);
res = s48_enter_integer(meta (curses_extract_window(win),
S48_EXTRACT_BOOLEAN(bf)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_nodelay(s48_value win, s48_value bf)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, bf, res);
res = s48_enter_integer(nodelay(curses_extract_window(win),
S48_EXTRACT_BOOLEAN(bf)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_raw(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(raw());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_noraw(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(noraw());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_qiflush(void)
{
(void) qiflush();
return S48_UNSPECIFIC;
}
s48_value scsh_noqiflush(void)
{
(void) noqiflush();
return S48_UNSPECIFIC;
}
//Terminalfunktionen
s48_value scsh_beep(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(beep());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_flash(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(flash());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_def_prog_mode(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(def_prog_mode());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_def_shell_mode(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(def_shell_mode());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_reset_prog_mode(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(reset_prog_mode());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_reset_shell_mode(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(reset_shell_mode());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_resetty(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(resetty());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_savetty(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(savetty());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_curs_set(s48_value visibility)
{
curs_set may return either the old visibility or ERR
2005-06-01 12:06:13 -04:00
int old_vis;
old_vis = curs_set(s48_extract_fixnum(visibility));
if (old_vis == ERR)
return S48_FALSE;
else return s48_enter_fixnum(old_vis);
first commit
2004-09-07 05:13:21 -04:00
}
s48_value scsh_napms(s48_value ms)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(ms, res);
res = s48_enter_integer(napms(s48_extract_integer(ms)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_mcprint(s48_value data, s48_value len)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(data, len, res);
res = s48_enter_integer(mcprint(s48_extract_string (data),
s48_extract_integer(len)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_is_term_resized(s48_value lines, s48_value columns)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(lines, columns, res);
res = S48_ENTER_BOOLEAN(is_term_resized
(s48_extract_integer(lines),
s48_extract_integer(columns)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_resize_term(s48_value lines, s48_value columns)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(lines, columns, res);
res = s48_enter_integer(resize_term
(s48_extract_integer(lines),
s48_extract_integer(columns)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_resizeterm(s48_value lines, s48_value columns)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(lines, columns, res);
res = s48_enter_integer(resizeterm
(s48_extract_integer(lines),
s48_extract_integer(columns)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_scr_dump(s48_value filename)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(filename, res);
res = s48_enter_integer(scr_dump
(s48_extract_string (filename)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_scr_restore(s48_value filename)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(filename, res);
res = s48_enter_integer(scr_restore
(s48_extract_string (filename)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_scr_init(s48_value filename)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(filename, res);
res = s48_enter_integer(scr_init
(s48_extract_string (filename)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_scr_set(s48_value filename)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(filename, res);
res = s48_enter_integer(scr_set
(s48_extract_string (filename)));
S48_GC_UNPROTECT();
return res;
}
//mehrere Terminals
s48_value scsh_set_term(s48_value new)
{
SCREEN *res;
s48_value res_s;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(new, res_s);
res= set_term (curses_extract_screen(new));
if(res==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res_s = curses_enter_screen(res);
S48_GC_UNPROTECT();
return res_s;
}
}
//*************************************************************************
//FENSTER
//Allgemeine:
s48_value scsh_newwin(s48_value height, s48_value width,
s48_value starty, s48_value startx)
{
WINDOW *win;
s48_value res;
S48_DECLARE_GC_PROTECT(5);
S48_GC_PROTECT_5(height,width,starty,startx, res);
win=(newwin ((int) s48_extract_integer(height)
,(int) s48_extract_integer(width)
,(int) s48_extract_integer(starty)
,(int) s48_extract_integer(startx)));
if (win==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res = curses_enter_window(win);
S48_GC_UNPROTECT();
return res;
}
}
s48_value scsh_delwin(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer(delwin (curses_extract_window (win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_mvwin(s48_value win, s48_value y, s48_value x)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, y, x, res);
res = s48_enter_integer(mvwin (curses_extract_window (win),
s48_extract_integer(y),
s48_extract_integer(x)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_subwin(s48_value orig, s48_value nlines,
s48_value ncols, s48_value begin_y,
s48_value begin_x)
{
WINDOW *res;
s48_value res_s;
S48_DECLARE_GC_PROTECT(6);
S48_GC_PROTECT_6(orig, nlines, ncols, begin_y, begin_x, res_s);
res=subwin (curses_extract_window (orig),
s48_extract_integer(nlines),
s48_extract_integer(ncols),
s48_extract_integer(begin_y),
s48_extract_integer(begin_x));
if(res==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res_s = curses_enter_window(res);
S48_GC_UNPROTECT();
return res_s;
}
}
s48_value scsh_derwin(s48_value orig, s48_value nlines,
s48_value ncols, s48_value begin_y,
s48_value begin_x)
{
WINDOW *res;
s48_value res_s;
S48_DECLARE_GC_PROTECT(6);
S48_GC_PROTECT_6(orig, nlines, ncols, begin_y, begin_x, res_s);
res=derwin (curses_extract_window (orig),
s48_extract_integer(nlines),
s48_extract_integer(ncols),
s48_extract_integer(begin_y),
s48_extract_integer(begin_x));
if(res==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res_s = curses_enter_window(res);
S48_GC_UNPROTECT();
return res_s;
}
}
s48_value scsh_mvderwin(s48_value win, s48_value par_y,
s48_value par_x)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, par_y, par_x, res);
res = s48_enter_integer (mvderwin(curses_extract_window (win),
s48_extract_integer(par_y),
s48_extract_integer(par_x)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_dupwin(s48_value win)
{
WINDOW *res;
s48_value res_s;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res_s);
res=dupwin(curses_extract_window(win));
if(res==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res_s = curses_enter_window(res);
S48_GC_UNPROTECT();
return res_s;
}
}
s48_value scsh_wsyncup(s48_value win)
{
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(win);
(void) wsyncup(curses_extract_window(win));
S48_GC_UNPROTECT();
return S48_UNSPECIFIC;
}
s48_value scsh_wcursyncup(s48_value win)
{
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(win);
(void) wcursyncup(curses_extract_window(win));
S48_GC_UNPROTECT();
return S48_UNSPECIFIC;
}
s48_value scsh_wsyncdown(s48_value win)
{
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(win);
(void) wsyncdown(curses_extract_window(win));
S48_GC_UNPROTECT();
return S48_UNSPECIFIC;
}
s48_value scsh_syncok(s48_value win, s48_value bf)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, bf, res);
res = s48_enter_integer (syncok(curses_extract_window (win),
S48_EXTRACT_BOOLEAN(bf)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wrefresh(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer(wrefresh(curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wnoutrefresh(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer(wnoutrefresh(curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_redrawwin(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer(redrawwin(curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_doupdate(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(doupdate());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wredrawln(s48_value win, s48_value beg_line,
s48_value num_lines)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, beg_line, num_lines, res);
res = s48_enter_integer(wredrawln(curses_extract_window(win),
s48_extract_integer(beg_line),
s48_extract_integer(num_lines)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_gety(s48_value win)
{
int y=0;
int x=0;
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
getyx(curses_extract_window(win), y, x);
res = s48_enter_integer(y);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_getx(s48_value win)
{
int y = 0;
int x = 0;
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
getyx(curses_extract_window(win), y, x);
res = s48_enter_integer(x);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_getmaxy(s48_value win)
{
int y = 0;
int x = 0;
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
getmaxyx(curses_extract_window(win), y, x);
res = s48_enter_integer(y);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_getmaxx(s48_value win)
{
int y = 0;
int x = 0;
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
getmaxyx(curses_extract_window(win), y, x);
res = s48_enter_integer(x);
S48_GC_UNPROTECT();
return res;
}
/*
s48_value scsh_getyx(s48_value win, s48_value y, s48_value x)
{
getyx(curses_extract_window(win),
s48_extract_integer(y),
s48_extract_integer(x));
return S48_UNSPECIFIC;
}
s48_value scsh_getparyx(s48_value win, s48_value y, s48_value x)
{
(void) getparyx(curses_extract_window(win),
s48_extract_integer(y),
s48_extract_integer(x));
return S48_UNSPECIFIC;
}
s48_value scsh_getbegyx(s48_value win, s48_value y, s48_value x)
{
(void) getbegyx(curses_extract_window(win),
s48_extract_integer(y),
s48_extract_integer(x));
return S48_UNSPECIFIC;
}
s48_value scsh_getmaxyx(s48_value win, s48_value y, s48_value x)
{
(void) getmaxyx(curses_extract_window(win),
s48_extract_integer(y),
s48_extract_integer(x));
return S48_UNSPECIFIC;
}
*/
s48_value scsh_wresize(s48_value win, s48_value lines,
s48_value columns)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, lines, columns, res);
res = s48_enter_integer(wresize
(curses_extract_window(win),
s48_extract_integer(lines),
s48_extract_integer(columns)));
S48_GC_UNPROTECT();
return res;
}
//Ausgabe-Einstellungen
s48_value scsh_idlok(s48_value win, s48_value bf)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win,bf , res);
res = s48_enter_integer(idlok
(curses_extract_window(win),
S48_EXTRACT_BOOLEAN(bf)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_leaveok(s48_value win, s48_value bf)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win ,bf , res);
res = s48_enter_integer(leaveok
(curses_extract_window(win),
S48_EXTRACT_BOOLEAN(bf)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_scrollok(s48_value win, s48_value bf)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win ,bf , res);
res = s48_enter_integer(scrollok
(curses_extract_window(win),
S48_EXTRACT_BOOLEAN(bf)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_idcok(s48_value win, s48_value bf)
{
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win ,bf);
(void) idcok(curses_extract_window(win), S48_EXTRACT_BOOLEAN(bf));
S48_GC_UNPROTECT();
return S48_UNSPECIFIC;
}
s48_value scsh_immedok(s48_value win, s48_value bf)
{
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win ,bf);
(void) immedok(curses_extract_window(win), S48_EXTRACT_BOOLEAN(bf));
S48_GC_UNPROTECT();
return S48_UNSPECIFIC;
}
s48_value scsh_wsetscrreg(s48_value win, s48_value top,
s48_value bot)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, top, bot, res);
res = s48_enter_integer(wsetscrreg
(curses_extract_window(win),
s48_extract_integer(top),
s48_extract_integer(bot)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_nl(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(nl());
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_nonl(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer(nonl());
S48_GC_UNPROTECT();
return res;
}
//Text anzeigen:
s48_value scsh_waddch(s48_value win, s48_value ch)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, ch, res);
res = s48_enter_integer(waddch
(curses_extract_window(win),
curses_extract_chtype(ch)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wechochar(s48_value win, s48_value ch)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, ch, res);
res = s48_enter_integer(wechochar
(curses_extract_window(win),
curses_extract_chtype(ch)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_waddstr(s48_value win, s48_value str)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, str, res);
res = s48_enter_integer (waddstr
(curses_extract_window(win),
s48_extract_string(str)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_waddnstr(s48_value win, s48_value str,
s48_value n)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, str, n, res);
res = s48_enter_integer (waddnstr
(curses_extract_window(win),
s48_extract_string(str),
s48_extract_integer(n)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_winsch(s48_value win, s48_value ch)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, ch, res);
res = s48_enter_integer(winsch
(curses_extract_window(win),
curses_extract_chtype(ch)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_winsstr(s48_value win, s48_value str)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, str, res);
res = s48_enter_integer (winsstr
(curses_extract_window(win),
s48_extract_string(str)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_winsnstr(s48_value win, s48_value str,
s48_value n)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, str, n, res);
res = s48_enter_integer (winsnstr
(curses_extract_window(win),
s48_extract_string(str),
s48_extract_integer(n)));
S48_GC_UNPROTECT();
return res;
}
//Attribute
s48_value scsh_wattroff(s48_value win, s48_value attr)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, attr, res);
res = s48_enter_integer (wattroff(curses_extract_window (win),
s48_extract_integer(attr)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wattron(s48_value win, s48_value attr)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, attr, res);
res = s48_enter_integer (wattron(curses_extract_window (win),
s48_extract_integer(attr)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wattrset(s48_value win, s48_value attr)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, attr, res);
res = s48_enter_integer (wattrset(curses_extract_window (win),
s48_extract_integer(attr)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wstandend(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer (wstandend(curses_extract_window (win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wstandout(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer (wstandout(curses_extract_window (win)));
S48_GC_UNPROTECT();
return res;
}
//Background:
s48_value scsh_wbkgdset(s48_value win, s48_value ch)
{
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, ch);
(void) wbkgdset(curses_extract_window(win),
curses_extract_chtype(ch));
S48_GC_UNPROTECT();
return S48_UNSPECIFIC;
}
s48_value scsh_wbkgd(s48_value win, s48_value ch)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, ch, res);
res = s48_enter_integer( wbkgd
(curses_extract_window(win),
curses_extract_chtype(ch)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_getbkgd(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = curses_enter_chtype( getbkgd
(curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
//Umrandung des Fensters
s48_value scsh_wborder(s48_value win, s48_value ls,
s48_value rs, s48_value ts,
s48_value bs, s48_value tl,
s48_value tr, s48_value bl,
s48_value br)
{
return s48_enter_integer(wborder
(curses_extract_window(win),
curses_extract_chtype(ls),
curses_extract_chtype(rs),
curses_extract_chtype(ts),
curses_extract_chtype(bs),
curses_extract_chtype(tl),
curses_extract_chtype(tr),
curses_extract_chtype(bl),
curses_extract_chtype(br)));
}
s48_value scsh_box(s48_value win, s48_value verch, s48_value horch)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, verch, horch, res);
res = s48_enter_integer ( box(curses_extract_window(win),
curses_extract_chtype(verch),
curses_extract_chtype(horch)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_whline(s48_value win, s48_value ch, s48_value n)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, ch, n, res);
res = s48_enter_integer (whline(curses_extract_window(win),
curses_extract_chtype(ch),
s48_extract_integer(n)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wvline(s48_value win, s48_value ch, s48_value n)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, ch, n, res);
res = s48_enter_integer ( wvline(curses_extract_window(win),
curses_extract_chtype(ch),
s48_extract_integer(n)));
S48_GC_UNPROTECT();
return res;
}
//Cursor:
s48_value scsh_scroll(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer( scroll (curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wscrl(s48_value win, s48_value n)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, n, res);
res = s48_enter_integer( wscrl
(curses_extract_window(win),
s48_extract_integer(n)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wmove(s48_value win, s48_value y,
s48_value x)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, y, x, res);
res = s48_enter_integer( wmove
(curses_extract_window(win),
s48_extract_integer(y),
s48_extract_integer(x)));
S48_GC_UNPROTECT();
return res;
}
//Eingabe
s48_value scsh_wgetch(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer (wgetch (curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_winch(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = curses_enter_chtype (winch (curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_winstr(s48_value win)
{
char *str;
int status;
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
status = winstr (curses_extract_window(win), str);
if(status==ERR)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res = s48_enter_string(str);
S48_GC_UNPROTECT();
return res;
}
}
s48_value scsh_winnstr(s48_value win, s48_value n)
{
char *str;
int status;
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, n, res);
status = winnstr (curses_extract_window(win), str,
s48_extract_integer(n));
if(status==ERR)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res = s48_enter_string(str);
S48_GC_UNPROTECT();
return res;
}
}
//Loeschen:
s48_value scsh_werase(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer( werase (curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wclear(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer( wclear (curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wclrtobot(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer( wclrtobot (curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wclrtoeol(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer( wclrtoeol (curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_clearok(s48_value win, s48_value bf)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, bf, res);
res = s48_enter_integer( clearok (curses_extract_window(win),
S48_EXTRACT_BOOLEAN(bf)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wdelch(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer( wdelch (curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wdeleteln(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer( wdeleteln (curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_winsertln(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer( winsertln (curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_winsdelln(s48_value win, s48_value n)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, n, res);
res = s48_enter_integer( winsdelln
(curses_extract_window(win),
s48_extract_integer(n)));
S48_GC_UNPROTECT();
return res;
}
//mehrere Fenster
s48_value scsh_overlay(s48_value srcwin, s48_value dstwin)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(srcwin, dstwin, res);
res = s48_enter_integer (overlay(curses_extract_window(srcwin),
curses_extract_window(dstwin)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_overwrite(s48_value srcwin, s48_value dstwin)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(srcwin, dstwin, res);
res = s48_enter_integer (overwrite(curses_extract_window(srcwin),
curses_extract_window(dstwin)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_copywin(s48_value srcwin, s48_value dstwin,
s48_value sminrow, s48_value smincol,
s48_value dminrow, s48_value dmincol,
s48_value dmaxrow, s48_value dmaxcol,
s48_value overlay)
{
S48_DECLARE_GC_PROTECT(9);
S48_GC_PROTECT_9(srcwin, dstwin, sminrow, smincol, dminrow, dmincol,
dmaxrow, dmaxcol, overlay);
int res = copywin(curses_extract_window(srcwin),
curses_extract_window(dstwin),
s48_extract_integer(sminrow),
s48_extract_integer(smincol),
s48_extract_integer(dminrow),
s48_extract_integer(dmincol),
s48_extract_integer(dmaxrow),
s48_extract_integer(dmaxcol),
s48_extract_integer(overlay));
S48_GC_UNPROTECT();
return s48_enter_integer(res);
}
//Eigenschaften
s48_value scsh_touchline(s48_value win, s48_value start,
s48_value count)
{
s48_value res;
S48_DECLARE_GC_PROTECT(4);
S48_GC_PROTECT_4(win, start, count, res);
res = s48_enter_integer(touchline
(curses_extract_window(win),
s48_extract_integer(start),
s48_extract_integer(count)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_touchwin(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer(touchwin
(curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_untouchwin(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = s48_enter_integer(untouchwin
(curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wtouchln(s48_value win, s48_value y,
s48_value n, s48_value changed)
{
s48_value res;
S48_DECLARE_GC_PROTECT(5);
S48_GC_PROTECT_5(win, y, n, changed, res);
res = s48_enter_integer(wtouchln
(curses_extract_window(win),
s48_extract_integer(y),
s48_extract_integer(n),
s48_extract_integer(changed)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_is_linetouched(s48_value win, s48_value line)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(win, line, res);
res = S48_ENTER_BOOLEAN(is_linetouched
(curses_extract_window(win),
s48_extract_integer(line)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_is_wintouched(s48_value win)
{
s48_value res;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win, res);
res = S48_ENTER_BOOLEAN(is_wintouched
(curses_extract_window(win)));
S48_GC_UNPROTECT();
return res;
}
//*************************************************************************
//PADS
s48_value scsh_newpad(s48_value nlines, s48_value ncols)
{
WINDOW *pad;
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(nlines, ncols, res);
pad=(newpad ((int) s48_extract_integer(nlines)
,(int) s48_extract_integer(ncols)));
if (pad==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res = curses_enter_window(pad);
S48_GC_UNPROTECT();
return res;
}
}
s48_value scsh_subpad(s48_value win, s48_value nlines,
s48_value ncols, s48_value begin_y,
s48_value begin_x)
{
WINDOW *pad;
s48_value res;
S48_DECLARE_GC_PROTECT(6);
S48_GC_PROTECT_6(win, nlines, ncols, begin_y, begin_x, res);
pad=(subpad (curses_extract_window(win),
(int) s48_extract_integer(nlines),
(int) s48_extract_integer(ncols),
(int) s48_extract_integer(begin_y),
(int) s48_extract_integer(begin_x)));
if (pad==NULL)
{
S48_GC_UNPROTECT();
return S48_FALSE;
}
else
{
res = curses_enter_window(pad);
S48_GC_UNPROTECT();
return res;
}
}
s48_value scsh_prefresh(s48_value orig, s48_value pminrow,
s48_value pmincol, s48_value sminrow,
s48_value smincol, s48_value smaxrow,
s48_value smaxcol)
{
s48_value res;
S48_DECLARE_GC_PROTECT(8);
S48_GC_PROTECT_8(orig, pminrow, pmincol, sminrow, smincol, smaxrow,
smaxcol, res);
res = s48_enter_integer (prefresh(curses_extract_window(orig),
s48_extract_integer(pminrow),
s48_extract_integer(pmincol),
s48_extract_integer(sminrow),
s48_extract_integer(smincol),
s48_extract_integer(smaxrow),
s48_extract_integer(smaxcol)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_pnoutrefresh(s48_value orig, s48_value pminrow,
s48_value pmincol, s48_value sminrow,
s48_value smincol, s48_value smaxrow,
s48_value smaxcol)
{
s48_value res;
S48_DECLARE_GC_PROTECT(8);
S48_GC_PROTECT_8(orig, pminrow, pmincol, sminrow, smincol, smaxrow,
smaxcol, res);
res = s48_enter_integer (pnoutrefresh(curses_extract_window(orig),
s48_extract_integer(pminrow),
s48_extract_integer(pmincol),
s48_extract_integer(sminrow),
s48_extract_integer(smincol),
s48_extract_integer(smaxrow),
s48_extract_integer(smaxcol)));
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_pechochar(s48_value pad, s48_value ch)
{
s48_value res;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(pad, ch, res);
res = s48_enter_integer (pechochar(curses_extract_window(pad),
curses_extract_chtype(ch)));
S48_GC_UNPROTECT();
return res;
}
//*************************************************************************
//KONSTANTEN:
//Standard-Screen
s48_value scsh_stdscr(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = curses_enter_window (stdscr);
S48_GC_UNPROTECT();
return res;
}
//Lines-Cols
s48_value scsh_LINES(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = curses_enter_window (LINES);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_COLS(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = curses_enter_window (COLS);
S48_GC_UNPROTECT();
return res;
}
//Attribute
s48_value scsh_A_NORMAL(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (A_NORMAL);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_A_STANDOUT(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (A_STANDOUT);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_A_UNDERLINE(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (A_UNDERLINE);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_A_REVERSE(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (A_REVERSE);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_A_BLINK(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (A_BLINK);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_A_DIM(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (A_DIM);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_A_BOLD(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (A_BOLD);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_A_PROTECT(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (A_PROTECT);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_A_INVIS(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (A_INVIS);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_A_ALTCHARSET(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (A_ALTCHARSET);
S48_GC_UNPROTECT();
return res;
}
//Farben:
s48_value scsh_COLOR_BLACK(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (COLOR_BLACK);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_COLOR_RED(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (COLOR_RED);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_COLOR_GREEN(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (COLOR_GREEN);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_COLOR_YELLOW(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (COLOR_YELLOW);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_COLOR_BLUE(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (COLOR_BLUE);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_COLOR_MAGENTA(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (COLOR_MAGENTA);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_COLOR_CYAN(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (COLOR_CYAN);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_COLOR_WHITE(void)
{
s48_value res;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
res = s48_enter_integer (COLOR_WHITE);
S48_GC_UNPROTECT();
return res;
}
s48_value scsh_wprintw(s48_value win, s48_value string)
{
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(win,string);
int res = wprintw(curses_extract_window(win),
s48_extract_string(string));
S48_GC_UNPROTECT();
return s48_enter_integer(res);
}
s48_value scsh_printw(s48_value text)
{
(void) printw(s48_extract_string(text));
return S48_UNSPECIFIC;
}
s48_value scsh_refresh(void)
{
(void) refresh();
return S48_UNSPECIFIC;
}
s48_value scsh_clear(void)
{
(void) clear();
return S48_UNSPECIFIC;
}
added bindings to ioctl() with TIOCGWINSZ and TIOCSWINSZ
2005-05-27 03:04:24 -04:00
s48_value scsh_get_term_window_size(s48_value fd)
{
struct winsize size;
if (ioctl(s48_extract_fixnum(fd), TIOCGWINSZ, (char *) &size) < 0)
return S48_FALSE;
else
return s48_list_4(s48_enter_fixnum(size.ws_row),
s48_enter_fixnum(size.ws_col),
s48_enter_fixnum(size.ws_xpixel),
s48_enter_fixnum(size.ws_ypixel));
}
s48_value scsh_set_term_window_size(s48_value fd, s48_value row,
s48_value col, s48_value xpixel,
s48_value ypixel)
{
struct winsize size;
first commit
2004-09-07 05:13:21 -04:00
added bindings to ioctl() with TIOCGWINSZ and TIOCSWINSZ
2005-05-27 03:04:24 -04:00
size.ws_row = (unsigned short) s48_extract_fixnum(row);
size.ws_col = (unsigned short) s48_extract_fixnum(col);
size.ws_xpixel = (unsigned short) s48_extract_fixnum(xpixel);
size.ws_ypixel = (unsigned short) s48_extract_fixnum(ypixel);
if (ioctl(s48_extract_fixnum(fd), TIOCSWINSZ, (char *) &size) < 0)
return S48_TRUE;
else
return S48_FALSE;
}
first commit
2004-09-07 05:13:21 -04:00
Renamed init function
2004-09-07 10:30:27 -04:00
void s48_init_ncurses(void)
first commit
2004-09-07 05:13:21 -04:00
{
S48_EXPORT_FUNCTION(scsh_initscr);
S48_EXPORT_FUNCTION(scsh_newterm);
S48_EXPORT_FUNCTION(scsh_endwin);
S48_EXPORT_FUNCTION(scsh_isendwin);
S48_EXPORT_FUNCTION(scsh_delscreen);
S48_EXPORT_FUNCTION(scsh_unctrl);
S48_EXPORT_FUNCTION(scsh_keyname);
S48_EXPORT_FUNCTION(scsh_filter);
S48_EXPORT_FUNCTION(scsh_use_env);
S48_EXPORT_FUNCTION(scsh_putwin);
S48_EXPORT_FUNCTION(scsh_getwin);
S48_EXPORT_FUNCTION(scsh_delay_output);
S48_EXPORT_FUNCTION(scsh_flushinp);
S48_EXPORT_FUNCTION(scsh_curses_version);
S48_EXPORT_FUNCTION(scsh_use_default_colors);
S48_EXPORT_FUNCTION(scsh_assume_default_colors);
S48_EXPORT_FUNCTION(scsh_define_key);
S48_EXPORT_FUNCTION(scsh_baudrate);
S48_EXPORT_FUNCTION(scsh_erasechar);
S48_EXPORT_FUNCTION(scsh_has_ic);
S48_EXPORT_FUNCTION(scsh_has_il);
S48_EXPORT_FUNCTION(scsh_killchar);
S48_EXPORT_FUNCTION(scsh_longname);
S48_EXPORT_FUNCTION(scsh_termname);
S48_EXPORT_FUNCTION(scsh_has_key);
S48_EXPORT_FUNCTION(scsh_start_color);
S48_EXPORT_FUNCTION(scsh_init_pair);
S48_EXPORT_FUNCTION(scsh_init_color);
S48_EXPORT_FUNCTION(scsh_has_colors);
S48_EXPORT_FUNCTION(scsh_can_change_colors);
S48_EXPORT_FUNCTION(scsh_color_pair);
S48_EXPORT_FUNCTION(scsh_cbreak);
S48_EXPORT_FUNCTION(scsh_no_cbreak);
S48_EXPORT_FUNCTION(scsh_echo);
S48_EXPORT_FUNCTION(scsh_noecho);
S48_EXPORT_FUNCTION(scsh_halfdelay);
S48_EXPORT_FUNCTION(scsh_intrflush);
S48_EXPORT_FUNCTION(scsh_keypad);
S48_EXPORT_FUNCTION(scsh_meta);
S48_EXPORT_FUNCTION(scsh_nodelay);
S48_EXPORT_FUNCTION(scsh_raw);
S48_EXPORT_FUNCTION(scsh_noraw);
S48_EXPORT_FUNCTION(scsh_qiflush);
S48_EXPORT_FUNCTION(scsh_noqiflush);
S48_EXPORT_FUNCTION(scsh_beep);
S48_EXPORT_FUNCTION(scsh_flash);
S48_EXPORT_FUNCTION(scsh_def_prog_mode);
S48_EXPORT_FUNCTION(scsh_def_shell_mode);
S48_EXPORT_FUNCTION(scsh_reset_prog_mode);
S48_EXPORT_FUNCTION(scsh_reset_shell_mode);
S48_EXPORT_FUNCTION(scsh_resetty);
S48_EXPORT_FUNCTION(scsh_savetty);
S48_EXPORT_FUNCTION(scsh_curs_set);
S48_EXPORT_FUNCTION(scsh_napms);
S48_EXPORT_FUNCTION(scsh_mcprint);
S48_EXPORT_FUNCTION(scsh_is_term_resized);
S48_EXPORT_FUNCTION(scsh_resize_term);
S48_EXPORT_FUNCTION(scsh_resizeterm);
S48_EXPORT_FUNCTION(scsh_scr_dump);
S48_EXPORT_FUNCTION(scsh_scr_restore);
S48_EXPORT_FUNCTION(scsh_scr_init);
S48_EXPORT_FUNCTION(scsh_scr_set);
S48_EXPORT_FUNCTION(scsh_set_term);
S48_EXPORT_FUNCTION(scsh_newwin);
S48_EXPORT_FUNCTION(scsh_delwin);
S48_EXPORT_FUNCTION(scsh_mvwin);
S48_EXPORT_FUNCTION(scsh_subwin);
S48_EXPORT_FUNCTION(scsh_derwin);
S48_EXPORT_FUNCTION(scsh_mvderwin);
S48_EXPORT_FUNCTION(scsh_dupwin);
S48_EXPORT_FUNCTION(scsh_wsyncup);
S48_EXPORT_FUNCTION(scsh_wcursyncup);
S48_EXPORT_FUNCTION(scsh_wsyncdown);
S48_EXPORT_FUNCTION(scsh_syncok);
S48_EXPORT_FUNCTION(scsh_wrefresh);
S48_EXPORT_FUNCTION(scsh_wnoutrefresh);
S48_EXPORT_FUNCTION(scsh_redrawwin);
S48_EXPORT_FUNCTION(scsh_doupdate);
S48_EXPORT_FUNCTION(scsh_wredrawln);
/*S48_EXPORT_FUNCTION(scsh_getyx);
S48_EXPORT_FUNCTION(scsh_getparyx);
S48_EXPORT_FUNCTION(scsh_getbegyx);
S48_EXPORT_FUNCTION(scsh_getmaxyx);*/
S48_EXPORT_FUNCTION(scsh_gety);
S48_EXPORT_FUNCTION(scsh_getx);
S48_EXPORT_FUNCTION(scsh_getmaxy);
S48_EXPORT_FUNCTION(scsh_getmaxx);
S48_EXPORT_FUNCTION(scsh_wresize);
S48_EXPORT_FUNCTION(scsh_idlok);
S48_EXPORT_FUNCTION(scsh_leaveok);
S48_EXPORT_FUNCTION(scsh_scrollok);
S48_EXPORT_FUNCTION(scsh_idcok);
S48_EXPORT_FUNCTION(scsh_immedok);
S48_EXPORT_FUNCTION(scsh_wsetscrreg);
S48_EXPORT_FUNCTION(scsh_nl);
S48_EXPORT_FUNCTION(scsh_nonl);
S48_EXPORT_FUNCTION(scsh_waddch);
S48_EXPORT_FUNCTION(scsh_wechochar);
S48_EXPORT_FUNCTION(scsh_waddstr);
S48_EXPORT_FUNCTION(scsh_waddnstr);
S48_EXPORT_FUNCTION(scsh_winsch);
S48_EXPORT_FUNCTION(scsh_winsstr);
S48_EXPORT_FUNCTION(scsh_winsnstr);
S48_EXPORT_FUNCTION(scsh_wattroff);
S48_EXPORT_FUNCTION(scsh_wattron);
S48_EXPORT_FUNCTION(scsh_wattrset);
S48_EXPORT_FUNCTION(scsh_wstandend);
S48_EXPORT_FUNCTION(scsh_wstandout);
S48_EXPORT_FUNCTION(scsh_wbkgdset);
S48_EXPORT_FUNCTION(scsh_wbkgd);
S48_EXPORT_FUNCTION(scsh_getbkgd);
S48_EXPORT_FUNCTION(scsh_wborder);
S48_EXPORT_FUNCTION(scsh_box);
S48_EXPORT_FUNCTION(scsh_whline);
S48_EXPORT_FUNCTION(scsh_wvline);
S48_EXPORT_FUNCTION(scsh_scroll);
S48_EXPORT_FUNCTION(scsh_wscrl);
S48_EXPORT_FUNCTION(scsh_wmove);
S48_EXPORT_FUNCTION(scsh_wgetch);
S48_EXPORT_FUNCTION(scsh_winch);
S48_EXPORT_FUNCTION(scsh_winstr);
S48_EXPORT_FUNCTION(scsh_winnstr);
S48_EXPORT_FUNCTION(scsh_werase);
S48_EXPORT_FUNCTION(scsh_wclear);
S48_EXPORT_FUNCTION(scsh_wclrtobot);
S48_EXPORT_FUNCTION(scsh_wclrtoeol);
S48_EXPORT_FUNCTION(scsh_clearok);
S48_EXPORT_FUNCTION(scsh_wdelch);
S48_EXPORT_FUNCTION(scsh_wdeleteln);
S48_EXPORT_FUNCTION(scsh_winsertln);
S48_EXPORT_FUNCTION(scsh_winsdelln);
S48_EXPORT_FUNCTION(scsh_overlay);
S48_EXPORT_FUNCTION(scsh_overwrite);
S48_EXPORT_FUNCTION(scsh_copywin);
S48_EXPORT_FUNCTION(scsh_touchline);
S48_EXPORT_FUNCTION(scsh_touchwin);
S48_EXPORT_FUNCTION(scsh_untouchwin);
S48_EXPORT_FUNCTION(scsh_wtouchln);
S48_EXPORT_FUNCTION(scsh_is_linetouched);
S48_EXPORT_FUNCTION(scsh_is_wintouched);
S48_EXPORT_FUNCTION(scsh_newpad);
S48_EXPORT_FUNCTION(scsh_subpad);
S48_EXPORT_FUNCTION(scsh_prefresh);
S48_EXPORT_FUNCTION(scsh_pnoutrefresh);
S48_EXPORT_FUNCTION(scsh_pechochar);
S48_EXPORT_FUNCTION(scsh_stdscr);
S48_EXPORT_FUNCTION(scsh_LINES);
S48_EXPORT_FUNCTION(scsh_COLS);
S48_EXPORT_FUNCTION(scsh_A_NORMAL);
S48_EXPORT_FUNCTION(scsh_A_STANDOUT);
S48_EXPORT_FUNCTION(scsh_A_UNDERLINE);
S48_EXPORT_FUNCTION(scsh_A_REVERSE);
S48_EXPORT_FUNCTION(scsh_A_BLINK);
S48_EXPORT_FUNCTION(scsh_A_DIM);
S48_EXPORT_FUNCTION(scsh_A_BOLD);
S48_EXPORT_FUNCTION(scsh_A_PROTECT);
S48_EXPORT_FUNCTION(scsh_A_INVIS);
S48_EXPORT_FUNCTION(scsh_A_ALTCHARSET);
S48_EXPORT_FUNCTION(scsh_COLOR_BLACK);
S48_EXPORT_FUNCTION(scsh_COLOR_RED);
S48_EXPORT_FUNCTION(scsh_COLOR_GREEN);
S48_EXPORT_FUNCTION(scsh_COLOR_YELLOW);
S48_EXPORT_FUNCTION(scsh_COLOR_BLUE);
S48_EXPORT_FUNCTION(scsh_COLOR_MAGENTA);
S48_EXPORT_FUNCTION(scsh_COLOR_CYAN);
S48_EXPORT_FUNCTION(scsh_COLOR_WHITE);
S48_EXPORT_FUNCTION(scsh_wprintw);
S48_EXPORT_FUNCTION(scsh_printw);
S48_EXPORT_FUNCTION(scsh_refresh);
S48_EXPORT_FUNCTION(scsh_clear);
added bindings to ioctl() with TIOCGWINSZ and TIOCSWINSZ
2005-05-27 03:04:24 -04:00
S48_EXPORT_FUNCTION(scsh_get_term_window_size);
S48_EXPORT_FUNCTION(scsh_set_term_window_size);
first commit
2004-09-07 05:13:21 -04:00
}