/*
* Suspend / Resume
*/
static errr Term_xtra_sla_alive(int v)
{
/* Suspend */
if (!v)
{
/* Oops */
if (!slang_on) return (1);
/* We are now off */
slang_on = FALSE;
/* Block further signals, so double signals wont confuse us */
SLsig_block_signals();
/* Shut down (temporarily) */
if (SLsmg_suspend_smg() < 0)
quit("Could not save S-Lang state");
SLang_reset_tty();
/* Done with blocking */
SLsig_unblock_signals();
}
/* Resume */
else
{
/* Oops */
if (slang_on) return (1);
/* Block further signals, so double signals wont confuse us */
SLsig_block_signals();
/* Initialize, check for errors */
if (SLang_init_tty(-1, TRUE, 0) == -1)
quit("S-Lang re-initialization failed");
#ifdef HANDLE_SIGNALS
/* Allow keyboard generated suspend signal (on Unix, ^Z) */
SLtty_set_suspend_state(TRUE);
#endif
/* Restore the and screen and screen management state */
if (SLsmg_resume_smg() == -1)
{
SLang_reset_tty();
quit("Could not get back virtual display memory");
}
/* Done with blocking */
SLsig_unblock_signals();
/* Note that we are on */
slang_on = TRUE;
}
/* Success */
return (0);
}
static void sig_sigtstp (int sig) /*{{{*/
{
(void) sig;
SLsig_block_signals ();
reset_tty ();
kill(getpid(),SIGSTOP);
init_tty ();
if (Use_SLang_Readline == 0)
{
#ifdef HAVE_GNU_READLINE
rl_refresh_line (0,0);
#endif
}
else
{
if (Active_Rline_Info != NULL)
{
SLrline_set_display_width (Active_Rline_Info, SLtt_Screen_Cols);
SLrline_redraw (Active_Rline_Info);
}
}
SLsig_unblock_signals ();
}
void SLang_reset_tty (void)
{
SLsig_block_signals ();
if (TTY_Inited == 0)
{
SLsig_unblock_signals ();
return;
}
while ((-1 == SET_TERMIOS(SLang_TT_Read_FD, &Old_TTY))
&& (errno == EINTR))
;
if (TTY_Open)
{
while ((-1 == close (SLang_TT_Read_FD))
&& (errno == EINTR))
;
TTY_Open = 0;
SLang_TT_Read_FD = -1;
}
TTY_Inited = 0;
SLsig_unblock_signals ();
}
static void smg_refresh (void)
{
if (Smg_Initialized <= 0)
return;
SLsig_block_signals ();
SLsmg_refresh ();
SLsig_unblock_signals ();
}
static void smg_reset_smg (void)
{
if (Smg_Initialized <= 0)
return;
SLsig_block_signals ();
SLsmg_reset_smg ();
SLsig_unblock_signals ();
Smg_Initialized = 0;
}
static void smg_init_smg (void)
{
if (Smg_Initialized != 0)
return;
SLsig_block_signals ();
(void) SLsmg_init_smg ();
SLsig_unblock_signals ();
Smg_Initialized = 1;
}
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();
}
void SLtty_set_suspend_state (int mode)
{
TTY_Termio_Type newtty;
SLsig_block_signals ();
if (TTY_Inited == 0)
{
SLsig_unblock_signals ();
return;
}
while ((-1 == GET_TERMIOS (SLang_TT_Read_FD, &newtty))
&& (errno == EINTR))
;
#ifndef HAVE_TERMIOS_H
/* I do not know if all systems define the t_dsuspc field */
if (mode == 0)
{
newtty.lt.t_suspc = 255;
newtty.lt.t_dsuspc = 255;
}
else
{
newtty.lt.t_suspc = Old_TTY.lt.t_suspc;
newtty.lt.t_dsuspc = Old_TTY.lt.t_dsuspc;
}
#else
if (mode == 0)
{
newtty.c_cc[VSUSP] = NULL_VALUE;
#ifdef VDSUSP
newtty.c_cc[VDSUSP] = NULL_VALUE;
#endif
}
else
{
newtty.c_cc[VSUSP] = Old_TTY.c_cc[VSUSP];
#ifdef VDSUSP
newtty.c_cc[VDSUSP] = Old_TTY.c_cc[VDSUSP];
#endif
}
#endif
while ((-1 == SET_TERMIOS (SLang_TT_Read_FD, &newtty))
&& (errno == EINTR))
;
SLsig_unblock_signals ();
}
static void sig_sigtstp (int sig)
{
(void) sig;
SLsig_block_signals ();
reset_tty ();
kill(getpid(),SIGSTOP);
init_tty ();
if (Active_Rline_Info != NULL)
{
SLrline_set_display_width (Active_Rline_Info, SLtt_Screen_Cols);
SLrline_redraw (Active_Rline_Info);
}
SLsig_unblock_signals ();
}
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 void reset_tty (void) /*{{{*/
{
#ifdef HAVE_GNU_READLINE
if (Use_SLang_Readline == 0)
{
SLsig_block_signals ();
SLsignal (SIGINT, last_sig_sigint);
SLsignal (SIGTSTP, last_sig_sigtstp);
SLsig_unblock_signals ();
return;
}
#endif
if (TTY_Inited == 0)
return;
TTY_Inited = 0;
SLsig_block_signals ();
SLsignal (SIGTSTP, last_sig_sigtstp);
SLang_reset_tty ();
SLsig_unblock_signals ();
fputs ("\r\n", stdout); /* need this with buggy Linux rlogin? */
fflush (stdout);
}
static void sig_exit_jed(int sig) /*{{{*/
{
char buf[48];
if (Signal_In_Progress)
return;
Signal_In_Progress = 1;
SLsig_block_signals ();
auto_save_all ();
sprintf (buf, "Killed by signal %d.", sig);
exit_error (buf, (sig == SIGSEGV) || (sig == SIGBUS));
exit (1);
}
static void suspend_slsh (void)
{
reset_tty ();
(void) SLang_run_hooks ("slsh_readline_suspend_before_hook", 0);
kill (0, SIGSTOP);
(void) SLang_run_hooks ("slsh_readline_suspend_after_hook", 0);
init_tty ();
if (Active_Rline_Info != NULL)
{
SLsig_block_signals ();
SLrline_set_display_width (Active_Rline_Info->rli, SLtt_Screen_Cols);
SLrline_redraw (Active_Rline_Info->rli);
SLsig_unblock_signals ();
}
}
int jed_spawn_fg_process (int (*f)(VOID_STAR), VOID_STAR cd)
{
int status;
int inited;
if ((Jed_Secure_Mode)
|| (Jed_Suspension_Not_Allowed))
{
msg_error ("Access to shell denied.");
return -1;
}
/* FIXME: X_Suspend_Hook should not be here. Currently, this hook is
* used only by GUI jed, where suspension makes no sense. Of course in
* this case, spawning a foreground process also does not make sense.
*/
if (Batch || (X_Suspend_Hook != NULL))
return (*f) (cd);
SLsig_block_signals ();
inited = Jed_Display_Initialized;
SLsig_unblock_signals ();
jed_reset_display();
#if !defined(IBMPC_SYSTEM) && !defined(VMS)
jed_reset_signals ();
#endif
reset_tty();
status = (*f) (cd);
if (inited)
{
#if !defined(IBMPC_SYSTEM) && !defined(VMS)
init_signals();
#endif
if (-1 == init_tty())
{
exit_error ("Unable to initialize terminal.", 0);
}
flush_input ();
jed_init_display ();
}
check_buffers();
return status;
}
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);
}
static void background_read (int sig) /*{{{*/
{
sig = errno;
if (Stdin_Is_TTY == 0)
{
if (Signal_In_Progress)
return;
Signal_In_Progress = 1;
SLsig_block_signals ();
exit_error ("Attempt to read from background-- exiting.", 0);
exit (1);
}
sig_sys_spawn_cmd (0);
errno = sig;
}
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 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 int slang_end_graphics(caca_display_t *dp)
{
_caca_set_term_title("");
SLtt_set_mouse_mode(0, 0);
SLtt_set_cursor_visibility(1);
SLang_reset_tty();
SLsig_block_signals();
SLsmg_reset_smg();
SLsig_unblock_signals();
#if defined HAVE_GETENV && defined HAVE_PUTENV
slang_uninstall_terminal(dp);
#endif
free(dp->drv.p);
return 0;
}
static void reset_tty (void)
{
if (TTY_Inited == 0)
return;
TTY_Inited--;
if (TTY_Inited)
return;
# if SYSTEM_SUPPORTS_SIGNALS
SLsig_block_signals ();
deinit_sigtstp ();
# endif
SLang_reset_tty ();
# if SYSTEM_SUPPORTS_SIGNALS
SLsig_unblock_signals ();
# endif
}
static void reset_tty (void)
{
if (TTY_Inited == 0)
return;
TTY_Inited = 0;
# if SYSTEM_SUPPORTS_SIGNALS
SLsig_block_signals ();
SLsignal (SIGTSTP, last_sig_sigtstp);
# endif
SLang_reset_tty ();
# if SYSTEM_SUPPORTS_SIGNALS
SLsig_unblock_signals ();
# endif
/* Add a \r here to work around what I believe is a solaris kernel bug.
* The terminal is being reset by SLang_reset_tty which uses TCSADRAIN
* option. However, that is not supposed to affect output after that
* call is made (like the output below), but it does.
*/
fputs ("\r\n", stdout);
fflush (stdout);
}
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
}
int SLang_init_tty (int abort_char, int no_flow_control, int opost)
{
TTY_Termio_Type newtty;
SLsig_block_signals ();
if (TTY_Inited)
{
SLsig_unblock_signals ();
return 0;
}
TTY_Open = 0;
SLKeyBoard_Quit = 0;
if ((SLang_TT_Read_FD == -1)
|| (1 != isatty (SLang_TT_Read_FD)))
{
#ifdef O_RDWR
# if !defined(__BEOS__) && !defined(__APPLE__)
/* I have been told that BEOS will HANG if passed /dev/tty */
if ((SLang_TT_Read_FD = open("/dev/tty", O_RDWR)) >= 0)
{
# ifdef FD_CLOEXEC
/* Make sure /dev/tty is closed upon exec */
int flags = fcntl (SLang_TT_Read_FD, F_GETFD);
if (flags >= 0)
(void) fcntl(SLang_TT_Read_FD, F_SETFD, flags | FD_CLOEXEC);
# endif
TTY_Open = 1;
}
# endif
#endif
if (TTY_Open == 0)
{
SLang_TT_Read_FD = fileno (stderr);
if (1 != isatty (SLang_TT_Read_FD))
{
SLang_TT_Read_FD = fileno (stdin);
if (1 != isatty (SLang_TT_Read_FD))
{
fprintf (stderr, "Failed to open terminal.");
return -1;
}
}
}
}
SLang_Abort_Char = abort_char;
/* Some systems may not permit signals to be blocked. As a result, the
* return code must be checked.
*/
while (-1 == GET_TERMIOS(SLang_TT_Read_FD, &Old_TTY))
{
if (errno != EINTR)
{
SLsig_unblock_signals ();
return -1;
}
}
while (-1 == GET_TERMIOS(SLang_TT_Read_FD, &newtty))
{
if (errno != EINTR)
{
SLsig_unblock_signals ();
return -1;
}
}
#ifndef HAVE_TERMIOS_H
(void) opost;
(void) no_flow_control;
newtty.s.sg_flags &= ~(ECHO);
newtty.s.sg_flags &= ~(CRMOD);
/* if (Flow_Control == 0) newtty.s.sg_flags &= ~IXON; */
newtty.t.t_eofc = 1;
if (abort_char == -1) SLang_Abort_Char = newtty.t.t_intrc;
newtty.t.t_intrc = SLang_Abort_Char; /* ^G */
newtty.t.t_quitc = 255;
newtty.lt.t_suspc = 255; /* to ignore ^Z */
newtty.lt.t_dsuspc = 255; /* to ignore ^Y */
newtty.lt.t_lnextc = 255;
newtty.s.sg_flags |= CBREAK; /* do I want cbreak or raw????? */
#else
/* get baud rate */
newtty.c_iflag &= ~(ECHO | INLCR | ICRNL);
#ifdef ISTRIP
/* newtty.c_iflag &= ~ISTRIP; */
#endif
if (opost == 0) newtty.c_oflag &= ~OPOST;
set_baud_rate (&newtty);
if (no_flow_control) newtty.c_iflag &= ~IXON; else newtty.c_iflag |= IXON;
newtty.c_cc[VEOF] = 1;
newtty.c_cc[VMIN] = 1;
newtty.c_cc[VTIME] = 0;
newtty.c_lflag = ISIG | NOFLSH;
if (abort_char == -1) SLang_Abort_Char = newtty.c_cc[VINTR];
newtty.c_cc[VINTR] = SLang_Abort_Char; /* ^G */
newtty.c_cc[VQUIT] = NULL_VALUE;
newtty.c_cc[VSUSP] = NULL_VALUE; /* to ignore ^Z */
#ifdef VDSUSP
newtty.c_cc[VDSUSP] = NULL_VALUE; /* to ignore ^Y */
#endif
#ifdef VLNEXT
newtty.c_cc[VLNEXT] = NULL_VALUE; /* to ignore ^V ? */
#endif
#ifdef VSWTCH
newtty.c_cc[VSWTCH] = NULL_VALUE; /* to ignore who knows what */
#endif
#endif /* NOT HAVE_TERMIOS_H */
while (-1 == SET_TERMIOS(SLang_TT_Read_FD, &newtty))
{
if (errno != EINTR)
{
SLsig_unblock_signals ();
return -1;
}
}
TTY_Inited = 1;
SLsig_unblock_signals ();
return 0;
}
static int slang_init_graphics(caca_display_t *dp)
{
dp->drv.p = malloc(sizeof(struct driver_private));
dp->drv.p->sigint_event = 0;
#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
slang_install_terminal(dp);
#endif
#if defined(HAVE_SIGNAL)
sigwinch_d = dp;
signal(SIGWINCH, sigwinch_handler);
#endif
_caca_set_term_title("caca for S-Lang");
/* Initialise slang library */
SLsig_block_signals();
/* Disable SLang's own SIGINT on ctrl-c */
SLang_set_abort_signal(default_sigint);
SLtt_get_terminfo();
if(SLkp_init() == -1)
{
SLsig_unblock_signals();
return -1;
}
SLang_init_tty(-1, 0, 1);
if(SLsmg_init_smg() == -1)
{
SLsig_unblock_signals();
return -1;
}
SLsmg_cls();
SLtt_set_cursor_visibility(0);
SLkp_define_keysym("\e[M", 1001);
SLtt_set_mouse_mode(1, 0);
SLsmg_refresh();
/* Disable scrolling so that hashmap scrolling optimization code
* does not cause ugly refreshes due to slow terminals */
SLtt_Term_Cannot_Scroll = 1;
slang_init_palette();
#if defined(VMS) || defined(REAL_UNIX_SYSTEM)
/* Disable alt charset support so that we get a chance to have all
* 256 colour pairs */
SLtt_Has_Alt_Charset = 0;
#endif
#ifdef HAVE_SLSMG_UTF8_ENABLE
SLsmg_utf8_enable(1); /* 1 == force, 0 == disable, -1 == autodetect */
SLtt_utf8_enable(1);
#endif
caca_add_dirty_rect(dp->cv, 0, 0, dp->cv->width, dp->cv->height);
dp->resize.allow = 1;
caca_set_canvas_size(dp->cv, SLtt_Screen_Cols, SLtt_Screen_Rows);
dp->resize.allow = 0;
SLsig_unblock_signals();
return 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();
}
/*
* Prepare "S-Lang" for use by the file "z-term.c"
* Installs the "hook" functions defined above
*/
errr init_sla(int argc, char **argv)
{
int err;
term *t = &term_screen_body;
/* Unused parameters */
(void)argc;
(void)argv;
/* Block signals, so signals cannot confuse the setup */
SLsig_block_signals();
/* Initialize, check for errors */
err = (SLang_init_tty(-1, TRUE, 0) == -1);
/* Quit on error */
if (err) quit("SLang initialization failed");
/* Get terminal info */
SLtt_get_terminfo();
#ifdef HANDLE_SIGNALS
/* Allow keyboard generated suspend signal (on Unix, ^Z) */
SLtty_set_suspend_state(TRUE);
/* Instead of signal(), use sigaction():SA_RESTART via SLsignal() */
signal_aux = SLsignal;
#endif
/* Initialize some more */
if (SLsmg_init_smg() == -1)
{
SLang_reset_tty();
quit("Could not get virtual display memory");
}
/* Check we have enough screen. */
err = ((SLtt_Screen_Rows < 24) || (SLtt_Screen_Cols < 80));
/* Quit with message */
if (err)
{
SLsmg_reset_smg();
SLang_reset_tty();
quit("SLang screen must be at least 80x24");
}
/* Now let's go for a little bit of color! */
err = !has_colors();
/* Do we have color available? */
can_use_color = !err;
/* Init the Color-pairs and set up a translation table */
/* If the terminal has enough colors */
/* Color-pair 0 is *always* WHITE on BLACK */
/* XXX XXX XXX See "main-gcu.c" for proper method */
/* Only do this on color machines */
if (can_use_color)
{
/* Prepare the color pairs */
init_pair(1, COLOR_RED, COLOR_BLACK);
init_pair(2, COLOR_GREEN, COLOR_BLACK);
init_pair(3, COLOR_YELLOW, COLOR_BLACK);
init_pair(4, COLOR_BLUE, COLOR_BLACK);
init_pair(5, COLOR_MAGENTA, COLOR_BLACK);
init_pair(6, COLOR_CYAN, COLOR_BLACK);
init_pair(7, COLOR_BLACK, COLOR_BLACK);
init_pair(9, COLOR_BRED, COLOR_BLACK);
init_pair(10, COLOR_BGREEN, COLOR_BLACK);
init_pair(11, COLOR_BYELLOW, COLOR_BLACK);
init_pair(12, COLOR_BBLUE, COLOR_BLACK);
init_pair(13, COLOR_BMAGENTA, COLOR_BLACK);
init_pair(14, COLOR_BCYAN, COLOR_BLACK);
init_pair(15, COLOR_BBLACK, COLOR_BLACK);
/* Prepare the color table */
colortable[0] = 7; /* Black */
colortable[1] = 0; /* White */
colortable[2] = 6; /* Grey XXX */
colortable[3] = 11; /* Orange XXX */
colortable[4] = 1; /* Red */
colortable[5] = 2; /* Green */
colortable[6] = 4; /* Blue */
colortable[7] = 3; /* Brown */
colortable[8] = 15; /* Dark-grey XXX */
colortable[9] = 14; /* Light-grey XXX */
colortable[10] = 5; /* Purple */
colortable[11] = 11; /* Yellow */
colortable[12] = 9; /* Light Red */
colortable[13] = 10; /* Light Green */
colortable[14] = 12; /* Light Blue */
colortable[15] = 3; /* Light Brown XXX */
}
/* Done with blocking */
SLsig_unblock_signals();
/* Initialize the term */
term_init(t, 80, 24, 64);
/* Stick in some hooks */
t->nuke_hook = Term_nuke_sla;
t->init_hook = Term_init_sla;
/* Stick in some more hooks */
t->xtra_hook = Term_xtra_sla;
t->curs_hook = Term_curs_sla;
t->wipe_hook = Term_wipe_sla;
t->text_hook = Term_text_sla;
/* Save the term */
term_screen = t;
/* Activate it */
Term_activate(t);
/* Success */
return 0;
}
static void slang_display(caca_display_t *dp)
{
int x, y, i;
SLsig_block_signals();
for(i = 0; i < caca_get_dirty_rect_count(dp->cv); i++)
{
uint32_t const *cvchars, *cvattrs;
int dx, dy, dw, dh;
caca_get_dirty_rect(dp->cv, i, &dx, &dy, &dw, &dh);
cvchars = caca_get_canvas_chars(dp->cv) + dx + dy * dp->cv->width;
cvattrs = caca_get_canvas_attrs(dp->cv) + dx + dy * dp->cv->width;
for(y = dy; y < dy + dh; y++)
{
SLsmg_gotorc(y, dx);
for(x = dx; x < dx + dw; x++)
{
uint32_t ch = *cvchars++;
#if defined(OPTIMISE_SLANG_PALETTE)
/* If foreground == background, just don't use this colour
* pair, and print a space instead of the real character. */
/* XXX: disabled, because I can't remember what it was
* here for, and in cases where SLang does not render
* bright backgrounds, it's just f****d up. */
#if 0
uint8_t fgcolor = caca_attr_to_ansi_fg(*cvattrs);
uint8_t bgcolor = caca_attr_to_ansi_bg(*cvattrs);
if(fgcolor >= 0x10)
fgcolor = CACA_LIGHTGRAY;
if(bgcolor >= 0x10)
bgcolor = CACA_BLACK; /* FIXME: handle transparency */
if(fgcolor == bgcolor)
{
if(fgcolor == CACA_BLACK)
fgcolor = CACA_WHITE;
else if(fgcolor == CACA_WHITE
|| fgcolor <= CACA_LIGHTGRAY)
fgcolor = CACA_BLACK;
else
fgcolor = CACA_WHITE;
SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);
SLsmg_write_char(' ');
cvattrs++;
}
else
#endif
{
SLsmg_set_color(slang_assoc[caca_attr_to_ansi(*cvattrs++)]);
slang_write_utf32(ch);
}
#else
SLsmg_set_color(caca_attr_to_ansi(*cvattrs++));
slang_write_utf32(ch);
#endif
}
cvchars += dp->cv->width - dw;
cvattrs += dp->cv->width - dw;
}
}
SLsmg_gotorc(caca_wherey(dp->cv), caca_wherex(dp->cv));
SLsmg_refresh();
SLsig_unblock_signals();
}
