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