static void write_color_chars (SLcurses_Cell_Type *p, unsigned int len)
{
int color = -1;
unsigned int i;
for (i = 0; i < len; i++)
{
SLwchar_Type ch;
int this_color;
int j;
if (p[i].main == SLCURSES_NULLATTR)
continue; /* prev char was multicolumn */
ch = SLCURSES_EXTRACT_CHAR(p[i].main);
this_color = SLCURSES_EXTRACT_COLOR(p[i].main);
if (this_color != color)
{
SLsmg_set_color (this_color);
color = this_color;
}
if (p[i].is_acs)
SLsmg_set_char_set (1);
SLsmg_write_char (ch);
for (j = 0; j < SLSMG_MAX_CHARS_PER_CELL-1; j++)
{
SLwchar_Type combining = p[i].combining[j];
if (combining == SLCURSES_NULLCHAR)
break; /* no more combining chars */
SLsmg_write_char (combining);
}
if (p[i].is_acs)
SLsmg_set_char_set (0);
}
}
/* displays a table containing 256 characters in a single character
set, starting a column col. The 'label' is displayed over the
table, and the alternate character set is displayed iff
isAlternate is nonzero */
static void drawCharSet(int col, int isAlternate, char * label) {
int i, j;
int n = 0;
/* draw the box */
SLsmg_draw_box(0, col, 20, 38);
/* center the label */
SLsmg_gotorc(0, col + 2);
SLsmg_write_string(label);
/* draw the horizontal legend */
SLsmg_gotorc(2, col + 4);
SLsmg_write_string("0 1 2 3 4 5 6 7 8 9 A B C D E F");
/* set the character set to use */
SLsmg_set_char_set(isAlternate);
/* this iterates over the 4 most significant bits */
for (i = 0; i < 16; i++) {
SLsmg_gotorc(3 + i, 2 + col);
SLsmg_write_char(i < 10 ? i + '0' : (i - 10) + 'A');
/* this iterates over the 4 least significant bits */
for (j = 0; j < 16; j++) {
SLsmg_gotorc(3 + i, col + 4 + (j * 2));
SLsmg_write_char(n++);
}
}
SLsmg_set_char_set(0);
}
/** Draws the caption of the box
*
* \param x the x coordonate of the box
* \param y the y coordonate of the box
*/
void RainbruRPG::Terminal::ListBox::drawTheCaption( int x, int y){
SLsmg_gotorc ( y, x+2);
SLsmg_set_char_set (1);
SLsmg_write_char( SLSMG_RTEE_CHAR );
SLsmg_set_char_set (0);
// cast to char* to avoid deprecating conversion warning
SLsmg_printf( (char*)" %s ", caption.c_str() );
SLsmg_set_char_set (1);
SLsmg_write_char( SLSMG_LTEE_CHAR );
SLsmg_set_char_set (0);
}
/** Draws the borders of the Dialog
*
*/
void RainbruRPG::Terminal::Dialog::drawBorder(){
//The lightgray border
SLsmg_set_color (8);
SLsmg_gotorc (yPos, xPos);
SLsmg_set_char_set (1); //Use the alt charset
// The top line
SLsmg_write_char(SLSMG_ULCORN_CHAR);
SLsmg_draw_hline(width-1);
// The left border
for (int y=1; y<height; y++){
SLsmg_gotorc (yPos+y, xPos);
if (y==height-3)
SLsmg_write_char(SLSMG_LTEE_CHAR);
else if (y==height-1)
SLsmg_write_char(SLSMG_LLCORN_CHAR);
else
SLsmg_write_char(SLSMG_VLINE_CHAR);
}
// The buttonbar line
SLsmg_gotorc (yPos+height-3, xPos+1);
SLsmg_draw_hline(width-1);
// The gray border
SLsmg_set_color (9);
for (int y=0; y<height; y++){
SLsmg_gotorc (yPos+y, xPos+width);
if (y==0)
SLsmg_write_char(SLSMG_URCORN_CHAR);
else if (y==height-3)
SLsmg_write_char(SLSMG_RTEE_CHAR);
else if (y==height-1)
SLsmg_write_char(SLSMG_LRCORN_CHAR);
else
SLsmg_write_char(SLSMG_VLINE_CHAR);
}
// The bottom line
SLsmg_gotorc (yPos+height-1, xPos+1);
SLsmg_draw_hline(width-1);
SLsmg_set_char_set(0); //Use the normal charset
SLsmg_set_color(0);
}
void newtPopWindowNoRefresh(void) {
int j, row, col;
int n = 0;
if (currentWindow == NULL)
return;
row = col = 0;
row = currentWindow->top - 1;
col = currentWindow->left - 2;
if (row < 0)
row = 0;
if (col < 0)
col = 0;
for (j = 0; j < currentWindow->height + 3; j++, row++) {
SLsmg_gotorc(row, col);
SLsmg_write_raw(currentWindow->buffer + n,
currentWindow->width + 5);
n += currentWindow->width + 5;
}
free(currentWindow->buffer);
free(currentWindow->title);
if (currentWindow == windowStack)
currentWindow = NULL;
else
currentWindow--;
SLsmg_set_char_set(0);
newtTrashScreen();
}
static void ui_browser__scrollbar_set(struct ui_browser *browser)
{
int height = browser->height, h = 0, pct = 0,
col = browser->width,
row = 0;
if (browser->nr_entries > 1) {
pct = ((browser->index * (browser->height - 1)) /
(browser->nr_entries - 1));
}
SLsmg_set_char_set(1);
while (h < height) {
ui_browser__gotorc(browser, row++, col);
SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_CKBRD_CHAR);
++h;
}
SLsmg_set_char_set(0);
}
/** Create graphically the window
*
* It draws the box according to the window stateand call the
* layout's draw() method.
*
* It finally the Layout::draw() method.
*/
void RainbruRPG::Terminal::Window::draw( ){
int x, y, h, w;
if (state==NORMAL){
x=this->x;
y=this->y;
h=this->height;
w=this->width;
}
else if(state==MAXIMIZED){
x=0;
y=1;
h=SLtt_Screen_Rows-2;
w=SLtt_Screen_Cols;
}
if (focusWindow&&selected){
SLsmg_set_color (6);
}
// Border
SLsmg_draw_box ( y, x, h, w );
// Title
SLsmg_gotorc ( y, x+2);
SLsmg_set_char_set (1);
SLsmg_write_char( SLSMG_RTEE_CHAR );
SLsmg_set_char_set (0);
// cast to char* to avoid deprecated converion warning
SLsmg_printf( (char*)" %s ", caption );
SLsmg_set_char_set (1);
SLsmg_write_char( SLSMG_LTEE_CHAR );
SLsmg_set_char_set (0);
SLsmg_set_color (0);
layout->draw();
};
/** Draws the title of the Dialog
*
*/
void RainbruRPG::Terminal::Dialog::drawTitle(){
int l=title.length();
int x=(SLtt_Screen_Cols/2)-(l/2);
SLsmg_set_color (8);
SLsmg_set_char_set (1); //Use the alt charset
SLsmg_gotorc (yPos, x-2);
SLsmg_write_char(SLSMG_RTEE_CHAR);
SLsmg_gotorc (yPos, x+l+1);
SLsmg_write_char(SLSMG_LTEE_CHAR);
//title
SLsmg_set_color (9);
SLsmg_gotorc (yPos, x-1);
SLsmg_set_char_set (0); //Use the alt charset
// cast to char* to avoid deprecating conversion warning
SLsmg_printf( (char*)" %s ", title.c_str() );
}
int main(void) {
SLtt_get_terminfo();
SLtt_Use_Ansi_Colors = 1;
SLsmg_init_smg();
SLang_init_tty(4, 0, 0);
SLsmg_cls();
printall(0);
SLsmg_set_char_set(1);
printall(40);
SLsmg_refresh();
SLang_getkey();
SLsmg_gotorc(SLtt_Screen_Rows - 1, 0);
SLsmg_refresh();
SLsmg_reset_smg();
SLang_reset_tty();
return 0;
}
void
tty_set_alt_charset (gboolean alt_charset)
{
SLsmg_set_char_set ((int) alt_charset);
}
/**
* Open a new window.
* @param left. int Size; _not_ including border
* @param top: int size, _not_ including border
* @param width unsigned int
* @param height unsigned int
* @param title - title string
* @return zero on success
*/
int newtOpenWindow(int left, int top,
unsigned int width, unsigned int height,
const char * title) {
int j, row, col;
int n;
int i;
newtFlushInput();
if (currentWindow && currentWindow - windowStack + 1
>= sizeof (windowStack) / sizeof (struct Window))
return 1;
if (!currentWindow) {
currentWindow = windowStack;
} else {
currentWindow++;
}
currentWindow->left = left;
currentWindow->top = top;
currentWindow->width = width;
currentWindow->height = height;
currentWindow->title = title ? strdup(title) : NULL;
currentWindow->buffer = malloc(sizeof(SLsmg_Char_Type) * (width + 5) * (height + 3));
row = top - 1;
col = left - 2;
/* clip to the current screen bounds - msw */
if (row < 0)
row = 0;
if (col < 0)
col = 0;
if (left + width > SLtt_Screen_Cols)
width = SLtt_Screen_Cols - left;
if (top + height > SLtt_Screen_Rows)
height = SLtt_Screen_Rows - top;
n = 0;
for (j = 0; j < height + 3; j++, row++) {
SLsmg_gotorc(row, col);
SLsmg_read_raw(currentWindow->buffer + n,
currentWindow->width + 5);
n += currentWindow->width + 5;
}
newtTrashScreen();
SLsmg_set_color(NEWT_COLORSET_BORDER);
SLsmg_set_char_set(1);
SLsmg_draw_box(top - 1, left - 1, height + 2, width + 2);
SLsmg_set_char_set(0);
if (currentWindow->title) {
trim_string (currentWindow->title, width-4);
i = wstrlen(currentWindow->title,-1) + 4;
i = ((width - i) / 2) + left;
SLsmg_gotorc(top - 1, i);
SLsmg_set_char_set(1);
SLsmg_write_char(SLSMG_RTEE_CHAR);
SLsmg_set_char_set(0);
SLsmg_write_char(' ');
SLsmg_set_color(NEWT_COLORSET_TITLE);
SLsmg_write_string((char *)currentWindow->title);
SLsmg_set_color(NEWT_COLORSET_BORDER);
SLsmg_write_char(' ');
SLsmg_set_char_set(1);
SLsmg_write_char(SLSMG_LTEE_CHAR);
SLsmg_set_char_set(0);
}
SLsmg_set_color(NEWT_COLORSET_WINDOW);
SLsmg_fill_region(top, left, height, width, ' ');
SLsmg_set_color(NEWT_COLORSET_SHADOW);
SLsmg_fill_region(top + height + 1, left, 1, width + 2, ' ');
SLsmg_fill_region(top, left + width + 1, height + 1, 1, ' ');
for (i = top; i < (top + height + 1); i++) {
SLsmg_gotorc(i, left + width + 1);
SLsmg_write_string(" ");
}
return 0;
}
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;
}
}
