G:/ScriptBasic/source/extensions/curses/interface.c

Go to the documentation of this file.

/* FILE: curses.c

This file implements the curses module for ScriptBasic. This module is
an interface to the Unix curses library.

--GNU LGPL
This library 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.1 of the License, or (at your option) any later version.

This library 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 library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

the next line tells the program setup.pl that this module can be installed only
under UNIX.

UXLIBS: -lcurses

*/
#include <curses.h>
#include <malloc.h>

#include "../../basext.h"

#define MAX_WINDOWS 16
WINDOW *window_list[MAX_WINDOWS];
WINDOW *current_window;

/* This variable stores whether the module should issue a refresh() call
   after each operation that can potentially modify the screen
*/

static int auto_refresh = -1;

static int color_to_basic(int color)
{
        switch (color) {
            case COLOR_BLACK: return 0;
            case COLOR_RED: return 1;
            case COLOR_GREEN: return 2;
            case COLOR_YELLOW: return 3;
            case COLOR_BLUE: return 4;
            case COLOR_MAGENTA: return 5;
            case COLOR_CYAN: return 6;
            case COLOR_WHITE: return 7;
            default:
                return -1;
        }
}

static int color_to_curses(int sbcolor)
{
        int colors[] = {
                COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW,
                COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE
        };

        if (sbcolor < 0 || sbcolor > 7)
                return -1;

        return colors[sbcolor];
}

static int attr_to_basic(int attr)
{
        int sbattr = 0;

        if (attr & A_NORMAL)
                sbattr |= 0x0001;
        if (attr & A_STANDOUT)
                sbattr |= 0x0002;
        if (attr & A_UNDERLINE)
                sbattr |= 0x0004;
        if (attr & A_REVERSE)
                sbattr |= 0x0008;
        if (attr & A_BLINK)
                sbattr |= 0x0010;
        if (attr & A_DIM)
                sbattr |= 0x0020;
        if (attr & A_BOLD)
                sbattr |= 0x0040;
        if (attr & A_PROTECT)
                sbattr |= 0x0080;
        if (attr & A_INVIS)
                sbattr |= 0x0100;
        if (attr & A_ALTCHARSET)
                sbattr |= 0x0200;
        if (attr & A_CHARTEXT)
                sbattr |= 0x0400;

        return sbattr;
}

static attr_t attr_to_curses(int sbattr)
{
        attr_t attr = 0;

        if (sbattr & 0x0001)
                attr |= A_NORMAL;
        if (sbattr & 0x0002)
                attr |= A_STANDOUT;
        if (sbattr & 0x0004)
                attr |= A_UNDERLINE;
        if (sbattr & 0x0008)
                attr |= A_REVERSE;
        if (sbattr & 0x0010)
                attr |= A_BLINK;
        if (sbattr & 0x0020)
                attr |= A_DIM;
        if (sbattr & 0x0040)
                attr |= A_BOLD;
        if (sbattr & 0x0080)
                attr |= A_PROTECT;
        if (sbattr & 0x0100)
                attr |= A_INVIS;
        if (sbattr & 0x0200)
                attr |= A_ALTCHARSET;
        if (sbattr & 0x0400)
                attr |= A_CHARTEXT;

        return attr;
}

#define AUTO_REFRESH do { if (auto_refresh) {  refresh(); } } while (0)
#define HANDLE_ERR(cmd) \
        LONGVALUE(besRETURNVALUE) =  ((cmd) == ERR) ? 0 : -1;

static int color_supported;
besSUB_SHUTDOWN
  return 0;
besEND

besSUB_FINISH
{
        endwin();
}
besEND

besSUB_START
{
        int i;
        
        initscr();
        current_window = stdscr;
        cbreak();
        noecho();
        if (start_color() == ERR)
                color_supported = FALSE;
        else
                color_supported = TRUE;

        for (i=0; i<MAX_WINDOWS; i++)
                window_list[i] = NULL;

        window_list[0] = stdscr;
        return COMMAND_ERROR_SUCCESS;
}  
besEND

