Utils/Termlib/Editor.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2009
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief Editor non-inline non-template implementation */
  25
  26 #include "Editor.hh"
  27 //#include "Editor.ih"
  28
  29 // Custom includes
  30 #include <senf/Utils/membind.hh>
  31 #include <senf/Scheduler/Scheduler.hh>
  32
  33 //#include "Editor.mpp"
  34 #define prefix_
  35 ///////////////////////////////cc.p////////////////////////////////////////
  36
  37 prefix_ senf::term::BaseEditor::BaseEditor(AbstractTerminal & terminal)
  38     : terminal_ (&terminal),
  39       keyTimeout_ (senf::ClockService::milliseconds(DEFAULT_KEY_TIMEOUT_MS)),
  40       timer_ ("senf::term::BaseEditor::keySequenceTimeout",
  41               senf::membind(&BaseEditor::keySequenceTimeout, this)),
  42       column_ (0u), displayHeight_ (1u), line_ (0u)
  43 {
  44     terminal_->setCallbacks(*this);
  45 }
  46
  47 prefix_ void senf::term::BaseEditor::newline()
  48 {
  49     reset();
  50     write("\n");
  51     write(tifo_.getString(Terminfo::properties::ClrEol));
  52     column_ = 0;
  53 }
  54
  55 prefix_ void senf::term::BaseEditor::toColumn(unsigned c)
  56 {
  57     if (c >= width())
  58         c = width();
  59     if (c > column_) {
  60         if (tifo_.hasProperty(Terminfo::properties::ParmRightCursor)) {
  61             write(tifo_.formatString(Terminfo::properties::ParmRightCursor, c - column_));
  62             column_ = c;
  63         }
  64         else {
  65             char const * cuf1 (tifo_.getString(Terminfo::properties::CursorRight));
  66             while (c > column_) {
  67                 write(cuf1);
  68                 ++column_;
  69             }
  70         }
  71     }
  72     else if (c < column_) {
  73         if (tifo_.hasProperty(Terminfo::properties::ParmLeftCursor)) {
  74             write(tifo_.formatString(Terminfo::properties::ParmLeftCursor, column_ - c));
  75             column_ = c;
  76         }
  77         else {
  78             char const * cub1 (tifo_.getString(Terminfo::properties::CursorLeft));
  79             while (c < column_) {
  80                 write(cub1);
  81                 --column_;
  82             }
  83         }
  84     }
  85 }
  86
  87 prefix_ void senf::term::BaseEditor::put(char ch)
  88 {
  89     if (column_ >= width()-1)
  90         return;
  91     write(ch);
  92     ++ column_;
  93 }
  94
  95 prefix_ void senf::term::BaseEditor::put(std::string const & text)
  96 {
  97     if (text.size() > width()-column_-1) {
  98         write(text.substr(0,width()-column_-1));
  99         column_ = width() - 1;
 100     }
 101     else {
 102         write(text);
 103         column_ += text.size();
 104     }
 105 }
 106
 107 prefix_ void senf::term::BaseEditor::clearLine()
 108 {
 109     write("\r");
 110     write(tifo_.getString(Terminfo::properties::ClrEol));
 111     column_ = 0;
 112 }
 113
 114 prefix_ void senf::term::BaseEditor::setBold()
 115 {
 116     if (tifo_.hasProperty(Terminfo::properties::EnterBoldMode) &&
 117         tifo_.hasProperty(Terminfo::properties::ExitAttributeMode))
 118         write(tifo_.getString(Terminfo::properties::EnterBoldMode));
 119 }
 120
 121 prefix_ void senf::term::BaseEditor::setNormal()
 122 {
 123     if (tifo_.hasProperty(Terminfo::properties::EnterBoldMode) &&
 124         tifo_.hasProperty(Terminfo::properties::ExitAttributeMode))
 125         write(tifo_.getString(Terminfo::properties::ExitAttributeMode));
 126 }
 127
 128 prefix_ void senf::term::BaseEditor::maybeClrScr()
 129 {
 130     if (tifo_.hasProperty(Terminfo::properties::ClearScreen))
 131         write(tifo_.getString(Terminfo::properties::ClearScreen));
 132 }
 133
 134 prefix_ void senf::term::BaseEditor::toLine(unsigned l)
 135 {
 136     if (l >= height())
 137         l = height() - 1;
 138     unsigned ll (l);
 139     if (ll >= displayHeight_)
 140         ll = displayHeight_-1;
 141     if (ll > line_) {
 142         if (tifo_.hasProperty(Terminfo::properties::ParmDownCursor)) {
 143             write(tifo_.formatString(Terminfo::properties::ParmDownCursor, ll - line_));
 144             line_ = ll;
 145         }
 146         else {
 147             char const * cud1 (tifo_.getString(Terminfo::properties::CursorDown));
 148             while (ll > line_) {
 149                 write(cud1);
 150                 ++line_;
 151             }
 152         }
 153     }
 154     else if (ll < line_) {
 155         if (tifo_.hasProperty(Terminfo::properties::ParmUpCursor)) {
 156             write(tifo_.formatString(Terminfo::properties::ParmUpCursor, line_ - ll));
 157             line_ = ll;
 158         }
 159         else {
 160             char const * cuu1 (tifo_.getString(Terminfo::properties::CursorUp));
 161             while (ll < line_) {
 162                 write(cuu1);
 163                 --line_;
 164             }
 165         }
 166     }
 167     while (line_ < l) {
 168         write("\n");
 169         write(tifo_.getString(Terminfo::properties::ClrEol));
 170         ++displayHeight_;
 171         ++line_;
 172     }
 173     write('\r');
 174     column_ = 0;
 175 }
 176
 177 prefix_ void senf::term::BaseEditor::reset()
 178 {
 179     for (unsigned i (1); i < displayHeight_; ++i) {
 180         toLine(i);
 181         clearLine();
 182     }
 183     toLine(0);
 184     displayHeight_ = 1;
 185 }
 186
 187 prefix_ unsigned senf::term::BaseEditor::currentColumn()
 188    const
 189 {
 190     return column_;
 191 }
 192
 193 prefix_ unsigned senf::term::BaseEditor::currentLine()
 194     const
 195 {
 196     return line_;
 197 }
 198
 199 prefix_ bool senf::term::BaseEditor::cb_init()
 200 {
 201     try {
 202         tifo_.load(terminal_->terminalType());
 203         keyParser_.load(tifo_);
 204     }
 205     catch (Terminfo::InvalidTerminfoException & ex) {
 206         return false;
 207     }
 208
 209     typedef Terminfo::properties p;
 210     if (! (tifo_.hasProperty(p::ClrEol) &&
 211            (tifo_.hasProperty(p::ParmRightCursor) || tifo_.hasProperty(p::CursorRight)) &&
 212            (tifo_.hasProperty(p::ParmLeftCursor) || tifo_.hasProperty(p::CursorLeft))))
 213         return false;
 214
 215     if (tifo_.hasProperty(Terminfo::properties::KeypadXmit))
 216         write(tifo_.getString(Terminfo::properties::KeypadXmit));
 217     return true;
 218 }
 219
 220 prefix_ void senf::term::BaseEditor::cb_charReceived(char c)
 221 {
 222     inputBuffer_ += c;
 223     timer_.timeout(senf::scheduler::eventTime() + keyTimeout_);
 224     processKeys();
 225 }
 226
 227 prefix_ void senf::term::BaseEditor::cb_windowSizeChanged()
 228 {
 229     if (column_ >= width())
 230         column_ = width()-1;
 231 }
 232
 233 prefix_ void senf::term::BaseEditor::keySequenceTimeout()
 234 {
 235     while (!inputBuffer_.empty()) {
 236         processKeys();
 237         v_keyReceived(keycode_t(inputBuffer_[0]));
 238         inputBuffer_.erase(0, 1);
 239     }
 240 }
 241
 242 prefix_ void senf::term::BaseEditor::processKeys()
 243 {
 244     do {
 245         std::pair<senf::term::KeyParser::keycode_t, std::string::size_type> result
 246             (keyParser_.lookup(inputBuffer_));
 247         if (result.first == senf::term::KeyParser::Incomplete)
 248             return;
 249         v_keyReceived(result.first);
 250         inputBuffer_.erase(0, result.second);
 251     } while (! inputBuffer_.empty());
 252     timer_.disable();
 253 }
 254
 255 prefix_ unsigned senf::term::BaseEditor::width()
 256 {
 257     return terminal_->width();
 258 }
 259
 260 prefix_ unsigned senf::term::BaseEditor::height()
 261 {
 262     return terminal_->height();
 263 }
 264
 265 prefix_ void senf::term::BaseEditor::write(char ch)
 266 {
 267     terminal_->write(ch);
 268 }
 269
 270 prefix_ void senf::term::BaseEditor::write(std::string const & s)
 271 {
 272     for (std::string::const_iterator i (s.begin()); i != s.end(); ++i)
 273         write(*i);
 274 }
 275
 276 ///////////////////////////////////////////////////////////////////////////
 277
 278 prefix_ senf::term::LineEditor::LineEditor(AbstractTerminal & terminal, AcceptCallback cb)
 279     : BaseEditor(terminal), enabled_ (false), prompt_ ("$"), promptWidth_ (1u), editWidth_ (0u),
 280       text_ (""), point_ (0u), displayPos_ (0u), lastKey_ (0u), callback_ (cb), historyPoint_ (0u)
 281 {
 282     defineKey(KeyParser::Return,    &bindings::accept);
 283     defineKey(KeyParser::Right,     &bindings::forwardChar);
 284     defineKey(KeyParser::Left,      &bindings::backwardChar);
 285     defineKey(KeyParser::Up,        &bindings::prevHistory);
 286     defineKey(KeyParser::Down,      &bindings::nextHistory);
 287     defineKey(KeyParser::Backspace, &bindings::backwardDeleteChar);
 288     defineKey(KeyParser::Delete,    &bindings::deleteChar);
 289     defineKey(KeyParser::Home,      &bindings::beginningOfLine);
 290     defineKey(KeyParser::End,       &bindings::endOfLine);
 291     defineKey(KeyParser::Ctrl('K'), &bindings::deleteToEndOfLine);
 292     defineKey(KeyParser::Ctrl('A'), &bindings::beginningOfLine);
 293     defineKey(KeyParser::Ctrl('E'), &bindings::endOfLine);
 294     defineKey(KeyParser::Ctrl('D'), &bindings::deleteChar);
 295     defineKey(KeyParser::Ctrl('C'), &bindings::restartEdit);
 296     defineKey(KeyParser::Ctrl('L'), &bindings::clearScreen);
 297 }
 298
 299 prefix_ void senf::term::LineEditor::prompt(std::string const & text)
 300 {
 301     prompt_ = text;
 302     promptWidth_ = prompt_.size();
 303     if (promptWidth_ > width() - 4 && width() > 4)
 304         promptWidth_ = width() - 4;
 305     editWidth_ = width() - promptWidth_ - 3;
 306     if (enabled_)
 307         redisplay();
 308 }
 309
 310 prefix_ void senf::term::LineEditor::set(std::string const & text, unsigned pos)
 311 {
 312     text_ = text;
 313     point_ = pos;
 314     if (point_ > text.size())
 315         point_ = text.size();
 316     displayPos_ = 0u;
 317     if (point_ > editWidth_)
 318         displayPos_ = point_ - editWidth_;
 319     redisplay();
 320 }
 321
 322 prefix_ void senf::term::LineEditor::show()
 323 {
 324     if (enabled_)
 325         return;
 326     enabled_ = true;
 327     for (unsigned n (0); n < auxDisplay_.size(); ++n) {
 328         toLine(n+1);
 329         put(auxDisplay_[n]);
 330     }
 331     toLine(0);
 332     forceRedisplay();
 333 }
 334
 335 prefix_ void senf::term::LineEditor::hide()
 336 {
 337     if (! enabled_)
 338         return;
 339     reset();
 340     clearLine();
 341     enabled_ = false;
 342 }
 343
 344 prefix_ void senf::term::LineEditor::accept()
 345 {
 346     if (enabled_)
 347         newline();
 348     hide();
 349     pushHistory(text_);
 350     callback_(text_);
 351     clear();
 352 }
 353
 354 prefix_ void senf::term::LineEditor::clear()
 355 {
 356     set("");
 357     historyPoint_ = history_.size();
 358 }
 359
 360 prefix_ void senf::term::LineEditor::redisplay()
 361 {
 362     redisplayNeeded_ = true;
 363 }
 364
 365 prefix_ void senf::term::LineEditor::forceRedisplay()
 366 {
 367     if (! enabled_)
 368         return;
 369     clearLine();
 370     setBold();
 371     if (prompt_.size() > promptWidth_)
 372         put(prompt_.substr(prompt_.size()-promptWidth_));
 373     else
 374         put(prompt_);
 375     put( displayPos_ > 0 ? '<' : ' ' );
 376     if (text_.size() > displayPos_ + editWidth_) {
 377         toColumn(editWidth_ + promptWidth_ + 1);
 378         put('>');
 379         toColumn(promptWidth_ + 1);
 380     }
 381     setNormal();
 382     put(text_.substr(displayPos_, editWidth_));
 383     toColumn(point_ - displayPos_ + promptWidth_ + 1);
 384     redisplayNeeded_ = false;
 385 }
 386
 387 prefix_ void senf::term::LineEditor::gotoChar(unsigned n)
 388 {
 389     point_ = n;
 390     if (point_ > text_.size())
 391         point_ = text_.size();
 392     if (point_ < displayPos_)
 393         displayPos_ = point_;
 394     if (point_ > displayPos_+editWidth_)
 395         displayPos_ = point_-editWidth_;
 396     redisplay();
 397 }
 398
 399 prefix_ void senf::term::LineEditor::scrollTo(unsigned n)
 400 {
 401     displayPos_ = n;
 402     if (displayPos_ > text_.size())
 403         displayPos_ = text_.size();
 404     if (point_ < displayPos_)
 405         point_ = displayPos_;
 406     if (point_ > displayPos_+editWidth_)
 407         point_ = displayPos_+editWidth_;
 408     redisplay();
 409 }
 410
 411 prefix_ void senf::term::LineEditor::deleteChar(unsigned n)
 412 {
 413     if (point_ >= text_.size())
 414         return;
 415     text_.erase(point_, n);
 416     redisplay();
 417 }
 418
 419 prefix_ void senf::term::LineEditor::insert(char ch)
 420 {
 421     text_.insert(point_, std::string(1, ch));
 422     gotoChar(point_+1);
 423     redisplay();
 424 }
 425
 426 prefix_ void senf::term::LineEditor::insert(std::string const & text)
 427 {
 428     text_.insert(point_, text);
 429     gotoChar(point_+text.size());
 430     redisplay();
 431 }
 432
 433 prefix_ void senf::term::LineEditor::pushHistory(std::string const & text)
 434 {
 435     if (! text.empty()
 436         && (history_.empty() || history_.back() != text)) {
 437         history_.push_back(text);
 438         while (history_.size() > MAX_HISTORY_SIZE)
 439             history_.erase(history_.begin());
 440         historyPoint_ = history_.size() - 1;
 441     }
 442 }
 443
 444 prefix_ void senf::term::LineEditor::prevHistory()
 445 {
 446     if (historyPoint_ <= 0)
 447         return;
 448     pushHistory(text_);
 449     std::string entry (history_[--historyPoint_]);
 450     set(entry, entry.size());
 451 }
 452
 453 prefix_ void senf::term::LineEditor::nextHistory()
 454 {
 455     if (historyPoint_ >= history_.size())
 456         return;
 457     pushHistory(text_);
 458     ++ historyPoint_;
 459     if (historyPoint_ >= history_.size())
 460         set("");
 461     else {
 462         std::string entry (history_[historyPoint_]);
 463         set(entry, entry.size());
 464     }
 465 }
 466
 467 prefix_ void senf::term::LineEditor::auxDisplay(unsigned line, std::string const & text)
 468 {
 469     toLine(line+1);
 470     clearLine();
 471     put(text);
 472     while (auxDisplay_.size() < line+1)
 473         auxDisplay_.push_back("");
 474     auxDisplay_[line] = text;
 475 }
 476
 477 prefix_ unsigned senf::term::LineEditor::maxAuxDisplayHeight()
 478 {
 479     return height()-1;
 480 }
 481
 482 prefix_ void senf::term::LineEditor::clearAuxDisplay()
 483 {
 484     reset();
 485     auxDisplay_.clear();
 486 }
 487
 488 prefix_ std::string const & senf::term::LineEditor::text()
 489 {
 490     return text_;
 491 }
 492
 493 prefix_ unsigned senf::term::LineEditor::point()
 494 {
 495     return point_;
 496 }
 497
 498 prefix_ unsigned senf::term::LineEditor::displayPos()
 499 {
 500     return displayPos_;
 501 }
 502
 503 prefix_ senf::term::LineEditor::keycode_t senf::term::LineEditor::lastKey()
 504 {
 505     return lastKey_;
 506 }
 507
 508 prefix_ void senf::term::LineEditor::defineKey(keycode_t key, KeyBinding binding)
 509 {
 510     bindings_[key] = binding;
 511 }
 512
 513 prefix_ void senf::term::LineEditor::unsetKey(keycode_t key)
 514 {
 515     bindings_.erase(key);
 516 }
 517
 518 prefix_ bool senf::term::LineEditor::cb_init()
 519 {
 520     if (!BaseEditor::cb_init())
 521         return false;
 522     prompt(prompt_);
 523     show();
 524     return true;
 525 }
 526
 527 prefix_ void senf::term::LineEditor::cb_windowSizeChanged()
 528 {
 529     BaseEditor::cb_windowSizeChanged();
 530     clearAuxDisplay();
 531     prompt(prompt_);
 532     gotoChar(point_);
 533     forceRedisplay();
 534 }
 535
 536 prefix_ void senf::term::LineEditor::v_keyReceived(keycode_t key)
 537 {
 538     if (! enabled_)
 539         return;
 540     clearAuxDisplay();
 541     lastKey_ = key;
 542     KeyMap::iterator i (bindings_.find(key));
 543     if (i != bindings_.end())
 544         i->second(*this);
 545     else if (key >= ' ' && key < 256)
 546         insert(char(key));
 547     if (currentLine() != 0)
 548         toLine(0);
 549     if (redisplayNeeded_)
 550         forceRedisplay();
 551     else
 552         toColumn(point_ - displayPos_ + promptWidth_ + 1);
 553 }
 554
 555 ///////////////////////////////////////////////////////////////////////////
 556
 557 prefix_ void senf::term::bindings::selfInsertCommand(LineEditor & editor)
 558 {
 559     LineEditor::keycode_t key (editor.lastKey());
 560     if (key >= ' ' && key < 256)
 561         editor.insert(key);
 562 }
 563
 564 prefix_ void senf::term::bindings::forwardChar(LineEditor & editor)
 565 {
 566     editor.gotoChar(editor.point()+1);
 567 }
 568
 569 prefix_ void senf::term::bindings::backwardChar(LineEditor & editor)
 570 {
 571     unsigned p (editor.point());
 572     if (p>0)
 573         editor.gotoChar(p-1);
 574 }
 575
 576 prefix_ void senf::term::bindings::accept(LineEditor & editor)
 577 {
 578     editor.accept();
 579 }
 580
 581 prefix_ void senf::term::bindings::backwardDeleteChar(LineEditor & editor)
 582 {
 583     unsigned p (editor.point());
 584     if (p>0) {
 585         editor.gotoChar(p-1);
 586         editor.deleteChar();
 587     }
 588 }
 589
 590 prefix_ void senf::term::bindings::deleteChar(LineEditor & editor)
 591 {
 592     editor.deleteChar();
 593 }
 594
 595 prefix_ void senf::term::bindings::beginningOfLine(LineEditor & editor)
 596 {
 597     editor.gotoChar(0u);
 598 }
 599
 600 prefix_ void senf::term::bindings::endOfLine(LineEditor & editor)
 601 {
 602     editor.gotoChar(editor.text().size());
 603 }
 604
 605 prefix_ void senf::term::bindings::deleteToEndOfLine(LineEditor & editor)
 606 {
 607     editor.deleteChar(editor.text().size()-editor.point());
 608 }
 609
 610 prefix_ void senf::term::bindings::restartEdit(LineEditor & editor)
 611 {
 612     editor.newline();
 613     editor.clear();
 614     editor.redisplay();
 615 }
 616
 617 prefix_ void senf::term::bindings::prevHistory(LineEditor & editor)
 618 {
 619     editor.prevHistory();
 620 }
 621
 622 prefix_ void senf::term::bindings::nextHistory(LineEditor & editor)
 623 {
 624     editor.nextHistory();
 625 }
 626
 627 prefix_ void senf::term::bindings::clearScreen(LineEditor & editor)
 628 {
 629     editor.maybeClrScr();
 630     editor.clearLine();
 631     editor.forceRedisplay();
 632 }
 633
 634 prefix_ void senf::term::bindings::complete(LineEditor & editor, Completer completer)
 635 {
 636     typedef std::vector<std::string> Completions;
 637
 638     Completions completions;
 639     completer(editor, 0, editor.point(), completions);
 640     if (completions.empty())
 641         return;
 642
 643     // Find common start string of all completions
 644     unsigned commonStart (completions[0].size());
 645     unsigned maxLen (commonStart);
 646     for (Completions::const_iterator i (boost::next(completions.begin()));
 647          i != completions.end(); ++i) {
 648         if (i->size() > maxLen)
 649             maxLen = i->size();
 650         unsigned n (0u);
 651         for (; n < commonStart && n < i->size() && completions[0][n] == (*i)[n]; ++n) ;
 652         commonStart = n;
 653     }
 654
 655     // Replace to-be-completed string with the common start string shared by all completions
 656     std::string text (editor.text());
 657     std::string completion (completions[0].substr(0, commonStart));
 658     bool didComplete (false);
 659     if (text.substr(0, editor.point()) != completion) {
 660         text.erase(0, editor.point());
 661         text.insert(0, completion);
 662         didComplete = true;
 663     }
 664
 665     // Otherwise place cursor directly after the (possibly partial) completion
 666     editor.set(text, commonStart);
 667     if (didComplete || completions.size() == 1)
 668         return;
 669
 670     // Text was not changed, show list of possible completions
 671     unsigned colWidth (maxLen+2);
 672     unsigned nColumns ((editor.width()-1) / colWidth);
 673     if (nColumns < 1) nColumns = 1;
 674     unsigned nRows ((completions.size()+nColumns-1) / nColumns);
 675     if (nRows > editor.maxAuxDisplayHeight()) {
 676         editor.auxDisplay(0, "(too many completions)");
 677         return;
 678     }
 679     Completions::iterator i (completions.begin());
 680     for (unsigned row (0); row < nRows; ++row) {
 681         std::string line;
 682         for (unsigned column (0); column < nColumns && i != completions.end(); ++column) {
 683             std::string entry (colWidth, ' ');
 684             if (i->size() > colWidth-2)
 685                 std::copy(i->begin(), i->begin()+colWidth-2, entry.begin());
 686             else
 687                 std::copy(i->begin(), i->end(), entry.begin());
 688             line += entry;
 689             ++i;
 690         }
 691         editor.auxDisplay(row, line);
 692     }
 693 }
 694
 695 ///////////////////////////////cc.e////////////////////////////////////////
 696 #undef prefix_
 697 //#include "Editor.mpp"
 698
 699 \f
 700 // Local Variables:
 701 // mode: c++
 702 // fill-column: 100
 703 // comment-column: 40
 704 // c-file-style: "senf"
 705 // indent-tabs-mode: nil
 706 // ispell-local-dictionary: "american"
 707 // compile-command: "scons -u test"
 708 // End: