/* 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(); } }