besFUNCTION(sbsetwin)
{
        int err, wn;

        besALLOC_RETURN_LONG;
        
        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "i", &wn besGETARGE;
        if (err)
                return err;
        wn--;
        
        if (wn < 0 || wn >= MAX_WINDOWS || window_list[wn] == NULL) {
                LONGVALUE(besRETURNVALUE) = 0;
        } else {
                current_window = window_list[wn];
                LONGVALUE(besRETURNVALUE) = -1;
        }
}
besEND

besFUNCTION(sbborder)
{
        wborder(current_window, 0, 0, 0, 0, 0, 0, 0, 0);
        AUTO_REFRESH;
}
besEND

besFUNCTION(sbnewwin)
{
        int i;
        WINDOW *wnd;
        int rows, cols, y, x;
        int err;
        
        besALLOC_RETURN_LONG;
        if (besARGNR < 4)
                return COMMAND_ERROR_FEW_ARGS;
        err = besGETARGS "iiii", &x, &y, &cols, &rows besGETARGE;
        if (err)
                return err;
        
        for (i=0; i<MAX_WINDOWS; i++)
                if (window_list[i] == NULL)
                        break;
        
        if (i == MAX_WINDOWS) {
                LONGVALUE(besRETURNVALUE) = 0;
                return COMMAND_ERROR_SUCCESS;
        }

        wnd = newwin(rows, cols, y, x);
        if (wnd == NULL) {
                LONGVALUE(besRETURNVALUE) = 0;
                return COMMAND_ERROR_SUCCESS;
        }
        
        window_list[i] = wnd;
        current_window = wnd;
        LONGVALUE(besRETURNVALUE) = i+1;
}
besEND

besFUNCTION(sbdelwin)
{
        int i, err;

        besALLOC_RETURN_LONG;
                
        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "i", &i besGETARGE;
        if (err)
                return err;
        i--;
        
        if (i < 0 || i >= MAX_WINDOWS || window_list[i] == NULL)
                return COMMAND_ERROR_BAD_CALL;

        err = delwin(window_list[i]);
        if (err == ERR) {
                LONGVALUE(besRETURNVALUE) = 0;
        } else {
                window_list[i] = NULL;
                LONGVALUE(besRETURNVALUE) = -1;
        }
}
besEND

besFUNCTION(sbautorefresh)
{
        int err;
        int v;

        besALLOC_RETURN_LONG;
        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "i", &v besGETARGE;
        if (err)
                return err;
        auto_refresh = v;
}
besEND

besFUNCTION(sbbeep)
{
        beep();
}
besEND

besFUNCTION(sbflash)
{
        flash();
}
besEND

besFUNCTION(sberase)
{
        erase();
        //      AUTO_REFRESH;
}
besEND

besFUNCTION(sbrefresh)
{
        wrefresh(current_window);
}
besEND


besFUNCTION(sbmove)
{
        int err;
        int x, y;

        besALLOC_RETURN_LONG;
        if (besARGNR < 2)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "ii", &x, &y besGETARGE;
        if (err)
                return err;

        HANDLE_ERR(wmove(current_window, y, x));
}
besEND

besFUNCTION(sbgetx)
{
        int x, y;

        besALLOC_RETURN_LONG;

        getyx(current_window, y, x);
        LONGVALUE(besRETURNVALUE) = x;
}
besEND

besFUNCTION(sbgety)
{
        int err;
        int x, y;

        besALLOC_RETURN_LONG;

        getyx(current_window, y, x);
        LONGVALUE(besRETURNVALUE) = y;
}
besEND

besFUNCTION(sbgetsizex)
{
        int err;
        int x, y;

        besALLOC_RETURN_LONG;

        getmaxyx(current_window, y, x);
        LONGVALUE(besRETURNVALUE) = x;
}
besEND

besFUNCTION(sbgetsizey)
{
        int err;
        int x, y;

        besALLOC_RETURN_LONG;

        getmaxyx(current_window, y, x);
        LONGVALUE(besRETURNVALUE) = y;
}
besEND

