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