crawl-ref/source/cio.cc

   1 /*
   2  *  File:       cio.cc
   3  *  Summary:    Platform-independent console IO functions.
   4  *  Created by: dshaligram on Wed Jun 20 19:00:52 2007 UTC
   5  */
   6
   7 #include "AppHdr.h"
   8
   9 #include "cio.h"
  10 #include "externs.h"
  11 #include "options.h"
  12 #include "libutil.h"
  13 #include "macro.h"
  14 #include "message.h"
  15 #include "state.h"
  16 #include "viewgeom.h"
  17
  18 #include <queue>
  19
  20 #ifdef UNIX
  21 extern int unixcurses_get_vi_key(int keyin);
  22
  23 static keycode_type _numpad2vi(keycode_type key)
  24 {
  25 #ifndef USE_TILE
  26     key = unixcurses_get_vi_key(key);
  27 #endif
  28     switch (key)
  29     {
  30     case CK_UP:    key = 'k'; break;
  31     case CK_DOWN:  key = 'j'; break;
  32     case CK_LEFT:  key = 'h'; break;
  33     case CK_RIGHT: key = 'l'; break;
  34     case 1001:     key = 'b'; break;
  35     case 1002:     key = 'j'; break;
  36     case 1003:     key = 'n'; break;
  37     case 1004:     key = 'h'; break;
  38     case 1005:     key = '.'; break;
  39     case 1006:     key = 'l'; break;
  40     case 1007:     key = 'y'; break;
  41     case 1008:     key = 'k'; break;
  42     case 1009:     key = 'u'; break;
  43     }
  44     if (key >= '1' && key <= '9')
  45     {
  46         const char *vikeys = "bjnh.lyku";
  47         return keycode_type(vikeys[key - '1']);
  48     }
  49     return (key);
  50 }
  51 #endif
  52
  53 int unmangle_direction_keys(int keyin, KeymapContext keymap,
  54                             bool fake_ctrl, bool fake_shift)
  55 {
  56 #ifdef UNIX
  57     // Kludging running and opening as two character sequences
  58     // for Unix systems.  This is an easy way out... all the
  59     // player has to do is find a termcap and numlock setting
  60     // that will get curses the numbers from the keypad.  This
  61     // will hopefully be easy.
  62
  63     /* can we say yuck? -- haranp */
  64     if (fake_ctrl && keyin == '*')
  65     {
  66         keyin = getchm(keymap);
  67         // return control-key
  68         keyin = CONTROL(toupper(_numpad2vi(keyin)));
  69     }
  70     else if (fake_shift && keyin == '/')
  71     {
  72         keyin = getchm(keymap);
  73         // return shift-key
  74         keyin = toupper(_numpad2vi(keyin));
  75     }
  76 #else
  77     // Old DOS keypad support
  78     if (keyin == 0)
  79     {
  80         /* FIXME haranp - hackiness */
  81         const char DOSidiocy[10]     = { "OPQKSMGHI" };
  82         const char DOSunidiocy[10]   = { "bjnh.lyku" };
  83         const int DOScontrolidiocy[9] =
  84         {
  85             117, 145, 118, 115, 76, 116, 119, 141, 132
  86         };
  87         keyin = getchm(keymap);
  88         for (int j = 0; j < 9; ++j)
  89         {
  90             if (keyin == DOSidiocy[j])
  91             {
  92                 keyin = DOSunidiocy[j];
  93                 break;
  94             }
  95             if (keyin == DOScontrolidiocy[j])
  96             {
  97                 keyin = CONTROL(toupper(DOSunidiocy[j]));
  98                 break;
  99             }
 100         }
 101     }
 102 #endif
 103
 104     // [dshaligram] More lovely keypad mangling.
 105     switch (keyin)
 106     {
 107 #ifdef UNIX
 108     case '1': return 'b';
 109     case '2': return 'j';
 110     case '3': return 'n';
 111     case '4': return 'h';
 112     case '6': return 'l';
 113     case '7': return 'y';
 114     case '8': return 'k';
 115     case '9': return 'u';
 116
 117  #ifndef USE_TILE
 118     default: return unixcurses_get_vi_key(keyin);
 119  #endif
 120
 121 #else
 122     case '1': return 'B';
 123     case '2': return 'J';
 124     case '3': return 'N';
 125     case '4': return 'H';
 126     case '6': return 'L';
 127     case '7': return 'Y';
 128     case '8': return 'K';
 129     case '9': return 'U';
 130 #endif
 131     }
 132
 133     return (keyin);
 134 }
 135
 136 // Wrapper around cgotoxy that can draw a fake cursor for Unix terms where
 137 // cursoring over darkgrey or black causes problems.
 138 void cursorxy(int x, int y)
 139 {
 140 #if defined(USE_TILE)
 141     coord_def ep(x, y);
 142     coord_def gc = crawl_view.screen2grid(ep);
 143     tiles.place_cursor(CURSOR_MOUSE, gc);
 144 #elif defined(UNIX)
 145     if (Options.use_fake_cursor)
 146         fakecursorxy(x, y);
 147     else
 148         cgotoxy(x, y, GOTO_CRT);
 149 #else
 150     cgotoxy(x, y, GOTO_CRT);
 151 #endif
 152 }
 153
 154 // cprintf that stops outputting when wrapped
 155 // Conceptually very similar to wrapcprintf()
 156 int nowrapcprintf(int wrapcol, const char *s, ...)
 157 {
 158     char buf[1000]; // Hard max
 159
 160     va_list args;
 161     va_start(args, s);
 162     // XXX: If snprintf isn't available, vsnprintf probably isn't, either.
 163     const int len = vsnprintf(buf, sizeof buf, s, args);
 164     va_end(args);
 165
 166     // Sanity checking to prevent buffer overflows
 167     const int maxlen = std::min(std::max(wrapcol + 1 - wherex(), 0), len);
 168
 169     // Force the string to terminate at maxlen
 170     buf[maxlen] = 0;
 171
 172     cprintf("%s", buf);
 173     return std::min(len, maxlen);
 174 }
 175
 176 // convenience wrapper (hah) for nowrapcprintf
 177 // FIXME: should pass off to nowrapcprintf() instead of doing it manually
 178 int nowrap_eol_cprintf(const char *s, ...)
 179 {
 180     const int wrapcol = get_number_of_cols() - 1;
 181     char buf[1000]; // Hard max
 182
 183     va_list args;
 184     va_start(args, s);
 185     // XXX: If snprintf isn't available, vsnprintf probably isn't, either.
 186     const int len = vsnprintf(buf, sizeof buf, s, args);
 187     va_end(args);
 188
 189     // Sanity checking to prevent buffer overflows
 190     const int maxlen = std::min(std::max(wrapcol + 1 - wherex(), 0), len);
 191
 192     // Force the string to terminate at maxlen
 193     buf[maxlen] = 0;
 194
 195     cprintf("%s", buf);
 196     return std::min(len, maxlen);
 197 }
 198
 199 // cprintf that knows how to wrap down lines (primitive, but what the heck)
 200 int wrapcprintf(int wrapcol, const char *s, ...)
 201 {
 202     char buf[1000]; // Hard max
 203     va_list args;
 204     va_start(args, s);
 205
 206     // XXX: If snprintf isn't available, vsnprintf probably isn't, either.
 207     int len = vsnprintf(buf, sizeof buf, s, args);
 208     int olen = len;
 209     va_end(args);
 210
 211     char *run = buf;
 212     while (len > 0)
 213     {
 214         int x = wherex(), y = wherey();
 215
 216         if (x > wrapcol) // Somebody messed up!
 217             return 0;
 218
 219         int avail = wrapcol - x + 1;
 220         int c = 0;
 221         if (len > avail)
 222         {
 223             c = run[avail];
 224             run[avail] = 0;
 225         }
 226         cprintf("%s", run);
 227
 228         if (len > avail)
 229             run[avail] = c;
 230
 231         if ((len -= avail) > 0)
 232             cgotoxy(1, y + 1);
 233         run += avail;
 234     }
 235     return (olen);
 236 }
 237
 238 int cancelable_get_line(char *buf, int len, input_history *mh,
 239                         int (*keyproc)(int &ch))
 240 {
 241     flush_prev_message();
 242
 243     mouse_control mc(MOUSE_MODE_MORE);
 244     line_reader reader(buf, len, get_number_of_cols());
 245     reader.set_input_history(mh);
 246     reader.set_keyproc(keyproc);
 247
 248     return reader.read_line();
 249 }
 250
 251
 252 /////////////////////////////////////////////////////////////
 253 // input_history
 254 //
 255
 256 input_history::input_history(size_t size)
 257     : history(), pos(), maxsize(size)
 258 {
 259     if (maxsize < 2)
 260         maxsize = 2;
 261
 262     pos = history.end();
 263 }
 264
 265 void input_history::new_input(const std::string &s)
 266 {
 267     history.remove(s);
 268
 269     if (history.size() == maxsize)
 270         history.pop_front();
 271
 272     history.push_back(s);
 273
 274     // Force the iterator to the end (also revalidates it)
 275     go_end();
 276 }
 277
 278 const std::string *input_history::prev()
 279 {
 280     if (history.empty())
 281         return NULL;
 282
 283     if (pos == history.begin())
 284         pos = history.end();
 285
 286     return &*--pos;
 287 }
 288
 289 const std::string *input_history::next()
 290 {
 291     if (history.empty())
 292         return NULL;
 293
 294     if (pos == history.end() || ++pos == history.end())
 295         pos = history.begin();
 296
 297     return &*pos;
 298 }
 299
 300 void input_history::go_end()
 301 {
 302     pos = history.end();
 303 }
 304
 305 void input_history::clear()
 306 {
 307     history.clear();
 308     go_end();
 309 }
 310
 311 /////////////////////////////////////////////////////////////////////////
 312 // line_reader
 313
 314 line_reader::line_reader(char *buf, size_t sz, int wrap)
 315     : buffer(buf), bufsz(sz), history(NULL), region(GOTO_CRT),
 316       start(coord_def(0,0)), keyfn(NULL), wrapcol(wrap),
 317       cur(NULL), length(0), pos(-1)
 318 {
 319 }
 320
 321 line_reader::~line_reader()
 322 {
 323 }
 324
 325 std::string line_reader::get_text() const
 326 {
 327     return (buffer);
 328 }
 329
 330 void line_reader::set_input_history(input_history *i)
 331 {
 332     history = i;
 333 }
 334
 335 void line_reader::set_keyproc(keyproc fn)
 336 {
 337     keyfn = fn;
 338 }
 339
 340 void line_reader::cursorto(int ncx)
 341 {
 342     int x = (start.x + ncx - 1) % wrapcol + 1;
 343     int y = start.y + (start.x + ncx - 1) / wrapcol;
 344     int diff = y - cgetsize(region).y;
 345     if (diff > 0)
 346     {
 347         // There's no space left in the region, so we scroll it.
 348         // XXX: cscroll only implemented for GOTO_MSG.
 349         // XXX: wrapcprintf works in GOTO_SCREEN; in particular
 350         //      it wraps to the screen's first column, so this
 351         //      won't work for regions that don't start at the
 352         //      left edge.
 353         cscroll(diff, region);
 354         start.y -= diff;
 355         y -= diff;
 356         cgotoxy(start.x, start.y, region);
 357         wrapcprintf(wrapcol, "%s", buffer);
 358     }
 359     cgotoxy(x, y, region);
 360 }
 361
 362 int line_reader::read_line(bool clear_previous)
 363 {
 364     if (bufsz <= 0)
 365         return (false);
 366
 367     cursor_control con(true);
 368
 369     if (clear_previous)
 370         *buffer = 0;
 371
 372     region = get_cursor_region();
 373     start = cgetpos(region);
 374
 375     length = strlen(buffer);
 376
 377     // Remember the previous cursor position, if valid.
 378     if (pos < 0 || pos > length)
 379         pos = length;
 380
 381     cur = buffer + pos;
 382
 383     if (length)
 384         wrapcprintf(wrapcol, "%s", buffer);
 385
 386     if (pos != length)
 387         cursorto(pos);
 388
 389     if (history)
 390         history->go_end();
 391
 392     while (true)
 393     {
 394         int ch = getchm(getch_ck);
 395
 396 #if defined(USE_UNIX_SIGNALS) && defined(SIGHUP_SAVE) && defined(USE_CURSES)
 397         // Don't return a partial string if a HUP signal interrupted things
 398         if (crawl_state.seen_hups)
 399         {
 400             buffer[0] = '\0';
 401             return (0);
 402         }
 403 #endif
 404
 405         if (keyfn)
 406         {
 407             int whattodo = (*keyfn)(ch);
 408             if (whattodo == 0)
 409             {
 410                 buffer[length] = 0;
 411                 if (history && length)
 412                     history->new_input(buffer);
 413                 return (0);
 414             }
 415             else if (whattodo == -1)
 416             {
 417                 buffer[length] = 0;
 418                 return (ch);
 419             }
 420         }
 421
 422         int ret = process_key(ch);
 423         if (ret != -1)
 424             return (ret);
 425     }
 426 }
 427
 428 void line_reader::backspace()
 429 {
 430     if (pos)
 431     {
 432         buffer[length] = 0;
 433         --cur;
 434         char *c = cur;
 435         while (*c)
 436         {
 437             *c = *(c+1);
 438             c++;
 439         }
 440         --pos;
 441         --length;
 442
 443         cursorto(pos);
 444         buffer[length] = 0;
 445         wrapcprintf(wrapcol, "%s ", cur);
 446         cursorto(pos);
 447     }
 448 }
 449
 450 bool line_reader::is_wordchar(int c)
 451 {
 452     return isalnum(c) || c == '_' || c == '-';
 453 }
 454
 455 void line_reader::kill_to_begin()
 456 {
 457     if (!pos || cur == buffer)
 458         return;
 459
 460     buffer[length] = 0;
 461     cursorto(0);
 462     wrapcprintf(wrapcol, "%s%*s", cur, cur - buffer, "");
 463     memmove(buffer, cur, length - pos);
 464     length -= pos;
 465     pos = 0;
 466     cur = buffer;
 467     cursorto(pos);
 468 }
 469
 470 void line_reader::killword()
 471 {
 472     if (!pos || cur == buffer)
 473         return;
 474
 475     bool foundwc = false;
 476     while (pos)
 477     {
 478         if (is_wordchar(cur[-1]))
 479             foundwc = true;
 480         else if (foundwc)
 481             break;
 482
 483         backspace();
 484     }
 485 }
 486
 487 int line_reader::process_key(int ch)
 488 {
 489     switch (ch)
 490     {
 491     CASE_ESCAPE
 492         return (CK_ESCAPE);
 493     case CK_UP:
 494     case CK_DOWN:
 495     {
 496         if (!history)
 497             break;
 498
 499         const std::string *text = (ch == CK_UP) ? history->prev()
 500                                                 : history->next();
 501
 502         if (text)
 503         {
 504             int olen = length;
 505             length = text->length();
 506             if (length >= static_cast<int>(bufsz))
 507                 length = bufsz - 1;
 508             memcpy(buffer, text->c_str(), length);
 509             buffer[length] = 0;
 510             cursorto(0);
 511
 512             int clear = length < olen ? olen - length : 0;
 513             wrapcprintf(wrapcol, "%s%*s", buffer, clear, "");
 514
 515             pos = length;
 516             cur = buffer + pos;
 517             cursorto(pos);
 518         }
 519         break;
 520     }
 521     case CK_ENTER:
 522         buffer[length] = 0;
 523         if (history && length)
 524             history->new_input(buffer);
 525         return (0);
 526
 527     case CONTROL('K'):
 528     {
 529         // Kill to end of line.
 530         int erase = length - pos;
 531         if (erase)
 532         {
 533             length = pos;
 534             buffer[length] = 0;
 535             wrapcprintf(wrapcol, "%*s", erase, "");
 536             cursorto(pos);
 537         }
 538         break;
 539     }
 540     case CK_DELETE:
 541         if (pos < length)
 542         {
 543             char *c = cur;
 544             while (c - buffer < length)
 545             {
 546                 *c = c[1];
 547                 c++;
 548             }
 549             --length;
 550
 551             cursorto(pos);
 552             buffer[length] = 0;
 553             wrapcprintf(wrapcol, "%s ", cur);
 554             cursorto(pos);
 555         }
 556         break;
 557
 558     case CK_BKSP:
 559         backspace();
 560         break;
 561
 562     case CONTROL('W'):
 563         killword();
 564         break;
 565
 566     case CONTROL('U'):
 567         kill_to_begin();
 568         break;
 569
 570     case CK_LEFT:
 571         if (pos)
 572         {
 573             --pos;
 574             cur = buffer + pos;
 575             cursorto(pos);
 576         }
 577         break;
 578     case CK_RIGHT:
 579         if (pos < length)
 580         {
 581             ++pos;
 582             cur = buffer + pos;
 583             cursorto(pos);
 584         }
 585         break;
 586     case CK_HOME:
 587     case CONTROL('A'):
 588         pos = 0;
 589         cur = buffer + pos;
 590         cursorto(pos);
 591         break;
 592     case CK_END:
 593     case CONTROL('E'):
 594         pos = length;
 595         cur = buffer + pos;
 596         cursorto(pos);
 597         break;
 598     case CK_MOUSE_CLICK:
 599         return (-1);
 600     default:
 601         if (isprint(ch) && length < static_cast<int>(bufsz) - 1)
 602         {
 603             if (pos < length)
 604             {
 605                 char *c = buffer + length - 1;
 606                 while (c >= cur)
 607                 {
 608                     c[1] = *c;
 609                     c--;
 610                 }
 611             }
 612             *cur++ = static_cast<char>(ch);
 613             ++length;
 614             buffer[length] = 0;
 615             ++pos;
 616             putch(ch);
 617             if (pos < length)
 618                 wrapcprintf(wrapcol, "%s", cur);
 619             cursorto(pos);
 620         }
 621         break;
 622     }
 623
 624     return (-1);
 625 }
 626
 627 /////////////////////////////////////////////////////////////////////////////
 628 // Of mice and other mice.
 629
 630 static std::queue<c_mouse_event> mouse_events;
 631
 632 coord_def get_mouse_pos()
 633 {
 634     // lib$(OS) has to maintain mousep. This function is just the messenger.
 635     return (crawl_view.mousep);
 636 }
 637
 638 c_mouse_event get_mouse_event()
 639 {
 640     if (mouse_events.empty())
 641         return c_mouse_event();
 642
 643     c_mouse_event ce = mouse_events.front();
 644     mouse_events.pop();
 645     return (ce);
 646 }
 647
 648 void new_mouse_event(const c_mouse_event &ce)
 649 {
 650     mouse_events.push(ce);
 651 }
 652
 653 static void _flush_mouse_events()
 654 {
 655     while (!mouse_events.empty())
 656         mouse_events.pop();
 657 }
 658
 659 void c_input_reset(bool enable_mouse, bool flush)
 660 {
 661     crawl_state.mouse_enabled = (enable_mouse && Options.mouse_input);
 662     set_mouse_enabled(crawl_state.mouse_enabled);
 663
 664     if (flush)
 665         _flush_mouse_events();
 666 }