besFUNCTION(sbaddstr)
{
        int i, err;
        char *str;
        VARIABLE arg;
        
        besALLOC_RETURN_LONG;
        
        for (i=1; i<=besARGNR; i++) {
                arg = besARGUMENT(i);
                if (arg == NULL)
                        return COMMAND_ERROR_FEW_ARGS;
                besDEREFERENCE(arg);
                if (arg == NULL) 
                        return COMMAND_ERROR_ARGUMENT_RANGE;
                arg = besCONVERT2STRING(arg);
                besCONVERT2ZCHAR(arg, str);
                err = waddstr(current_window, str);
                if (err == ERR)
                        break;
        }

        AUTO_REFRESH;
        HANDLE_ERR(err);
}
besEND

besFUNCTION(sbinsstr)
{
        int err;
        char *str;

        besALLOC_RETURN_LONG;
        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;
        
        err = besGETARGS "z", &str besGETARGE;
        if (err)
                return err;
        
        err = winsstr(current_window, str);
        AUTO_REFRESH;
        HANDLE_ERR(err);
}       
besEND

besFUNCTION(sbinsdelln)
{
        int err;
        int n;

        besALLOC_RETURN_LONG;
        
        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "i", &n besGETARGE;
        if (err)
                return err;

        err = winsdelln(current_window, n);
        AUTO_REFRESH;
        HANDLE_ERR(err);
}
besEND

besFUNCTION(sbdelch)
{
        wdelch(current_window);
}
besEND

besFUNCTION(sbinstr)
{
        char *buf;
        int err;
        int no;

        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;
        err = besGETARGS "i", &no besGETARGE;
        if (err)
                return err;

        buf = malloc(no+1);
        winnstr(current_window, buf, no);
        
        besALLOC_RETURN_STRING(strlen(buf));
        memcpy(STRINGVALUE(besRETURNVALUE), buf, STRLEN(besRETURNVALUE));
        free(buf);
}
besEND

besFUNCTION(sbattron)
{
        int err;
        int sbattr;
        attr_t attr;
        
        besALLOC_RETURN_LONG;
        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "i", &sbattr besGETARGE;
        if (err)
                return err;
        attr = attr_to_curses(sbattr);
        wattron(current_window, attr);
}
besEND

besFUNCTION(sbattroff)
{
        int err;
        int sbattr;
        attr_t attr;
        
        besALLOC_RETURN_LONG;
        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "i", &sbattr besGETARGE;
        if (err)
                return err;
        attr = attr_to_curses(sbattr);
        wattroff(current_window, attr);
}
besEND

besFUNCTION(sbattrset)
{
        int err;
        int sbattr;
        attr_t attr;
        
        besALLOC_RETURN_LONG;
        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "i", &sbattr besGETARGE;
        if (err)
                return err;
        attr = attr_to_curses(sbattr);
        wattrset(current_window, attr);
}
besEND

besFUNCTION(sbchgat)
{
        int err;
        int no, col, attr;

        if (besARGNR < 3)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "iii", &no, &col, &attr besGETARGE;
        if (err)
                return err;
        
        attr = attr_to_curses(attr);
        wchgat(current_window, no, attr, col, NULL);
}
besEND

besFUNCTION(sbmaxcolors)
{
        besALLOC_RETURN_LONG;
        LONGVALUE(besRETURNVALUE) = COLOR_PAIRS - 1;
}
besEND

besFUNCTION(sbinitpair)
{
        int err;
        int c, f, b;

        besALLOC_RETURN_LONG;
        if (besARGNR < 3)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "iii", &c, &f, &b besGETARGE;
        if (err)
                return err;

        f = color_to_curses(f);
        b = color_to_curses(b);

        HANDLE_ERR(init_pair(c, f, b));
}
besEND

besFUNCTION(sbsetcolor)
{
        int err;
        int c;

        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;

        err = besGETARGS "i", &c besGETARGE;
        if (err)
                return err;

        /* disable all color attributes and enable color wished for */
        attroff(~attr_to_curses(0x07ff)); /* this is perhaps unnecessary */
        attron(COLOR_PAIR(c));
}
besEND

