/* non blocking getkey */
static int getkey_handler() {
unsigned int ch = 0;
if(SLang_input_pending(1))
// return SLang_getkey();
ch = SLang_getkey();
if(ch) func("getkey_handler detected char %u",ch);
return ch;
}
int newtGetKey(void) {
int key, lastcode, errors = 0;
unsigned char *chptr = keyreader_buf, *lastmatch;
struct kmap_trie_entry *curr = kmap_trie_root;
do {
key = getkey();
if (key == SLANG_GETKEY_ERROR) {
if (needResize) {
needResize = 0;
return NEWT_KEY_RESIZE;
}
/* Ignore other signals, but assume that stdin disappeared (the
* parent terminal was proably closed) if the error persists.
*/
if (errors++ > 10)
return NEWT_KEY_ERROR;
continue;
}
if (key == NEWT_KEY_SUSPEND && suspendCallback)
suspendCallback(suspendCallbackData);
} while (key == NEWT_KEY_SUSPEND || key == SLANG_GETKEY_ERROR);
/* Read more characters, matching against the trie as we go */
lastcode = *chptr = key;
lastmatch = chptr ;
while(1) {
while (curr->c != key) {
curr = curr->next ;
if (curr==NULL) goto break2levels;
}
if (curr->code) {
lastcode = curr->code;
lastmatch = chptr;
}
curr = curr->contseq;
if (curr==NULL) break;
if (SLang_input_pending(5) <= 0)
break;
if (chptr==keyreader_buf+keyreader_buf_len-1) break;
*++chptr = key = getkey();
}
break2levels:
/* The last time the trie matched was at position lastmatch. Back
* up if we have read too many characters. */
while (chptr > lastmatch)
SLang_ungetkey(*chptr--);
return lastcode;
}
/*
* Process an event, wait if requested
*/
static errr Term_xtra_sla_event(int v)
{
/* Do not wait unless requested */
if (!v && (SLang_input_pending(0) == 0)) return (1);
/* Get and enqueue the key */
Term_keypress(SLang_getkey ());
/* Success */
return 0;
}
int main(void) {
int i;
char * buf;
SLtt_get_terminfo();
SLang_init_tty(4, 0, 0);
buf = SLtt_tgetstr("ku");
if (!buf) {
printf("termcap entry not found for kl\n\r");
} else {
printf("termcap entry found for kl: %s", buf);
while (*buf) {
printf("0x%02x ", *buf++);
}
printf("\n\r");
}
printf("\n\r");
printf("Press a key: ");
fflush(stdout);
SLang_input_pending(50);
printf("\n\r");
printf("You pressed: ");
while (SLang_input_pending(1)) {
i = SLang_getkey();
printf("0x%02x ", i);
}
printf("\n\r");
SLang_reset_tty();
return 0;
}
int
tty_lowlevel_getch (void)
{
int c;
if (no_slang_delay && (SLang_input_pending (0) == 0))
return -1;
c = SLang_getkey ();
if (c == SLANG_GETKEY_ERROR)
{
fprintf (stderr,
"SLang_getkey returned SLANG_GETKEY_ERROR\n"
"Assuming EOF on stdin and exiting\n");
exit (EXIT_FAILURE);
}
return c;
}
int SLcurses_wgetch (SLcurses_Window_Type *w)
{
if (w == NULL)
return ERR;
SLcurses_wrefresh (w);
if ((Keyboard_Buffer_Start != Keyboard_Buffer_Stop)
|| (w->delay_off == -1)
|| SLang_input_pending (w->delay_off))
{
if (w->use_keypad)
return get_keypad_key ();
return SLang_getkey ();
}
return ERR;
}
static int ctl_read(int32 *valp)
{
int c;
if (!SLang_input_pending(0))
return RC_NONE;
c=SLang_getkey();
switch(c)
{
case 'h':
case '?':
ctl_help_mode();
return RC_NONE;
case 'V':
*valp=10;
return RC_CHANGE_VOLUME;
case 'v':
*valp=-10;
return RC_CHANGE_VOLUME;
case 'q':
return RC_QUIT;
case 'n':
return RC_NEXT;
case 'p':
return RC_REALLY_PREVIOUS;
case 'r':
return RC_RESTART;
case 'f':
*valp=play_mode->rate;
return RC_FORWARD;
case 'b':
*valp=play_mode->rate;
return RC_BACK;
case 's':
return RC_TOGGLE_PAUSE;
}
return RC_NONE;
}
static int get_keypad_key (void)
{
int ch;
if (Keyboard_Buffer_Stop != Keyboard_Buffer_Start)
return get_buffered_key ();
ch = SLang_getkey ();
if (ch == '\033')
{
if (0 == SLang_input_pending (ESCDELAY / 100))
return ch;
}
else if (ch == SLANG_GETKEY_ERROR) return ERR;
SLang_ungetkey (ch);
ch = SLkp_getkey ();
if (ch == SL_KEY_ERR)
ch = get_buffered_key ();
else
Keyboard_Buffer_Stop = Keyboard_Buffer_Start;
return ch;
}
int newtGetKey(void) {
int key;
char buf[10], * chptr = buf;
const struct keymap * curr;
do {
key = SLang_getkey();
if (key == 0xFFFF) {
if (needResize)
return NEWT_KEY_RESIZE;
/* ignore other signals */
continue;
}
if (key == NEWT_KEY_SUSPEND && suspendCallback)
suspendCallback(suspendCallbackData);
} while (key == NEWT_KEY_SUSPEND);
switch (key) {
case 'v' | 0x80:
case 'V' | 0x80:
return NEWT_KEY_PGUP;
case 22:
return NEWT_KEY_PGDN;
return NEWT_KEY_BKSPC;
case 0x7f:
return NEWT_KEY_BKSPC;
case 0x08:
return NEWT_KEY_BKSPC;
default:
if (key != keyPrefix) return key;
}
memset(buf, 0, sizeof(buf));
*chptr++ = key;
while (SLang_input_pending(5)) {
key = SLang_getkey();
if (key == keyPrefix) {
/* he hit unknown keys too many times -- start over */
memset(buf, 0, sizeof(buf));
chptr = buf;
}
*chptr++ = key;
/* this search should use bsearch(), but when we only look through
a list of 20 (or so) keymappings, it's probably faster just to
do a inline linear search */
for (curr = keymap; curr->code; curr++) {
if (curr->str) {
if (!strcmp(curr->str, buf))
return curr->code;
}
}
}
for (curr = keymap; curr->code; curr++) {
if (curr->str) {
if (!strcmp(curr->str, buf))
return curr->code;
}
}
/* Looks like we were a bit overzealous in reading characters. Return
just the first character, and put everything else back in the buffer
for later */
chptr--;
while (chptr > buf)
SLang_ungetkey(*chptr--);
return *chptr;
}
int main() {
int i, j;
int keepRunning;
int input;
unsigned int ch;
int ch2;
char inputBuffer[40];
int terminalIndex;
struct tesiObject *to;
for(i = 0; i < 10; i++)
tesiObjects[i] = NULL;
SLtt_get_terminfo();
SLang_init_tty(-1, 0, 0);
SLsmg_init_smg();
SLsmg_refresh();
inputBuffer[0] = 0;
terminalIndex = -1;
keepRunning = 1;
while(keepRunning) {
j = 0;
for(i = 0; i < 10; i++) {
if(tesiObjects[i] != NULL)
j += tesi_handleInput(tesiObjects[i]);
}
if(j)
SLsmg_refresh();
if(!SLang_input_pending(1)) // wait 1/10 of a second
continue;
ch = SLang_getkey();
switch(ch) {
case '`': // tilde pressed, cycle through terms?
terminalIndex++;
if(terminalIndex == 10 || vtGet(terminalIndex) == NULL)
terminalIndex = -1;
// highlight selected terminal
break;
case 'Q':
keepRunning = 0;
break;
default:
if(terminalIndex > -1) { // send input to terminal
to = vtGet(terminalIndex);
if(to) // this should never be null, but check anyway
write(to->fd_input, &ch, 1);
} else { // build input buffer
#ifdef DEBUG
fprintf(stderr, "Keypress: %d\n", ch);
#endif
if(ch == 13) { // parse buffer when Enter is pressed
// new terminal
processInput(inputBuffer);
inputBuffer[0] = 0;
} else {
i = strlen(inputBuffer);
inputBuffer[ i ] = ch;
inputBuffer[ i + 1 ] = 0;
SLsmg_gotorc(SLtt_Screen_Rows - 1, 0);
SLsmg_write_string(inputBuffer);
SLsmg_refresh();
}
}
break;
}
}
for(i = 0; i < 10; i++) {
if(tesiObjects[i] != NULL) {
vtDestroy(i);
}
}
SLsmg_reset_smg();
SLang_reset_tty();
return 0;
}
int display_input_to_flush(void)
{
return SLang_input_pending(0);
}
static int slang_get_event(caca_display_t *dp, caca_privevent_t *ev)
{
int intkey;
/* If SIGINT was caught, we pass it to the application as Ctrl-C. */
if(dp->drv.p->sigint_event > 0)
{
ev->type = CACA_EVENT_KEY_PRESS;
ev->data.key.ch = CACA_KEY_CTRL_C;
ev->data.key.utf32 = 0x03;
ev->data.key.utf8[0] = 0x03;
ev->data.key.utf8[1] = 0;
dp->drv.p->sigint_event--;
return 1;
}
if(!SLang_input_pending(0))
{
ev->type = CACA_EVENT_NONE;
return 0;
}
/* We first use SLang_getkey() to see whether Esc was pressed
* alone, then (if it wasn't) we unget the key and use SLkp_getkey()
* instead, so that escape sequences are interpreted. */
intkey = SLang_getkey();
if(intkey != 0x1b /* Esc */ || SLang_input_pending(0))
{
SLang_ungetkey(intkey);
intkey = SLkp_getkey();
}
/* If the key was ASCII, return it immediately */
if(intkey < 0x7f)
{
ev->type = CACA_EVENT_KEY_PRESS;
ev->data.key.ch = intkey;
ev->data.key.utf32 = intkey;
ev->data.key.utf8[0] = intkey;
ev->data.key.utf8[1] = '\0';
return 1;
}
/* If the key was UTF-8, parse the whole sequence */
if(intkey >= 0x80 && intkey < 0x100)
{
int keys[7]; /* Necessary for ungetkey(); */
char utf8[7];
uint32_t utf32;
size_t i, bytes = 0;
keys[0] = intkey;
utf8[0] = intkey;
for(i = 1; i < 6; i++)
{
if(!SLang_input_pending(0))
break;
keys[i] = SLang_getkey();
utf8[i] = (unsigned char)keys[i];
}
utf8[i] = '\0';
utf32 = caca_utf8_to_utf32(utf8, &bytes);
while(i > bytes)
SLang_ungetkey(keys[--i]);
if(bytes)
{
ev->type = CACA_EVENT_KEY_PRESS;
ev->data.key.ch = 0;
ev->data.key.utf32 = utf32;
strcpy(ev->data.key.utf8, utf8);
return 1;
}
}
if(intkey == 0x3e9)
{
int button = (SLang_getkey() - ' ' + 1) & 0xf;
int x = SLang_getkey() - '!';
int y = SLang_getkey() - '!';
ev->data.mouse.button = button;
ev->type = CACA_EVENT_MOUSE_PRESS;
_push_event(dp, ev);
ev->type = CACA_EVENT_MOUSE_RELEASE;
_push_event(dp, ev);
if(dp->mouse.x == x && dp->mouse.y == y)
return _pop_event(dp, ev);
dp->mouse.x = x;
dp->mouse.y = y;
ev->type = CACA_EVENT_MOUSE_MOTION;
ev->data.mouse.x = dp->mouse.x;
ev->data.mouse.y = dp->mouse.y;
return 1;
}
switch(intkey)
{
case SL_KEY_UP: ev->data.key.ch = CACA_KEY_UP; break;
case SL_KEY_DOWN: ev->data.key.ch = CACA_KEY_DOWN; break;
case SL_KEY_LEFT: ev->data.key.ch = CACA_KEY_LEFT; break;
case SL_KEY_RIGHT: ev->data.key.ch = CACA_KEY_RIGHT; break;
case SL_KEY_IC: ev->data.key.ch = CACA_KEY_INSERT; break;
case SL_KEY_DELETE: ev->data.key.ch = CACA_KEY_DELETE; break;
case 0x7f:
case SL_KEY_BACKSPACE: ev->data.key.ch = CACA_KEY_BACKSPACE; break;
case SL_KEY_HOME: ev->data.key.ch = CACA_KEY_HOME; break;
case SL_KEY_END: ev->data.key.ch = CACA_KEY_END; break;
case SL_KEY_PPAGE: ev->data.key.ch = CACA_KEY_PAGEUP; break;
case SL_KEY_NPAGE: ev->data.key.ch = CACA_KEY_PAGEDOWN; break;
case SL_KEY_F(1): ev->data.key.ch = CACA_KEY_F1; break;
case SL_KEY_F(2): ev->data.key.ch = CACA_KEY_F2; break;
case SL_KEY_F(3): ev->data.key.ch = CACA_KEY_F3; break;
case SL_KEY_F(4): ev->data.key.ch = CACA_KEY_F4; break;
case SL_KEY_F(5): ev->data.key.ch = CACA_KEY_F5; break;
case SL_KEY_F(6): ev->data.key.ch = CACA_KEY_F6; break;
case SL_KEY_F(7): ev->data.key.ch = CACA_KEY_F7; break;
case SL_KEY_F(8): ev->data.key.ch = CACA_KEY_F8; break;
case SL_KEY_F(9): ev->data.key.ch = CACA_KEY_F9; break;
case SL_KEY_F(10): ev->data.key.ch = CACA_KEY_F10; break;
case SL_KEY_F(11): ev->data.key.ch = CACA_KEY_F11; break;
case SL_KEY_F(12): ev->data.key.ch = CACA_KEY_F12; break;
default:
/* Unknown key */
ev->type = CACA_EVENT_NONE; return 0;
}
ev->type = CACA_EVENT_KEY_PRESS;
ev->data.key.utf32 = 0;
ev->data.key.utf8[0] = '\0';
return 1;
}
static int sl_output(int port, char *buf, int len)
{
int x,y,z,v,w;
char *str, *t1, *t2, *t3;
int ret;
char ch;
/* check for signals */
if (signal_cought != 0) { /* async out signal */
char xxx[5];
xxx[0] = 0;
put_int32(signal_cought, xxx+1);
driver_output(port, xxx, 5);
signal_cought = 0;
}
switch (*buf++) {
case INIT_TTY: {
int abort_char, flow_ctl, opost;
abort_char = get_int32(buf); buf+=4;
flow_ctl = get_int32(buf); buf+= 4;
opost = get_int32(buf); buf+= 4;
ret = SLang_init_tty (abort_char,flow_ctl, opost);
return ret_int(port, ret);
}
case SET_ABORT_FUNCTION: {
SLang_set_abort_signal (NULL);
return ret_int(port, 0);
}
case GETKEY: {
unsigned int key;
if (SLang_input_pending (0) == 0) {
wait_for = GETKEY;
driver_select(port, 0, DO_READ, 1);
return 0;
}
x = SLang_getkey ();
return ret_int(port, x);
}
/* read a symbol */
case KP_GETKEY: {
if (SLang_input_pending (0) == 0) {
wait_for = KP_GETKEY;
driver_select(port, 0, DO_READ, 1);
return 0;
}
x = SLkp_getkey ();
return ret_int(port, x);
}
case UNGETKEY: {
unsigned char key = (unsigned char) *buf;
SLang_ungetkey (key);
return 0;
}
case RESET_TTY: {
SLang_reset_tty();
return 0;
}
case KP_INIT: {
return ret_int(port, SLkp_init ());
}
case SETVAR: {
x = get_int32(buf);buf+= 4;
y = get_int32(buf);
switch (x) {
case esl_baud_rate:
SLang_TT_Baud_Rate = y; return 0;
case esl_read_fd:
return 0;
case esl_abort_char:
SLang_Abort_Char = y; return 0;
case esl_ignore_user_abort:
SLang_Ignore_User_Abort=y; return 0;
case esl_input_buffer_len :
SLang_Input_Buffer_Len=y; return 0;
case esl_keyboard_quit:
SLKeyBoard_Quit=y; return 0;
case esl_last_key_char:
SLang_Last_Key_Char=y; return 0;
case esl_rl_eof_char:
SLang_RL_EOF_Char=y; return 0;
case esl_rline_quit:
SLang_Rline_Quit=y; return 0;
case esl_screen_rows:
case esl_screen_cols :
return 0;
case esl_tab_width:
SLsmg_Tab_Width=y; return 0;
case esl_newline_behaviour:
SLsmg_Newline_Behavior=y; return 0;
case esl_error:
SLang_Error=y; return 0;
case esl_version:
return 0;
case esl_backspace_moves :
SLsmg_Backspace_Moves=y; return 0;
case esl_display_eight_bit:
SLsmg_Display_Eight_Bit=y; return 0;
default:
return 0;
}
}
case GETVAR: {
x = get_int32(buf);
switch (x) {
case esl_baud_rate:
return ret_int(port, SLang_TT_Baud_Rate);
case esl_read_fd:
return ret_int(port, SLang_TT_Read_FD);
case esl_abort_char:
return (ret_int(port, SLang_Abort_Char));
case esl_ignore_user_abort:
return ret_int(port, SLang_Ignore_User_Abort);
case esl_input_buffer_len :
return ret_int(port, SLang_Input_Buffer_Len);
case esl_keyboard_quit:
return ret_int(port, SLKeyBoard_Quit);
case esl_last_key_char:
return ret_int(port, SLang_Last_Key_Char);
case esl_rl_eof_char:
return ret_int(port, SLang_RL_EOF_Char);
case esl_rline_quit:
return ret_int(port, SLang_Rline_Quit);
case esl_screen_rows:
return ret_int(port, SLtt_Screen_Rows);
case esl_screen_cols :
return ret_int(port, SLtt_Screen_Cols);
case esl_tab_width:
return ret_int(port, SLsmg_Tab_Width);
case esl_newline_behaviour:
return ret_int(port, SLsmg_Newline_Behavior);
case esl_error:
return ret_int(port, SLang_Error);
case esl_version:
return ret_int(port, SLang_Version);
case esl_backspace_moves :
return ret_int(port, SLsmg_Backspace_Moves);
case esl_display_eight_bit:
return ret_int(port, SLsmg_Display_Eight_Bit);
default:
return ret_int(port, -1);
}
}
/*{{{ SLsmg Screen Management Functions */
case SMG_FILL_REGION: {
x = get_int32(buf); buf+= 4;
y = get_int32(buf); buf+= 4;
z = get_int32(buf); buf+= 4;
v = get_int32(buf); buf+= 4;
ch = *buf;
SLsmg_fill_region(x, y,z,v,ch);
return 0;
}
case SMG_SET_CHAR_SET: {
x = get_int32(buf); buf+= 4;
SLsmg_set_char_set(x);
return 0;
}
case SMG_SUSPEND_SMG: {
return ret_int(port, SLsmg_suspend_smg());
}
case SMG_RESUME_SMG: {
ret_int(port, SLsmg_resume_smg());
}
case SMG_ERASE_EOL: {
SLsmg_erase_eol();
return 0;
}
case SMG_GOTORC: {
x = get_int32(buf); buf+= 4;
y = get_int32(buf); buf+= 4;
SLsmg_gotorc(x, y);
return 0;
}
case SMG_ERASE_EOS: {
SLsmg_erase_eos();
return 0;
}
case SMG_REVERSE_VIDEO: {
SLsmg_reverse_video();
return 0;
}
case SMG_SET_COLOR: {
x = get_int32(buf); buf+= 4;
SLsmg_set_color(x);
return 0;
}
case SMG_NORMAL_VIDEO: {
SLsmg_normal_video();
return 0;
}
case SMG_WRITE_STRING: {
SLsmg_write_string(buf);
return 0;
}
case SMG_WRITE_CHAR: {
ch = *buf;
SLsmg_write_char(ch);
return 0;
}
case SMG_WRITE_WRAPPED_STRING: {
t1 = buf;
buf += strlen(t1) + 1;
x = get_int32(buf); buf+= 4;
y = get_int32(buf); buf+= 4;
z = get_int32(buf); buf+= 4;
v = get_int32(buf); buf+= 4;
w = get_int32(buf); buf+= 4;
SLsmg_write_wrapped_string(t1, x,y,z,v,w);
return 0;
}
case SMG_CLS: {
SLsmg_cls();
return 0;
}
case SMG_REFRESH: {
SLsmg_refresh();
return 0;
}
case SMG_TOUCH_LINES: {
x = get_int32(buf); buf+= 4;
y = get_int32(buf); buf+= 4;
SLsmg_touch_lines(x, y);
return 0;
}
case SMG_TOUCH_SCREEN: {
#if (SLANG_VERSION < 10400 )
return ret_int(port, -1);
#else
SLsmg_touch_screen();
#endif
return 0;
}
case SMG_INIT_SMG: {
return ret_int(port, SLsmg_init_smg());
}
case SMG_REINIT_SMG: {
#if (SLANG_VERSION < 10400 )
return ret_int(port, -1);
#else
return ret_int(port, SLsmg_reinit_smg());
#endif
}
case SMG_RESET_SMG: {
SLsmg_reset_smg();
return 0;
}
case SMG_CHAR_AT: {
return ret_int(port, SLsmg_char_at());
}
case SMG_SET_SCREEN_START: {
int *ip1, *ip2;
*ip1 = get_int32(buf); buf+= 4;
*ip2 = get_int32(buf); buf+= 4;
SLsmg_set_screen_start(ip1, ip2);
return ret_int_int(port, *ip1, *ip2);
}
case SMG_DRAW_HLINE: {
x = get_int32(buf); buf+= 4;
SLsmg_draw_hline(x);
return 0;
}
case SMG_DRAW_VLINE: {
x = get_int32(buf); buf+= 4;
SLsmg_draw_vline(x);
return 0;
}
case SMG_DRAW_OBJECT: {
x = get_int32(buf); buf+= 4;
y = get_int32(buf); buf+= 4;
x = get_int32(buf); buf+= 4;
SLsmg_draw_object(x, y,z);
return 0;
}
case SMG_DRAW_BOX: {
x = get_int32(buf); buf+= 4;
y = get_int32(buf); buf+= 4;
z = get_int32(buf); buf+= 4;
v = get_int32(buf); buf+= 4;
SLsmg_draw_box(x, y,z,v);
return 0;
}
case SMG_GET_COLUMN: {
return ret_int(port, SLsmg_get_column());
}
case SMG_GET_ROW: {
return ret_int(port, SLsmg_get_row());
}
case SMG_FORWARD: {
x = get_int32(buf); buf+= 4;
SLsmg_forward(x);
return 0;
}
case SMG_WRITE_COLOR_CHARS: {
SLsmg_Char_Type * sl;
sl = decode_smg_char_type(&buf);
x = get_int32(buf); buf+= 4;
SLsmg_write_color_chars(sl, x);
return 0;
}
case SMG_READ_RAW: {
x = get_int32(buf); buf+= 4;
t1 = malloc((2*x) + 2 + 1);
y = SLsmg_read_raw((unsigned short*)t1 +1, x);
t1[1] = 1;
driver_output(port, t1, y+1);
free(t1);
return 0;
}
case SMG_WRITE_RAW: {
SLsmg_Char_Type * sl;
sl = decode_smg_char_type(&buf);
x = get_int32(buf);
y = SLsmg_write_raw(sl, x);
return ret_int(port, y);
}
case SMG_SET_COLOR_IN_REGION: {
x = get_int32(buf); buf+= 4;
y = get_int32(buf); buf+= 4;
z = get_int32(buf); buf+= 4;
v = get_int32(buf); buf+= 4;
w = get_int32(buf); buf+= 4;
SLsmg_set_color_in_region(x, y,z,v,w);
return 0;
}
/* all the tt_functions */
case TT_FLUSH_OUTPUT: {
ret = SLtt_flush_output();
return ret_int(port, ret);
}
case TT_SET_SCROLL_REGION: {
x = get_int32(buf); buf+=4;
y = get_int32(buf); buf+=4;
SLtt_set_scroll_region(x, y);
return 0;
}
case TT_RESET_SCROLL_REGION: {
SLtt_reset_scroll_region();
return 0;
}
case TT_REVERSE_VIDEO: {
SLtt_reverse_video (get_int32(buf));
return 0;
}
case TT_BOLD_VIDEO: {
SLtt_begin_insert();
return 0;
}
case TT_BEGIN_INSERT: {
SLtt_begin_insert();
return 0;
}
case TT_END_INSERT: {
SLtt_end_insert();
return 0;
}
case TT_DEL_EOL: {
SLtt_del_eol();
return 0;
}
case TT_GOTO_RC: {
x = get_int32(buf); buf+=4;
y = get_int32(buf); buf+=4;
SLtt_goto_rc (x, y);
return 0;
}
case TT_DELETE_NLINES: {
SLtt_delete_nlines(get_int32(buf));
return 0;
}
case TT_DELETE_CHAR: {
SLtt_delete_char();
return 0;
}
case TT_ERASE_LINE: {
SLtt_erase_line();
return 0;
}
case TT_NORMAL_VIDEO: {
SLtt_normal_video();
return 0;
}
case TT_CLS: {
SLtt_cls();
return 0;
}
case TT_BEEP: {
SLtt_beep();
return 0;
}
case TT_REVERSE_INDEX: {
SLtt_reverse_index(get_int32(buf));
return 0;
}
case TT_SMART_PUTS: {
SLsmg_Char_Type *t1 ;
SLsmg_Char_Type *t2;
t1 = decode_smg_char_type(&buf);
t2 = decode_smg_char_type(&buf);
x = get_int32(buf); buf+=4;
y = get_int32(buf); buf+=4;
SLtt_smart_puts(t1, t2,x,y);
return 0;
}
case TT_WRITE_STRING: {
SLtt_write_string (buf);
return 0;
}
case TT_PUTCHAR: {
SLtt_putchar((char) get_int32(buf));
return 0;
}
case TT_INIT_VIDEO: {
ret = SLtt_init_video ();
return ret_int(port, ret);
}
case TT_RESET_VIDEO: {
SLtt_reset_video ();
return 0;
}
case TT_GET_TERMINFO: {
SLtt_get_terminfo();
return 0;
}
case TT_GET_SCREEN_SIZE: {
SLtt_get_screen_size ();
return 0;
}
case TT_SET_CURSOR_VISIBILITY: {
ret = SLtt_set_cursor_visibility (get_int32(buf));
return ret_int(port, ret);
}
case TT_SET_MOUSE_MODE: {
x = get_int32(buf); buf+=4;
y = get_int32(buf); buf+=4;
ret = SLtt_set_mouse_mode (x,y);
return ret_int(port, ret);
}
case TT_INITIALIZE: {
ret =SLtt_initialize (buf);
return ret_int(port, ret);
}
case TT_ENABLE_CURSOR_KEYS: {
SLtt_enable_cursor_keys();
return 0;
}
case TT_SET_TERM_VTXXX: {
return 0;
}
case TT_SET_COLOR_ESC: {
x = get_int32(buf); buf+=4;
SLtt_set_color_esc (x, buf);
return 0;
}
case TT_WIDE_WIDTH: {
SLtt_narrow_width();
return 0;
}
case TT_NARROW_WIDTH: {
SLtt_narrow_width();
return 0;
}
case TT_SET_ALT_CHAR_SET: {
SLtt_set_alt_char_set (get_int32(buf));
return 0;
}
case TT_WRITE_TO_STATUS_LINE: {
x = get_int32(buf); buf+=4;
SLtt_write_to_status_line (buf, x);
return 0;
}
case TT_DISABLE_STATUS_LINE: {
SLtt_disable_status_line ();
return 0;
}
case TT_TGETSTR: {
str = SLtt_tgetstr (buf);
return ret_string(port, str);
}
case TT_TGETNUM: {
x = SLtt_tgetnum (buf);
return ret_int(port, x);
}
case TT_TGETFLAG: {
x = SLtt_tgetflag (buf);
return ret_int(port, x);
}
case TT_TIGETENT: {
str = SLtt_tigetent (buf);
return ret_string(port, str);
}
case TT_TIGETSTR: {
return 0;
}
case TT_TIGETNUM: {
return 0;
}
case SLTT_GET_COLOR_OBJECT: {
x = get_int32(buf); buf+=4;
y = SLtt_get_color_object (x);
return ret_int(port, y);
return 0;
}
case TT_SET_COLOR_OBJECT: {
x = get_int32(buf); buf+=4;
y = get_int32(buf); buf+=4;
SLtt_set_color_object (x, y);
return 0;
}
case TT_SET_COLOR: {
x = get_int32(buf); buf+=4;
t1 = buf;
t2 = buf + (strlen(t1) + 1);
t3 = buf + (strlen(t1) + strlen(t2) + 2);
SLtt_set_color (x, t1, t2, t3);
return 0;
}
case TT_SET_MONO: {
x = get_int32(buf); buf+=4;
t1 = buf;
buf += strlen(t1) + 1;
y = get_int32(buf);
SLtt_set_mono (x, t1, y);
return 0;
}
case TT_ADD_COLOR_ATTRIBUTE: {
x = get_int32(buf); buf+=4;
y = get_int32(buf); buf+=4;
SLtt_add_color_attribute (x, y);
return 0;
}
case TT_SET_COLOR_FGBG: {
x = get_int32(buf); buf+=4;
y = get_int32(buf); buf+=4;
z = get_int32(buf); buf+=4;
SLtt_set_color_fgbg (x, y, z);
return 0;
}
case ISATTY: {
x = get_int32(buf); buf+=4;
return ret_int(port, isatty(x));
}
case EFORMAT: {
fprintf(stderr, "%s", buf);
fflush(stderr);
return 0;
}
case SIGNAL: {
x = get_int32(buf); buf+=4;
SLsignal(x_to_sig(x), sig_handler);
return 0;
}
case SIGNAL_CHECK: {
/* polled */
if (signal_cought != 0)
signal_cought = 0;
return ret_int(port, signal_cought);
}
default:
return 0;
}
}
int main() {
int i, j, k, screenHeight, screenWidth;
int input;
unsigned int ch;
char *boundString;
int ch2;
char inputBuffer[40];
int terminalIndex, fdMax;
fd_set fileDescriptors;
struct timespec timeout;
//struct tesiObject *to;
struct virtualTerminal *vt;
for(i = 0; i < 10; i++)
virtualTerminals[i] = NULL;
fdMax = 0;
timeout.tv_sec = 0;
timeout.tv_nsec = 50000000; // 10E-9
#ifdef USE_NCURSES
ncursesScreen = initscr();
if(ncursesScreen == NULL) {
perror("Error initializing nCurses\n");
exit(1);
}
if(has_colors()) {
start_color();
#ifdef DEBUG
fprintf(stderr, "max colors: %d\n", COLORS);
fprintf(stderr, "max color pairs: %d\n", COLOR_PAIRS);
#endif
k = 1;
for(i = 0; i < COLORS; i++) {
for(j = 0; j < COLORS; j++) {
vt_colors[i][j] = k;
init_pair(k, i, j);
k++;
}
}
//init all color pairs
/*
* black red green yellow blue magenta cyan white
* attributes 30-37
* in iterm, black starts at 1
* */
}
keypad(ncursesScreen, true); // cause nCurses to package key combos into special, single values
nodelay(ncursesScreen, TRUE); // return immediately if no input is waiting
raw();
noecho(); // don't echo input
refresh(); // clear the main window
// Get main window dimensions. This will be used when creating additional virtual terminals
getmaxyx(ncursesScreen, screenHeight, screenWidth);
#endif
inputBuffer[0] = 0;
mvwaddstr(ncursesScreen, screenHeight - 1, 0, ":");
mvwaddstr(ncursesScreen, 1, 0, "USING KNOX\n\nCommands\n\t\"create\" - creates a new Virtual Terminal\n\t\"create #\" - create # number of new Virtual Terminals\n\t\"NUMBER\" - sets focus to so numbered terminal\n\t\"NUMBER COMMAND\" - sends COMMAND to numbered terminal followed by newline");
wmove(ncursesScreen, screenHeight - 1, 1);
terminalIndex = -1;
keepRunning = 1;
k = 0;
while(keepRunning) {
FD_ZERO(&fileDescriptors);
for(i = 0; i < 10; i++) {
//if(vtGet(i) != NULL && tesi_handleInput(vtGet(i))) {
vt = vtGet(i);
if(vt && vt->fd != -1) {
if(vt->fd > fdMax)
fdMax = vt->fd;
FD_SET(vt->fd, &fileDescriptors);
}
}
pselect(fdMax + 1, &fileDescriptors, NULL, NULL, &timeout, NULL);
j = 0;
for(i = 0; i < 10; i++) {
//if(vtGet(i) != NULL && tesi_handleInput(vtGet(i))) {
vt = vtGet(i);
if(vt != NULL && vt->fd != -1 && FD_ISSET(vt->fd, &fileDescriptors)) {
VTCore_dispatch(vt->core);
#ifdef USE_NCURSES
//vt = (struct virtualTerminal*) vtGet(i)->pointer;
wnoutrefresh(vt->window);
#endif
j++; // keep track of the terminals that need updating
}
}
if(j || k) { // if a VT or command window needs updating
#ifdef USE_NCURSES
// re-move cursor to correct location after updating screens
if(terminalIndex > -1) {
//to = (struct tesiObject*) vtGet(terminalIndex);
//vt = (struct virtualTerminal*) to->pointer;
vt = vtGet(terminalIndex);
//wmove(vt->window, to->y, to->x);
} else {
wmove(ncursesScreen, screenHeight - 1, 1 + strlen(inputBuffer));
}
doupdate();
}
k = 0;
ch = wgetch(ncursesScreen); // ?
#endif
#ifdef USE_SLANG
SLsmg_refresh();
if(!SLang_input_pending(1)) // wait 1/10 of a second
continue;
ch = SLang_getkey();
#endif
#ifdef USE_NCURSES
#endif
switch(ch) {
case '`': // tilde pressed, cycle through terms?
//case KEY_RIGHT: // tilde pressed, cycle through terms?
terminalIndex++;
if(terminalIndex == 10 || vtGet(terminalIndex) == NULL)
terminalIndex = -1;
vtHighlight(terminalIndex);
k = 1; // update cursor position
break;
case ERR: // no input
break;
default:
if(terminalIndex > -1) { // send input to terminal
//to = vtGet(terminalIndex);
vt = vtGet(terminalIndex);
if(vt) { // this should never be null, but check anyway
boundString = keybound(ch, 0);
if(boundString) {
#ifdef DEBUG
fprintf(stderr, "key string: %s\n", boundString);
#endif
write(vt->fd, boundString, strlen(boundString));
free(boundString);
} else
write(vt->fd, &ch, 1);
}
} else { // build input buffer
#ifdef DEBUG
fprintf(stderr, "Keypress: %d\n", ch);
#endif
if(ch == 10) { // parse buffer when Enter is pressed, returns active terminal index
//wclear(ncursesScreen);
terminalIndex = processInput(inputBuffer, terminalIndex, screenHeight, screenWidth);
vtHighlight(terminalIndex);
FD_ZERO(&fileDescriptors);
FD_SET(0, &fileDescriptors);
#ifdef USE_NCURSES
// clear command window
mvwaddch(ncursesScreen, screenHeight - 1, 0, ':');
wmove(ncursesScreen, screenHeight - 1, 1);
wclrtoeol(ncursesScreen);
wmove(ncursesScreen, screenHeight - 1, 1);
wnoutrefresh(ncursesScreen);
k = 1;
#endif
inputBuffer[0] = 0;
} else {
i = strlen(inputBuffer);
inputBuffer[ i ] = ch;
inputBuffer[ i + 1 ] = 0;
#ifdef USE_NCURSES
mvwaddstr(ncursesScreen, screenHeight - 1, 1, inputBuffer);
#endif
#ifdef USE_SLANG
SLsmg_gotorc(SLtt_Screen_Rows - 1, 0);
SLsmg_write_string(inputBuffer);
SLsmg_refresh();
#endif
}
}
break;
}
}
for(i = 0; i < 10; i++) {
if(virtualTerminals[i] != NULL) {
vtDestroy(i);
}
}
#ifdef USE_NCURSES
endwin();
#endif
#ifdef USE_SLANG
SLsmg_reset_smg();
SLang_reset_tty();
#endif
return 0;
}
static int slang_getchar(aa_context * c1, int wait)
{
int c;
volatile int flag = 0;
#ifdef GPM_MOUSEDRIVER
static Gpm_Event ev;
#endif
struct timeval tv;
fd_set readfds;
if (wait) {
setjmp(buf);
iswaiting = 1;
} else
iswaiting = 0;
if (__resized_slang == 2) {
iswaiting = 0;
__resized_slang = 1;
return (AA_RESIZE);
}
/*non-gpm way */
if (!wait) {
#ifdef GPM_MOUSEDRIVER
if (gpm_fd == -1) {
#endif
if (!SLang_input_pending(0))
return AA_NONE;
#ifdef GPM_MOUSEDRIVER
} else {
GPM_DRAWPOINTER(&ev);
tv.tv_sec = 0;
tv.tv_usec = 0;
FD_ZERO(&readfds);
if (gpm_fd != -2)
FD_SET(gpm_fd, &readfds);
FD_SET(STDIN_FILENO, &readfds);
if (!(flag = select( ((gpm_fd == -2)?STDIN_FILENO:gpm_fd) + 1, &readfds, NULL, NULL, &tv)))
return AA_NONE;
}
#endif
}
#ifdef GPM_MOUSEDRIVER
if (gpm_fd != -1) {
GPM_DRAWPOINTER(&ev);
while (!flag) {
FD_ZERO(&readfds);
if (gpm_fd != -2)
FD_SET(gpm_fd, &readfds);
FD_SET(STDIN_FILENO, &readfds);
tv.tv_sec = 60;
flag = select( ((gpm_fd == -2)?STDIN_FILENO:gpm_fd) + 1, &readfds, NULL, NULL, &tv);
}
if (flag == -1) {
printf("error!\n");
return (AA_NONE);
}
if ((gpm_fd > -1) && (FD_ISSET(gpm_fd, &readfds))) {
if (Gpm_GetEvent(&ev) && gpm_handler
&& ((*gpm_handler) (&ev, gpm_data))) {
gpm_hflag = 1;
return AA_MOUSE;
}
}
}
if (gpm_fd == -2)
c = Gpm_Getchar();
else
#endif
c = SLkp_getkey();
iswaiting = 0;
if (__resized_slang == 2) {
__resized_slang = 1;
return (AA_RESIZE);
}
if (c == 27)
return (AA_ESC);
if (c > 0 && c < 128 && c != 127)
return (c);
switch (c) {
case SL_KEY_ERR:
return (AA_NONE);
case SL_KEY_LEFT:
return (AA_LEFT);
case SL_KEY_RIGHT:
return (AA_RIGHT);
case SL_KEY_UP:
return (AA_UP);
case SL_KEY_DOWN:
return (AA_DOWN);
case SL_KEY_BACKSPACE:
case 127:
return (AA_BACKSPACE);
}
return (AA_UNKNOWN);
}
/**
* @brief Clear the keybuffer
*/
void newtClearKeyBuffer(void) {
while (SLang_input_pending(1)) {
getkey();
}
}
void newtFlushInput(void) {
while (SLang_input_pending(0)) {
getkey();
}
}
