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