src/key.c

   1 /* Keyboard support routines.
   2
   3    Copyright (C) 1994,1995 the Free Software Foundation.
   4
   5    Written by: 1994, 1995 Miguel de Icaza.
   6                1994, 1995 Janne Kukonlehto.
   7                1995  Jakub Jelinek.
   8                1997  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  23
  24 #include <config.h>
  25 #include <stdio.h>
  26 #include <sys/types.h>
  27 #include <string.h>
  28 #ifdef HAVE_UNISTD_H
  29 #   include <unistd.h>
  30 #endif
  31 #include <ctype.h>
  32 #include <errno.h>
  33
  34 #include "global.h"
  35 #include "tty.h"
  36 #include "mouse.h"
  37 #include "key.h"
  38 #include "main.h"
  39 #include "win.h"
  40 #include "cons.saver.h"
  41 #include "../vfs/vfs.h"
  42
  43 #ifdef HAVE_TEXTMODE_X11_SUPPORT
  44 #include <X11/Xlib.h>
  45 #endif
  46
  47 #ifdef __linux__
  48 #    if defined(__GLIBC__) && (__GLIBC__ < 2)
  49 #        include <linux/termios.h>      /* This is needed for TIOCLINUX */
  50 #    else
  51 #        include <termios.h>
  52 #    endif
  53 #    include <sys/ioctl.h>
  54 #endif
  55
  56 #define GET_TIME(tv)    (gettimeofday(&tv, (struct timezone *)NULL))
  57 #define DIF_TIME(t1,t2) ((t2.tv_sec -t1.tv_sec) *1000+ \
  58                          (t2.tv_usec-t1.tv_usec)/1000)
  59
  60 /* timeout for old_esc_mode in usec */
  61 #define ESCMODE_TIMEOUT 1000000
  62
  63 int mou_auto_repeat = 100;
  64 int double_click_speed = 250;
  65 int old_esc_mode = 0;
  66
  67 int use_8th_bit_as_meta = 1;
  68
  69 typedef struct key_def {
  70     char ch;                    /* Holds the matching char code */
  71     int code;                   /* The code returned, valid if child == NULL */
  72     struct key_def *next;
  73     struct key_def *child;      /* sequence continuation */
  74     int action;                 /* optional action to be done. Now used only
  75                                    to mark that we are just after the first
  76                                    Escape */
  77 } key_def;
  78
  79 /* This holds all the key definitions */
  80 static key_def *keys = 0;
  81
  82 static int input_fd;
  83 static int disabled_channels = 0; /* Disable channels checking */
  84 static int xgetch_second (void);
  85
  86 /* File descriptor monitoring add/remove routines */
  87 typedef struct SelectList {
  88     int fd;
  89     select_fn callback;
  90     void *info;
  91     struct SelectList *next;
  92 } SelectList;
  93
  94 static SelectList *select_list = 0;
  95
  96 void add_select_channel (int fd, select_fn callback, void *info)
  97 {
  98     SelectList *new;
  99
 100     new = g_new (SelectList, 1);
 101     new->fd = fd;
 102     new->callback = callback;
 103     new->info = info;
 104     new->next = select_list;
 105     select_list = new;
 106 }
 107
 108 void delete_select_channel (int fd)
 109 {
 110     SelectList *p = select_list;
 111     SelectList *p_prev = 0;
 112     SelectList *p_next;
 113
 114     while (p) {
 115         if (p->fd == fd) {
 116             p_next = p->next;
 117
 118             if (p_prev)
 119                 p_prev->next = p_next;
 120             else
 121                 select_list = p_next;
 122
 123             g_free (p);
 124             p = p_next;
 125             continue;
 126         }
 127
 128         p_prev = p;
 129         p = p->next;
 130     }
 131 }
 132
 133 inline static int add_selects (fd_set *select_set)
 134 {
 135     SelectList *p;
 136     int        top_fd = 0;
 137
 138     if (disabled_channels)
 139         return 0;
 140
 141     for (p = select_list; p; p = p->next){
 142         FD_SET (p->fd, select_set);
 143         if (p->fd > top_fd)
 144             top_fd = p->fd;
 145     }
 146     return top_fd;
 147 }
 148
 149 static void check_selects (fd_set *select_set)
 150 {
 151     SelectList *p;
 152
 153     if (disabled_channels)
 154         return;
 155
 156     for (p = select_list; p; p = p->next)
 157         if (FD_ISSET (p->fd, select_set))
 158             (*p->callback)(p->fd, p->info);
 159 }
 160
 161 void channels_down (void)
 162 {
 163     disabled_channels ++;
 164 }
 165
 166 void channels_up (void)
 167 {
 168     if (!disabled_channels)
 169         fprintf (stderr,
 170                  "Error: channels_up called with disabled_channels = 0\n");
 171     disabled_channels--;
 172 }
 173
 174 typedef const struct {
 175     int code;
 176     char *seq;
 177     int action;
 178 } key_define_t;
 179
 180 static key_define_t mc_bindings [] = {
 181     { KEY_END,    ESC_STR ">", MCKEY_NOACTION },
 182     { KEY_HOME,   ESC_STR "<", MCKEY_NOACTION },
 183     { 0, 0, MCKEY_NOACTION },
 184 };
 185
 186 /* Broken terminfo and termcap databases on xterminals */
 187 static key_define_t xterm_key_defines [] = {
 188     { KEY_F(1),   ESC_STR "OP",   MCKEY_NOACTION },
 189     { KEY_F(2),   ESC_STR "OQ",   MCKEY_NOACTION },
 190     { KEY_F(3),   ESC_STR "OR",   MCKEY_NOACTION },
 191     { KEY_F(4),   ESC_STR "OS",   MCKEY_NOACTION },
 192     { KEY_F(1),   ESC_STR "[11~", MCKEY_NOACTION },
 193     { KEY_F(2),   ESC_STR "[12~", MCKEY_NOACTION },
 194     { KEY_F(3),   ESC_STR "[13~", MCKEY_NOACTION },
 195     { KEY_F(4),   ESC_STR "[14~", MCKEY_NOACTION },
 196     { KEY_F(5),   ESC_STR "[15~", MCKEY_NOACTION },
 197     { KEY_F(6),   ESC_STR "[17~", MCKEY_NOACTION },
 198     { KEY_F(7),   ESC_STR "[18~", MCKEY_NOACTION },
 199     { KEY_F(8),   ESC_STR "[19~", MCKEY_NOACTION },
 200     { KEY_F(9),   ESC_STR "[20~", MCKEY_NOACTION },
 201     { KEY_F(10),  ESC_STR "[21~", MCKEY_NOACTION },
 202     { 0, 0, MCKEY_NOACTION },
 203 };
 204
 205 static key_define_t mc_default_keys [] = {
 206     { ESC_CHAR, ESC_STR, MCKEY_ESCAPE },
 207     { ESC_CHAR, ESC_STR ESC_STR, MCKEY_NOACTION },
 208     { 0, 0, MCKEY_NOACTION },
 209 };
 210
 211 static void
 212 define_sequences (key_define_t *kd)
 213 {
 214     int i;
 215
 216     for (i = 0; kd [i].code; i++)
 217         define_sequence(kd [i].code, kd [i].seq, kd [i].action);
 218 }
 219
 220 #ifdef HAVE_TEXTMODE_X11_SUPPORT
 221 static Display *x11_display;
 222 static Window x11_window;
 223 #endif /* HAVE_TEXTMODE_X11_SUPPORT */
 224
 225 /* This has to be called before slang_init or whatever routine
 226    calls any define_sequence */
 227 void init_key (void)
 228 {
 229     char *term = (char *) getenv ("TERM");
 230
 231     /* This has to be the first define_sequence */
 232     /* So, we can assume that the first keys member has ESC */
 233     define_sequences (mc_default_keys);
 234
 235     /* Terminfo on irix does not have some keys */
 236     if ((!strncmp (term, "iris-ansi", 9)) || (!strncmp (term, "xterm", 5)))
 237         define_sequences (xterm_key_defines);
 238
 239     define_sequences (mc_bindings);
 240
 241     /* load some additional keys (e.g. direct Alt-? support) */
 242     load_xtra_key_defines();
 243
 244 #ifdef __QNX__
 245     if (strncmp(term, "qnx", 3) == 0){
 246         /* Modify the default value of use_8th_bit_as_meta: we would
 247          * like to provide a working mc for a newbie who knows nothing
 248          * about [Options|Display bits|Full 8 bits input]...
 249          *
 250          * Don't use 'meta'-bit, when we are dealing with a
 251          * 'qnx*'-type terminal: clear the default value!
 252          * These terminal types use 0xFF as an escape character,
 253          * so use_8th_bit_as_meta==1 must not be enabled!
 254          *
 255          * [mc-4.1.21+,slint.c/getch(): the DEC_8BIT_HACK stuff
 256          * is not used now (doesn't even depend on use_8th_bit_as_meta
 257          * as in mc-3.1.2)...GREAT!...no additional code is required!]
 258          */
 259         use_8th_bit_as_meta = 0;
 260     }
 261 #endif /* __QNX__ */
 262
 263 #ifdef HAVE_TEXTMODE_X11_SUPPORT
 264     x11_display = XOpenDisplay (0);
 265     if (x11_display)
 266         x11_window = DefaultRootWindow (x11_display);
 267 #endif /* HAVE_TEXTMODE_X11_SUPPORT */
 268 }
 269
 270 /* This has to be called after SLang_init_tty/slint_init */
 271 void init_key_input_fd (void)
 272 {
 273 #ifdef HAVE_SLANG
 274     input_fd = SLang_TT_Read_FD;
 275 #endif
 276 }
 277
 278
 279 static void
 280 xmouse_get_event (Gpm_Event *ev)
 281 {
 282     int btn;
 283     static struct timeval tv1 = { 0, 0 }; /* Force first click as single */
 284     static struct timeval tv2;
 285     static int clicks;
 286     static int last_btn = 0;
 287
 288     /* Decode Xterm mouse information to a GPM style event */
 289
 290     /* Variable btn has following meaning: */
 291     /* 0 = btn1 dn, 1 = btn2 dn, 2 = btn3 dn, 3 = btn up */
 292     btn = getch () - 32;
 293
 294     /* There seems to be no way of knowing which button was released */
 295     /* So we assume all the buttons were released */
 296
 297     if (btn == 3){
 298         if (last_btn) {
 299             ev->type = GPM_UP | (GPM_SINGLE << clicks);
 300             ev->buttons = 0;
 301             last_btn = 0;
 302             GET_TIME (tv1);
 303             clicks = 0;
 304         } else {
 305             /* Bogus event, maybe mouse wheel */
 306             ev->type = 0;
 307         }
 308     } else {
 309         ev->type = GPM_DOWN;
 310         GET_TIME (tv2);
 311         if (tv1.tv_sec && (DIF_TIME (tv1,tv2) < double_click_speed)){
 312             clicks++;
 313             clicks %= 3;
 314         } else
 315             clicks = 0;
 316
 317         switch (btn) {
 318         case 0:
 319             ev->buttons = GPM_B_LEFT;
 320             break;
 321         case 1:
 322             ev->buttons = GPM_B_MIDDLE;
 323             break;
 324         case 2:
 325             ev->buttons = GPM_B_RIGHT;
 326             break;
 327         case 64:
 328             ev->buttons = GPM_B_UP;
 329             break;
 330         case 65:
 331             ev->buttons = GPM_B_DOWN;
 332             break;
 333         default:
 334             /* Nothing */
 335             ev->type = 0;
 336             ev->buttons = 0;
 337             break;
 338         }
 339         last_btn = ev->buttons;
 340     }
 341     /* Coordinates are 33-based */
 342     /* Transform them to 1-based */
 343     ev->x = getch () - 32;
 344     ev->y = getch () - 32;
 345 }
 346
 347 static key_def *create_sequence (char *seq, int code, int action)
 348 {
 349     key_def *base, *p, *attach;
 350
 351     for (base = attach = NULL; *seq; seq++){
 352         p = g_new (key_def, 1);
 353         if (!base) base = p;
 354         if (attach) attach->child = p;
 355
 356         p->ch   = *seq;
 357         p->code = code;
 358         p->child = p->next = NULL;
 359         if (!seq[1])
 360             p->action = action;
 361         else
 362             p->action = MCKEY_NOACTION;
 363         attach = p;
 364     }
 365     return base;
 366 }
 367
 368 /* The maximum sequence length (32 + null terminator) */
 369 #define SEQ_BUFFER_LEN 33
 370 static int seq_buffer [SEQ_BUFFER_LEN];
 371 static int *seq_append = 0;
 372
 373 static int push_char (int c)
 374 {
 375     if (!seq_append)
 376         seq_append = seq_buffer;
 377
 378     if (seq_append == &(seq_buffer [SEQ_BUFFER_LEN-2]))
 379         return 0;
 380     *(seq_append++) = c;
 381     *seq_append = 0;
 382     return 1;
 383 }
 384
 385 /*
 386  * Return 1 on success, 0 on error.
 387  * An error happens if SEQ is a beginning of an existing longer sequence.
 388  */
 389 int define_sequence (int code, char *seq, int action)
 390 {
 391     key_def *base;
 392
 393     if (strlen (seq) > SEQ_BUFFER_LEN-1)
 394         return 0;
 395
 396     for (base = keys; (base != 0) && *seq; ){
 397         if (*seq == base->ch){
 398             if (base->child == 0){
 399                 if (*(seq+1)){
 400                     base->child = create_sequence (seq+1, code, action);
 401                     return 1;
 402                 } else {
 403                     /* The sequence matches an existing one.  */
 404                     base->code = code;
 405                     base->action = action;
 406                     return 1;
 407                 }
 408             } else {
 409                 base = base->child;
 410                 seq++;
 411             }
 412         } else {
 413             if (base->next)
 414                 base = base->next;
 415             else {
 416                 base->next = create_sequence (seq, code, action);
 417                 return 1;
 418             }
 419         }
 420     }
 421
 422     if (!*seq) {
 423         /* Attempt to redefine a sequence with a shorter sequence.  */
 424         return 0;
 425     }
 426
 427     keys = create_sequence (seq, code, action);
 428     return 1;
 429 }
 430
 431 static int *pending_keys;
 432
 433 static int
 434 correct_key_code (int c)
 435 {
 436     /* This is needed on some OS that do not support ncurses and */
 437     /* do some magic after read()ing the data */
 438     if (c == '\r')
 439         return '\n';
 440
 441 #ifdef IS_AIX
 442     if (c == KEY_SCANCEL)
 443         return '\t';
 444 #endif
 445
 446     if (c == KEY_F(0))
 447         return KEY_F(10);
 448
 449     if (!alternate_plus_minus)
 450         switch (c) {
 451             case KEY_KP_ADD: c = '+'; break;
 452             case KEY_KP_SUBTRACT: c = '-'; break;
 453             case KEY_KP_MULTIPLY: c = '*'; break;
 454         }
 455
 456     return c;
 457 }
 458
 459 int get_key_code (int no_delay)
 460 {
 461     int c;
 462     static key_def *this = NULL, *parent;
 463     static struct timeval esctime = { -1, -1 };
 464     static int lastnodelay = -1;
 465
 466     if (no_delay != lastnodelay) {
 467         this = NULL;
 468         lastnodelay = no_delay;
 469     }
 470
 471  pend_send:
 472     if (pending_keys){
 473         int d = *pending_keys++;
 474  check_pend:
 475         if (!*pending_keys){
 476             pending_keys = 0;
 477             seq_append = 0;
 478         }
 479         if (d == ESC_CHAR && pending_keys){
 480             d = ALT(*pending_keys++);
 481             goto check_pend;
 482         }
 483         if ((d & 0x80) && use_8th_bit_as_meta)
 484             d = ALT(d & 0x7f);
 485         this = NULL;
 486         return correct_key_code (d);
 487     }
 488
 489  nodelay_try_again:
 490     if (no_delay) {
 491         nodelay (stdscr, TRUE);
 492     }
 493     c = getch ();
 494 #if defined(USE_NCURSES) && defined(KEY_RESIZE)
 495     if (c == KEY_RESIZE)
 496         goto nodelay_try_again;
 497 #endif
 498     if (no_delay) {
 499         nodelay (stdscr, FALSE);
 500         if (c == ERR) {
 501             if (this != NULL && parent != NULL &&
 502                 parent->action == MCKEY_ESCAPE && old_esc_mode) {
 503                 struct timeval current, timeout;
 504
 505                 if (esctime.tv_sec == -1)
 506                     return ERR;
 507                 GET_TIME (current);
 508                 timeout.tv_sec = ESCMODE_TIMEOUT / 1000000 + esctime.tv_sec;
 509                 timeout.tv_usec = ESCMODE_TIMEOUT % 1000000 + esctime.tv_usec;
 510                 if (timeout.tv_usec > 1000000) {
 511                     timeout.tv_usec -= 1000000;
 512                     timeout.tv_sec++;
 513                 }
 514                 if (current.tv_sec < timeout.tv_sec)
 515                     return ERR;
 516                 if (current.tv_sec == timeout.tv_sec &&
 517                     current.tv_usec < timeout.tv_usec)
 518                     return ERR;
 519                 this = NULL;
 520                 pending_keys = seq_append = NULL;
 521                 return ESC_CHAR;
 522             }
 523             return ERR;
 524         }
 525     } else if (c == ERR){
 526         /* Maybe we got an incomplete match.
 527            This we do only in delay mode, since otherwise
 528            getch can return ERR at any time. */
 529         if (seq_append) {
 530             pending_keys = seq_buffer;
 531             goto pend_send;
 532         }
 533         this = NULL;
 534         return ERR;
 535     }
 536
 537     /* Search the key on the root */
 538     if (!no_delay || this == NULL) {
 539         this = keys;
 540         parent = NULL;
 541
 542         if ((c & 0x80) && use_8th_bit_as_meta) {
 543             c &= 0x7f;
 544
 545             /* The first sequence defined starts with esc */
 546             parent = keys;
 547             this = keys->child;
 548         }
 549     }
 550     while (this){
 551         if (c == this->ch){
 552             if (this->child){
 553                 if (!push_char (c)){
 554                     pending_keys = seq_buffer;
 555                     goto pend_send;
 556                 }
 557                 parent = this;
 558                 this = this->child;
 559                 if (parent->action == MCKEY_ESCAPE && old_esc_mode) {
 560                     if (no_delay) {
 561                         GET_TIME (esctime);
 562                         if (this == NULL) {
 563                             /* Shouldn't happen */
 564                             fprintf (stderr, "Internal error\n");
 565                             exit (1);
 566                         }
 567                         goto nodelay_try_again;
 568                     }
 569                     esctime.tv_sec = -1;
 570                     c = xgetch_second ();
 571                     if (c == ERR) {
 572                         pending_keys = seq_append = NULL;
 573                         this = NULL;
 574                         return ESC_CHAR;
 575                     }
 576                 } else {
 577                     if (no_delay)
 578                         goto nodelay_try_again;
 579                     c = getch ();
 580                 }
 581             } else {
 582                 /* We got a complete match, return and reset search */
 583                 int code;
 584
 585                 pending_keys = seq_append = NULL;
 586                 code = this->code;
 587                 this = NULL;
 588                 return correct_key_code (code);
 589             }
 590         } else {
 591             if (this->next)
 592                 this = this->next;
 593             else {
 594                 if (parent != NULL && parent->action == MCKEY_ESCAPE) {
 595                     /* This is just to save a lot of define_sequences */
 596                     if (isalpha(c)
 597                         || (c == '\n') || (c == '\t') || (c == XCTRL('h'))
 598                         || (c == KEY_BACKSPACE) || (c == '!') || (c == '\r')
 599                         || c == 127 || c == '+' || c == '-' || c == '\\'
 600                         || c == '?')
 601                         c = ALT(c);
 602                     else if (isdigit(c))
 603                         c = KEY_F (c-'0');
 604                     else if (c == ' ')
 605                         c = ESC_CHAR;
 606                     pending_keys = seq_append = NULL;
 607                     this = NULL;
 608                     return correct_key_code (c);
 609                 }
 610                 /* Did not find a match or {c} was changed in the if above,
 611                    so we have to return everything we had skipped
 612                  */
 613                 push_char (c);
 614                 pending_keys = seq_buffer;
 615                 goto pend_send;
 616             }
 617         }
 618     }
 619     this = NULL;
 620     return correct_key_code (c);
 621 }
 622
 623 /* If set timeout is set, then we wait 0.1 seconds, else, we block */
 624 static void
 625 try_channels (int set_timeout)
 626 {
 627     struct timeval timeout;
 628     static fd_set select_set;
 629     struct timeval *timeptr;
 630     int v;
 631     int maxfdp;
 632
 633     while (1){
 634         FD_ZERO (&select_set);
 635         FD_SET  (input_fd, &select_set);        /* Add stdin */
 636         maxfdp = max (add_selects (&select_set), input_fd);
 637
 638         if (set_timeout){
 639             timeout.tv_sec = 0;
 640             timeout.tv_usec = 100000;
 641             timeptr = &timeout;
 642         } else
 643             timeptr = 0;
 644
 645         v = select (maxfdp + 1, &select_set, NULL, NULL, timeptr);
 646         if (v > 0){
 647             check_selects (&select_set);
 648             if (FD_ISSET (input_fd, &select_set))
 649                 return;
 650         }
 651     }
 652 }
 653
 654 /* Workaround for System V Curses vt100 bug */
 655 static int getch_with_delay (void)
 656 {
 657     int c;
 658
 659     /* This routine could be used on systems without mouse support,
 660        so we need to do the select check :-( */
 661     while (1){
 662         if (!pending_keys)
 663             try_channels (0);
 664
 665         /* Try to get a character */
 666         c = get_key_code (0);
 667         if (c != ERR)
 668             break;
 669         /* Failed -> wait 0.1 secs and try again */
 670         try_channels (1);
 671     }
 672     /* Success -> return the character */
 673     return c;
 674 }
 675
 676 extern int max_dirt_limit;
 677
 678 /* Returns a character read from stdin with appropriate interpretation */
 679 /* Also takes care of generated mouse events */
 680 /* Returns EV_MOUSE if it is a mouse event */
 681 /* Returns EV_NONE  if non-blocking or interrupt set and nothing was done */
 682 int
 683 get_event (Gpm_Event * event, int redo_event, int block)
 684 {
 685     int c;
 686     static int flag;            /* Return value from select */
 687 #ifdef HAVE_LIBGPM
 688     static Gpm_Event ev;        /* Mouse event */
 689 #endif
 690     struct timeval timeout;
 691     struct timeval *time_addr = NULL;
 692     static int dirty = 3;
 693
 694     if ((dirty == 3) || is_idle ()) {
 695         mc_refresh ();
 696         doupdate ();
 697         dirty = 1;
 698     } else
 699         dirty++;
 700
 701     vfs_timeout_handler ();
 702
 703     /* Ok, we use (event->x < 0) to signal that the event does not contain
 704        a suitable position for the mouse, so we can't use show_mouse_pointer
 705        on it.
 706      */
 707     if (event->x > 0) {
 708         show_mouse_pointer (event->x, event->y);
 709         if (!redo_event)
 710             event->x = -1;
 711     }
 712
 713     /* Repeat if using mouse */
 714     while (mouse_enabled && !pending_keys) {
 715         int maxfdp;
 716         fd_set select_set;
 717
 718         FD_ZERO (&select_set);
 719         FD_SET (input_fd, &select_set);
 720         maxfdp = max (add_selects (&select_set), input_fd);
 721
 722 #ifdef HAVE_LIBGPM
 723         if (use_mouse_p == MOUSE_GPM) {
 724             if (gpm_fd == -1) {
 725                 /* Connection to gpm broken, possibly gpm has died */
 726                 mouse_enabled = 0;
 727                 use_mouse_p = MOUSE_NONE;
 728                 break;
 729             }
 730             FD_SET (gpm_fd, &select_set);
 731             maxfdp = max (maxfdp, gpm_fd);
 732         }
 733 #endif
 734
 735         if (redo_event) {
 736             timeout.tv_usec = mou_auto_repeat * 1000;
 737             timeout.tv_sec = 0;
 738
 739             time_addr = &timeout;
 740         } else {
 741             int seconds;
 742
 743             if ((seconds = vfs_timeouts ())) {
 744                 /* the timeout could be improved and actually be
 745                  * the number of seconds until the next vfs entry
 746                  * timeouts in the stamp list.
 747                  */
 748
 749                 timeout.tv_sec = seconds;
 750                 timeout.tv_usec = 0;
 751                 time_addr = &timeout;
 752             } else
 753                 time_addr = NULL;
 754         }
 755
 756         if (!block) {
 757             time_addr = &timeout;
 758             timeout.tv_sec = 0;
 759             timeout.tv_usec = 0;
 760         }
 761         enable_interrupt_key ();
 762         flag = select (maxfdp + 1, &select_set, NULL, NULL, time_addr);
 763         disable_interrupt_key ();
 764
 765         /* select timed out: it could be for any of the following reasons:
 766          * redo_event -> it was because of the MOU_REPEAT handler
 767          * !block     -> we did not block in the select call
 768          * else       -> 10 second timeout to check the vfs status.
 769          */
 770         if (flag == 0) {
 771             if (redo_event)
 772                 return EV_MOUSE;
 773             if (!block)
 774                 return EV_NONE;
 775             vfs_timeout_handler ();
 776         }
 777         if (flag == -1 && errno == EINTR)
 778             return EV_NONE;
 779
 780         check_selects (&select_set);
 781
 782         if (FD_ISSET (input_fd, &select_set))
 783             break;
 784 #ifdef HAVE_LIBGPM
 785         if (use_mouse_p == MOUSE_GPM && FD_ISSET (gpm_fd, &select_set)) {
 786             Gpm_GetEvent (&ev);
 787             Gpm_FitEvent (&ev);
 788             *event = ev;
 789             return EV_MOUSE;
 790         }
 791 #endif                          /* !HAVE_LIBGPM */
 792     }
 793 #ifndef HAVE_SLANG
 794     flag = is_wintouched (stdscr);
 795     untouchwin (stdscr);
 796 #endif                          /* !HAVE_SLANG */
 797     c = block ? getch_with_delay () : get_key_code (1);
 798
 799 #ifndef HAVE_SLANG
 800     if (flag)
 801         touchwin (stdscr);
 802 #endif                          /* !HAVE_SLANG */
 803
 804     if (c == MCKEY_MOUSE
 805 #ifdef KEY_MOUSE
 806         || c == KEY_MOUSE
 807 #endif                          /* KEY_MOUSE */
 808         ) {
 809         /* Mouse event */
 810         xmouse_get_event (event);
 811         if (event->type)
 812             return EV_MOUSE;
 813         else
 814             return EV_NONE;
 815     }
 816
 817     return c;
 818 }
 819
 820 /* Returns a key press, mouse events are discarded */
 821 int mi_getch ()
 822 {
 823     Gpm_Event ev;
 824     int       key;
 825
 826     ev.x = -1;
 827     while ((key = get_event (&ev, 0, 1)) == EV_NONE)
 828         ;
 829     return key;
 830 }
 831
 832 static int xgetch_second (void)
 833 {
 834     fd_set Read_FD_Set;
 835     int c;
 836     struct timeval timeout;
 837
 838     timeout.tv_sec = ESCMODE_TIMEOUT / 1000000;
 839     timeout.tv_usec = ESCMODE_TIMEOUT % 1000000;
 840     nodelay (stdscr, TRUE);
 841     FD_ZERO (&Read_FD_Set);
 842     FD_SET (input_fd, &Read_FD_Set);
 843     select (input_fd + 1, &Read_FD_Set, NULL, NULL, &timeout);
 844     c = getch ();
 845     nodelay (stdscr, FALSE);
 846     return c;
 847 }
 848
 849 static void
 850 learn_store_key (char *buffer, char **p, int c)
 851 {
 852     if (*p - buffer > 253)
 853         return;
 854     if (c == ESC_CHAR) {
 855         *(*p)++ = '\\';
 856         *(*p)++ = 'e';
 857     } else if (c < ' ') {
 858         *(*p)++ = '^';
 859         *(*p)++ = c + 'a' - 1;
 860     } else if (c == '^') {
 861         *(*p)++ = '^';
 862         *(*p)++ = '^';
 863     } else
 864         *(*p)++ = (char) c;
 865 }
 866
 867 char *learn_key (void)
 868 {
 869 /* LEARN_TIMEOUT in usec */
 870 #define LEARN_TIMEOUT 200000
 871
 872     fd_set Read_FD_Set;
 873     struct timeval endtime;
 874     struct timeval timeout;
 875     int c;
 876     char buffer [256];
 877     char *p = buffer;
 878
 879     keypad(stdscr, FALSE); /* disable intepreting keys by ncurses */
 880     c = getch ();
 881     while (c == ERR)
 882         c = getch (); /* Sanity check, should be unnecessary */
 883     learn_store_key (buffer, &p, c);
 884     GET_TIME (endtime);
 885     endtime.tv_usec += LEARN_TIMEOUT;
 886     if (endtime.tv_usec > 1000000) {
 887         endtime.tv_usec -= 1000000;
 888         endtime.tv_sec++;
 889     }
 890     nodelay (stdscr, TRUE);
 891     for (;;) {
 892         while ((c = getch ()) == ERR) {
 893             GET_TIME (timeout);
 894             timeout.tv_usec = endtime.tv_usec - timeout.tv_usec;
 895             if (timeout.tv_usec < 0)
 896                 timeout.tv_sec++;
 897             timeout.tv_sec = endtime.tv_sec - timeout.tv_sec;
 898             if (timeout.tv_sec >= 0 && timeout.tv_usec > 0) {
 899                 FD_ZERO (&Read_FD_Set);
 900                 FD_SET (input_fd, &Read_FD_Set);
 901                 select (input_fd + 1, &Read_FD_Set, NULL, NULL, &timeout);
 902             } else
 903                 break;
 904         }
 905         if (c == ERR)
 906             break;
 907         learn_store_key (buffer, &p, c);
 908     }
 909     keypad(stdscr, TRUE);
 910     nodelay (stdscr, FALSE);
 911     *p = 0;
 912     return g_strdup (buffer);
 913 }
 914
 915 /* xterm and linux console only: set keypad to numeric or application
 916    mode. Only in application keypad mode it's possible to distinguish
 917    the '+' key and the '+' on the keypad ('*' and '-' ditto)*/
 918 void
 919 numeric_keypad_mode (void)
 920 {
 921     if (console_flag || xterm_flag) {
 922         fprintf (stdout, "\033>");
 923         fflush (stdout);
 924     }
 925 }
 926
 927 void
 928 application_keypad_mode (void)
 929 {
 930     if (console_flag || xterm_flag) {
 931         fprintf (stdout, "\033=");
 932         fflush (stdout);
 933     }
 934 }
 935
 936
 937 /* A function to check if we're idle.
 938    Currently checks only for key presses.
 939    We could also check the mouse. */
 940 int is_idle (void)
 941 {
 942     /* Check for incoming key presses     *
 943      * If there are any we say we're busy */
 944
 945     fd_set select_set;
 946     struct timeval timeout;
 947     FD_ZERO (&select_set);
 948     FD_SET (0, &select_set);
 949     timeout.tv_sec = 0;
 950     timeout.tv_usec = 0;
 951     select (1, &select_set, 0, 0, &timeout);
 952     return ! FD_ISSET (0, &select_set);
 953 }
 954
 955
 956 int
 957 get_modifier (void)
 958 {
 959 #ifdef HAVE_TEXTMODE_X11_SUPPORT
 960     if (x11_display) {
 961         Window root, child;
 962         int root_x, root_y;
 963         int win_x, win_y;
 964         unsigned int mask;
 965         Bool b;
 966         int result = 0;
 967
 968         b = XQueryPointer(x11_display, x11_window, &root, &child,
 969                                   &root_x, &root_y,
 970                                   &win_x, &win_y,
 971                                   &mask);
 972
 973         if (mask & ShiftMask)
 974             result |= SHIFT_PRESSED;
 975         if (mask & ControlMask)
 976             result |= CONTROL_PRESSED;
 977         return result;
 978     } else
 979 #endif
 980 #ifdef __linux__
 981     {
 982         unsigned char modifiers;
 983
 984         modifiers = 6;
 985
 986         if (ioctl (0, TIOCLINUX, &modifiers) < 0)
 987             return 0;
 988
 989         return (int) modifiers;
 990     }
 991 #else
 992     return 0;
 993 #endif
 994 }
 995
 996 int
 997 ctrl_pressed (void)
 998 {
 999     if (get_modifier () & CONTROL_PRESSED)
1000         return 1;
1001     else
1002         return 0;
1003 }
1004
1005 static void k_dispose (key_def *k)
1006 {
1007     if (!k)
1008         return;
1009     k_dispose (k->child);
1010     k_dispose (k->next);
1011     g_free (k);
1012 }
1013
1014 static void s_dispose (SelectList *sel)
1015 {
1016     if (!sel)
1017         return;
1018
1019     s_dispose (sel->next);
1020     g_free (sel);
1021 }
1022
1023 void done_key ()
1024 {
1025     k_dispose (keys);
1026     s_dispose (select_list);
1027
1028 #ifdef HAVE_TEXTMODE_X11_SUPPORT
1029     if (x11_display)
1030         XCloseDisplay (x11_display);
1031 #endif /* HAVE_TEXTMODE_X11_SUPPORT */
1032 }