int main(void) {
struct winsize ws;
/* get the size of the terminal connected to stdout */
if (ioctl(1, TIOCGWINSZ, &ws)) {
perror("failed to get window size");
return 1;
}
SLtt_get_terminfo();
SLtt_Screen_Rows = ws.ws_row;
SLtt_Screen_Cols = ws.ws_col;
SLsmg_init_smg();
/* heart of the program goes here */
SLsmg_gotorc(SLtt_Screen_Rows - 1, 0);
SLsmg_refresh();
SLsmg_reset_smg();
SLang_reset_tty();
return 0;
}
void
tty_reset_prog_mode (void)
{
tcsetattr (SLang_TT_Read_FD, TCSANOW, &new_mode);
SLsmg_init_smg ();
SLsmg_touch_lines (0, LINES);
}
int main(void) {
struct winsize ws;
/* get the size of the terminal connected to stdout */
if (ioctl(1, TIOCGWINSZ, &ws)) {
perror("failed to get window size");
return 1;
}
SLtt_get_terminfo();
SLtt_Screen_Rows = ws.ws_row;
SLtt_Screen_Cols = ws.ws_col;
SLsmg_init_smg();
SLang_init_tty(-1, 0, 1);
drawCharSet(0, 0, "Normal Character Set");
drawCharSet(40, 1, "Alternate Character Set");
SLsmg_refresh();
SLang_getkey();
SLsmg_gotorc(SLtt_Screen_Rows - 1, 0);
SLsmg_refresh();
SLsmg_reset_smg();
SLang_reset_tty();
return 0;
}
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
}
static void smg_init_smg (void)
{
if (Smg_Initialized != 0)
return;
SLsig_block_signals ();
(void) SLsmg_init_smg ();
SLsig_unblock_signals ();
Smg_Initialized = 1;
}
void
init_curses ()
{
#ifndef HAS_ACS_AS_PCCHARS
if (force_ugly_line_drawing)
SLtt_Has_Alt_Charset = 0;
#endif
SLsmg_init_smg ();
do_enter_ca_mode ();
init_colors ();
keypad (stdscr, TRUE);
nodelay (stdscr, FALSE);
}
int SLsmg_reinit_smg (void)
{
int ret;
if (Smg_Inited == 0)
return SLsmg_init_smg ();
BLOCK_SIGNALS;
reset_smg ();
ret = init_smg ();
UNBLOCK_SIGNALS;
return ret;
}
void jed_init_display (void)
{
if (Batch) return;
jed_reset_display ();
alloc_display ();
if (-1 == SLsmg_init_smg ())
exit_error ("init_display: error initializing display", 0);
#if defined(VMS) || defined(REAL_UNIX_SYSTEM)
(void) jed_va_run_hooks ("_jed_init_display_hooks", JED_HOOKS_RUN_ALL, 0);
#endif
Jed_Display_Initialized = 1;
}
void init_curses ()
{
extern int force_ugly_line_drawing;
extern int SLtt_Has_Alt_Charset;
SLtt_get_terminfo ();
#ifndef OS2_NT
if (force_ugly_line_drawing)
SLtt_Has_Alt_Charset = 0;
#endif
SLsmg_init_smg ();
do_enter_ca_mode ();
init_colors ();
keypad (stdscr, TRUE);
nodelay (stdscr, FALSE);
}
/* this routine should be called after receiving SIGWINCH */
void mutt_resize_screen (void)
{
char *cp;
int fd;
struct winsize w;
#ifdef HAVE_RESIZETERM
int SLtt_Screen_Rows, SLtt_Screen_Cols;
#endif
SLtt_Screen_Rows = -1;
SLtt_Screen_Cols = -1;
if ((fd = open ("/dev/tty", O_RDONLY)) != -1)
{
if (ioctl (fd, TIOCGWINSZ, &w) != -1)
{
SLtt_Screen_Rows = w.ws_row;
SLtt_Screen_Cols = w.ws_col;
}
close (fd);
}
if (SLtt_Screen_Rows <= 0)
{
if ((cp = getenv ("LINES")) != NULL)
{
SLtt_Screen_Rows = atoi (cp);
}
else
SLtt_Screen_Rows = 24;
}
if (SLtt_Screen_Cols <= 0)
{
if ((cp = getenv ("COLUMNS")) != NULL)
SLtt_Screen_Cols = atoi (cp);
else
SLtt_Screen_Cols = 80;
}
#ifdef USE_SLANG_CURSES
delwin (stdscr);
SLsmg_reset_smg ();
SLsmg_init_smg ();
stdscr = newwin (0, 0, 0, 0);
keypad (stdscr, TRUE);
#else
resizeterm (SLtt_Screen_Rows, SLtt_Screen_Cols);
#endif
}
void display_setup(void)
{
SLtt_get_terminfo();
if (SLang_init_tty (ABORT, 1, 0) == -1) {
fprintf(stderr, "tweak: SLang_init_tty: returned error code\n");
exit (1);
}
SLang_set_abort_signal (NULL);
SLtt_Use_Ansi_Colors = TRUE;
get_screen_size ();
if (SLsmg_init_smg () < 0) {
fprintf(stderr, "tweak: SLsmg_init_smg: returned error code\n");
SLang_reset_tty ();
exit (1);
}
#if defined(unix) && !defined(GO32)
signal (SIGWINCH, (void *) sigwinch);
#endif
}
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;
}
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;
}
static int slang_init(__AA_CONST struct aa_hardware_params *p,__AA_CONST void *none, struct aa_hardware_params *dest, void **params)
{
struct aa_hardware_params def={NULL, AA_NORMAL_MASK | AA_BOLD_MASK | AA_REVERSE_MASK | AA_BOLDFONT_MASK | AA_DIM_MASK};
*dest=def;
fflush(stdout);
if (!__slang_is_up) {
SLtt_get_terminfo();
__slang_is_up = 1;
uninitslang = 1;
}
if (SLsmg_init_smg() != 0)
return 0;
if (SLtt_Use_Ansi_Colors) {
dest->supported &= ~AA_BOLDFONT_MASK;
}
SLsmg_Display_Eight_Bit = 128;
dest->supported |= AA_EIGHT;
#ifdef GPM_MOUSEDRIVER
aa_recommendlowmouse("gpm");
#endif
aa_recommendlowkbd ("linux");
aa_recommendlowkbd("slang");
return 1;
}
void
dialog_change_screen_size (void)
{
mc_global.tty.winch_flag = FALSE;
#if defined(HAVE_SLANG) || NCURSES_VERSION_MAJOR >= 4
#if defined TIOCGWINSZ
#ifndef NCURSES_VERSION
tty_noraw_mode ();
tty_reset_screen ();
#endif
tty_change_screen_size ();
#ifdef HAVE_SLANG
/* XSI Curses spec states that portable applications shall not invoke
* initscr() more than once. This kludge could be done within the scope
* of the specification by using endwin followed by a refresh (in fact,
* more than one curses implementation does this); it is guaranteed to work
* only with slang.
*/
SLsmg_init_smg ();
do_enter_ca_mode ();
tty_keypad (TRUE);
tty_nodelay (FALSE);
#endif
/* Inform all suspending dialogs */
dialog_switch_got_winch ();
/* Inform all running dialogs */
g_list_foreach (top_dlg, (GFunc) dlg_resize_cb, NULL);
/* Now, force the redraw */
repaint_screen ();
#endif /* TIOCGWINSZ */
#endif /* defined(HAVE_SLANG) || NCURSES_VERSION_MAJOR >= 4 */
}
/*
* 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;
}
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;
}
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;
}
}
/*ARGSUSED*/
static int ctl_open(int using_stdin, int using_stdout)
{
#ifdef TIOCGWINSZ
struct winsize size;
#endif
int i;
int save_lines, save_cols;
SLtt_get_terminfo();
/*
* Save the terminfo values for lines and cols
* then detect the real values.
*/
save_lines = SLtt_Screen_Rows;
save_cols = SLtt_Screen_Cols;
#ifdef TIOCGWINSZ
if (!ioctl(0, TIOCGWINSZ, &size)) {
SLtt_Screen_Cols=size.ws_col;
SLtt_Screen_Rows=size.ws_row;
} else
#endif
{
SLtt_Screen_Cols=atoi(getenv("COLUMNS"));
SLtt_Screen_Rows=atoi(getenv("LINES"));
}
if (!SLtt_Screen_Cols || !SLtt_Screen_Rows) {
SLtt_Screen_Rows = save_lines;
SLtt_Screen_Cols = save_cols;
}
SLang_init_tty(7, 0, 0);
SLsmg_init_smg();
SLtt_set_color (20, "Normal", "lightgray", "black");
SLtt_set_color (21, "HighLight", "white", "black");
SLtt_set_color (22, "Reverse", "black", "white");
SLtt_Use_Ansi_Colors = 1;
SLtt_Term_Cannot_Scroll = 1;
ctl.opened=1;
SLsmg_cls();
ctl_head();
SLsmg_printfrc(3,0, "File:");
if (ctl.trace_playing)
{
SLsmg_printfrc(4,0, "Time:");
SLsmg_gotorc(4,6+6+1);
SLsmg_write_char('/');
SLsmg_gotorc(4,40);
SLsmg_printf("Voices: / %d", voices);
}
else
{
SLsmg_printfrc(4,0, "Time:");
SLsmg_printfrc(4,13, "/");
}
SLsmg_printfrc(4,SLtt_Screen_Cols-20, "Master volume:");
SLsmg_gotorc(5,0);
for (i=0; i<SLtt_Screen_Cols; i++)
SLsmg_write_char('_');
if (ctl.trace_playing)
{
SLsmg_printfrc(6,0, "Ch");
SLsmg_printfrc(6,SLtt_Screen_Cols-20, "Prg Vol Exp Pan S B");
SLsmg_gotorc(7,0);
for (i=0; i<SLtt_Screen_Cols; i++)
SLsmg_write_char('-');
for (i=0; i<16; i++)
{
SLsmg_printfrc(8+i, 0, "%02d", i+1);
}
set_trace_loop_hook(update_indicator);
indicator_width=SLtt_Screen_Cols-2;
if(indicator_width<40)
indicator_width=40;
lyric_row=2;
}
else
msg_row = 6;
memset(comment_indicator_buffer =
(char *)safe_malloc(indicator_width), 0, indicator_width);
memset(current_indicator_message =
(char *)safe_malloc(indicator_width), 0, indicator_width);
_ctl_refresh();
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;
}
void display_recheck_size(void)
{
SLsmg_reset_smg ();
get_screen_size ();
SLsmg_init_smg ();
}
/*
* Prepare "SLang" for use by the file "term.c"
* Installs the "hook" functions defined above
*/
errr init_sla(void)
{
int i, err;
term *t = &term_screen_body;
/* 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();
/* Initialize some more */
if (SLsmg_init_smg() == 0)
{
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) 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 */
}
/* 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;
}
void
tty_init (gboolean mouse_enable, gboolean is_xterm)
{
SLtt_Ignore_Beep = 1;
SLutf8_enable (-1); /* has to be called first before any of the other functions. */
SLtt_get_terminfo ();
/*
* If the terminal in not in terminfo but begins with a well-known
* string such as "linux" or "xterm" S-Lang will go on, but the
* terminal size and several other variables won't be initialized
* (as of S-Lang 1.4.4). Detect it and abort. Also detect extremely
* small, large and negative screen dimensions.
*/
if ((COLS < 10) || (LINES < 5)
|| (COLS > SLTT_MAX_SCREEN_COLS) || (LINES > SLTT_MAX_SCREEN_ROWS))
{
fprintf (stderr,
_("Screen size %dx%d is not supported.\n"
"Check the TERM environment variable.\n"), COLS, LINES);
exit (EXIT_FAILURE);
}
tcgetattr (fileno (stdin), &boot_mode);
/* 255 = ignore abort char; XCTRL('g') for abort char = ^g */
SLang_init_tty (XCTRL ('g'), 1, 0);
if (mc_global.tty.ugly_line_drawing)
SLtt_Has_Alt_Charset = 0;
/* If SLang uses fileno(stderr) for terminal input MC will hang
if we call SLang_getkey between calls to open_error_pipe and
close_error_pipe, e.g. when we do a growing view of an gzipped
file. */
if (SLang_TT_Read_FD == fileno (stderr))
SLang_TT_Read_FD = fileno (stdin);
if (tcgetattr (SLang_TT_Read_FD, &new_mode) == 0)
{
#ifdef VDSUSP
new_mode.c_cc[VDSUSP] = NULL_VALUE; /* to ignore ^Y */
#endif
#ifdef VLNEXT
new_mode.c_cc[VLNEXT] = NULL_VALUE; /* to ignore ^V */
#endif
tcsetattr (SLang_TT_Read_FD, TCSADRAIN, &new_mode);
}
tty_reset_prog_mode ();
load_terminfo_keys ();
SLtt_Blink_Mode = tty_use_256colors ()? 1 : 0;
tty_start_interrupt_key ();
/* It's the small part from the previous init_key() */
init_key_input_fd ();
/* For 8-bit locales, NCurses handles 154 (0x9A) symbol properly, while S-Lang
* requires SLsmg_Display_Eight_Bit >= 154 (OR manual filtering if xterm display
* detected - but checking TERM would fail under screen, OR running xterm
* with allowC1Printable).
*/
tty_display_8bit (FALSE);
SLsmg_init_smg ();
if (!mouse_enable)
use_mouse_p = MOUSE_DISABLED;
tty_init_xterm_support (is_xterm); /* do it before do_enter_ca_mode() call */
init_mouse ();
do_enter_ca_mode ();
tty_keypad (TRUE);
tty_nodelay (FALSE);
tty_setup_sigwinch (sigwinch_handler);
}
int os_inner_init(const char* title)
{
const char* display;
struct utsname uts;
struct sigaction term_action;
struct sigaction quit_action;
struct sigaction hup_action;
struct sigaction pipe_action;
#ifdef USE_SDL
SDL_version compiled;
#endif
unsigned char endian[4] = { 0x1, 0x2, 0x3, 0x4 };
uint32 endian_little = 0x04030201;
uint32 endian_big = 0x01020304;
log_std(("os: os_inner_init\n"));
if (uname(&uts) != 0) {
log_std(("ERROR:os: uname failed\n"));
} else {
log_std(("os: sys %s\n", uts.sysname));
log_std(("os: release %s\n", uts.release));
log_std(("os: version %s\n", uts.version));
log_std(("os: machine %s\n", uts.machine));
}
#if HAVE_SYSCONF
#ifdef _SC_CLK_TCK
log_std(("os: sysconf(_SC_CLK_TCK) %ld\n", sysconf(_SC_CLK_TCK)));
#endif
#ifdef _SC_NPROCESSORS_CONF
log_std(("os: sysconf(_SC_NPROCESSORS_CONF) %ld\n", sysconf(_SC_NPROCESSORS_CONF)));
#endif
#ifdef _SC_NPROCESSORS_ONLN
log_std(("os: sysconf(_SC_NPROCESSORS_ONLN) %ld\n", sysconf(_SC_NPROCESSORS_ONLN)));
#endif
#ifdef _SC_PHYS_PAGES
log_std(("os: sysconf(_SC_PHYS_PAGES) %ld\n", sysconf(_SC_PHYS_PAGES)));
#endif
#ifdef _SC_AVPHYS_PAGES
log_std(("os: sysconf(_SC_AVPHYS_PAGES) %ld\n", sysconf(_SC_AVPHYS_PAGES)));
#endif
#ifdef _SC_CHAR_BIT
log_std(("os: sysconf(_SC_CHAR_BIT) %ld\n", sysconf(_SC_CHAR_BIT)));
#endif
#ifdef _SC_LONG_BIT
log_std(("os: sysconf(_SC_LONG_BIT) %ld\n", sysconf(_SC_LONG_BIT)));
#endif
#ifdef _SC_WORD_BIT
log_std(("os: sysconf(_SC_WORD_BIT) %ld\n", sysconf(_SC_WORD_BIT)));
#endif
#endif
#ifdef _POSIX_PRIORITY_SCHEDULING /* OSDEF Check for POSIX scheduling */
log_std(("os: scheduling available\n"));
#else
log_std(("os: scheduling NOT available\n"));
#endif
/* print the compiler version */
#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) /* OSDEF Detect compiler version */
#define COMPILER_RESOLVE(a) #a
#define COMPILER(a, b, c) COMPILER_RESOLVE(a) "." COMPILER_RESOLVE(b) "." COMPILER_RESOLVE(c)
log_std(("os: compiler GNU %s\n", COMPILER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)));
#else
log_std(("os: compiler unknown\n"));
#endif
/* check for int size */
if (sizeof(uint8) != 1) {
target_err("The program is compiled with invalid uint8 type.\n");
return -1;
}
if (sizeof(uint16) != 2) {
target_err("The program is compiled with invalid uint16 type.\n");
return -1;
}
if (sizeof(uint32) != 4) {
target_err("The program is compiled with invalid uint32 type.\n");
return -1;
}
if (sizeof(uint64) != 8) {
target_err("The program is compiled with invalid uint64 type.\n");
return -1;
}
/* check for the endianess */
#ifdef USE_MSB
log_std(("os: compiled big endian system\n"));
if (memcmp(endian, &endian_big, 4) != 0) {
target_err("The program is compiled as bigendian but system doesn't appear to be bigendian.\n");
return -1;
}
#endif
#ifdef USE_LSB
log_std(("os: compiled little endian system\n"));
if (memcmp(endian, &endian_little, 4) != 0) {
target_err("The program is compiled as littleendian but system doesn't appear to be littleendian.\n");
return -1;
}
#endif
#ifdef USE_SMP
/* check the thread support */
if (os_thread() != 0) {
target_err("Error on the threading support.\n");
return -1;
}
#endif
/* get DISPLAY environment variable */
display = getenv("DISPLAY");
if (display)
log_std(("os: DISPLAY=%s\n", display));
else
log_std(("os: DISPLAY undef\n"));
/* probe the delay system */
os_delay();
if (!os_internal_wm_active()) {
log_std(("os: save term\n"));
if (tcgetattr(fileno(stdin), &OS.term) != 0) {
log_std(("ERROR:os: error getting the tty state.\n"));
OS.term_active = 0;
} else {
OS.term_active = 1;
}
}
#if defined(USE_X)
OS.x_active = 0;
{
int event_base, error_base;
int major_version, minor_version;
log_std(("os: XOpenDisplay()\n"));
OS.dga_display = XOpenDisplay(0);
if (OS.dga_display) {
OS.x_active = 1;
} else {
log_std(("WARNING:os: XOpenDisplay() failed. All the X drivers will be disabled.\n"));
}
}
#endif
#if defined(USE_SVGALIB)
OS.svgalib_active = 0;
if (!os_internal_wm_active()) {
int h;
log_std(("os: open /dev/svga\n"));
/* try opening the device, otherwise vga_init() will abort the program. */
h = open("/dev/svga", O_RDWR);
if (h >= 0) {
int res;
close(h);
vga_disabledriverreport();
/* check the version of the SVGALIB */
res = vga_setmode(-1);
if (res < 0 || res < 0x1911) { /* 1.9.11 */
log_std(("WARNING:os: invalid SVGALIB version %x. All the SVGALIB drivers will be disabled.\n", (int)res));
/* don't print the message. It may be a normal condition. */
/* target_nfo("Invalid SVGALIB version, you need SVGALIB version 1.9.x or 2.0.x.\nPlease upgrade or recompile without SVGALIB support.\n"); */
} else {
log_std(("os: vga_init()\n"));
if (vga_init() != 0) {
log_std(("os: vga_init() failed\n"));
target_err("Error initializing the SVGALIB video support.\n");
return -1;
}
OS.svgalib_active = 1;
}
} else {
log_std(("WARNING:os: open /dev/svga failed. All the SVGALIB drivers will be disabled.\n"));
/* don't print the message. It may be a normal condition. */
/* target_nfo("Error opening the SVGALIB device /dev/svga.\n"); */
}
} else {
log_std(("WARNING:os: vga_init() skipped because X is active. All the SVGALIB drivers will be disabled.\n"));
/* don't print the message. It may be a normal condition. */
/* target_nfo("SVGALIB not initialized because it's unusable in X.\n"); */
}
#endif
#if defined(USE_SDL)
log_std(("os: SDL_Init(SDL_INIT_NOPARACHUTE)\n"));
if (SDL_Init(SDL_INIT_NOPARACHUTE) != 0) {
log_std(("os: SDL_Init() failed, %s\n", SDL_GetError()));
target_err("Error initializing the SDL video support.\n");
return -1;
}
OS.sdl_active = 1;
SDL_VERSION(&compiled);
log_std(("os: compiled with sdl %d.%d.%d\n", compiled.major, compiled.minor, compiled.patch));
log_std(("os: linked with sdl %d.%d.%d\n", SDL_Linked_Version()->major, SDL_Linked_Version()->minor, SDL_Linked_Version()->patch));
#ifdef USE_MSB
if (SDL_BYTEORDER != SDL_BIG_ENDIAN) {
target_err("Invalid SDL endianess.\n");
return -1;
}
#endif
#ifdef USE_LSB
if (SDL_BYTEORDER != SDL_LIL_ENDIAN) {
target_err("Invalid SDL endianess.\n");
return -1;
}
#endif
#endif
#if defined(USE_SLANG)
OS.slang_active = 0;
if (!os_internal_wm_active()) {
log_std(("os: SLtt_get_terminfo()\n"));
SLtt_get_terminfo();
log_std(("os: SLsmg_init_smg()\n"));
SLsmg_init_smg();
OS.slang_active = 1;
} else {
log_std(("WARNING:os: SLang_init_tty() skipped because X is active. All the SLang drivers will be disabled.\n"));
}
#endif
#if defined(USE_CURSES)
OS.curses_active = 0;
if (!os_internal_wm_active()) {
log_std(("os: initscr()\n"));
initscr();
start_color();
cbreak();
noecho();
nonl();
OS.curses_active = 1;
} else {
log_std(("WARNING:os: curses initscr() skipped because X is active. All the curses drivers will be disabled.\n"));
}
#endif
/* set the titlebar */
sncpy(OS.title_buffer, sizeof(OS.title_buffer), title);
/* set some signal handlers */
/* STANDARD signals */
term_action.sa_handler = (void (*)(int))os_signal;
/* block external generated signals in the signal handler */
sigemptyset(&term_action.sa_mask);
sigaddset(&term_action.sa_mask, SIGALRM);
sigaddset(&term_action.sa_mask, SIGINT);
sigaddset(&term_action.sa_mask, SIGTERM);
sigaddset(&term_action.sa_mask, SIGHUP);
sigaddset(&term_action.sa_mask, SIGQUIT);
term_action.sa_flags = SA_RESTART | SA_SIGINFO;
/* external generated */
sigaction(SIGALRM, &term_action, 0);
sigaction(SIGINT, &term_action, 0);
sigaction(SIGTERM, &term_action, 0);
/* internal generated */
sigaction(SIGABRT, &term_action, 0);
sigaction(SIGFPE, &term_action, 0);
sigaction(SIGILL, &term_action, 0);
sigaction(SIGSEGV, &term_action, 0);
sigaction(SIGBUS, &term_action, 0);
/* HUP signal */
hup_action.sa_handler = os_hup_signal;
sigemptyset(&hup_action.sa_mask);
hup_action.sa_flags = SA_RESTART;
sigaction(SIGHUP, &hup_action, 0);
/* QUIT signal */
quit_action.sa_handler = os_quit_signal;
sigemptyset(&quit_action.sa_mask);
quit_action.sa_flags = SA_RESTART;
sigaction(SIGQUIT, &quit_action, 0);
/* PIPE signal, ignoring it force some functions to */
/* return with error. It happen for example on the LCD sockets. */
pipe_action.sa_handler = SIG_IGN;
sigemptyset(&pipe_action.sa_mask);
pipe_action.sa_flags = SA_RESTART;
sigaction(SIGPIPE, &pipe_action, 0);
return 0;
}
int main() {
TerminalIO *tio;
VTCore *vt;
VTScreenView *view;
char *argv[] = {"/bin/bash", 0};
//char input[65];
unsigned int input;
char ch[2];
int fd;
fd_set fileDescriptors;
struct timeval timeout;
// Initialize Terminal
SLtt_get_terminfo ();
SLang_init_tty (-1, 0, 0);
SLsmg_init_smg ();
SLsmg_refresh();
// iTerm Setup
// new iTerm TerminalIO object
tio = TtyTerminalIO_new(SLtt_Screen_Cols, SLtt_Screen_Rows, "/bin/bash", argv); // width, height, program, argv
if(tio == NULL) {
printf("Error initializing TerminalIO\n");
return 1;
}
// new Virtual Terminal Screen View object
view = malloc (sizeof (VTScreenView));
if (view == NULL) {
perror ("VTScreenView_new");
return 1;
}
VTScreenView_init (view);
view->draw_text = vtDrawText;
view->update_cursor_position = vtMoveCursor;
view->clear_rect = vtClearRect;
view->scroll_view = vtScroll;
// Start the iTerm core
vt = VTCore_new(tio, SLtt_Screen_Cols, SLtt_Screen_Rows, 10); // terminalIO, cols, rows, history
if(vt == NULL) {
printf("Error initializing VTCore\n");
return 1;
}
// Tell the core with view to use ... can we have multiple?
VTCore_set_screen_view(vt, view);
timeout.tv_sec = 0;
timeout.tv_usec = 100000;
fd = TtyTerminalIO_get_associated_fd(tio);
while(1) {
FD_ZERO(&fileDescriptors);
FD_SET(0, &fileDescriptors);
FD_SET( TtyTerminalIO_get_associated_fd(tio), &fileDescriptors);
timeout.tv_sec = 0;
timeout.tv_usec = 100000;
select(fd + 1, &fileDescriptors, NULL, NULL, &timeout);
if(FD_ISSET(fd, &fileDescriptors)) {
VTCore_dispatch(vt);
SLsmg_refresh();
}
if(FD_ISSET(0, &fileDescriptors)) {
input = SLang_getkey();
//printf("input: %c\n", (char)input);
ch[0] = (char) input;
ch[1] = 0;
write(fd, &ch, 1);
if(ch[0] == 'Q')
break;
}
}
free(view);
VTCore_destroy(vt);
TtyTerminalIO_destroy(tio);
// Shut down s-lang IO
SLsmg_reset_smg ();
SLang_reset_tty ();
return 0;
}
bool SLangConsole::init() {
setenv("TERM","xterm-color",0);
SLtt_get_terminfo();
if( -1 == SLkp_init() ) { // keyboard interface
error("failure in SLkp_init()");
return false;
}
SLang_init_tty(-1, 0, 0);
SLsmg_init_smg(); // screen manager
// SLutf8_enable(1); // enable UTF8 character set
// this is a mess ...
screen_size_changed = false;
// register signals
SLsignal (SIGWINCH, sigwinch_handler);
SLang_set_abort_signal(sigint_handler);
SLkp_set_getkey_function(getkey_handler);
// SLsmg_Tab_Width = 8;
// SLsmg_Display_Eight_Bit = 1;
// SLtt_Use_Ansi_Colors = 0;
// SLtt_Term_Cannot_Scroll = 0;
// set sizes of the whole console
w = SLtt_Screen_Cols;
h = SLtt_Screen_Rows;
/* setup colors with the palette scheme:
n = normal;
n+10 = highlight;
n+20 = reverse normal;
n+30 = reverse highlight; */
// crazy casting for crazy slang
SLtt_set_color(1,NULL,(char *)"lightgray",(char *)"black");
SLtt_set_color(11,NULL,(char *)"white",(char *)"black");
SLtt_set_color(21,NULL,(char *)"black",(char *)"lightgray");
SLtt_set_color(31,NULL,(char *)"black",(char *)"white");
SLtt_set_color(2,NULL,(char *)"red",(char *)"black");
SLtt_set_color(12,NULL,(char *)"brightred",(char *)"black");
SLtt_set_color(22,NULL,(char *)"black",(char *)"red");
SLtt_set_color(32,NULL,(char *)"black",(char *)"brightred");
SLtt_set_color(3,NULL,(char *)"green",(char *)"black");
SLtt_set_color(13,NULL,(char *)"brightgreen",(char *)"black");
SLtt_set_color(23,NULL,(char *)"black",(char *)"green");
SLtt_set_color(33,NULL,(char *)"black",(char *)"brightgreen");
SLtt_set_color(4,NULL,(char *)"brown",(char *)"black");
SLtt_set_color(14,NULL,(char *)"yellow",(char *)"black");
SLtt_set_color(24,NULL,(char *)"black",(char *)"brown");
SLtt_set_color(34,NULL,(char *)"black",(char *)"yellow");
SLtt_set_color(5,NULL,(char *)"blue",(char *)"black");
SLtt_set_color(15,NULL,(char *)"brightblue",(char *)"black");
SLtt_set_color(25,NULL,(char *)"black",(char *)"blue");
SLtt_set_color(35,NULL,(char *)"black",(char *)"brightblue");
SLtt_set_color(6,NULL,(char *)"magenta",(char *)"black");
SLtt_set_color(16,NULL,(char *)"brightmagenta",(char *)"black");
SLtt_set_color(26,NULL,(char *)"black",(char *)"magenta");
SLtt_set_color(36,NULL,(char *)"black",(char *)"brightmagenta");
SLtt_set_color(7,NULL,(char *)"cyan",(char *)"black");
SLtt_set_color(17,NULL,(char *)"brightcyan",(char *)"black");
SLtt_set_color(27,NULL,(char *)"black",(char *)"cyan");
SLtt_set_color(37,NULL,(char *)"black",(char *)"brightcyan");
refresh();
return true;
}
/* this is the main key processing loop for interactive mode */
void display_results_interactively() {
bool_t done = 0;
int c, c1;
/* set up the terminal etc. */
SLang_init_tty(-1, 0, 0);
SLtt_get_terminfo();
if(-1 == SLsmg_init_smg() ) {
fprintf (stderr, "Unable to initialize terminal.");
return;
}
SLkp_init(); /* for cursor keys */
SLsignal(SIGWINCH, sigwinch_handler);
init_disp_state();
while(!done) {
redraw_current_state();
c = SLang_getkey();
/* if it's a meta combination, translate */
if( c == '' ) {
c1 = SLang_getkey();
switch(c1) {
case '<':
c = SL_KEY_HOME;
break;
case '>':
c = SL_KEY_END;
break;
case 'v':
case 'V':
c = SL_KEY_PPAGE;
break;
case 'r':
case 'R':
c = '?';
break;
case 's':
case 'S':
c = '/';
break;
default:
/* could be special cursor keys */
SLang_ungetkey(c1);
SLang_ungetkey(c);
c = SLkp_getkey();
}
}
/* handle key press */
switch(c) {
case 'q':
case 'Q':
done = 1;
break;
case 'c':
interactive_categorize();
disp.highlighted = disp.first_visible = 0;
break;
case '\r':
case 'v':
if( emails.num_limited > 0 ) {
view_current_email();
}
break;
case SL_KEY_F(1):
if( emails.num_limited > 0 && disp.fkey_cmd[0] ) {
interactive_pipe_all_tagged(disp.fkey_cmd[0]);
}
break;
case SL_KEY_F(2):
if( emails.num_limited > 0 && disp.fkey_cmd[1] ) {
interactive_pipe_all_tagged(disp.fkey_cmd[1]);
}
break;
case SL_KEY_F(3):
if( emails.num_limited > 0 && disp.fkey_cmd[2] ) {
interactive_pipe_all_tagged(disp.fkey_cmd[2]);
}
break;
case SL_KEY_F(4):
if( emails.num_limited > 0 && disp.fkey_cmd[3] ) {
interactive_pipe_all_tagged(disp.fkey_cmd[3]);
}
break;
case SL_KEY_F(5):
if( emails.num_limited > 0 && disp.fkey_cmd[4] ) {
interactive_pipe_all_tagged(disp.fkey_cmd[4]);
}
break;
case SL_KEY_F(6):
if( emails.num_limited > 0 && disp.fkey_cmd[5] ) {
interactive_pipe_all_tagged(disp.fkey_cmd[5]);
}
break;
case SL_KEY_F(7):
if( emails.num_limited > 0 && disp.fkey_cmd[6] ) {
interactive_pipe_all_tagged(disp.fkey_cmd[6]);
}
break;
case SL_KEY_F(8):
if( emails.num_limited > 0 && disp.fkey_cmd[7] ) {
interactive_pipe_all_tagged(disp.fkey_cmd[7]);
}
break;
case SL_KEY_F(9):
if( emails.num_limited > 0 && disp.fkey_cmd[8] ) {
interactive_pipe_all_tagged(disp.fkey_cmd[8]);
}
break;
case SL_KEY_F(10):
if( emails.num_limited > 0 && disp.fkey_cmd[9] ) {
interactive_pipe_all_tagged(disp.fkey_cmd[9]);
}
break;
case 's':
if( emails.num_limited > 0 ) {
interactive_pipe_current("");
}
break;
case 'S':
if( emails.num_limited > 0 ) {
interactive_pipe_all_tagged("");
}
break;
case 'o':
if( ++emails.score_type >= MAX_SCORES ) {
emails.score_type = 0;
}
qsort(emails.list, emails.num_emails, sizeof(mbox_item), compare_scores);
recalculate_limited();
break;
case 'p':
if( ++emails.index_format >= MAX_FORMATS ) {
emails.index_format = 0;
}
break;
case 't':
if( emails.num_limited > 0 ) {
tag_current(1);
}
break;
case 'T':
if( emails.num_limited > 0 ) {
tag_all_limited(1);
}
break;
case 'u':
if( emails.num_limited > 0 ) {
tag_current(0);
}
break;
case 'U':
if( emails.num_limited > 0 ) {
tag_all_limited(0);
}
break;
case 'z':
reverse_sort();
recalculate_limited();
break;
case 'G':
case SL_KEY_END:
if( emails.num_limited > 0 ) {
disp.first_visible = emails.num_limited - 1;
} else {
disp.highlighted = disp.first_visible = 0;
}
break;
case '1':
case SL_KEY_HOME:
disp.first_visible = 0;
break;
case '':
case SL_KEY_PPAGE:
if( disp.first_visible > disp.num_rows )
{ disp.first_visible -= disp.num_rows; }
else
{ disp.first_visible = 0; disp.highlighted = 0; }
/* assert emails.num_limited >= disp.first_visible */
if( disp.highlighted > (emails.num_limited - disp.first_visible) ) {
disp.highlighted = (emails.num_limited - disp.first_visible);
}
break;
case 'k':
case '':
case SL_KEY_UP:
if( disp.highlighted > 0 ) {
disp.highlighted--;
} else {
if( disp.first_visible > 1 )
{ disp.first_visible -= 1; }
else
{ disp.first_visible = 0; }
}
break;
case 'j':
case '':
case SL_KEY_DOWN:
if( emails.num_limited > 0 ) {
if( disp.highlighted < (emails.num_limited - disp.first_visible - 1) ) {
if( disp.highlighted < (disp.num_rows - 3) ) {
disp.highlighted++;
} else {
if( (disp.first_visible += 1) >= emails.num_limited )
{ disp.first_visible = emails.num_limited - 1; }
}
}
} else {
disp.highlighted = disp.first_visible = 0;
}
break;
case '':
case '':
case ' ':
case SL_KEY_NPAGE:
if( emails.num_limited > 0 ) {
if( (disp.first_visible += disp.num_rows) >= emails.num_limited )
{ disp.first_visible = emails.num_limited - 1; }
if( disp.highlighted > (emails.num_limited - disp.first_visible) ) {
disp.highlighted = (emails.num_limited - disp.first_visible) - 1;
}
} else {
disp.highlighted = disp.first_visible = 0;
}
break;
case '?':
interactive_search(0, "");
disp.highlighted = disp.first_visible = 0;
break;
case '/':
interactive_search(1, "");
disp.highlighted = disp.first_visible = 0;
break;
default:
break;
}
}
/* we're done */
SLsmg_reset_smg();
SLang_reset_tty();
}
SLcurses_Window_Type *SLcurses_initscr (void)
{
SLcurses_Is_Endwin = 0;
SLsmg_Newline_Behavior = SLSMG_NEWLINE_MOVES;
SLtt_get_terminfo ();
#if !defined(IBMPC_SYSTEM) && !defined(VMS)
if (-1 == (SLcurses_Num_Colors = SLtt_tgetnum ("Co")))
#endif
SLcurses_Num_Colors = 8;
if ((-1 == SLkp_init ())
|| (-1 == SLcurses_cbreak ())
|| (NULL == (SLcurses_Stdscr = SLcurses_newwin (0, 0, 0, 0)))
|| (-1 == SLsmg_init_smg ()))
{
SLang_exit_error ("SLcurses_initscr: init failed\n");
return NULL;
}
SLkp_set_getkey_function (getkey_function);
#ifdef SIGINT
signal (SIGINT, sigint_handler);
#endif
#if defined(SIGTSTP) && defined(SIGSTOP)
signal (SIGTSTP, sigtstp_handler);
#endif
SLtt_set_mono (SLCURSES_EXTRACT_COLOR(A_BOLD), NULL, SLTT_BOLD_MASK);
SLtt_set_mono (SLCURSES_EXTRACT_COLOR(A_UNDERLINE), NULL, SLTT_ULINE_MASK);
SLtt_set_mono (SLCURSES_EXTRACT_COLOR(A_REVERSE), NULL, SLTT_REV_MASK);
/* SLtt_set_mono (SLCURSES_EXTRACT_COLOR(A_BLINK), NULL, SLTT_BLINK_MASK); */
SLtt_set_mono ((SLCURSES_EXTRACT_COLOR(A_BOLD|A_UNDERLINE)), NULL, SLTT_ULINE_MASK|SLTT_BOLD_MASK);
SLtt_set_mono ((SLCURSES_EXTRACT_COLOR(A_REVERSE|A_UNDERLINE)), NULL, SLTT_ULINE_MASK|SLTT_REV_MASK);
if (SLtt_Has_Alt_Charset)
{
SLcurses_Acs_Map[SLSMG_ULCORN_CHAR] = SLSMG_ULCORN_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_URCORN_CHAR] = SLSMG_URCORN_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_LLCORN_CHAR] = SLSMG_LLCORN_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_LRCORN_CHAR] = SLSMG_LRCORN_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_UTEE_CHAR] = SLSMG_UTEE_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_DTEE_CHAR] = SLSMG_DTEE_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_LTEE_CHAR] = SLSMG_LTEE_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_RTEE_CHAR] = SLSMG_RTEE_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_VLINE_CHAR] = SLSMG_VLINE_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_HLINE_CHAR] = SLSMG_HLINE_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_PLUS_CHAR] = SLSMG_PLUS_CHAR | A_ALTCHARSET;
SLcurses_Acs_Map[SLSMG_CKBRD_CHAR] = SLSMG_CKBRD_CHAR | A_ALTCHARSET;
}
else
{
/* ugly defaults to use on terminals which don't support graphics */
SLcurses_Acs_Map[SLSMG_ULCORN_CHAR] = '+';
SLcurses_Acs_Map[SLSMG_URCORN_CHAR] = '+';
SLcurses_Acs_Map[SLSMG_LLCORN_CHAR] = '+';
SLcurses_Acs_Map[SLSMG_LRCORN_CHAR] = '+';
SLcurses_Acs_Map[SLSMG_UTEE_CHAR] = '+';
SLcurses_Acs_Map[SLSMG_DTEE_CHAR] = '+';
SLcurses_Acs_Map[SLSMG_LTEE_CHAR] = '+';
SLcurses_Acs_Map[SLSMG_RTEE_CHAR] = '+';
SLcurses_Acs_Map[SLSMG_VLINE_CHAR] = '|';
SLcurses_Acs_Map[SLSMG_HLINE_CHAR] = '-';
SLcurses_Acs_Map[SLSMG_PLUS_CHAR] = '+';
SLcurses_Acs_Map[SLSMG_CKBRD_CHAR] = '#';
}
return SLcurses_Stdscr;
}
