src/slint.c

   1 /* Slang interface to the Midnight Commander
   2    This emulates some features of ncurses on top of slang
   3
   4    Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   5    2005, 2007 Free Software Foundation, Inc.
   6
   7    Author Miguel de Icaza
   8           Norbert Warmuth
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  23
  24 /** \file slint.c
  25  *  \brief Source: slang %interface to the Midnight Commander
  26  *  \warning This module will be removed soon
  27  */
  28
  29 #include <config.h>
  30
  31 #include <signal.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #ifdef HAVE_TERMIOS_H
  37 #include <termios.h>
  38 #endif
  39 #include <unistd.h>
  40
  41 #include "global.h"
  42 #include "tty.h"
  43 #include "color.h"
  44 #include "mouse.h"              /* Gpm_Event is required in key.h */
  45 #include "key.h"                /* define_sequence */
  46 #include "main.h"               /* extern: force_colors */
  47 #include "win.h"                /* do_exit_ca_mode */
  48 #include "setup.h"
  49 #include "background.h"         /* we_are_background */
  50
  51 #ifdef HAVE_SLANG
  52
  53 /* Taken from S-Lang's slutty.c */
  54 #ifdef ultrix   /* Ultrix gets _POSIX_VDISABLE wrong! */
  55 # define NULL_VALUE -1
  56 #else
  57 # ifdef _POSIX_VDISABLE
  58 #  define NULL_VALUE _POSIX_VDISABLE
  59 # else
  60 #  define NULL_VALUE 255
  61 # endif
  62 #endif
  63
  64 #ifndef SA_RESTART
  65 #    define SA_RESTART 0
  66 #endif
  67
  68 /* Various saved termios settings that we control here */
  69 static struct termios boot_mode;
  70 static struct termios new_mode;
  71
  72 /* Controls whether we should wait for input in getch */
  73 static int no_slang_delay;
  74
  75 /* Forward declarations */
  76 static void load_terminfo_keys (void);
  77
  78 #ifndef HAVE_SLANG_PRIVATE
  79 /* Private interfaces have been stripped, so we cannot use them */
  80 #define SLang_getkey2() SLang_getkey()
  81 #define SLang_input_pending2(s) SLang_input_pending(s)
  82 #else
  83 /* Copied from ../slang/slgetkey.c, removed the DEC_8Bit_HACK. */
  84 extern unsigned char SLang_Input_Buffer [];
  85 #if SLANG_VERSION >= 10000
  86 extern unsigned int _SLsys_getkey (void);
  87 extern int _SLsys_input_pending (int);
  88 #else
  89 extern unsigned int SLsys_getkey (void);
  90 extern int SLsys_input_pending (int);
  91 #endif
  92
  93 static unsigned int SLang_getkey2 (void)
  94 {
  95    unsigned int imax;
  96    unsigned int ch;
  97
  98    if (SLang_Input_Buffer_Len)
  99      {
 100         ch = (unsigned int) *SLang_Input_Buffer;
 101         SLang_Input_Buffer_Len--;
 102         imax = SLang_Input_Buffer_Len;
 103
 104         memmove ((char *) SLang_Input_Buffer,
 105                 (char *) (SLang_Input_Buffer + 1), imax);
 106         return(ch);
 107      }
 108 #if SLANG_VERSION >= 10000
 109    else return(_SLsys_getkey ());
 110 #else
 111    else return(SLsys_getkey());
 112 #endif
 113 }
 114
 115 static int SLang_input_pending2 (int tsecs)
 116 {
 117    int n, i;
 118    unsigned char c;
 119
 120    if (SLang_Input_Buffer_Len) return (int) SLang_Input_Buffer_Len;
 121 #if SLANG_VERSION >= 10000
 122    n = _SLsys_input_pending (tsecs);
 123 #else
 124    n = SLsys_input_pending (tsecs);
 125 #endif
 126    if (n <= 0) return 0;
 127
 128    i = SLang_getkey2 ();
 129    if (i == SLANG_GETKEY_ERROR)
 130         return 0;  /* don't put crippled error codes into the input buffer */
 131    c = (unsigned char)i;
 132    SLang_ungetkey_string (&c, 1);
 133
 134    return n;
 135 }
 136 #endif /* HAVE_SLANG_PRIVATE */
 137
 138 /* Only done the first time */
 139 void
 140 slang_init (void)
 141 {
 142     SLtt_get_terminfo ();
 143 #if SLANG_VERSION >= 20000
 144     SLutf8_enable (-1);
 145 #endif
 146    /*
 147     * If the terminal in not in terminfo but begins with a well-known
 148     * string such as "linux" or "xterm" S-Lang will go on, but the
 149     * terminal size and several other variables won't be initialized
 150     * (as of S-Lang 1.4.4). Detect it and abort. Also detect extremely
 151     * small, large and negative screen dimensions.
 152     */
 153     if ((COLS < 10) || (LINES < 5) ||
 154     (SLang_Version < 10407 && (COLS > 255 || LINES > 255)) ||
 155     (SLang_Version >= 10407 && (COLS > 512 || LINES > 512))) {
 156
 157         fprintf (stderr,
 158                  _("Screen size %dx%d is not supported.\n"
 159                    "Check the TERM environment variable.\n"),
 160                  COLS, LINES);
 161         exit (1);
 162     }
 163
 164     tcgetattr (fileno (stdin), &boot_mode);
 165     /* 255 = ignore abort char; XCTRL('g') for abort char = ^g */
 166     SLang_init_tty (XCTRL('c'), 1, 0);
 167
 168     /* If SLang uses fileno(stderr) for terminal input MC will hang
 169        if we call SLang_getkey between calls to open_error_pipe and
 170        close_error_pipe, e.g. when we do a growing view of an gzipped
 171        file. */
 172     if (SLang_TT_Read_FD == fileno (stderr))
 173         SLang_TT_Read_FD = fileno (stdin);
 174
 175     if (force_ugly_line_drawing)
 176         SLtt_Has_Alt_Charset = 0;
 177     if (tcgetattr (SLang_TT_Read_FD, &new_mode) == 0) {
 178 #ifdef VDSUSP
 179         new_mode.c_cc[VDSUSP] = NULL_VALUE;   /* to ignore ^Y */
 180 #endif
 181 #ifdef VLNEXT
 182         new_mode.c_cc[VLNEXT] = NULL_VALUE;   /* to ignore ^V */
 183 #endif
 184         tcsetattr (SLang_TT_Read_FD, TCSADRAIN, &new_mode);
 185     }
 186     slang_prog_mode ();
 187     load_terminfo_keys ();
 188     SLtt_Blink_Mode = 0;
 189 }
 190
 191 void
 192 slang_set_raw_mode (void)
 193 {
 194     tcsetattr (SLang_TT_Read_FD, TCSANOW, &new_mode);
 195 }
 196
 197 /* Done each time we come back from done mode */
 198 void
 199 slang_prog_mode (void)
 200 {
 201     tcsetattr (SLang_TT_Read_FD, TCSANOW, &new_mode);
 202     SLsmg_init_smg ();
 203     SLsmg_touch_lines (0, LINES);
 204 }
 205
 206 /* Called each time we want to shutdown slang screen manager */
 207 void
 208 slang_shell_mode (void)
 209 {
 210     tcsetattr (SLang_TT_Read_FD, TCSANOW, &boot_mode);
 211 }
 212
 213 void
 214 slang_shutdown (void)
 215 {
 216     char *op_cap;
 217
 218     slang_shell_mode ();
 219     do_exit_ca_mode ();
 220     SLang_reset_tty ();
 221
 222     /* Load the op capability to reset the colors to those that were
 223      * active when the program was started up
 224      */
 225     op_cap = SLtt_tgetstr ("op");
 226     if (op_cap){
 227         fprintf (stdout, "%s", op_cap);
 228         fflush (stdout);
 229     }
 230 }
 231
 232 /* HP Terminals have capabilities (pfkey, pfloc, pfx) to program function keys.
 233    elm 2.4pl15 invoked with the -K option utilizes these softkeys and the
 234    consequence is that function keys don't work in MC sometimes.
 235    Unfortunately I don't now the one and only escape sequence to turn off
 236    softkeys (elm uses three different capabilities to turn on softkeys and two
 237    capabilities to turn them off).
 238    Among other things elm uses the pair we already use in slang_keypad. That's
 239    the reason why I call slang_reset_softkeys from slang_keypad. In lack of
 240    something better the softkeys are programmed to their defaults from the
 241    termcap/terminfo database.
 242    The escape sequence to program the softkeys is taken from elm and it is
 243    hardcoded because neither slang nor ncurses 4.1 know how to 'printf' this
 244    sequence. -- Norbert
 245  */
 246
 247 static void
 248 slang_reset_softkeys (void)
 249 {
 250     int key;
 251     char *send;
 252     static const char display[] = "                ";
 253     char tmp[BUF_SMALL];
 254
 255     for (key = 1; key < 9; key++) {
 256         g_snprintf (tmp, sizeof (tmp), "k%d", key);
 257         send = (char *) SLtt_tgetstr (tmp);
 258         if (send) {
 259             g_snprintf (tmp, sizeof (tmp), "\033&f%dk%dd%dL%s%s", key,
 260                         (int) (sizeof (display) - 1), (int) strlen (send),
 261                         display, send);
 262             SLtt_write_string (tmp);
 263         }
 264     }
 265 }
 266
 267 /* keypad routines */
 268 void
 269 slang_keypad (int set)
 270 {
 271     char *keypad_string;
 272     extern int reset_hp_softkeys;
 273
 274     keypad_string = (char *) SLtt_tgetstr (set ? "ks" : "ke");
 275     if (keypad_string)
 276         SLtt_write_string (keypad_string);
 277     if (set && reset_hp_softkeys)
 278         slang_reset_softkeys ();
 279 }
 280
 281 void
 282 set_slang_delay (int v)
 283 {
 284     no_slang_delay = v;
 285 }
 286
 287 void
 288 hline (int ch, int len)
 289 {
 290     int last_x, last_y;
 291
 292     last_x = SLsmg_get_column ();
 293     last_y = SLsmg_get_row ();
 294
 295     if (ch == 0)
 296         ch = ACS_HLINE;
 297
 298     if (ch == ACS_HLINE){
 299         SLsmg_draw_hline (len);
 300     } else {
 301         while (len--)
 302             addch (ch);
 303     }
 304     move (last_y, last_x);
 305 }
 306
 307 void
 308 vline (int character, int len)
 309 {
 310     (void) character;
 311     if (!slow_terminal){
 312         SLsmg_draw_vline (len);
 313     } else {
 314         int last_x, last_y, pos = 0;
 315
 316         last_x = SLsmg_get_column ();
 317         last_y = SLsmg_get_row ();
 318
 319         while (len--){
 320             move (last_y + pos++, last_x);
 321             addch (' ');
 322         }
 323         move (last_x, last_y);
 324     }
 325 }
 326
 327 int has_colors (void)
 328 {
 329     const char *terminal = getenv ("TERM");
 330     char *cts = color_terminal_string, *s;
 331     size_t i;
 332
 333     if (force_colors)
 334        SLtt_Use_Ansi_Colors = 1;
 335     if (NULL != getenv ("COLORTERM"))
 336         SLtt_Use_Ansi_Colors = 1;
 337
 338     /* We want to allow overwriding */
 339     if (!disable_colors){
 340       /* check color_terminal_string */
 341       if (*cts)
 342       {
 343         while (*cts)
 344         {
 345           while (*cts == ' ' || *cts == '\t') cts++;
 346
 347           s = cts;
 348           i = 0;
 349
 350           while (*cts && *cts != ',')
 351           {
 352             cts++;
 353             i++;
 354           }
 355           if (i && i == strlen(terminal) && strncmp(s, terminal, i) == 0)
 356             SLtt_Use_Ansi_Colors = 1;
 357
 358           if (*cts == ',') cts++;
 359         }
 360       }
 361     }
 362
 363     /* Setup emulated colors */
 364     if (SLtt_Use_Ansi_Colors){
 365         if (use_colors){
 366             mc_init_pair (A_REVERSE, "black", "white");
 367             mc_init_pair (A_BOLD, "white", "black");
 368         } else {
 369             mc_init_pair (A_REVERSE, "black", "lightgray");
 370             mc_init_pair (A_BOLD, "white", "black");
 371             mc_init_pair (A_BOLD_REVERSE, "white", "lightgray");
 372         }
 373     } else {
 374         SLtt_set_mono (A_BOLD,    NULL, SLTT_BOLD_MASK);
 375         SLtt_set_mono (A_REVERSE, NULL, SLTT_REV_MASK);
 376         SLtt_set_mono (A_BOLD|A_REVERSE, NULL, SLTT_BOLD_MASK | SLTT_REV_MASK);
 377     }
 378     return SLtt_Use_Ansi_Colors;
 379 }
 380
 381 void
 382 attrset (int color)
 383 {
 384     if (!SLtt_Use_Ansi_Colors){
 385         SLsmg_set_color (color);
 386         return;
 387     }
 388
 389     if (color & A_BOLD){
 390         if (color == A_BOLD)
 391             SLsmg_set_color (A_BOLD);
 392         else
 393             SLsmg_set_color ((color & (~A_BOLD)) + 8);
 394         return;
 395     }
 396
 397     if (color == A_REVERSE)
 398         SLsmg_set_color (A_REVERSE);
 399     else
 400         SLsmg_set_color (color);
 401 }
 402
 403 /* This table describes which capabilities we want and which values we
 404  * assign to them.
 405  */
 406 static const struct {
 407     int  key_code;
 408     const char *key_name;
 409 } key_table [] = {
 410     { KEY_F(0),  "k0" },
 411     { KEY_F(1),  "k1" },
 412     { KEY_F(2),  "k2" },
 413     { KEY_F(3),  "k3" },
 414     { KEY_F(4),  "k4" },
 415     { KEY_F(5),  "k5" },
 416     { KEY_F(6),  "k6" },
 417     { KEY_F(7),  "k7" },
 418     { KEY_F(8),  "k8" },
 419     { KEY_F(9),  "k9" },
 420     { KEY_F(10), "k;" },
 421     { KEY_F(11), "F1" },
 422     { KEY_F(12), "F2" },
 423     { KEY_F(13), "F3" },
 424     { KEY_F(14), "F4" },
 425     { KEY_F(15), "F5" },
 426     { KEY_F(16), "F6" },
 427     { KEY_F(17), "F7" },
 428     { KEY_F(18), "F8" },
 429     { KEY_F(19), "F9" },
 430     { KEY_F(20), "FA" },
 431     { KEY_IC,    "kI" },
 432     { KEY_NPAGE, "kN" },
 433     { KEY_PPAGE, "kP" },
 434     { KEY_LEFT,  "kl" },
 435     { KEY_RIGHT, "kr" },
 436     { KEY_UP,    "ku" },
 437     { KEY_DOWN,  "kd" },
 438     { KEY_DC,    "kD" },
 439     { KEY_BACKSPACE, "kb" },
 440     { KEY_HOME,  "kh" },
 441     { KEY_END,   "@7" },
 442     { 0, 0}
 443 };
 444
 445 static void
 446 do_define_key (int code, const char *strcap)
 447 {
 448     char    *seq;
 449
 450     seq = (char *) SLtt_tgetstr ((char*) strcap);
 451     if (seq)
 452         define_sequence (code, seq, MCKEY_NOACTION);
 453 }
 454
 455 static void
 456 load_terminfo_keys (void)
 457 {
 458     int i;
 459
 460     for (i = 0; key_table [i].key_code; i++)
 461         do_define_key (key_table [i].key_code, key_table [i].key_name);
 462 }
 463
 464 int
 465 getch (void)
 466 {
 467     int c;
 468     if (no_slang_delay)
 469         if (SLang_input_pending2 (0) == 0)
 470             return -1;
 471
 472     c = SLang_getkey2 ();
 473     if (c == SLANG_GETKEY_ERROR) {
 474         fprintf (stderr,
 475                  "SLang_getkey returned SLANG_GETKEY_ERROR\n"
 476                  "Assuming EOF on stdin and exiting\n");
 477         exit (1);
 478     }
 479     return c;
 480 }
 481 #endif /* HAVE_SLANG */
 482
 483 void
 484 mc_refresh (void)
 485 {
 486 #ifdef WITH_BACKGROUND
 487     if (!we_are_background)
 488 #endif                          /* WITH_BACKGROUND */
 489         refresh ();
 490 }