static void ctl_help_mode(void)
{
if (ctl_helpmode)
{
ctl_helpmode=0;
/*
* Clear the head zone and reprint head message.
*/
SLsmg_gotorc(0,0);
SLsmg_erase_eol();
SLsmg_gotorc(1,0);
SLsmg_erase_eol();
ctl_head();
_ctl_refresh();
}
else
{
ctl_helpmode=1;
SLsmg_reverse();
SLsmg_gotorc(0,0);
SLsmg_erase_eol();
SLsmg_write_string(
"V=Louder b=Skip back "
"n=Next file r=Restart file");
SLsmg_gotorc(1,0);
SLsmg_erase_eol();
SLsmg_write_string(
"v=Softer f=Skip forward "
"p=Previous file q=Quit program");
SLsmg_normal();
_ctl_refresh();
}
}
void SLsmg_erase_eos (void)
{
if (Smg_Inited == 0) return;
SLsmg_erase_eol ();
clear_region (This_Row + 1, (int)Screen_Rows, 0x20);
}
static void update_display (void)
{
unsigned int row, nrows;
File_Line_Type *line;
/* All well behaved applications should block signals that may affect
* the display while performing screen update.
*/
SLsig_block_signals ();
Line_Window.nrows = nrows = SLtt_Screen_Rows - 1;
/* Always make the current line equal to the top window line. */
if (Line_Window.top_window_line != NULL)
Line_Window.current_line = Line_Window.top_window_line;
SLscroll_find_top (&Line_Window);
row = 0;
line = (File_Line_Type *) Line_Window.top_window_line;
SLsmg_normal_video ();
while (row < Line_Window.nrows)
{
SLsmg_gotorc (row, 0);
if (line != NULL)
{
SLsmg_write_string (line->data);
line = line->next;
}
SLsmg_erase_eol ();
row++;
}
SLsmg_gotorc (row, 0);
SLsmg_reverse_video ();
SLsmg_printf ("%s | UTF-8 = %d",
(File_Name == NULL) ? "<stdin>" : File_Name,
SLutf8_is_utf8_mode ());
SLsmg_erase_eol ();
SLsmg_refresh ();
SLsig_unblock_signals ();
}
static void ctl_file_name(char *name)
{
SLsmg_gotorc(3,6);
SLsmg_erase_eol();
SLsmg_bold();
SLsmg_write_string(name);
SLsmg_normal();
_ctl_refresh();
}
void ephemeral_message(char *s) {
SLsmg_gotorc(disp.num_rows - 1, 0);
SLsmg_set_color(3);
SLsmg_write_string(s);
SLsmg_erase_eol();
SLsmg_refresh();
}
static void rline_update(unsigned char *buf, int len, int col) {
SLsmg_gotorc (SLtt_Screen_Rows - 1, 0);
SLsmg_set_color(2);
if( buf ) {
SLsmg_write_nchars ((char *) buf, len);
}
SLsmg_erase_eol ();
SLsmg_gotorc (SLtt_Screen_Rows - 1, col);
SLsmg_refresh ();
}
static void init_lyric(char *lang)
{
int i;
if(ctl.trace_playing)
return;
for(i=6;i<=SLtt_Screen_Rows;i++){
SLsmg_gotorc(i,0);
SLsmg_erase_eol();
}
}
static void do_dialog(char *b)
{
char *quit = "Quit!";
if (Batch) return;
#ifdef FIX_CHAR_WIDTH
FIX_CHAR_WIDTH;
#endif
if (! *b)
{
if(!SLKeyBoard_Quit) return;
b = quit;
}
if ((b == Error_Buffer) || (b == quit))
{
SLsmg_set_color (JERROR_COLOR);
touch_screen();
}
else
SLsmg_set_color (JMESSAGE_COLOR);
SLsmg_Newline_Behavior = SLSMG_NEWLINE_PRINTABLE;
SLsmg_gotorc (Jed_Num_Screen_Rows - 1, 0);
SLsmg_write_string (b);
SLsmg_set_color (0);
SLsmg_erase_eol ();
SLsmg_Newline_Behavior = 0;
if ((b == Error_Buffer) || (SLKeyBoard_Quit))
{
jed_beep();
flush_input();
}
if (*b)
{
if (MiniBuffer != NULL)
{
SLsmg_refresh ();
(void) input_pending(&Number_Ten);
}
Mini_Ghost = -1;
}
else Mini_Ghost = 0;
}
static void update_top_screen_line (void)
{
#if JED_HAS_MENUS
if (Jed_Menus_Active
|| (Top_Window_SY > 0))
{
jed_redraw_menus ();
return;
}
#else
if (Top_Window_SY == 0)
return;
SLsmg_gotorc (0,0);
SLsmg_set_color (JMENU_COLOR);
SLsmg_write_string (Top_Screen_Line_Buffer);
SLsmg_erase_eol ();
JScreen[0].is_modified = 0;
#endif
}
static void display_lyric(char *lyric, int sep)
{
char *p;
int len, idlen, sepoffset;
static int crflag = 0;
if(lyric == NULL)
{
indicator_last_update = get_current_calender_time();
crflag = 0;
return;
}
if(indicator_mode != INDICATOR_LYRIC || crflag)
{
memset(comment_indicator_buffer, 0, indicator_width);
SLsmg_gotorc(lyric_row,0);
SLsmg_erase_eol();
ctl_refresh();
indicator_mode = INDICATOR_LYRIC;
crflag = 0;
}
if(*lyric == '\0')
{
indicator_last_update = get_current_calender_time();
return;
}
else if(*lyric == '\n')
{
if(!ctl.trace_playing)
{
crflag = 1;
lyric_row++;
SLsmg_gotorc(0,lyric_row);
return;
}
else
lyric = " / ";
}
if(strchr(lyric, '\r') != NULL)
{
crflag = 1;
if(!ctl.trace_playing)
{
int i;
for(i = title_row+1; i <= lyric_row; i++)
{
SLsmg_gotorc(i,0);
SLsmg_erase_eol();
}
lyric_row = title_row+1;
}
if(lyric[0] == '\r' && lyric[1] == '\0')
{
indicator_last_update = get_current_calender_time();
return;
}
}
idlen = strlen(comment_indicator_buffer);
len = strlen(lyric);
if(sep)
{
while(idlen > 0 && comment_indicator_buffer[idlen - 1] == ' ')
comment_indicator_buffer[--idlen] = '\0';
while(len > 0 && lyric[len - 1] == ' ')
len--;
}
if(len == 0)
{
/* update time stamp */
indicator_last_update = get_current_calender_time();
reuse_mblock(&tmpbuffer);
return;
}
sepoffset = (sep != 0);
if(len >= indicator_width - 2)
{
memcpy(comment_indicator_buffer, lyric, indicator_width - 1);
comment_indicator_buffer[indicator_width - 1] = '\0';
}
else if(idlen == 0)
{
memcpy(comment_indicator_buffer, lyric, len);
comment_indicator_buffer[len] = '\0';
}
else if(len + idlen + 2 < indicator_width)
{
if(sep)
comment_indicator_buffer[idlen] = sep;
memcpy(comment_indicator_buffer + idlen + sepoffset, lyric, len);
comment_indicator_buffer[idlen + sepoffset + len] = '\0';
}
else
{
int spaces;
p = comment_indicator_buffer;
spaces = indicator_width - idlen - 2;
while(spaces < len)
{
char *q;
/* skip one word */
if((q = strchr(p, ' ')) == NULL)
{
p = NULL;
break;
}
do q++; while(*q == ' ');
spaces += (q - p);
p = q;
}
if(p == NULL)
{
SLsmg_gotorc(lyric_row,0);
SLsmg_erase_eol();
memcpy(comment_indicator_buffer, lyric, len);
comment_indicator_buffer[len] = '\0';
}
else
{
int d, l, r, i, j;
d = (p - comment_indicator_buffer);
l = strlen(p);
r = len - (indicator_width - 2 - l - d);
j = d - r;
for(i = 0; i < j; i++)
comment_indicator_buffer[i] = ' ';
for(i = 0; i < l; i++)
comment_indicator_buffer[j + i] =
comment_indicator_buffer[d + i];
if(sep)
comment_indicator_buffer[j + i] = sep;
memcpy(comment_indicator_buffer + j + i + sepoffset, lyric, len);
comment_indicator_buffer[j + i + sepoffset + len] = '\0';
}
}
SLsmg_printfrc(lyric_row,0,"%s",comment_indicator_buffer);
ctl_refresh();
reuse_mblock(&tmpbuffer);
indicator_last_update = get_current_calender_time();
}
static int cmsg(int type, int verbosity_level, char *fmt, ...)
{
va_list ap;
char p[1000];
if ((type==CMSG_TEXT || type==CMSG_INFO || type==CMSG_WARNING) &&
ctl.verbosity<verbosity_level)
return 0;
va_start(ap, fmt);
if (!ctl.opened)
{
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
}
else if (ctl.trace_playing)
{
switch(type)
{
/* Pretty pointless to only have one line for messages, but... */
case CMSG_WARNING:
case CMSG_ERROR:
case CMSG_FATAL:
SLsmg_gotorc(2,0);
SLsmg_erase_eol();
SLsmg_bold();
vsnprintf(p, sizeof(p), fmt, ap);
SLsmg_write_string(p);
SLsmg_normal();
_ctl_refresh();
if (type==CMSG_WARNING)
sleep(1); /* Don't you just _HATE_ it when programs do this... */
else
sleep(2);
SLsmg_gotorc(2,0);
SLsmg_erase_eol();
_ctl_refresh();
break;
}
}
else
{
SLsmg_gotorc(msg_row++,0);
if(msg_row==SLtt_Screen_Rows){
int i;
msg_row=6;
for(i=6;i<=SLtt_Screen_Rows;i++){
SLsmg_gotorc(i,0);
SLsmg_erase_eol();
}
}
switch(type)
{
default:
vsnprintf(p, sizeof(p), fmt, ap);
SLsmg_write_string(p);
_ctl_refresh();
break;
case CMSG_WARNING:
SLsmg_bold();
vsnprintf(p, sizeof(p), fmt, ap);
SLsmg_write_string(p);
SLsmg_normal();
_ctl_refresh();
break;
case CMSG_ERROR:
case CMSG_FATAL:
SLsmg_bold();
vsnprintf(p, sizeof(p), fmt, ap);
SLsmg_write_string(p);
SLsmg_normal();
_ctl_refresh();
if (type==CMSG_FATAL)
sleep(2);
break;
}
}
va_end(ap);
return 0;
}
static void display_line (Line *line, int sy, int sx)
{
unsigned int len;
int hscroll_col;
int is_mini;
Screen_Type *s;
#if JED_HAS_LINE_MARKS
Mark *line_marks;
#endif
int num_columns;
int color_set;
SLsmg_Tab_Width = Buffer_Local.tab;
(void) SLsmg_embedded_escape_mode (CBuf->flags & SMG_EMBEDDED_ESCAPE);
is_mini = (sy + 1 == Jed_Num_Screen_Rows);
SLsmg_gotorc (sy, sx);
SLsmg_set_color (0);
s = JScreen + sy;
s->line = line;
s->is_modified = 0;
if (line == NULL)
{
SLsmg_erase_eol ();
return;
}
hscroll_col = JWindow->hscroll_column - 1;
if ((line == HScroll_Line)
&& Wants_HScroll && HScroll)
hscroll_col += HScroll;
num_columns = JWindow->width;
if (hscroll_col || sx
#if JED_HAS_DISPLAY_LINE_NUMBERS
|| (CBuf->line_num_display_size)
#endif
)
{
int tmp = hscroll_col - sx;
#if JED_HAS_DISPLAY_LINE_NUMBERS
tmp -= CBuf->line_num_display_size;
num_columns -= CBuf->line_num_display_size;
#endif
SLsmg_set_screen_start (NULL, &tmp);
sx = 0;
}
len = line->len;
if (is_mini)
{
SLsmg_Newline_Behavior = SLSMG_NEWLINE_PRINTABLE;
SLsmg_write_string ((char *)Mini_Info.prompt);
}
else
{
SLsmg_Newline_Behavior = 0;
if (len && (line->data[len - 1] == '\n'))
len--;
}
color_set = 0;
#if JED_HAS_LINE_ATTRIBUTES
if (line->flags & JED_LINE_COLOR_BITS)
{
SLsmg_set_color (JED_GET_LINE_COLOR(line));
color_set = 1;
}
#endif
#if JED_HAS_LINE_MARKS
line_marks = CBuf->user_marks;
if (color_set == 0) while (line_marks != NULL)
{
if ((line_marks->line == line)
&& (line_marks->flags & JED_LINE_MARK))
{
SLsmg_set_color (line_marks->flags & MARK_COLOR_MASK);
color_set = 1;
break;
}
line_marks = line_marks->next;
}
#endif
if (len)
{
if ((color_set == 0)
&& Mode_Has_Syntax_Highlight
&& (line != &Eob_Line)
#if !defined(IBMPC_SYSTEM)
&& (*tt_Use_Ansi_Colors && Term_Supports_Color)
#endif
&& Wants_Syntax_Highlight)
write_syntax_highlight (sy, line, len);
else
{
if ((is_mini == 0)
&& Jed_Highlight_WS & HIGHLIGHT_WS_TRAILING)
{
unsigned char *pmin = line->data;
unsigned char *pmax = pmin + len;
unsigned char *p = pmax;
while (p > pmin)
{
p--;
if ((*p != ' ') && (*p != '\t'))
{
p++;
break;
}
}
SLsmg_write_nchars ((char *)pmin, p - pmin);
if (p != pmax)
{
SLsmg_set_color (JTWS_COLOR);
SLsmg_write_nchars ((char *)p, pmax - p);
SLsmg_set_color (0);
}
}
else SLsmg_write_nchars ((char *)line->data, len);
}
}
#if JED_HAS_LINE_ATTRIBUTES
if ((line->next != NULL)
&& (line->next->flags & JED_LINE_HIDDEN))
{
SLsmg_set_color (JDOTS_COLOR);
SLsmg_write_string ("...");
SLsmg_set_color (0);
}
#endif
SLsmg_erase_eol ();
if (Jed_Dollar)
{
char dollar = (char) Jed_Dollar;
if (hscroll_col + num_columns <= SLsmg_get_column ())
{
SLsmg_gotorc (sy, hscroll_col + num_columns - 1);
SLsmg_set_color (JDOLLAR_COLOR);
SLsmg_write_nchars (&dollar, 1);
}
if (hscroll_col)
{
SLsmg_gotorc (sy, hscroll_col);
SLsmg_set_color (JDOLLAR_COLOR);
SLsmg_write_nchars (&dollar, 1);
}
}
if ((s->hi0 != NULL) && Wants_Attributes)
{
int c;
len = (int) (s->hi1 - s->hi0);
if (len && (s->hi0[len - 1] == '\n'))
len--;
if (len)
{
c = jed_compute_effective_length (line->data, s->hi0);
if (is_mini)
c += Mini_Info.effective_prompt_len;
SLsmg_gotorc (sy, c);
SLsmg_set_color (JREGION_COLOR);
SLsmg_write_nchars ((char *)s->hi0, len);
}
}
/* if (hscroll_col + sx) */
SLsmg_set_screen_start (NULL, NULL);
SLsmg_set_color (0);
}
/* displays a selection of limited (visible) emails */
void redraw_current_state() {
int r = 0;
mbox_item *e;
SLsig_block_signals();
disp.num_rows = SLtt_Screen_Rows;
disp.num_cols = SLtt_Screen_Cols;
SLsmg_normal_video();
if( emails.num_limited > 0 ) {
for(r = 0; r < (disp.num_rows - 2); r++) {
if( r + disp.first_visible < emails.num_limited ) {
e = emails.llist[r + disp.first_visible];
SLsmg_gotorc(r + 1, 0);
SLsmg_printf("%c %8.1f %s",
(e->state & (1<<STATE_TAGGED)) ? 'T' : ' ',
e->score[emails.score_type],
e->description[emails.index_format]);
SLsmg_erase_eol();
} else {
SLsmg_gotorc(r + 1, 0);
SLsmg_erase_eol();
}
}
} else {
SLsmg_cls();
r = disp.num_rows - 2;
}
SLsmg_reverse_video();
e = emails.llist[disp.first_visible + disp.highlighted];
SLsmg_gotorc(disp.highlighted + 1, 0);
if( emails.num_limited > 0 ) {
SLsmg_printf("%c %8.1f %s",
(e->state & (1<<STATE_TAGGED)) ? 'T' : ' ',
e->score[emails.score_type],
e->description[emails.index_format]);
}
SLsmg_erase_eol();
SLsmg_set_color(2);
SLsmg_gotorc(0,0);
SLsmg_printf("mailinspect %s %ld msgs sorted(%d) by category %s",
emails.filename, (long)emails.num_limited, emails.score_type, cat[0].filename);
SLsmg_erase_eol();
SLsmg_gotorc(r + 1, 0);
SLsmg_printf("q: quit o: scoring z: rev. sort /: search tT: tag uU: untag sS: send to shell p: summary c: category");
SLsmg_erase_eol();
SLsmg_refresh();
SLsig_unblock_signals();
}
static void smg_erase_eol (void)
{
if (Smg_Initialized <= 0)
return;
SLsmg_erase_eol ();
}
void display_clear_to_eol(void)
{
SLsmg_erase_eol();
}
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;
}
}
