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         popup()->hide();
 502         if (popup_timer_.isActive())
 503                 popup_timer_.stop();
 504
 505         if (!inlineVisible())
 506                 setModel(new GuiCompletionModel(this, 0));
 507 }
 508
 509
 510 void GuiCompleter::showInline(Cursor & cur)
 511 {
 512         if (!inlinePossible(cur))
 513                 return;
 514
 515         updateModel(cur, popupVisible(), true);
 516 }
 517
 518
 519 void GuiCompleter::hideInline(Cursor & cur)
 520 {
 521         gui_->bufferView().setInlineCompletion(cur, DocIterator(), docstring());
 522         inlineVisible_ = false;
 523
 524         if (!popupVisible())
 525                 setModel(new GuiCompletionModel(this, 0));
 526 }
 527
 528
 529 void GuiCompleter::showPopup()
 530 {
 531         Cursor cur = gui_->bufferView().cursor();
 532         cur.updateFlags(Update::None);
 533
 534         showPopup(cur);
 535
 536         // redraw if needed
 537         if (cur.disp_.update())
 538                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 539 }
 540
 541
 542 void GuiCompleter::showInline()
 543 {
 544         Cursor cur = gui_->bufferView().cursor();
 545         cur.updateFlags(Update::None);
 546
 547         showInline(cur);
 548
 549         // redraw if needed
 550         if (cur.disp_.update())
 551                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 552 }
 553
 554
 555 void GuiCompleter::hidePopup()
 556 {
 557         Cursor cur = gui_->bufferView().cursor();
 558         cur.updateFlags(Update::None);
 559
 560         hidePopup(cur);
 561
 562         // redraw if needed
 563         if (cur.disp_.update())
 564                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 565 }
 566
 567
 568 void GuiCompleter::hideInline()
 569 {
 570         Cursor cur = gui_->bufferView().cursor();
 571         cur.updateFlags(Update::None);
 572
 573         hideInline(cur);
 574
 575         // redraw if needed
 576         if (cur.disp_.update())
 577                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 578 }
 579
 580
 581 void GuiCompleter::activate()
 582 {
 583         if (!popupVisible() && !inlineVisible())
 584                 return;
 585
 586         popupActivated(currentCompletion());
 587 }
 588
 589
 590 void GuiCompleter::tab()
 591 {
 592         BufferView * bv = &gui_->bufferView();
 593         Cursor cur = bv->cursor();
 594         cur.updateFlags(Update::None);
 595
 596         // check that inline completion is active
 597         if (!inlineVisible()) {
 598                 // try to activate the inline completion
 599                 if (cur.inset().inlineCompletionSupported(cur)) {
 600                         showInline();
 601
 602                         // show popup without delay because the completion was not unique
 603                         if (lyxrc.completion_popup_after_complete
 604                             && !popupVisible()
 605                             && popup()->model()->rowCount() > 1)
 606                                 popup_timer_.start(0);
 607
 608                         return;
 609                 }
 610                 // or try popup
 611                 if (!popupVisible() && cur.inset().completionSupported(cur)) {
 612                         showPopup();
 613                         return;
 614                 }
 615
 616                 return;
 617         }
 618
 619         // If completion is active, at least complete by one character
 620         docstring prefix = cur.inset().completionPrefix(cur);
 621         docstring completion = from_utf8(fromqstr(currentCompletion()));
 622         if (completion.size() <= prefix.size()) {
 623                 // finalize completion
 624                 cur.inset().insertCompletion(cur, docstring(), true);
 625
 626                 // hide popup and inline completion
 627                 hidePopup(cur);
 628                 hideInline(cur);
 629                 updateVisibility(false, false);
 630                 return;
 631         }
 632         docstring nextchar = completion.substr(prefix.size(), 1);
 633         if (!cur.inset().insertCompletion(cur, nextchar, false))
 634                 return;
 635         updatePrefix(cur);
 636
 637         // try to complete as far as it is unique
 638         docstring longestCompletion = longestUniqueCompletion();
 639         prefix = cur.inset().completionPrefix(cur);
 640         docstring postfix = longestCompletion.substr(min(longestCompletion.size(), prefix.size()));
 641         cur.inset().insertCompletion(cur, postfix, false);
 642         old_cursor_ = bv->cursor();
 643         updatePrefix(cur);
 644
 645         // show popup without delay because the completion was not unique
 646         if (lyxrc.completion_popup_after_complete
 647             && !popupVisible()
 648             && popup()->model()->rowCount() > 1)
 649                 popup_timer_.start(0);
 650
 651         // redraw if needed
 652         if (cur.disp_.update())
 653                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 654 }
 655
 656
 657 QString GuiCompleter::currentCompletion() const
 658 {
 659         if (!popup()->selectionModel()->hasSelection())
 660                 return QString();
 661
 662         // Not sure if this is bug in Qt: currentIndex() always
 663         // return the first element in the list.
 664         QModelIndex idx = popup()->currentIndex();
 665         return popup()->model()->data(idx, Qt::EditRole).toString();
 666 }
 667
 668
 669 void GuiCompleter::setCurrentCompletion(QString const & s)
 670 {
 671         QAbstractItemModel const & model = *popup()->model();
 672         size_t n = model.rowCount();
 673         if (n == 0)
 674                 return;
 675
 676         // select the first if s is empty
 677         if (s.length() == 0) {
 678                 updateLock_++;
 679                 popup()->setCurrentIndex(model.index(0, 0));
 680                 updateLock_--;
 681                 return;
 682         }
 683
 684         // find old selection in model
 685         size_t i;
 686         if (modelSorting() == QCompleter::UnsortedModel) {
 687                 // In unsorted models, iterate through list until the s is found
 688                 for (i = 0; i < n; ++i) {
 689                         QString const & is
 690                         = model.data(model.index(i, 0), Qt::EditRole).toString();
 691                         if (is == s)
 692                                 break;
 693                 }
 694         } else {
 695                 // In sorted models, do binary search for s.
 696                 int l = 0;
 697                 int r = n - 1;
 698                 while (r >= l && l < int(n)) {
 699                         size_t mid = (r + l) / 2;
 700                         QString const & mids
 701                         = model.data(model.index(mid, 0),
 702                                      Qt::EditRole).toString();
 703
 704                         // left or right?
 705                         // FIXME: is this really the same order that the docstring
 706                         // from the CompletionList has?
 707                         int c = s.compare(mids, Qt::CaseSensitive);
 708                         if (c == 0) {
 709                                 l = mid;
 710                                 break;
 711                         } else if (l == r) {
 712                                 l = n;
 713                                 break;
 714                         } else if (c > 0)
 715                                 // middle is not far enough
 716                                 l = mid + 1;
 717                         else
 718                                 // middle is too far
 719                                 r = mid - 1;
 720                 }
 721
 722                 // loop was left without finding anything
 723                 if (r < l)
 724                         i = n;
 725                 else
 726                         i = l;
 727                 BOOST_ASSERT(0 <= i && i <= n);
 728         }
 729
 730         // select the first if none was found
 731         if (i == n)
 732                 i = 0;
 733
 734         updateLock_++;
 735         popup()->setCurrentIndex(model.index(i, 0));
 736         updateLock_--;
 737 }
 738
 739
 740 size_t commonPrefix(QString const & s1, QString const & s2)
 741 {
 742         // find common prefix
 743         size_t j;
 744         size_t n1 = s1.length();
 745         size_t n2 = s2.length();
 746         for (j = 0; j < n1 && j < n2; ++j) {
 747                 if (s1.at(j) != s2.at(j))
 748                         break;
 749         }
 750         return j;
 751 }
 752
 753
 754 docstring GuiCompleter::longestUniqueCompletion() const
 755 {
 756         QAbstractItemModel const & model = *popup()->model();
 757         size_t n = model.rowCount();
 758         if (n == 0)
 759                 return docstring();
 760         QString s = model.data(model.index(0, 0), Qt::EditRole).toString();
 761
 762         if (modelSorting() == QCompleter::UnsortedModel) {
 763                 // For unsorted model we cannot do more than iteration.
 764                 // Iterate through the completions and cut off where s differs
 765                 for (size_t i = 0; i < n && s.length() > 0; ++i) {
 766                         QString const & is
 767                         = model.data(model.index(i, 0), Qt::EditRole).toString();
 768
 769                         s = s.left(commonPrefix(is, s));
 770                 }
 771         } else {
 772                 // For sorted models we can do binary search multiple times,
 773                 // each time to find the first string which has s not as prefix.
 774                 size_t i = 0;
 775                 while (i < n && s.length() > 0) {
 776                         // find first string that does not have s as prefix
 777                         // via binary search in [i,n-1]
 778                         size_t r = n - 1;
 779                         do {
 780                                 // get common prefix with the middle string
 781                                 size_t mid = (r + i) / 2;
 782                                 QString const & mids
 783                                 = model.data(model.index(mid, 0),
 784                                         Qt::EditRole).toString();
 785                                 size_t oldLen = s.length();
 786                                 size_t len = commonPrefix(mids, s);
 787                                 s = s.left(len);
 788
 789                                 // left or right?
 790                                 if (oldLen == len) {
 791                                         // middle is not far enough
 792                                         i = mid + 1;
 793                                 } else {
 794                                         // middle is maybe too far
 795                                         r = mid;
 796                                 }
 797                         } while (r - i > 0 && i < n);
 798                 }
 799         }
 800
 801         return from_utf8(fromqstr(s));
 802 }
 803
 804
 805 void GuiCompleter::popupActivated(const QString & completion)
 806 {
 807         Cursor cur = gui_->bufferView().cursor();
 808         cur.updateFlags(Update::None);
 809
 810         docstring prefix = cur.inset().completionPrefix(cur);
 811         docstring postfix = from_utf8(fromqstr(completion.mid(prefix.length())));
 812         cur.inset().insertCompletion(cur, postfix, true);
 813         hidePopup(cur);
 814         hideInline(cur);
 815
 816         if (cur.disp_.update())
 817                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 818 }
 819
 820
 821 void GuiCompleter::popupHighlighted(const QString & completion)
 822 {
 823         if (updateLock_ > 0)
 824                 return;
 825
 826         Cursor cur = gui_->bufferView().cursor();
 827         cur.updateFlags(Update::None);
 828
 829         if (inlineVisible())
 830                 updateInline(cur, completion);
 831
 832         if (cur.disp_.update())
 833                 gui_->bufferView().processUpdateFlags(cur.disp_.update());
 834 }
 835
 836 } // namespace frontend
 837 } // namespace lyx
 838
 839 #include "GuiCompleter_moc.cpp"