lib/tty/tty-slang.c

lib/tty/tty-slang.c
/* */
This source file includes following definitions.
tty_setup_sigwinch
sigwinch_handler
slang_reset_softkeys
do_define_key
load_terminfo_keys
mc_tty_normalize_lines_char
tty_init
tty_shutdown
tty_enter_ca_mode
tty_exit_ca_mode
tty_change_screen_size
tty_reset_prog_mode
tty_reset_shell_mode
tty_raw_mode
tty_noraw_mode
tty_noecho
tty_flush_input
tty_keypad
tty_nodelay
tty_baudrate
tty_lowlevel_getch
tty_reset_screen
tty_touch_screen
tty_gotoyx
tty_getyx
tty_draw_hline
tty_draw_vline
tty_fill_region
tty_set_alt_charset
tty_display_8bit
tty_print_char
tty_print_alt_char
tty_print_anychar
tty_print_string
tty_printf
tty_tgetstr
tty_refresh
tty_beep
   1 /*
   2    Interface to the terminal controlling library.
   3    Slang wrapper.
   4 
   5    Copyright (C) 2005-2019
   6    Free Software Foundation, Inc.
   7 
   8    Written by:
   9    Andrew Borodin <aborodin@vmail.ru>, 2009
  10    Egmont Koblinger <egmont@gmail.com>, 2010
  11 
  12    This file is part of the Midnight Commander.
  13 
  14    The Midnight Commander is free software: you can redistribute it
  15    and/or modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation, either version 3 of the License,
  17    or (at your option) any later version.
  18 
  19    The Midnight Commander is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23 
  24    You should have received a copy of the GNU General Public License
  25    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26  */
  27 
  28 /** \file
  29  *  \brief Source: S-Lang-based tty layer of Midnight Commander
  30  */
  31 
  32 #include <config.h>
  33 
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <sys/types.h>          /* size_t */
  38 #include <unistd.h>
  39 #ifdef HAVE_SYS_IOCTL_H
  40 #include <sys/ioctl.h>
  41 #endif
  42 #include <termios.h>
  43 
  44 #include "lib/global.h"
  45 #include "lib/strutil.h"        /* str_term_form */
  46 #include "lib/util.h"           /* is_printable() */
  47 
  48 #include "tty-internal.h"       /* mc_tty_normalize_from_utf8() */
  49 #include "tty.h"
  50 #include "color.h"
  51 #include "color-slang.h"
  52 #include "color-internal.h"
  53 #include "mouse.h"              /* Gpm_Event is required in key.h */
  54 #include "key.h"                /* define_sequence */
  55 #include "win.h"
  56 
  57 
  58 /*** global variables ****************************************************************************/
  59 
  60 /* If true program softkeys (HP terminals only) on startup and after every
  61    command ran in the subshell to the description found in the termcap/terminfo
  62    database */
  63 int reset_hp_softkeys = 0;
  64 
  65 /*** file scope macro definitions ****************************************************************/
  66 
  67 #ifndef SLTT_MAX_SCREEN_COLS
  68 #define SLTT_MAX_SCREEN_COLS 512
  69 #endif
  70 
  71 #ifndef SLTT_MAX_SCREEN_ROWS
  72 #define SLTT_MAX_SCREEN_ROWS 512
  73 #endif
  74 
  75 /*** file scope type declarations ****************************************************************/
  76 
  77 /*** file scope variables ************************************************************************/
  78 
  79 /* Various saved termios settings that we control here */
  80 static struct termios boot_mode;
  81 static struct termios new_mode;
  82 
  83 /* Controls whether we should wait for input in tty_lowlevel_getch */
  84 static gboolean no_slang_delay;
  85 
  86 static gboolean slsmg_active = FALSE;
  87 
  88 /* This table describes which capabilities we want and which values we
  89  * assign to them.
  90  */
  91 static const struct
  92 {
  93     int key_code;
  94     const char *key_name;
  95 } key_table[] =
  96 {
  97     /* *INDENT-OFF* */
  98     { KEY_F (0), "k0" },
  99     { KEY_F (1), "k1" },
 100     { KEY_F (2), "k2" },
 101     { KEY_F (3), "k3" },
 102     { KEY_F (4), "k4" },
 103     { KEY_F (5), "k5" },
 104     { KEY_F (6), "k6" },
 105     { KEY_F (7), "k7" },
 106     { KEY_F (8), "k8" },
 107     { KEY_F (9), "k9" },
 108     { KEY_F (10), "k;" },
 109     { KEY_F (11), "F1" },
 110     { KEY_F (12), "F2" },
 111     { KEY_F (13), "F3" },
 112     { KEY_F (14), "F4" },
 113     { KEY_F (15), "F5" },
 114     { KEY_F (16), "F6" },
 115     { KEY_F (17), "F7" },
 116     { KEY_F (18), "F8" },
 117     { KEY_F (19), "F9" },
 118     { KEY_F (20), "FA" },
 119     { KEY_IC, "kI" },
 120     { KEY_NPAGE, "kN" },
 121     { KEY_PPAGE, "kP" },
 122     { KEY_LEFT, "kl" },
 123     { KEY_RIGHT, "kr" },
 124     { KEY_UP, "ku" },
 125     { KEY_DOWN, "kd" },
 126     { KEY_DC, "kD" },
 127     { KEY_BACKSPACE, "kb" },
 128     { KEY_HOME, "kh" },
 129     { KEY_END, "@7" },
 130     { 0, NULL }
 131     /* *INDENT-ON* */
 132 };
 133 
 134 /* --------------------------------------------------------------------------------------------- */
 135 /*** file scope functions ************************************************************************/
 136 /* --------------------------------------------------------------------------------------------- */
 137 
 138 static void
 139 tty_setup_sigwinch (void (*handler) (int))
     /*   */
 140 {
 141     (void) SLsignal (SIGWINCH, handler);
 142     tty_create_winch_pipe ();
 143 }
 144 
 145 /* --------------------------------------------------------------------------------------------- */
 146 
 147 static void
 148 sigwinch_handler (int dummy)
     /*   */
 149 {
 150     ssize_t n = 0;
 151 
 152     (void) dummy;
 153 
 154     n = write (sigwinch_pipe[1], "", 1);
 155     (void) n;
 156 
 157     (void) SLsignal (SIGWINCH, sigwinch_handler);
 158 }
 159 
 160 /* --------------------------------------------------------------------------------------------- */
 161 
 162 /* HP Terminals have capabilities (pfkey, pfloc, pfx) to program function keys.
 163    elm 2.4pl15 invoked with the -K option utilizes these softkeys and the
 164    consequence is that function keys don't work in MC sometimes...
 165    Unfortunately I don't now the one and only escape sequence to turn off.
 166    softkeys (elm uses three different capabilities to turn on softkeys and two.
 167    capabilities to turn them off)..
 168    Among other things elm uses the pair we already use in slang_keypad. That's.
 169    the reason why I call slang_reset_softkeys from slang_keypad. In lack of
 170    something better the softkeys are programmed to their defaults from the
 171    termcap/terminfo database.
 172    The escape sequence to program the softkeys is taken from elm and it is.
 173    hardcoded because neither slang nor ncurses 4.1 know how to 'printf' this.
 174    sequence. -- Norbert
 175  */
 176 
 177 static void
 178 slang_reset_softkeys (void)
     /*   */
 179 {
 180     int key;
 181     static const char display[] = "                ";
 182     char tmp[BUF_SMALL];
 183 
 184     for (key = 1; key < 9; key++)
 185     {
 186         char *send;
 187 
 188         g_snprintf (tmp, sizeof (tmp), "k%d", key);
 189         send = SLtt_tgetstr (tmp);
 190         if (send != NULL)
 191         {
 192             g_snprintf (tmp, sizeof (tmp), ESC_STR "&f%dk%dd%dL%s%s", key,
 193                         (int) (sizeof (display) - 1), (int) strlen (send), display, send);
 194             SLtt_write_string (tmp);
 195         }
 196     }
 197 }
 198 
 199 /* --------------------------------------------------------------------------------------------- */
 200 
 201 static void
 202 do_define_key (int code, const char *strcap)
     /*   */
 203 {
 204     char *seq;
 205 
 206     seq = SLtt_tgetstr ((SLFUTURE_CONST char *) strcap);
 207     if (seq != NULL)
 208         define_sequence (code, seq, MCKEY_NOACTION);
 209 }
 210 
 211 /* --------------------------------------------------------------------------------------------- */
 212 
 213 static void
 214 load_terminfo_keys (void)
     /*   */
 215 {
 216     int i;
 217 
 218     for (i = 0; key_table[i].key_code; i++)
 219         do_define_key (key_table[i].key_code, key_table[i].key_name);
 220 }
 221 
 222 /* --------------------------------------------------------------------------------------------- */
 223 /*** public functions ****************************************************************************/
 224 /* --------------------------------------------------------------------------------------------- */
 225 
 226 int
 227 mc_tty_normalize_lines_char (const char *str)
     /*   */
 228 {
 229     char *str2;
 230     int res;
 231 
 232     struct mc_tty_lines_struct
 233     {
 234         const char *line;
 235         int line_code;
 236     } const lines_codes[] = {
 237         {"\342\224\214", SLSMG_ULCORN_CHAR},
 238         {"\342\224\220", SLSMG_URCORN_CHAR},
 239         {"\342\224\224", SLSMG_LLCORN_CHAR},
 240         {"\342\224\230", SLSMG_LRCORN_CHAR},
 241         {"\342\224\234", SLSMG_LTEE_CHAR},
 242         {"\342\224\244", SLSMG_RTEE_CHAR},
 243         {"\342\224\254", SLSMG_UTEE_CHAR},
 244         {"\342\224\264", SLSMG_DTEE_CHAR},
 245         {"\342\224\200", SLSMG_HLINE_CHAR},
 246         {"\342\224\202", SLSMG_VLINE_CHAR},
 247         {"\342\224\274", SLSMG_PLUS_CHAR},
 248 
 249         {NULL, 0}
 250     };
 251 
 252     if (!str)
 253         return (int) ' ';
 254 
 255     for (res = 0; lines_codes[res].line; res++)
 256     {
 257         if (strcmp (str, lines_codes[res].line) == 0)
 258             return lines_codes[res].line_code;
 259     }
 260 
 261     str2 = mc_tty_normalize_from_utf8 (str);
 262     res = g_utf8_get_char_validated (str2, -1);
 263 
 264     if (res < 0)
 265         res = (unsigned char) str2[0];
 266     g_free (str2);
 267 
 268     return res;
 269 }
 270 
 271 /* --------------------------------------------------------------------------------------------- */
 272 
 273 void
 274 tty_init (gboolean mouse_enable, gboolean is_xterm)
     /*   */
 275 {
 276     SLtt_Ignore_Beep = 1;
 277 
 278     SLutf8_enable (-1);         /* has to be called first before any of the other functions. */
 279     SLtt_get_terminfo ();
 280     /*
 281      * If the terminal in not in terminfo but begins with a well-known
 282      * string such as "linux" or "xterm" S-Lang will go on, but the
 283      * terminal size and several other variables won't be initialized
 284      * (as of S-Lang 1.4.4). Detect it and abort. Also detect extremely
 285      * small screen dimensions.
 286      */
 287     if ((COLS < 10) || (LINES < 5)
 288 #if SLANG_VERSION < 20303
 289         /* Beginning from pre2.3.3-8 (55f58798c267d76a1b93d0d916027b71a10ac1ee),
 290            these limitations were eliminated. */
 291         || (COLS > SLTT_MAX_SCREEN_COLS) || (LINES > SLTT_MAX_SCREEN_ROWS)
 292 #endif
 293         )
 294     {
 295         fprintf (stderr,
 296                  _("Screen size %dx%d is not supported.\n"
 297                    "Check the TERM environment variable.\n"), COLS, LINES);
 298         exit (EXIT_FAILURE);
 299     }
 300 
 301     tcgetattr (fileno (stdin), &boot_mode);
 302     /* 255 = ignore abort char; XCTRL('g') for abort char = ^g */
 303     SLang_init_tty (XCTRL ('g'), 1, 0);
 304 
 305     if (mc_global.tty.ugly_line_drawing)
 306         SLtt_Has_Alt_Charset = 0;
 307 
 308     tcgetattr (SLang_TT_Read_FD, &new_mode);
 309 
 310     tty_reset_prog_mode ();
 311     load_terminfo_keys ();
 312 
 313     SLtt_Blink_Mode = (tty_use_256colors () || tty_use_truecolors (NULL)) ? 1 : 0;
 314 
 315     tty_start_interrupt_key ();
 316 
 317     /* It's the small part from the previous init_key() */
 318     init_key_input_fd ();
 319 
 320     /* For 8-bit locales, NCurses handles 154 (0x9A) symbol properly, while S-Lang
 321      * requires SLsmg_Display_Eight_Bit >= 154 (OR manual filtering if xterm display
 322      * detected - but checking TERM would fail under screen, OR running xterm
 323      * with allowC1Printable).
 324      */
 325     tty_display_8bit (FALSE);
 326 
 327     SLsmg_init_smg ();
 328     slsmg_active = TRUE;
 329     if (!mouse_enable)
 330         use_mouse_p = MOUSE_DISABLED;
 331     tty_init_xterm_support (is_xterm);  /* do it before tty_enter_ca_mode() call */
 332     tty_enter_ca_mode ();
 333     tty_keypad (TRUE);
 334     tty_nodelay (FALSE);
 335 
 336     tty_setup_sigwinch (sigwinch_handler);
 337 }
 338 
 339 /* --------------------------------------------------------------------------------------------- */
 340 
 341 void
 342 tty_shutdown (void)
     /*   */
 343 {
 344     char *op_cap;
 345 
 346     tty_reset_shell_mode ();
 347     tty_noraw_mode ();
 348     tty_keypad (FALSE);
 349     tty_reset_screen ();
 350     tty_exit_ca_mode ();
 351     SLang_reset_tty ();
 352     slsmg_active = FALSE;
 353 
 354     /* Load the op capability to reset the colors to those that were 
 355      * active when the program was started up 
 356      */
 357     op_cap = SLtt_tgetstr ((SLFUTURE_CONST char *) "op");
 358     if (op_cap != NULL)
 359     {
 360         fputs (op_cap, stdout);
 361         fflush (stdout);
 362     }
 363 }
 364 
 365 /* --------------------------------------------------------------------------------------------- */
 366 
 367 void
 368 tty_enter_ca_mode (void)
     /*   */
 369 {
 370     /* S-Lang handles alternate screen switching and cursor position saving */
 371 }
 372 
 373 /* --------------------------------------------------------------------------------------------- */
 374 
 375 void
 376 tty_exit_ca_mode (void)
     /*   */
 377 {
 378     /* S-Lang handles alternate screen switching and cursor position restoring */
 379 }
 380 
 381 /* --------------------------------------------------------------------------------------------- */
 382 
 383 void
 384 tty_change_screen_size (void)
     /*   */
 385 {
 386     SLtt_get_screen_size ();
 387     if (slsmg_active)
 388         SLsmg_reinit_smg ();
 389 
 390 #ifdef ENABLE_SUBSHELL
 391     if (mc_global.tty.use_subshell)
 392         tty_resize (mc_global.tty.subshell_pty);
 393 #endif
 394 }
 395 
 396 /* --------------------------------------------------------------------------------------------- */
 397 /* Done each time we come back from done mode */
 398 
 399 void
 400 tty_reset_prog_mode (void)
     /*   */
 401 {
 402     tcsetattr (SLang_TT_Read_FD, TCSANOW, &new_mode);
 403     SLsmg_init_smg ();
 404     slsmg_active = TRUE;
 405     SLsmg_touch_lines (0, LINES);
 406 }
 407 
 408 /* --------------------------------------------------------------------------------------------- */
 409 /* Called each time we want to shutdown slang screen manager */
 410 
 411 void
 412 tty_reset_shell_mode (void)
     /*   */
 413 {
 414     tcsetattr (SLang_TT_Read_FD, TCSANOW, &boot_mode);
 415 }
 416 
 417 /* --------------------------------------------------------------------------------------------- */
 418 
 419 void
 420 tty_raw_mode (void)
     /*   */
 421 {
 422     tcsetattr (SLang_TT_Read_FD, TCSANOW, &new_mode);
 423 }
 424 
 425 /* --------------------------------------------------------------------------------------------- */
 426 
 427 void
 428 tty_noraw_mode (void)
     /*   */
 429 {
 430 }
 431 
 432 /* --------------------------------------------------------------------------------------------- */
 433 
 434 void
 435 tty_noecho (void)
     /*   */
 436 {
 437 }
 438 
 439 /* --------------------------------------------------------------------------------------------- */
 440 
 441 int
 442 tty_flush_input (void)
     /*   */
 443 {
 444     return 0;                   /* OK */
 445 }
 446 
 447 /* --------------------------------------------------------------------------------------------- */
 448 
 449 void
 450 tty_keypad (gboolean set)
     /*   */
 451 {
 452     char *keypad_string;
 453 
 454     keypad_string = SLtt_tgetstr ((SLFUTURE_CONST char *) (set ? "ks" : "ke"));
 455     if (keypad_string != NULL)
 456         SLtt_write_string (keypad_string);
 457     if (set && reset_hp_softkeys)
 458         slang_reset_softkeys ();
 459 }
 460 
 461 /* --------------------------------------------------------------------------------------------- */
 462 
 463 void
 464 tty_nodelay (gboolean set)
     /*   */
 465 {
 466     no_slang_delay = set;
 467 }
 468 
 469 /* --------------------------------------------------------------------------------------------- */
 470 
 471 int
 472 tty_baudrate (void)
     /*   */
 473 {
 474     return SLang_TT_Baud_Rate;
 475 }
 476 
 477 /* --------------------------------------------------------------------------------------------- */
 478 
 479 int
 480 tty_lowlevel_getch (void)
     /*   */
 481 {
 482     int c;
 483 
 484     if (no_slang_delay && (SLang_input_pending (0) == 0))
 485         return -1;
 486 
 487     c = SLang_getkey ();
 488     if (c == SLANG_GETKEY_ERROR)
 489     {
 490         fprintf (stderr,
 491                  "SLang_getkey returned SLANG_GETKEY_ERROR\n"
 492                  "Assuming EOF on stdin and exiting\n");
 493         exit (EXIT_FAILURE);
 494     }
 495 
 496     return c;
 497 }
 498 
 499 /* --------------------------------------------------------------------------------------------- */
 500 
 501 int
 502 tty_reset_screen (void)
     /*   */
 503 {
 504     SLsmg_reset_smg ();
 505     slsmg_active = FALSE;
 506     return 0;                   /* OK */
 507 }
 508 
 509 /* --------------------------------------------------------------------------------------------- */
 510 
 511 void
 512 tty_touch_screen (void)
     /*   */
 513 {
 514     SLsmg_touch_lines (0, LINES);
 515 }
 516 
 517 /* --------------------------------------------------------------------------------------------- */
 518 
 519 void
 520 tty_gotoyx (int y, int x)
     /*   */
 521 {
 522     SLsmg_gotorc (y, x);
 523 }
 524 
 525 /* --------------------------------------------------------------------------------------------- */
 526 
 527 void
 528 tty_getyx (int *py, int *px)
     /*   */
 529 {
 530     *py = SLsmg_get_row ();
 531     *px = SLsmg_get_column ();
 532 }
 533 
 534 /* --------------------------------------------------------------------------------------------- */
 535 
 536 void
 537 tty_draw_hline (int y, int x, int ch, int len)
     /*   */
 538 {
 539     int x1;
 540 
 541     if (y < 0 || y >= LINES || x >= COLS)
 542         return;
 543 
 544     x1 = x;
 545 
 546     if (x < 0)
 547     {
 548         len += x;
 549         if (len <= 0)
 550             return;
 551         x = 0;
 552     }
 553 
 554     if (ch == ACS_HLINE)
 555         ch = mc_tty_frm[MC_TTY_FRM_HORIZ];
 556     if (ch == 0)
 557         ch = ACS_HLINE;
 558 
 559     SLsmg_gotorc (y, x);
 560 
 561     if (ch == ACS_HLINE)
 562         SLsmg_draw_hline (len);
 563     else
 564         while (len-- != 0)
 565             tty_print_char (ch);
 566 
 567     SLsmg_gotorc (y, x1);
 568 }
 569 
 570 /* --------------------------------------------------------------------------------------------- */
 571 
 572 void
 573 tty_draw_vline (int y, int x, int ch, int len)
     /*   */
 574 {
 575     int y1;
 576 
 577     if (x < 0 || x >= COLS || y >= LINES)
 578         return;
 579 
 580     y1 = y;
 581 
 582     if (y < 0)
 583     {
 584         len += y;
 585         if (len <= 0)
 586             return;
 587         y = 0;
 588     }
 589 
 590     if (ch == ACS_VLINE)
 591         ch = mc_tty_frm[MC_TTY_FRM_VERT];
 592     if (ch == 0)
 593         ch = ACS_VLINE;
 594 
 595     SLsmg_gotorc (y, x);
 596 
 597     if (ch == ACS_VLINE)
 598         SLsmg_draw_vline (len);
 599     else
 600     {
 601         int pos = 0;
 602 
 603         while (len-- != 0)
 604         {
 605             SLsmg_gotorc (y + pos, x);
 606             tty_print_char (ch);
 607             pos++;
 608         }
 609     }
 610 
 611     SLsmg_gotorc (y1, x);
 612 }
 613 
 614 /* --------------------------------------------------------------------------------------------- */
 615 
 616 void
 617 tty_fill_region (int y, int x, int rows, int cols, unsigned char ch)
     /*   */
 618 {
 619     SLsmg_fill_region (y, x, rows, cols, ch);
 620 }
 621 
 622 /* --------------------------------------------------------------------------------------------- */
 623 
 624 void
 625 tty_set_alt_charset (gboolean alt_charset)
     /*   */
 626 {
 627     SLsmg_set_char_set ((int) alt_charset);
 628 }
 629 
 630 /* --------------------------------------------------------------------------------------------- */
 631 
 632 void
 633 tty_display_8bit (gboolean what)
     /*   */
 634 {
 635     SLsmg_Display_Eight_Bit = what ? 128 : 160;
 636 }
 637 
 638 /* --------------------------------------------------------------------------------------------- */
 639 
 640 void
 641 tty_print_char (int c)
     /*   */
 642 {
 643     SLsmg_write_char ((SLwchar_Type) ((unsigned int) c));
 644 }
 645 
 646 /* --------------------------------------------------------------------------------------------- */
 647 
 648 void
 649 tty_print_alt_char (int c, gboolean single)
     /*   */
 650 {
 651 #define DRAW(x, y) (x == y) \
 652        ? SLsmg_draw_object (SLsmg_get_row(), SLsmg_get_column(), x) \
 653        : SLsmg_write_char ((unsigned int) y)
 654     switch (c)
 655     {
 656     case ACS_VLINE:
 657         DRAW (c, mc_tty_frm[single ? MC_TTY_FRM_VERT : MC_TTY_FRM_DVERT]);
 658         break;
 659     case ACS_HLINE:
 660         DRAW (c, mc_tty_frm[single ? MC_TTY_FRM_HORIZ : MC_TTY_FRM_DHORIZ]);
 661         break;
 662     case ACS_LTEE:
 663         DRAW (c, mc_tty_frm[single ? MC_TTY_FRM_LEFTMIDDLE : MC_TTY_FRM_DLEFTMIDDLE]);
 664         break;
 665     case ACS_RTEE:
 666         DRAW (c, mc_tty_frm[single ? MC_TTY_FRM_RIGHTMIDDLE : MC_TTY_FRM_DRIGHTMIDDLE]);
 667         break;
 668     case ACS_TTEE:
 669         DRAW (c, mc_tty_frm[single ? MC_TTY_FRM_TOPMIDDLE : MC_TTY_FRM_DTOPMIDDLE]);
 670         break;
 671     case ACS_BTEE:
 672         DRAW (c, mc_tty_frm[single ? MC_TTY_FRM_BOTTOMMIDDLE : MC_TTY_FRM_DBOTTOMMIDDLE]);
 673         break;
 674     case ACS_ULCORNER:
 675         DRAW (c, mc_tty_frm[single ? MC_TTY_FRM_LEFTTOP : MC_TTY_FRM_DLEFTTOP]);
 676         break;
 677     case ACS_LLCORNER:
 678         DRAW (c, mc_tty_frm[single ? MC_TTY_FRM_LEFTBOTTOM : MC_TTY_FRM_DLEFTBOTTOM]);
 679         break;
 680     case ACS_URCORNER:
 681         DRAW (c, mc_tty_frm[single ? MC_TTY_FRM_RIGHTTOP : MC_TTY_FRM_DRIGHTTOP]);
 682         break;
 683     case ACS_LRCORNER:
 684         DRAW (c, mc_tty_frm[single ? MC_TTY_FRM_RIGHTBOTTOM : MC_TTY_FRM_DRIGHTBOTTOM]);
 685         break;
 686     case ACS_PLUS:
 687         DRAW (c, mc_tty_frm[MC_TTY_FRM_CROSS]);
 688         break;
 689     default:
 690         SLsmg_write_char ((unsigned int) c);
 691     }
 692 #undef DRAW
 693 }
 694 
 695 /* --------------------------------------------------------------------------------------------- */
 696 
 697 void
 698 tty_print_anychar (int c)
     /*   */
 699 {
 700     if (c > 255)
 701     {
 702         char str[UTF8_CHAR_LEN + 1];
 703         int res;
 704 
 705         res = g_unichar_to_utf8 (c, str);
 706         if (res == 0)
 707         {
 708             str[0] = '.';
 709             str[1] = '\0';
 710         }
 711         else
 712         {
 713             str[res] = '\0';
 714         }
 715         SLsmg_write_string ((char *) str_term_form (str));
 716     }
 717     else
 718     {
 719         if (!is_printable (c))
 720             c = '.';
 721         SLsmg_write_char ((SLwchar_Type) ((unsigned int) c));
 722     }
 723 }
 724 
 725 /* --------------------------------------------------------------------------------------------- */
 726 
 727 void
 728 tty_print_string (const char *s)
     /*   */
 729 {
 730     SLsmg_write_string ((char *) str_term_form (s));
 731 }
 732 
 733 /* --------------------------------------------------------------------------------------------- */
 734 
 735 void
 736 tty_printf (const char *fmt, ...)
     /*   */
 737 {
 738     va_list args;
 739 
 740     va_start (args, fmt);
 741     SLsmg_vprintf ((char *) fmt, args);
 742     va_end (args);
 743 }
 744 
 745 /* --------------------------------------------------------------------------------------------- */
 746 
 747 char *
 748 tty_tgetstr (const char *cap)
     /*   */
 749 {
 750     return SLtt_tgetstr ((SLFUTURE_CONST char *) cap);
 751 }
 752 
 753 /* --------------------------------------------------------------------------------------------- */
 754 
 755 void
 756 tty_refresh (void)
     /*   */
 757 {
 758     SLsmg_refresh ();
 759 }
 760 
 761 /* --------------------------------------------------------------------------------------------- */
 762 
 763 void
 764 tty_beep (void)
     /*   */
 765 {
 766     SLtt_beep ();
 767 }
 768 
 769 /* --------------------------------------------------------------------------------------------- */
/* */
root/lib/tty/tty-slang.c

DEFINITIONS
