src/frontends/qt4/GuiCompleter.cpp

   1 /**
   2  * \file GuiCompleter.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Stefan Schimanski
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "GuiWorkArea.h"
  14
  15 #include "Buffer.h"
  16 #include "BufferView.h"
  17 #include "Cursor.h"
  18 #include "Dimension.h"
  19 #include "FuncRequest.h"
  20 #include "GuiView.h"
  21 #include "LyXFunc.h"
  22 #include "LyXRC.h"
  23 #include "Paragraph.h"
  24 #include "version.h"
  25
  26 #include "support/debug.h"
  27
  28 #include <QApplication>
  29 #include <QAbstractListModel>
  30 #include <QHeaderView>
  31 #include <QPainter>
  32 #include <QPixmapCache>
  33 #include <QScrollBar>
  34 #include <QItemDelegate>
  35 #include <QTreeView>
  36 #include <QTimer>
  37
  38 using namespace std;
  39 using namespace lyx::support;
  40
  41 namespace lyx {
  42 namespace frontend {
  43
  44 class RtlItemDelegate : public QItemDelegate {
  45 public:
  46         explicit RtlItemDelegate(QObject * parent = 0)
  47                 : QItemDelegate(parent) {}
  48
  49         void setEnabled(bool enabled = true)
  50         {
  51                 enabled_ = enabled;
  52         }
  53
  54 protected:
  55         virtual void drawDisplay(QPainter * painter,
  56                 QStyleOptionViewItem const & option,
  57                 QRect const & rect, QString const & text) const
  58         {
  59                 if (!enabled_)
  60                         return QItemDelegate::drawDisplay(painter, option, rect, text);
  61
  62                 // FIXME: do this more elegantly
  63                 docstring stltext = qstring_to_ucs4(text);
  64                 reverse(stltext.begin(), stltext.end());
  65                 QItemDelegate::drawDisplay(painter, option, rect, toqstr(stltext));
  66         }
  67
  68 private:
  69         bool enabled_;
  70 };
  71
  72
  73 class PixmapItemDelegate : public QItemDelegate {
  74 public:
  75         explicit PixmapItemDelegate(QObject *parent = 0)
  76         : QItemDelegate(parent) {}
  77
  78 protected:
  79         void paint(QPainter *painter, const QStyleOptionViewItem &option,
  80                    const QModelIndex &index) const
  81         {
  82                 QStyleOptionViewItem opt = setOptions(index, option);
  83                 QVariant value = index.data(Qt::DisplayRole);
  84                 QPixmap pixmap = qvariant_cast<QPixmap>(value);
  85
  86                 // draw
  87                 painter->save();
  88                 drawBackground(painter, opt, index);
  89                 if (!pixmap.isNull()) {
  90                         const QSize size = pixmap.size();
  91                         painter->drawPixmap(option.rect.left() + (16 - size.width()) / 2,
  92                                 option.rect.top() + (option.rect.height() - size.height()) / 2,
  93                                 pixmap);
  94                 }
  95                 drawFocus(painter, opt, option.rect);
  96                 painter->restore();
  97         }
  98 };
  99
 100
 101 class GuiCompletionModel : public QAbstractListModel {
 102 public:
 103         ///
 104         GuiCompletionModel(QObject * parent,
 105                 Inset::CompletionList const * l)
 106                 : QAbstractListModel(parent), list_(l) {}
 107         ///
 108         ~GuiCompletionModel()
 109                 { delete list_; }
 110         ///
 111         bool sorted() const
 112         {
 113                 if (list_)
 114                         return list_->sorted();
 115                 else
 116                         return false;
 117         }
 118         ///
 119         int columnCount(const QModelIndex & /*parent*/ = QModelIndex()) const
 120         {
 121                 return 2;
 122         }
 123         ///
 124         int rowCount(const QModelIndex & /*parent*/ = QModelIndex()) const
 125         {
 126                 if (list_ == 0)
 127                         return 0;
 128                 else
 129                         return list_->size();
 130         }
 131
 132         ///
 133         QVariant data(const QModelIndex & index, int role) const
 134         {
 135                 if (list_ == 0)
 136                         return QVariant();
 137
 138                 if (index.row() < 0 || index.row() >= rowCount())
 139                         return QVariant();
 140
 141                 if (role != Qt::DisplayRole && role != Qt::EditRole)
 142                     return QVariant();
 143
 144                 if (index.column() == 0)
 145                         return toqstr(list_->data(index.row()));
 146                 else if (index.column() == 1) {
 147                         // get icon from cache
 148                         QPixmap scaled;
 149                         QString const name = ":" + toqstr(list_->icon(index.row()));
 150                         if (!QPixmapCache::find("completion" + name, scaled)) {
 151                                 // load icon from disk
 152                                 QPixmap p = QPixmap(name);
 153                                 if (!p.isNull()) {
 154                                         // scale it to 16x16 or smaller
 155                                         scaled = p.scaled(min(16, p.width()), min(16, p.height()),
 156                                                 Qt::KeepAspectRatio, Qt::SmoothTransformation);
 157                                 }
 158
 159                                 QPixmapCache::insert("completion" + name, scaled);
 160                         }
 161                         return scaled;
 162                 }
 163                 return QVariant();
 164         }
 165
 166 private:
 167         ///
 168         Inset::CompletionList const * list_;
 169 };
 170
 171
 172 GuiCompleter::GuiCompleter(GuiWorkArea * gui, QObject * parent)
 173         : QCompleter(parent), gui_(gui), updateLock_(0),
 174           inlineVisible_(false)
 175 {
 176         // Setup the completion popup
 177         setModel(new GuiCompletionModel(this, 0));
 178         setCompletionMode(QCompleter::PopupCompletion);
 179         setWidget(gui_);
 180
 181         // create the popup
 182         QTreeView *listView = new QTreeView;
 183         listView->setEditTriggers(QAbstractItemView::NoEditTriggers);
 184         listView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 185         listView->setSelectionBehavior(QAbstractItemView::SelectRows);
 186         listView->setSelectionMode(QAbstractItemView::SingleSelection);
 187         listView->header()->hide();
 188         listView->setIndentation(0);
 189         listView->setUniformRowHeights(true);
 190         setPopup(listView);
 191         popup()->setItemDelegateForColumn(1, new PixmapItemDelegate(this));
 192         rtlItemDelegate_ = new RtlItemDelegate(this);
 193         popup()->setItemDelegateForColumn(0, rtlItemDelegate_);
 194
 195         // create timeout timers
 196         popup_timer_.setSingleShot(true);
 197         inline_timer_.setSingleShot(true);
 198         connect(this, SIGNAL(highlighted(const QString &)),
 199                 this, SLOT(popupHighlighted(const QString &)));
 200         connect(this, SIGNAL(activated(const QString &)),
 201                 this, SLOT(popupActivated(const QString &)));
 202         connect(&popup_timer_, SIGNAL(timeout()),
 203                 this, SLOT(showPopup()));
 204         connect(&inline_timer_, SIGNAL(timeout()),
 205                 this, SLOT(showInline()));
 206 }
 207
 208
 209 GuiCompleter::~GuiCompleter()
 210 {
 211         popup()->hide();
 212 }
 213
 214
 215 bool GuiCompleter::eventFilter(QObject * watched, QEvent * e)
 216 {
 217         // hijack back the tab key from the popup
 218         // (which stole it from the workspace before)
 219         if (e->type() == QEvent::KeyPress && popupVisible()) {
 220                 QKeyEvent *ke = static_cast<QKeyEvent *>(e);
 221                 switch (ke->key()) {
 222                 case Qt::Key_Tab:
 223                         tab();
 224                         ke->accept();
 225                         return true;
 226                 default: break;
 227                 }
 228         }
 229
 230         return QCompleter::eventFilter(watched, e);
 231 }
 232
 233
 234 bool GuiCompleter::popupPossible(Cursor const & cur) const
 235 {
 236         return QApplication::activeWindow()
 237                 && gui_->hasFocus()
 238                 && cur.inset().completionSupported(cur);
 239 }
 240
 241
 242 bool GuiCompleter::inlinePossible(Cursor const & cur) const
 243 {
 244         return cur.inset().inlineCompletionSupported(cur);
 245 }
 246
 247
 248 bool GuiCompleter::completionAvailable() const
 249 {
 250         size_t n = popup()->model()->rowCount();
 251
 252         // if there is exactly one, we have to check whether it is a
 253         // real completion, i.e. longer than the current prefix.
 254         if (n == 1 && completionPrefix() == currentCompletion())
 255             return false;
 256
 257         return n > 0;
 258 }
 259
 260
 261 bool GuiCompleter::popupVisible() const
 262 {
 263         return popup()->isVisible();
 264 }
 265
 266
 267 bool GuiCompleter::inlineVisible() const
 268 {
 269         // In fact using BufferView::inlineCompletionPos.empty() should be
 270         // here. But unfortunately this information is not good enough
 271         // because destructive operations like backspace might invalidate
 272         // inlineCompletionPos. But then the completion should stay visible
 273         // (i.e. reshown on the next update). Hence be keep this information
 274         // in the inlineVisible_ variable.
 275         return inlineVisible_;
 276 }
 277
 278
 279 void GuiCompleter::updateVisibility(Cursor & cur, bool start, bool keep, bool cursorInView)
 280 {
 281         // parameters which affect the completion
 282         bool moved = cur != old_cursor_;
 283         if (moved)
 284                 old_cursor_ = cur;
 285
 286         bool possiblePopupState = popupPossible(cur) && cursorInView;
 287         bool possibleInlineState = inlinePossible(cur) && cursorInView;
 288
 289         // we moved or popup state is not ok for popup?
 290         if ((moved && !keep) || !possiblePopupState)
 291                 hidePopup(cur);
 292
 293         // we moved or inline state is not ok for inline completion?
 294         if ((moved && !keep) || !possibleInlineState)
 295                 hideInline(cur);
 296
 297         // we inserted something and are in a possible popup state?
 298         if (!popupVisible() && possiblePopupState && start
 299                 && cur.inset().automaticPopupCompletion())
 300                 popup_timer_.start(int(lyxrc.completion_popup_delay * 1000));
 301
 302         // we inserted something and are in a possible inline completion state?
 303         if (!inlineVisible() && possibleInlineState && start
 304                 && cur.inset().automaticInlineCompletion())
 305                 inline_timer_.start(int(lyxrc.completion_inline_delay * 1000));
 306
 307         // update prefix if any completion is possible
 308         bool modelActive = model()->rowCount() > 0;
 309         if (possiblePopupState || possibleInlineState) {
 310                 if (modelActive)
 311                         updatePrefix(cur);
 312                 else
 313                         updateAvailability();
 314         }
 315 }
 316
 317
 318 void GuiCompleter::updateVisibility(bool start, bool keep)
 319 {
 320         Cursor cur = gui_->bufferView().cursor();
 321         cur.updateFlags(Update::None);
 322
 323         updateVisibility(cur, start, keep);
 324
 325         if (cur.disp_.update())
 326                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 327 }
 328
 329
 330 void GuiCompleter::updatePrefix(Cursor & cur)
 331 {
 332         // get new prefix. Do nothing if unchanged
 333         QString newPrefix = toqstr(cur.inset().completionPrefix(cur));
 334         if (newPrefix == completionPrefix())
 335                 return;
 336
 337         // value which should be kept selected
 338         QString old = currentCompletion();
 339         if (old.length() == 0)
 340                 old = last_selection_;
 341
 342         // update completer to new prefix
 343         setCompletionPrefix(newPrefix);
 344
 345         // update popup because its size might have changed
 346         if (popupVisible())
 347                 updatePopup(cur);
 348
 349         // restore old selection
 350         setCurrentCompletion(old);
 351
 352         // if popup is not empty, the new selection will
 353         // be our last valid one
 354         QString const & s = currentCompletion();
 355         if (popupVisible() || inlineVisible()) {
 356                 if (s.length() > 0)
 357                         last_selection_ = s;
 358                 else
 359                         last_selection_ = old;
 360         }
 361
 362         // update inline completion because the default
 363         // completion string might have changed
 364         if (inlineVisible())
 365                 updateInline(cur, s);
 366 }
 367
 368
 369 void GuiCompleter::updateInline(Cursor & cur, QString const & completion)
 370 {
 371         if (!cur.inset().inlineCompletionSupported(cur))
 372                 return;
 373
 374         // compute postfix
 375         docstring prefix = cur.inset().completionPrefix(cur);
 376         docstring postfix = from_utf8(fromqstr(completion.mid(prefix.length())));
 377
 378         // shorten it if necessary
 379         if (lyxrc.completion_inline_dots != -1
 380             && postfix.size() > unsigned(lyxrc.completion_inline_dots))
 381                 postfix = postfix.substr(0, lyxrc.completion_inline_dots - 1) + "...";
 382
 383         // set inline completion at cursor position
 384         size_t uniqueTo = max(longestUniqueCompletion().size(), prefix.size());
 385         gui_->bufferView().setInlineCompletion(cur, cur, postfix, uniqueTo - prefix.size());
 386         inlineVisible_ = true;
 387 }
 388
 389
 390 void GuiCompleter::updatePopup(Cursor & cur)
 391 {
 392         if (!cur.inset().completionSupported(cur))
 393                 return;
 394
 395         if (completionCount() == 0)
 396                 return;
 397
 398         // get dimensions of completion prefix
 399         Dimension dim;
 400         int x;
 401         int y;
 402         cur.inset().completionPosAndDim(cur, x, y, dim);
 403
 404         // and calculate the rect of the popup
 405         QRect rect;
 406         if (popup()->layoutDirection() == Qt::RightToLeft)
 407                 rect = QRect(x + dim.width() - 200, y - dim.ascent() - 3, 200, dim.height() + 6);
 408         else
 409                 rect = QRect(x, y - dim.ascent() - 3, 200, dim.height() + 6);
 410
 411         // show/update popup
 412         QTreeView * p = static_cast<QTreeView *>(popup());
 413         p->setColumnWidth(0, popup()->width() - 22 - p->verticalScrollBar()->width());
 414
 415         complete(rect);
 416 }
 417
 418
 419 void GuiCompleter::updateAvailability()
 420 {
 421         // this should really only be of interest if no completion is
 422         // visible yet, i.e. especially if automatic completion is disabled.
 423         if (inlineVisible() || popupVisible())
 424                 return;
 425         Cursor & cur = gui_->bufferView().cursor();
 426         if (!popupPossible(cur) && !inlinePossible(cur))
 427                 return;
 428
 429         updateModel(cur, false, false);
 430 }
 431
 432
 433 void GuiCompleter::updateModel(Cursor & cur, bool popupUpdate, bool inlineUpdate)
 434 {
 435         // value which should be kept selected
 436         QString old = currentCompletion();
 437         if (old.length() == 0)
 438                 old = last_selection_;
 439
 440         // set whether rtl
 441         bool rtl = false;
 442         if (cur.inTexted()) {
 443                 Paragraph const & par = cur.paragraph();
 444                 Font const font =
 445                 par.getFontSettings(cur.bv().buffer().params(), cur.pos());
 446                 rtl = font.isVisibleRightToLeft();
 447         }
 448         popup()->setLayoutDirection(rtl ? Qt::RightToLeft : Qt::LeftToRight);
 449
 450         // turn the direction of the strings in the popup.
 451         // Qt does not do that itself.
 452         rtlItemDelegate_->setEnabled(rtl);
 453
 454         // set new model
 455         Inset::CompletionList const * list = cur.inset().createCompletionList(cur);
 456         setModel(new GuiCompletionModel(this, list));
 457         if (list->sorted())
 458                 setModelSorting(QCompleter::CaseSensitivelySortedModel);
 459         else
 460                 setModelSorting(QCompleter::UnsortedModel);
 461
 462         // set prefix
 463         QString newPrefix = toqstr(cur.inset().completionPrefix(cur));
 464         if (newPrefix != completionPrefix())
 465                 setCompletionPrefix(newPrefix);
 466
 467         // show popup
 468         if (popupUpdate)
 469                 updatePopup(cur);
 470
 471         // restore old selection
 472         setCurrentCompletion(old);
 473
 474         // if popup is not empty, the new selection will
 475         // be our last valid one
 476         if (popupVisible() || inlineVisible()) {
 477                 QString const & s = currentCompletion();
 478                 if (s.length() > 0)
 479                         last_selection_ = s;
 480                 else
 481                         last_selection_ = old;
 482         }
 483
 484         // show inline completion
 485         if (inlineUpdate)
 486                 updateInline(cur, currentCompletion());
 487 }
 488
 489
 490 void GuiCompleter::showPopup(Cursor & cur)
 491 {
 492         if (!popupPossible(cur))
 493                 return;
 494
 495         updateModel(cur, true, inlineVisible());
 496 }
 497
 498
 499 void GuiCompleter::hidePopup(Cursor & cur)
 500 {
 501         // hide popup asynchronously because we might be here inside of
 502         // LFUN dispatchers. Hiding a popup can trigger a focus event on the
 503         // workarea which then redisplays the cursor. But the metrics are not
 504         // yet up to date such that the coord cache has not all insets yet. The
 505         // cursorPos methods would triggers asserts in the coord cache then.
 506         QTimer::singleShot(0, popup(), SLOT(hide()));
 507
 508         if (popup_timer_.isActive())
 509                 popup_timer_.stop();
 510
 511         if (!inlineVisible())
 512                 setModel(new GuiCompletionModel(this, 0));
 513 }
 514
 515
 516 void GuiCompleter::showInline(Cursor & cur)
 517 {
 518         if (!inlinePossible(cur))
 519                 return;
 520
 521         updateModel(cur, popupVisible(), true);
 522 }
 523
 524
 525 void GuiCompleter::hideInline(Cursor & cur)
 526 {
 527         gui_->bufferView().setInlineCompletion(cur, DocIterator(), docstring());
 528         inlineVisible_ = false;
 529
 530         if (!popupVisible())
 531                 setModel(new GuiCompletionModel(this, 0));
 532 }
 533
 534
 535 void GuiCompleter::showPopup()
 536 {
 537         Cursor cur = gui_->bufferView().cursor();
 538         cur.updateFlags(Update::None);
 539
 540         showPopup(cur);
 541
 542         // redraw if needed
 543         if (cur.disp_.update())
 544                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 545 }
 546
 547
 548 void GuiCompleter::showInline()
 549 {
 550         Cursor cur = gui_->bufferView().cursor();
 551         cur.updateFlags(Update::None);
 552
 553         showInline(cur);
 554
 555         // redraw if needed
 556         if (cur.disp_.update())
 557                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 558 }
 559
 560
 561 void GuiCompleter::hidePopup()
 562 {
 563         Cursor cur = gui_->bufferView().cursor();
 564         cur.updateFlags(Update::None);
 565
 566         hidePopup(cur);
 567
 568         // redraw if needed
 569         if (cur.disp_.update())
 570                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 571 }
 572
 573
 574 void GuiCompleter::hideInline()
 575 {
 576         Cursor cur = gui_->bufferView().cursor();
 577         cur.updateFlags(Update::None);
 578
 579         hideInline(cur);
 580
 581         // redraw if needed
 582         if (cur.disp_.update())
 583                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 584 }
 585
 586
 587 void GuiCompleter::activate()
 588 {
 589         if (!popupVisible() && !inlineVisible())
 590                 return;
 591
 592         popupActivated(currentCompletion());
 593 }
 594
 595
 596 void GuiCompleter::tab()
 597 {
 598         BufferView * bv = &gui_->bufferView();
 599         Cursor cur = bv->cursor();
 600         cur.updateFlags(Update::None);
 601
 602         // check that inline completion is active
 603         if (!inlineVisible()) {
 604                 // try to activate the inline completion
 605                 if (cur.inset().inlineCompletionSupported(cur)) {
 606                         showInline();
 607
 608                         // show popup without delay because the completion was not unique
 609                         if (lyxrc.completion_popup_after_complete
 610                             && !popupVisible()
 611                             && popup()->model()->rowCount() > 1)
 612                                 popup_timer_.start(0);
 613
 614                         return;
 615                 }
 616                 // or try popup
 617                 if (!popupVisible() && cur.inset().completionSupported(cur)) {
 618                         showPopup();
 619                         return;
 620                 }
 621
 622                 return;
 623         }
 624
 625         // If completion is active, at least complete by one character
 626         docstring prefix = cur.inset().completionPrefix(cur);
 627         docstring completion = from_utf8(fromqstr(currentCompletion()));
 628         if (completion.size() <= prefix.size()) {
 629                 // finalize completion
 630                 cur.inset().insertCompletion(cur, docstring(), true);
 631
 632                 // hide popup and inline completion
 633                 hidePopup(cur);
 634                 hideInline(cur);
 635                 updateVisibility(false, false);
 636                 return;
 637         }
 638         docstring nextchar = completion.substr(prefix.size(), 1);
 639         if (!cur.inset().insertCompletion(cur, nextchar, false))
 640                 return;
 641         updatePrefix(cur);
 642
 643         // try to complete as far as it is unique
 644         docstring longestCompletion = longestUniqueCompletion();
 645         prefix = cur.inset().completionPrefix(cur);
 646         docstring postfix = longestCompletion.substr(min(longestCompletion.size(), prefix.size()));
 647         cur.inset().insertCompletion(cur, postfix, false);
 648         old_cursor_ = bv->cursor();
 649         updatePrefix(cur);
 650
 651         // show popup without delay because the completion was not unique
 652         if (lyxrc.completion_popup_after_complete
 653             && !popupVisible()
 654             && popup()->model()->rowCount() > 1)
 655                 popup_timer_.start(0);
 656
 657         // redraw if needed
 658         if (cur.disp_.update())
 659                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 660 }
 661
 662
 663 QString GuiCompleter::currentCompletion() const
 664 {
 665         if (!popup()->selectionModel()->hasSelection())
 666                 return QString();
 667
 668         // Not sure if this is bug in Qt: currentIndex() always
 669         // return the first element in the list.
 670         QModelIndex idx = popup()->currentIndex();
 671         return popup()->model()->data(idx, Qt::EditRole).toString();
 672 }
 673
 674
 675 void GuiCompleter::setCurrentCompletion(QString const & s)
 676 {
 677         QAbstractItemModel const & model = *popup()->model();
 678         size_t n = model.rowCount();
 679         if (n == 0)
 680                 return;
 681
 682         // select the first if s is empty
 683         if (s.length() == 0) {
 684                 updateLock_++;
 685                 popup()->setCurrentIndex(model.index(0, 0));
 686                 updateLock_--;
 687                 return;
 688         }
 689
 690         // find old selection in model
 691         size_t i;
 692         if (modelSorting() == QCompleter::UnsortedModel) {
 693                 // In unsorted models, iterate through list until the s is found
 694                 for (i = 0; i < n; ++i) {
 695                         QString const & is
 696                         = model.data(model.index(i, 0), Qt::EditRole).toString();
 697                         if (is == s)
 698                                 break;
 699                 }
 700         } else {
 701                 // In sorted models, do binary search for s.
 702                 int l = 0;
 703                 int r = n - 1;
 704                 while (r >= l && l < int(n)) {
 705                         size_t mid = (r + l) / 2;
 706                         QString const & mids
 707                         = model.data(model.index(mid, 0),
 708                                      Qt::EditRole).toString();
 709
 710                         // left or right?
 711                         // FIXME: is this really the same order that the docstring
 712                         // from the CompletionList has?
 713                         int c = s.compare(mids, Qt::CaseSensitive);
 714                         if (c == 0) {
 715                                 l = mid;
 716                                 break;
 717                         } else if (l == r) {
 718                                 l = n;
 719                                 break;
 720                         } else if (c > 0)
 721                                 // middle is not far enough
 722                                 l = mid + 1;
 723                         else
 724                                 // middle is too far
 725                                 r = mid - 1;
 726                 }
 727
 728                 // loop was left without finding anything
 729                 if (r < l)
 730                         i = n;
 731                 else
 732                         i = l;
 733                 BOOST_ASSERT(0 <= i && i <= n);
 734         }
 735
 736         // select the first if none was found
 737         if (i == n)
 738                 i = 0;
 739
 740         updateLock_++;
 741         popup()->setCurrentIndex(model.index(i, 0));
 742         updateLock_--;
 743 }
 744
 745
 746 size_t commonPrefix(QString const & s1, QString const & s2)
 747 {
 748         // find common prefix
 749         size_t j;
 750         size_t n1 = s1.length();
 751         size_t n2 = s2.length();
 752         for (j = 0; j < n1 && j < n2; ++j) {
 753                 if (s1.at(j) != s2.at(j))
 754                         break;
 755         }
 756         return j;
 757 }
 758
 759
 760 docstring GuiCompleter::longestUniqueCompletion() const
 761 {
 762         QAbstractItemModel const & model = *popup()->model();
 763         size_t n = model.rowCount();
 764         if (n == 0)
 765                 return docstring();
 766         QString s = model.data(model.index(0, 0), Qt::EditRole).toString();
 767
 768         if (modelSorting() == QCompleter::UnsortedModel) {
 769                 // For unsorted model we cannot do more than iteration.
 770                 // Iterate through the completions and cut off where s differs
 771                 for (size_t i = 0; i < n && s.length() > 0; ++i) {
 772                         QString const & is
 773                         = model.data(model.index(i, 0), Qt::EditRole).toString();
 774
 775                         s = s.left(commonPrefix(is, s));
 776                 }
 777         } else {
 778                 // For sorted models we can do binary search multiple times,
 779                 // each time to find the first string which has s not as prefix.
 780                 size_t i = 0;
 781                 while (i < n && s.length() > 0) {
 782                         // find first string that does not have s as prefix
 783                         // via binary search in [i,n-1]
 784                         size_t r = n - 1;
 785                         do {
 786                                 // get common prefix with the middle string
 787                                 size_t mid = (r + i) / 2;
 788                                 QString const & mids
 789                                 = model.data(model.index(mid, 0),
 790                                         Qt::EditRole).toString();
 791                                 size_t oldLen = s.length();
 792                                 size_t len = commonPrefix(mids, s);
 793                                 s = s.left(len);
 794
 795                                 // left or right?
 796                                 if (oldLen == len) {
 797                                         // middle is not far enough
 798                                         i = mid + 1;
 799                                 } else {
 800                                         // middle is maybe too far
 801                                         r = mid;
 802                                 }
 803                         } while (r - i > 0 && i < n);
 804                 }
 805         }
 806
 807         return from_utf8(fromqstr(s));
 808 }
 809
 810
 811 void GuiCompleter::popupActivated(const QString & completion)
 812 {
 813         Cursor cur = gui_->bufferView().cursor();
 814         cur.updateFlags(Update::None);
 815
 816         docstring prefix = cur.inset().completionPrefix(cur);
 817         docstring postfix = from_utf8(fromqstr(completion.mid(prefix.length())));
 818         cur.inset().insertCompletion(cur, postfix, true);
 819         hidePopup(cur);
 820         hideInline(cur);
 821
 822         if (cur.disp_.update())
 823                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 824 }
 825
 826
 827 void GuiCompleter::popupHighlighted(const QString & completion)
 828 {
 829         if (updateLock_ > 0)
 830                 return;
 831
 832         Cursor cur = gui_->bufferView().cursor();
 833         cur.updateFlags(Update::None);
 834
 835         if (inlineVisible())
 836                 updateInline(cur, completion);
 837
 838         if (cur.disp_.update())
 839                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 840 }
 841
 842 } // namespace frontend
 843 } // namespace lyx
 844
 845 #include "GuiCompleter_moc.cpp"