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_, true);
 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, bool accept)
 434 {
 435     if (! text.empty()
 436         && (accept || historyPoint_ == history_.size() || history_[historyPoint_] != text)
 437         && (history_.empty() || history_.back() != text)) {
 438         history_.push_back(text);
 439         while (history_.size() > MAX_HISTORY_SIZE)
 440             history_.erase(history_.begin());
 441         if (accept)
 442             historyPoint_ = history_.size() - 1;
 443     }
 444 }
 445
 446 prefix_ void senf::term::LineEditor::prevHistory()
 447 {
 448     if (historyPoint_ <= 0)
 449         return;
 450     pushHistory(text_);
 451     std::string entry (history_[--historyPoint_]);
 452     set(entry, entry.size());
 453 }
 454
 455 prefix_ void senf::term::LineEditor::nextHistory()
 456 {
 457     if (historyPoint_ >= history_.size())
 458         return;
 459     pushHistory(text_);
 460     ++ historyPoint_;
 461     if (historyPoint_ >= history_.size())
 462         set("");
 463     else {
 464         std::string entry (history_[historyPoint_]);
 465         set(entry, entry.size());
 466     }
 467 }
 468
 469 prefix_ void senf::term::LineEditor::auxDisplay(unsigned line, std::string const & text)
 470 {
 471     toLine(line+1);
 472     clearLine();
 473     put(text);
 474     while (auxDisplay_.size() < line+1)
 475         auxDisplay_.push_back("");
 476     auxDisplay_[line] = text;
 477 }
 478
 479 prefix_ unsigned senf::term::LineEditor::maxAuxDisplayHeight()
 480 {
 481     return height()-1;
 482 }
 483
 484 prefix_ void senf::term::LineEditor::clearAuxDisplay()
 485 {
 486     reset();
 487     auxDisplay_.clear();
 488 }
 489
 490 prefix_ std::string const & senf::term::LineEditor::text()
 491 {
 492     return text_;
 493 }
 494
 495 prefix_ unsigned senf::term::LineEditor::point()
 496 {
 497     return point_;
 498 }
 499
 500 prefix_ unsigned senf::term::LineEditor::displayPos()
 501 {
 502     return displayPos_;
 503 }
 504
 505 prefix_ senf::term::LineEditor::keycode_t senf::term::LineEditor::lastKey()
 506 {
 507     return lastKey_;
 508 }
 509
 510 prefix_ void senf::term::LineEditor::defineKey(keycode_t key, KeyBinding binding)
 511 {
 512     bindings_[key] = binding;
 513 }
 514
 515 prefix_ void senf::term::LineEditor::unsetKey(keycode_t key)
 516 {
 517     bindings_.erase(key);
 518 }
 519
 520 prefix_ bool senf::term::LineEditor::cb_init()
 521 {
 522     if (!BaseEditor::cb_init())
 523         return false;
 524     prompt(prompt_);
 525     show();
 526     return true;
 527 }
 528
 529 prefix_ void senf::term::LineEditor::cb_windowSizeChanged()
 530 {
 531     BaseEditor::cb_windowSizeChanged();
 532     clearAuxDisplay();
 533     prompt(prompt_);
 534     gotoChar(point_);
 535     forceRedisplay();
 536 }
 537
 538 prefix_ void senf::term::LineEditor::v_keyReceived(keycode_t key)
 539 {
 540     if (! enabled_)
 541         return;
 542     clearAuxDisplay();
 543     lastKey_ = key;
 544     KeyMap::iterator i (bindings_.find(key));
 545     if (i != bindings_.end())
 546         i->second(*this);
 547     else if (key >= ' ' && key < 256)
 548         insert(char(key));
 549     if (currentLine() != 0)
 550         toLine(0);
 551     if (redisplayNeeded_)
 552         forceRedisplay();
 553     else
 554         toColumn(point_ - displayPos_ + promptWidth_ + 1);
 555 }
 556
 557 ///////////////////////////////////////////////////////////////////////////
 558
 559 prefix_ void senf::term::bindings::selfInsertCommand(LineEditor & editor)
 560 {
 561     LineEditor::keycode_t key (editor.lastKey());
 562     if (key >= ' ' && key < 256)
 563         editor.insert(key);
 564 }
 565
 566 prefix_ void senf::term::bindings::forwardChar(LineEditor & editor)
 567 {
 568     editor.gotoChar(editor.point()+1);
 569 }
 570
 571 prefix_ void senf::term::bindings::backwardChar(LineEditor & editor)
 572 {
 573     unsigned p (editor.point());
 574     if (p>0)
 575         editor.gotoChar(p-1);
 576 }
 577
 578 prefix_ void senf::term::bindings::accept(LineEditor & editor)
 579 {
 580     editor.accept();
 581 }
 582
 583 prefix_ void senf::term::bindings::backwardDeleteChar(LineEditor & editor)
 584 {
 585     unsigned p (editor.point());
 586     if (p>0) {
 587         editor.gotoChar(p-1);
 588         editor.deleteChar();
 589     }
 590 }
 591
 592 prefix_ void senf::term::bindings::deleteChar(LineEditor & editor)
 593 {
 594     editor.deleteChar();
 595 }
 596
 597 prefix_ void senf::term::bindings::beginningOfLine(LineEditor & editor)
 598 {
 599     editor.gotoChar(0u);
 600 }
 601
 602 prefix_ void senf::term::bindings::endOfLine(LineEditor & editor)
 603 {
 604     editor.gotoChar(editor.text().size());
 605 }
 606
 607 prefix_ void senf::term::bindings::deleteToEndOfLine(LineEditor & editor)
 608 {
 609     editor.deleteChar(editor.text().size()-editor.point());
 610 }
 611
 612 prefix_ void senf::term::bindings::restartEdit(LineEditor & editor)
 613 {
 614     editor.newline();
 615     editor.clear();
 616     editor.redisplay();
 617 }
 618
 619 prefix_ void senf::term::bindings::prevHistory(LineEditor & editor)
 620 {
 621     editor.prevHistory();
 622 }
 623
 624 prefix_ void senf::term::bindings::nextHistory(LineEditor & editor)
 625 {
 626     editor.nextHistory();
 627 }
 628
 629 prefix_ void senf::term::bindings::clearScreen(LineEditor & editor)
 630 {
 631     editor.maybeClrScr();
 632     editor.clearLine();
 633     editor.forceRedisplay();
 634 }
 635
 636 prefix_ void senf::term::bindings::complete(LineEditor & editor, Completer completer)
 637 {
 638     typedef std::vector<std::string> Completions;
 639
 640     Completions completions;
 641     completer(editor, 0, editor.point(), completions);
 642     if (completions.empty())
 643         return;
 644
 645     // Find common start string of all completions
 646     unsigned commonStart (completions[0].size());
 647     unsigned maxLen (commonStart);
 648     for (Completions::const_iterator i (boost::next(completions.begin()));
 649          i != completions.end(); ++i) {
 650         if (i->size() > maxLen)
 651             maxLen = i->size();
 652         unsigned n (0u);
 653         for (; n < commonStart && n < i->size() && completions[0][n] == (*i)[n]; ++n) ;
 654         commonStart = n;
 655     }
 656
 657     // Replace to-be-completed string with the common start string shared by all completions
 658     std::string text (editor.text());
 659     std::string completion (completions[0].substr(0, commonStart));
 660     bool didComplete (false);
 661     if (text.substr(0, editor.point()) != completion) {
 662         text.erase(0, editor.point());
 663         text.insert(0, completion);
 664         didComplete = true;
 665     }
 666
 667     // Otherwise place cursor directly after the (possibly partial) completion
 668     editor.set(text, commonStart);
 669     if (didComplete || completions.size() == 1)
 670         return;
 671
 672     // Text was not changed, show list of possible completions
 673     unsigned colWidth (maxLen+2);
 674     unsigned nColumns ((editor.width()-1) / colWidth);
 675     if (nColumns < 1) nColumns = 1;
 676     unsigned nRows ((completions.size()+nColumns-1) / nColumns);
 677     if (nRows > editor.maxAuxDisplayHeight()) {
 678         editor.auxDisplay(0, "(too many completions)");
 679         return;
 680     }
 681     Completions::iterator i (completions.begin());
 682     for (unsigned row (0); row < nRows; ++row) {
 683         std::string line;
 684         for (unsigned column (0); column < nColumns && i != completions.end(); ++column) {
 685             std::string entry (colWidth, ' ');
 686             if (i->size() > colWidth-2)
 687                 std::copy(i->begin(), i->begin()+colWidth-2, entry.begin());
 688             else
 689                 std::copy(i->begin(), i->end(), entry.begin());
 690             line += entry;
 691             ++i;
 692         }
 693         editor.auxDisplay(row, line);
 694     }
 695 }
 696
 697 ///////////////////////////////cc.e////////////////////////////////////////
 698 #undef prefix_
 699 //#include "Editor.mpp"
 700
 701 \f
 702 // Local Variables:
 703 // mode: c++
 704 // fill-column: 100
 705 // comment-column: 40
 706 // c-file-style: "senf"
 707 // indent-tabs-mode: nil
 708 // ispell-local-dictionary: "american"
 709 // compile-command: "scons -u test"
 710 // End: