static void slang_getsize(aa_context * c, int *width, int *height)
{
SLtt_get_screen_size();
SLsmg_reset_smg();
if (SLsmg_init_smg() != 0)
printf("Internal error!\n");
SLtt_set_mono(AA_NORMAL, "normal", 0);
SLtt_set_mono(AA_BOLD, "bold", SLTT_BOLD_MASK);
SLtt_set_mono(AA_DIM, "dim", SLTT_ALTC_MASK);
SLtt_set_mono(AA_REVERSE, "reverse", SLTT_REV_MASK);
SLtt_set_mono(AA_SPECIAL, "special", 0);
SLtt_set_mono(AA_BOLDFONT, "boldfont", SLTT_BOLD_MASK);
SLtt_set_color(AA_NORMAL, "normal", "lightgray", "black");
SLtt_set_color(AA_BOLD, "bold", "white", "black");
SLtt_set_color(AA_DIM, "dim", "gray", "black");
SLtt_set_color(AA_REVERSE, "bold", "black", "lightgray");
SLtt_set_color(AA_SPECIAL, "dim", "lightgray", "blue");
SLtt_set_color(AA_BOLDFONT, "bold", "white", "black");
*width = SLtt_Screen_Cols;
*height = SLtt_Screen_Rows;
/*if(i==2) exit(1); */
#ifdef GPM_MOUSEDRIVER
gpm_mx = *width;
gpm_my = *height;
#endif
}
/**
* @brief Resize the screen
* @param redraw - boolean - should we redraw the screen?
*/
void newtResizeScreen(int redraw) {
/* we can't redraw from scratch, just redisplay SLang screen */
SLtt_get_screen_size();
/* SLsmg_reinit_smg(); */
if (redraw) {
SLsmg_touch_lines(0, SLtt_Screen_Rows);
newtRefresh();
}
}
void
tty_change_screen_size (void)
{
SLtt_get_screen_size ();
SLsmg_reinit_smg ();
do_enter_ca_mode ();
tty_keypad (TRUE);
tty_nodelay (FALSE);
}
void ui__refresh_dimensions(bool force)
{
if (force || ui__need_resize) {
ui__need_resize = 0;
pthread_mutex_lock(&ui__lock);
SLtt_get_screen_size();
SLsmg_reinit_smg();
pthread_mutex_unlock(&ui__lock);
}
}
void
tty_change_screen_size (void)
{
SLtt_get_screen_size ();
SLsmg_reinit_smg ();
#ifdef ENABLE_SUBSHELL
if (mc_global.tty.use_subshell)
tty_resize (mc_global.tty.subshell_pty);
#endif
}
static void slang_handle_resize(caca_display_t *dp)
{
SLtt_get_screen_size();
dp->resize.w = SLtt_Screen_Cols;
dp->resize.h = SLtt_Screen_Rows;
SLsig_block_signals();
if(dp->resize.w != caca_get_canvas_width(dp->cv)
|| dp->resize.h != caca_get_canvas_height(dp->cv))
SLsmg_reinit_smg();
SLsig_unblock_signals();
}
static int screen_size_changed_hook (VOID_STAR cd_unused)
{
(void) cd_unused;
if (Want_Window_Size_Change)
{
Want_Window_Size_Change = 0;
if (Active_Rline_Info != NULL)
{
SLtt_get_screen_size ();
SLrline_set_display_width (Active_Rline_Info, SLtt_Screen_Cols);
}
}
return 0;
}
void newtResizeScreen(int redraw) {
newtPushHelpLine("");
SLtt_get_screen_size();
SLang_init_tty(0, 0, 0);
SLsmg_touch_lines (0, SLtt_Screen_Rows - 1);
/* I don't know why I need this */
SLsmg_refresh();
newtPopHelpLine();
if (redraw)
SLsmg_refresh();
}
static void sigwinch_handler (int sig) {
SLsig_block_signals();
SLtt_get_screen_size();
SLsmg_reinit_smg();
if( !disp.delay_sigwinch ) {
redraw_current_state();
}
SLsig_unblock_signals();
SLsignal(SIGWINCH, sigwinch_handler);
}
bool SLangConsole::refresh() {
/* S-Lang says:
* All well behaved applications should block signals that
* may affect the display while performing screen update. */
SLsig_block_signals ();
if(screen_size_changed && !keyboard_quit) {
SLtt_get_screen_size ();
SLsmg_reinit_smg ();
this->w = SLtt_Screen_Cols;
this->h = SLtt_Screen_Rows;
screen_size_changed = false;
// refresh all widgets
SLangWidget *wid;
wid = (SLangWidget*) widgets.begin();
while(wid) {
wid->refresh();
wid = (SLangWidget*) wid->next;
}
}
if(focused && !keyboard_quit)
if(focused->cursor) {
SLtt_set_cursor_visibility(1);
focused->gotoxy( focused->cur_x, focused->cur_y);
} else
SLtt_set_cursor_visibility(0);
SLsmg_refresh();
SLsig_unblock_signals();
if(keyboard_quit) {
func("keyboard requested forced quit");
return false;
}
return true;
}
static char *read_input_line (Slsh_Readline_Type *sri, char *prompt, int noecho)
{
char *line;
if (Use_Readline == 0)
return read_with_no_readline (prompt, noecho);
#if SYSTEM_SUPPORTS_SIGNALS
init_tty ();
#endif
#if USE_GNU_READLINE
(void) sri;
if (noecho == 0)
rl_redisplay_function = rl_redisplay;
else
{
/* FIXME: What is the proper way to implement this in GNU readline? */
(void) fputs (prompt, stdout);
(void) fflush (stdout);
rl_redisplay_function = redisplay_dummy;
}
line = readline (prompt);
rl_redisplay_function = rl_redisplay;
#else
SLtt_get_screen_size ();
SLrline_set_display_width (sri->rli, SLtt_Screen_Cols);
(void) add_sigwinch_handlers ();
Active_Rline_Info = sri;
(void) SLrline_set_echo (sri->rli, (noecho == 0));
line = SLrline_read_line (sri->rli, prompt, NULL);
Active_Rline_Info = NULL;
#endif
#if SYSTEM_SUPPORTS_SIGNALS
reset_tty ();
#endif
if (sri->output_newline)
fputs ("\r\n", stdout);
fflush (stdout);
return line;
}
int ui__init(void)
{
int err;
SLutf8_enable(-1);
SLtt_get_terminfo();
SLtt_get_screen_size();
err = SLsmg_init_smg();
if (err < 0)
goto out;
err = SLang_init_tty(0, 0, 0);
if (err < 0)
goto out;
err = SLkp_init();
if (err < 0) {
pr_err("TUI initialization failed.\n");
goto out;
}
SLkp_define_keysym((char *)"^(kB)", SL_KEY_UNTAB);
ui_helpline__init();
ui_browser__init();
tui_progress__init();
signal(SIGSEGV, ui__signal_backtrace);
signal(SIGFPE, ui__signal_backtrace);
signal(SIGINT, ui__signal);
signal(SIGQUIT, ui__signal);
signal(SIGTERM, ui__signal);
perf_error__register(&perf_tui_eops);
hist_browser__init_hpp();
out:
return err;
}
/**
* @brief Initialize the newt library
* @return int - 0 for success, else < 0
*/
int newtInit(void) {
char * MonoValue, * MonoEnv = "NEWT_MONO";
const char *lang;
int ret;
if ((lang = getenv("LC_ALL")) == NULL)
if ((lang = getenv("LC_CTYPE")) == NULL)
if ((lang = getenv("LANG")) == NULL)
lang = "";
/* slang doesn't support multibyte encodings except UTF-8,
avoid character corruption by redrawing the screen */
if (strstr (lang, ".euc") != NULL)
trashScreen = 1;
(void) strlen(ident);
SLutf8_enable(-1);
SLtt_get_terminfo();
SLtt_get_screen_size();
MonoValue = getenv(MonoEnv);
if ( MonoValue != NULL )
SLtt_Use_Ansi_Colors = 0;
if ((ret = SLsmg_init_smg()) < 0)
return ret;
if ((ret = SLang_init_tty(0, 0, 0)) < 0)
return ret;
initColors();
newtCursorOff();
initKeymap();
SLsignal_intr(SIGWINCH, handleSigwinch);
SLang_getkey_intr_hook = getkeyInterruptHook;
return 0;
}
int newtInit(void) {
char * MonoValue, * MonoEnv = "NEWT_MONO", * lang;
lang = getenv ("LANG");
if (lang && !strcasecmp (lang, "ja_JP.eucJP"))
trashScreen = 1;
/* use the version variable just to be sure it gets included */
strlen(version);
SLtt_get_terminfo();
SLtt_get_screen_size();
MonoValue = getenv(MonoEnv);
if ( MonoValue == NULL ) {
SLtt_Use_Ansi_Colors = 1;
} else {
SLtt_Use_Ansi_Colors = 0;
}
SLsmg_init_smg();
SLang_init_tty(0, 0, 0);
newtSetColors(newtDefaultColorPalette);
newtCursorOff();
/*initKeymap();*/
/*memset(&sa, 0, sizeof(sa));
sa.sa_handler = handleSigwinch;
sigaction(SIGWINCH, &sa, NULL);*/
SLsignal_intr(SIGWINCH, handleSigwinch);
SLang_getkey_intr_hook = getkeyInterruptHook;
return 0;
}
static void init_tty (void)
{
int abort_char = 3;
TTY_Inited++;
if (TTY_Inited > 1)
return;
# if SYSTEM_SUPPORTS_SIGNALS
SLsig_block_signals ();
SLang_TT_Read_FD = fileno (stdin);
init_sigtstp ();
# endif
# ifdef REAL_UNIX_SYSTEM
abort_char = -1; /* determine from tty */
# endif
if (-1 == SLang_init_tty (abort_char, 1, 1)) /* opost was 0 */
{
# if SYSTEM_SUPPORTS_SIGNALS
deinit_sigtstp ();
SLsig_unblock_signals ();
# endif
SLang_exit_error ("Error initializing terminal.");
}
# ifdef REAL_UNIX_SYSTEM
SLang_getkey_intr_hook = getkey_intr_hook;
# endif
(void) add_sigwinch_handlers ();
SLtt_get_screen_size ();
# if SYSTEM_SUPPORTS_SIGNALS
SLtty_set_suspend_state (1);
SLsig_unblock_signals ();
# endif
}
static void init_tty (void) /*{{{*/
{
#ifdef HAVE_GNU_READLINE
if (Use_SLang_Readline == 0)
{
SLsig_block_signals ();
last_sig_sigint = SLsignal (SIGINT, gnu_rl_sigint_handler);
last_sig_sigtstp = SLsignal (SIGTSTP, sig_sigtstp);
SLsig_unblock_signals ();
return;
}
#endif
if (TTY_Inited)
return;
TTY_Inited++;
SLsig_block_signals ();
SLang_TT_Read_FD = fileno (stdin);
last_sig_sigtstp = SLsignal (SIGTSTP, sig_sigtstp);
if (-1 == SLang_init_tty (-1, 1, 0))
{
SLsignal (SIGTSTP, last_sig_sigtstp);
SLsig_unblock_signals ();
fprintf (stderr, "Error initializing terminal.");
exit (EXIT_FAILURE);
}
SLang_getkey_intr_hook = getkey_intr_hook;
(void) add_sigwinch_handlers ();
SLtt_get_screen_size ();
SLtty_set_suspend_state (1);
SLsig_unblock_signals ();
}
static char *read_input_line (SLang_RLine_Info_Type *rline, char *prompt, int noecho)
{
char *line;
#ifdef REAL_UNIX_SYSTEM
int stdin_is_noecho = 0;
#endif
if (Use_Readline == 0)
{
char buf[1024];
char *b;
fprintf (stdout, "%s", prompt); fflush (stdout);
if (noecho)
{
#ifdef REAL_UNIX_SYSTEM
if (isatty (fileno(stdin)))
{
(void) SLsystem ("stty -echo"); /* yuk */
stdin_is_noecho = 1;
}
#endif
}
line = buf;
while (NULL == fgets (buf, sizeof (buf), stdin))
{
#ifdef EINTR
if (errno == EINTR)
{
if (-1 == SLang_handle_interrupt ())
{
line = NULL;
break;
}
continue;
}
#endif
line = NULL;
break;
}
#ifdef REAL_UNIX_SYSTEM
if (stdin_is_noecho)
(void) SLsystem ("stty echo");
#endif
if (line == NULL)
return NULL;
/* Remove the final newline */
b = line;
while (*b && (*b != '\n'))
b++;
*b = 0;
return SLmake_string (line);
}
#if SYSTEM_SUPPORTS_SIGNALS
init_tty ();
#endif
#if USE_GNU_READLINE
(void) rline;
if (noecho == 0)
rl_redisplay_function = rl_redisplay;
else
{
/* FIXME: What is the proper way to implement this in GNU readline? */
(void) fputs (prompt, stdout); (void) fflush (stdout);
rl_redisplay_function = redisplay_dummy;
}
line = readline (prompt);
rl_redisplay_function = rl_redisplay;
#else
SLtt_get_screen_size ();
SLrline_set_display_width (rline, SLtt_Screen_Cols);
(void) add_sigwinch_handlers ();
Active_Rline_Info = rline;
(void) SLrline_set_echo (rline, (noecho == 0));
line = SLrline_read_line (rline, prompt, NULL);
Active_Rline_Info = NULL;
#endif
#if SYSTEM_SUPPORTS_SIGNALS
reset_tty ();
#else
fputs ("\r\n", stdout);
fflush (stdout);
#endif
return line;
}
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;
}
}
