File indexing completed on 2024-04-28 03:53:08

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 1999, 2000, 2001 Carsten Pfeiffer <pfeiffer@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kcompletion.h"
 #include "kcompletion_p.h"
 #include <kcompletion_debug.h>
 
 #include <QCollator>
 
 void KCompletionPrivate::addWeightedItem(const QString &item)
 {
     Q_Q(KCompletion);
     if (order != KCompletion::Weighted) {
         q->addItem(item, 0);
         return;
     }
 
     int len = item.length();
     uint weight = 0;
 
     // find out the weighting of this item (appended to the string as ":num")
     int index = item.lastIndexOf(QLatin1Char(':'));
     if (index > 0) {
         bool ok;
         weight = QStringView(item).mid(index + 1).toUInt(&ok);
         if (!ok) {
             weight = 0;
         }
 
         len = index; // only insert until the ':'
     }
 
     q->addItem(item.left(len), weight);
     return;
 }
 
 // tries to complete "string" from the tree-root
 QString KCompletionPrivate::findCompletion(const QString &string)
 {
     QString completion;
     const KCompTreeNode *node = m_treeRoot.get();
 
     // start at the tree-root and try to find the search-string
     for (const auto ch : string) {
         node = node->find(ch);
 
         if (node) {
             completion += ch;
         } else {
             return QString(); // no completion
         }
     }
 
     // Now we have the last node of the to be completed string.
     // Follow it as long as it has exactly one child (= longest possible
     // completion)
 
     while (node->childrenCount() == 1) {
         node = node->firstChild();
         if (!node->isNull()) {
             completion += *node;
         }
     }
     // if multiple matches and auto-completion mode
     // -> find the first complete match
     if (node && node->childrenCount() > 1) {
         hasMultipleMatches = true;
 
         if (completionMode == KCompletion::CompletionAuto) {
             rotationIndex = 1;
             if (order != KCompletion::Weighted) {
                 while ((node = node->firstChild())) {
                     if (!node->isNull()) {
                         completion += *node;
                     } else {
                         break;
                     }
                 }
             } else {
                 // don't just find the "first" match, but the one with the
                 // highest priority
 
                 const KCompTreeNode *temp_node = nullptr;
                 while (1) {
                     int count = node->childrenCount();
                     temp_node = node->firstChild();
                     uint weight = temp_node->weight();
                     const KCompTreeNode *hit = temp_node;
                     for (int i = 1; i < count; i++) {
                         temp_node = node->childAt(i);
                         if (temp_node->weight() > weight) {
                             hit = temp_node;
                             weight = hit->weight();
                         }
                     }
                     // 0x0 has the highest priority -> we have the best match
                     if (hit->isNull()) {
                         break;
                     }
 
                     node = hit;
                     completion += *node;
                 }
             }
         }
     }
 
     return completion;
 }
 
 void KCompletionPrivate::defaultSort(QStringList &stringList)
 {
     QCollator c;
     c.setCaseSensitivity(Qt::CaseSensitive);
     std::stable_sort(stringList.begin(), stringList.end(), c);
 }
 
 KCompletion::KCompletion()
     : d_ptr(new KCompletionPrivate(this))
 {
     setOrder(Insertion);
 }
 
 KCompletion::~KCompletion()
 {
 }
 
 void KCompletion::setOrder(CompOrder order)
 {
     Q_D(KCompletion);
     d->order = order;
     d->matches.setSorting(order);
 }
 
 KCompletion::CompOrder KCompletion::order() const
 {
     Q_D(const KCompletion);
     return d->order;
 }
 
 void KCompletion::setIgnoreCase(bool ignoreCase)
 {
     Q_D(KCompletion);
     d->ignoreCase = ignoreCase;
 }
 
 bool KCompletion::ignoreCase() const
 {
     Q_D(const KCompletion);
     return d->ignoreCase;
 }
 
 void KCompletion::setItems(const QStringList &itemList)
 {
     clear();
     insertItems(itemList);
 }
 
 void KCompletion::insertItems(const QStringList &items)
 {
     Q_D(KCompletion);
     for (const auto &str : items) {
         if (d->order == Weighted) {
             d->addWeightedItem(str);
         } else {
             addItem(str, 0);
         }
     }
 }
 
 QStringList KCompletion::items() const
 {
     Q_D(const KCompletion);
     KCompletionMatchesWrapper list(d->sorterFunction); // unsorted
     list.extractStringsFromNode(d->m_treeRoot.get(), QString(), d->order == Weighted);
     return list.list();
 }
 
 bool KCompletion::isEmpty() const
 {
     Q_D(const KCompletion);
     return (d->m_treeRoot->childrenCount() == 0);
 }
 
 void KCompletion::postProcessMatch(QString *) const
 {
 }
 
 void KCompletion::postProcessMatches(QStringList *) const
 {
 }
 
 void KCompletion::postProcessMatches(KCompletionMatches *) const
 {
 }
 
 void KCompletion::addItem(const QString &item)
 {
     Q_D(KCompletion);
     d->matches.clear();
     d->rotationIndex = 0;
     d->lastString.clear();
 
     addItem(item, 0);
 }
 
 void KCompletion::addItem(const QString &item, uint weight)
 {
     Q_D(KCompletion);
     if (item.isEmpty()) {
         return;
     }
 
     KCompTreeNode *node = d->m_treeRoot.get();
     int len = item.length();
 
     bool sorted = (d->order == Sorted);
     bool weighted = ((d->order == Weighted) && weight > 1);
 
     // knowing the weight of an item, we simply add this weight to all of its
     // nodes.
 
     for (int i = 0; i < len; i++) {
         node = node->insert(item.at(i), sorted);
         if (weighted) {
             node->confirm(weight - 1); // node->insert() sets weighting to 1
         }
     }
 
     // add 0x0-item as delimiter with evtl. weight
     node = node->insert(QChar(0x0), true);
     if (weighted) {
         node->confirm(weight - 1);
     }
     //     qDebug("*** added: %s (%i)", item.toLatin1().constData(), node->weight());
 }
 
 void KCompletion::removeItem(const QString &item)
 {
     Q_D(KCompletion);
     d->matches.clear();
     d->rotationIndex = 0;
     d->lastString.clear();
 
     d->m_treeRoot->remove(item);
 }
 
 void KCompletion::clear()
 {
     Q_D(KCompletion);
     d->matches.clear();
     d->rotationIndex = 0;
     d->lastString.clear();
 
     d->m_treeRoot.reset(new KCompTreeNode);
 }
 
 QString KCompletion::makeCompletion(const QString &string)
 {
     Q_D(KCompletion);
     if (d->completionMode == CompletionNone) {
         return QString();
     }
 
     // qDebug() << "KCompletion: completing: " << string;
 
     d->matches.clear();
     d->rotationIndex = 0;
     d->hasMultipleMatches = false;
     d->lastMatch = d->currentMatch;
 
     // in Shell-completion-mode, emit all matches when we get the same
     // complete-string twice
     if (d->completionMode == CompletionShell && string == d->lastString) {
         // Don't use d->matches since calling postProcessMatches()
         // on d->matches here would interfere with call to
         // postProcessMatch() during rotation
 
         d->matches.findAllCompletions(d->m_treeRoot.get(), string, d->ignoreCase, d->hasMultipleMatches);
         QStringList l = d->matches.list();
         postProcessMatches(&l);
         Q_EMIT matches(l);
 
         return QString();
     }
 
     QString completion;
     // in case-insensitive popup mode, we search all completions at once
     if (d->completionMode == CompletionPopup || d->completionMode == CompletionPopupAuto) {
         d->matches.findAllCompletions(d->m_treeRoot.get(), string, d->ignoreCase, d->hasMultipleMatches);
         if (!d->matches.isEmpty()) {
             completion = d->matches.first();
         }
     } else {
         completion = d->findCompletion(string);
     }
 
     if (d->hasMultipleMatches) {
         Q_EMIT multipleMatches();
     }
 
     d->lastString = string;
     d->currentMatch = completion;
 
     postProcessMatch(&completion);
 
     if (!string.isEmpty()) { // only emit match when string is not empty
         // qDebug() << "KCompletion: Match: " << completion;
         Q_EMIT match(completion);
     }
 
     return completion;
 }
 
 QStringList KCompletion::substringCompletion(const QString &string) const
 {
     Q_D(const KCompletion);
     // get all items in the tree, eventually in sorted order
     KCompletionMatchesWrapper allItems(d->sorterFunction, d->order);
     allItems.extractStringsFromNode(d->m_treeRoot.get(), QString(), false);
 
     QStringList list = allItems.list();
 
     // subStringMatches is invoked manually, via a shortcut
     if (list.isEmpty()) {
         return list;
     }
 
     if (!string.isEmpty()) { // If it's empty, nothing to compare
         auto it = std::remove_if(list.begin(), list.end(), [&string](const QString &item) {
             return !item.contains(string, Qt::CaseInsensitive); // always case insensitive
         });
         list.erase(it, list.end());
     }
 
     postProcessMatches(&list);
     return list;
 }
 
 void KCompletion::setCompletionMode(CompletionMode mode)
 {
     Q_D(KCompletion);
     d->completionMode = mode;
 }
 
 KCompletion::CompletionMode KCompletion::completionMode() const
 {
     Q_D(const KCompletion);
     return d->completionMode;
 }
 
 void KCompletion::setShouldAutoSuggest(const bool shouldAutoSuggest)
 {
     Q_D(KCompletion);
     d->shouldAutoSuggest = shouldAutoSuggest;
 }
 
 bool KCompletion::shouldAutoSuggest() const
 {
     Q_D(const KCompletion);
     return d->shouldAutoSuggest;
 }
 
 void KCompletion::setSorterFunction(SorterFunction sortFunc)
 {
     Q_D(KCompletion);
     d->sorterFunction = sortFunc ? sortFunc : KCompletionPrivate::defaultSort;
 }
 
 QStringList KCompletion::allMatches()
 {
     Q_D(KCompletion);
     // Don't use d->matches since calling postProcessMatches()
     // on d->matches here would interfere with call to
     // postProcessMatch() during rotation
     KCompletionMatchesWrapper matches(d->sorterFunction, d->order);
     bool dummy;
     matches.findAllCompletions(d->m_treeRoot.get(), d->lastString, d->ignoreCase, dummy);
     QStringList l = matches.list();
     postProcessMatches(&l);
     return l;
 }
 
 KCompletionMatches KCompletion::allWeightedMatches()
 {
     Q_D(KCompletion);
     // Don't use d->matches since calling postProcessMatches()
     // on d->matches here would interfere with call to
     // postProcessMatch() during rotation
     KCompletionMatchesWrapper matches(d->sorterFunction, d->order);
     bool dummy;
     matches.findAllCompletions(d->m_treeRoot.get(), d->lastString, d->ignoreCase, dummy);
     KCompletionMatches ret(matches);
     postProcessMatches(&ret);
     return ret;
 }
 
 QStringList KCompletion::allMatches(const QString &string)
 {
     Q_D(KCompletion);
     KCompletionMatchesWrapper matches(d->sorterFunction, d->order);
     bool dummy;
     matches.findAllCompletions(d->m_treeRoot.get(), string, d->ignoreCase, dummy);
     QStringList l = matches.list();
     postProcessMatches(&l);
     return l;
 }
 
 KCompletionMatches KCompletion::allWeightedMatches(const QString &string)
 {
     Q_D(KCompletion);
     KCompletionMatchesWrapper matches(d->sorterFunction, d->order);
     bool dummy;
     matches.findAllCompletions(d->m_treeRoot.get(), string, d->ignoreCase, dummy);
     KCompletionMatches ret(matches);
     postProcessMatches(&ret);
     return ret;
 }
 
 void KCompletion::setSoundsEnabled(bool enable)
 {
     Q_D(KCompletion);
     d->beep = enable;
 }
 
 bool KCompletion::soundsEnabled() const
 {
     Q_D(const KCompletion);
     return d->beep;
 }
 
 bool KCompletion::hasMultipleMatches() const
 {
     Q_D(const KCompletion);
     return d->hasMultipleMatches;
 }
 
 /////////////////////////////////////////////////////
 ///////////////// tree operations ///////////////////
 
 QString KCompletion::nextMatch()
 {
     Q_D(KCompletion);
     QString completion;
     d->lastMatch = d->currentMatch;
 
     if (d->matches.isEmpty()) {
         d->matches.findAllCompletions(d->m_treeRoot.get(), d->lastString, d->ignoreCase, d->hasMultipleMatches);
         if (!d->matches.isEmpty()) {
             completion = d->matches.first();
         }
         d->currentMatch = completion;
         d->rotationIndex = 0;
         postProcessMatch(&completion);
         Q_EMIT match(completion);
         return completion;
     }
 
     QStringList matches = d->matches.list();
     d->lastMatch = matches[d->rotationIndex++];
 
     if (d->rotationIndex == matches.count()) {
         d->rotationIndex = 0;
     }
 
     completion = matches[d->rotationIndex];
     d->currentMatch = completion;
     postProcessMatch(&completion);
     Q_EMIT match(completion);
     return completion;
 }
 
 const QString &KCompletion::lastMatch() const
 {
     Q_D(const KCompletion);
     return d->lastMatch;
 }
 
 QString KCompletion::previousMatch()
 {
     Q_D(KCompletion);
     QString completion;
     d->lastMatch = d->currentMatch;
 
     if (d->matches.isEmpty()) {
         d->matches.findAllCompletions(d->m_treeRoot.get(), d->lastString, d->ignoreCase, d->hasMultipleMatches);
         if (!d->matches.isEmpty()) {
             completion = d->matches.last();
         }
         d->currentMatch = completion;
         d->rotationIndex = 0;
         postProcessMatch(&completion);
         Q_EMIT match(completion);
         return completion;
     }
 
     QStringList matches = d->matches.list();
     d->lastMatch = matches[d->rotationIndex];
 
     if (d->rotationIndex == 0) {
         d->rotationIndex = matches.count();
     }
 
     d->rotationIndex--;
 
     completion = matches[d->rotationIndex];
     d->currentMatch = completion;
     postProcessMatch(&completion);
     Q_EMIT match(completion);
     return completion;
 }
 
 QSharedPointer<KZoneAllocator> KCompTreeNode::m_alloc(new KZoneAllocator(8 * 1024));
 
 #include "moc_kcompletion.cpp"