besFUNCTION(sbsetbackground)
{
        int err;
        int set, col, attr;

        besALLOC_RETURN_LONG;
        
        switch (besARGNR) {
            case 2:
                err = besGETARGS "ii", &col, &attr besGETARGE;
                if (err)
                        return err;
                set = 0;
                break;
            case 3:
                err = besGETARGS "iii", &col, &attr, &set besGETARGE;
                if (err)
                        return err;
                break;
            default:
                return COMMAND_ERROR_FEW_ARGS;
        }

        attr = attr_to_curses(attr) | COLOR_PAIR(col);
        if (set)
                err = wbkgd(current_window,attr);
        else { 
                wbkgdset(current_window, attr);
                err = OK;
        }

        HANDLE_ERR(err);
}
besEND

besFUNCTION(sbgetch)
{
        int err, doecho = 0, dodelay = 1;
        int ch;

        besALLOC_RETURN_LONG;

        switch (besARGNR) {
            case 1:
                err = besGETARGS "i", &doecho besGETARGE;
                if (err)
                        return err;
            case 0:
                break;
            default:
                err = besGETARGS "ii", &doecho, &dodelay besGETARGE;
                break;
                
        }

        if (doecho)
                echo();
        if (!dodelay) {
                nodelay(current_window, 1);
        }
        ch = wgetch(current_window);
        noecho();
        nodelay(current_window, 0);

        if (ch == ERR)
                LONGVALUE(besRETURNVALUE) = -1;
        else
                LONGVALUE(besRETURNVALUE) = ch;
}
besEND

besFUNCTION(sbgetstr)
{
        char *buf;
        int err;
        int no;

        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;
        err = besGETARGS "i", &no besGETARGE;
        if (err)
                return err;

        buf = malloc(no+1);
        echo();
        wgetnstr(current_window, buf, no);
        noecho();
        
        besALLOC_RETURN_STRING(strlen(buf));
        memcpy(STRINGVALUE(besRETURNVALUE), buf, STRLEN(besRETURNVALUE));
        free(buf);
}
besEND

besFUNCTION(sbkeyname)
{
        int err, key;
        const char *kn;
        
        if (besARGNR < 1)
                return COMMAND_ERROR_FEW_ARGS;
        err = besGETARGS "i", &key besGETARGE;
        if (err)
                return err;

        kn = keyname(key);
        
        besALLOC_RETURN_STRING(strlen(kn));
        memcpy(STRINGVALUE(besRETURNVALUE), kn, STRLEN(besRETURNVALUE));
}
besEND

besVERSION_NEGOTIATE

  return (int)INTERFACE_VERSION;

besEND

SLFST CURSES_SLFST[] ={

{ "shutmodu" , shutmodu },
{ "bootmodu" , bootmodu },
{ "versmodu" , versmodu },
{ "finimodu" , finimodu },
        
{ "beep" , sbbeep },
{ "flash", sbflash },
{ "erase", sberase },
{ "refresh", sbrefresh },
{ "autorefresh", sbautorefresh },
        
{ "move", sbmove },
{ "getx", sbgetx },
{ "gety", sbgety },
{ "getsizex", sbgetsizex },
{ "getsizey", sbgetsizey },

{ "addstr", sbaddstr },
{ "insstr", sbinsstr },
{ "insdelln", sbinsdelln },
{ "delch", sbdelch },
{ "instr", sbinstr },
        
{ "attron", sbattron },
{ "attroff", sbattroff },
{ "attrset", sbattrset },
{ "chgat", sbchgat },
        
{ "maxcolors", sbmaxcolors },
{ "initpair", sbinitpair },
{ "setcolor", sbsetcolor },
{ "setbackground", sbsetbackground },
        
{ "getch", sbgetch },
{ "getstr", sbgetstr },

{ "keyname", sbkeyname },

{ "setwin", sbsetwin },
{ "newwin", sbnewwin },
{ "delwin", sbdelwin },
{ "border", sbborder },
{ NULL , NULL }
};

---