File indexing completed on 2024-04-14 03:55:02

 /*
     SPDX-FileCopyrightText: 2005-2006 Hamish Rodda <rodda@kde.org>
     SPDX-FileCopyrightText: 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #ifndef KATECOMPLETIONMODEL_H
 #define KATECOMPLETIONMODEL_H
 
 #include <QAbstractProxyModel>
 #include <QList>
 #include <QPair>
 
 #include <ktexteditor/codecompletionmodel.h>
 
 #include "expandingtree/expandingwidgetmodel.h"
 #include <ktexteditor_export.h>
 
 #include <set>
 
 class KateCompletionWidget;
 class KateArgumentHintModel;
 namespace KTextEditor
 {
 class ViewPrivate;
 }
 class QWidget;
 class QTextEdit;
 class QTimer;
 class HierarchicalModelHandler;
 
 /**
  * This class has the responsibility for filtering, sorting, and manipulating
  * code completion data provided by a CodeCompletionModel.
  *
  * @author Hamish Rodda <rodda@kde.org>
  */
 class KateCompletionModel : public ExpandingWidgetModel
 {
     Q_OBJECT
 
 public:
     enum InternalRole {
         IsNonEmptyGroup = KTextEditor::CodeCompletionModel::LastExtraItemDataRole + 1,
     };
 
     explicit KateCompletionModel(KateCompletionWidget *parent = nullptr);
     ~KateCompletionModel() override;
 
     QList<KTextEditor::CodeCompletionModel *> completionModels() const;
     void clearCompletionModels();
     KTEXTEDITOR_EXPORT void addCompletionModel(KTextEditor::CodeCompletionModel *model);
     KTEXTEDITOR_EXPORT void setCompletionModel(KTextEditor::CodeCompletionModel *model);
     void setCompletionModels(const QList<KTextEditor::CodeCompletionModel *> &models);
     KTEXTEDITOR_EXPORT void removeCompletionModel(KTextEditor::CodeCompletionModel *model);
 
     KTextEditor::ViewPrivate *view() const;
     KateCompletionWidget *widget() const;
 
     KTEXTEDITOR_EXPORT QString currentCompletion(KTextEditor::CodeCompletionModel *model) const;
     void setCurrentCompletion(QMap<KTextEditor::CodeCompletionModel *, QString> currentMatch);
 
     int translateColumn(int sourceColumn) const;
 
     /// Returns a common prefix for all current visible completion entries
     /// If there is no common prefix, extracts the next useful prefix for the selected index
     QString commonPrefix(QModelIndex selectedIndex) const;
 
     void rowSelected(const QModelIndex &row) const;
 
     bool indexIsItem(const QModelIndex &index) const override;
 
     int columnCount(const QModelIndex &parent = QModelIndex()) const override;
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
     Qt::ItemFlags flags(const QModelIndex &index) const override;
     bool hasChildren(const QModelIndex &parent = QModelIndex()) const override;
     virtual bool hasIndex(int row, int column, const QModelIndex &parent = QModelIndex()) const;
     QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
 
     // Disabled in case of bugs, reenable once fully debugged.
     // virtual QMap<int, QVariant> itemData ( const QModelIndex & index ) const;
     QModelIndex parent(const QModelIndex &index) const override;
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
 
     /// Maps from this display-model into the appropriate source code-completion model
     virtual QModelIndex mapToSource(const QModelIndex &proxyIndex) const;
 
     /// Maps from an index in a source-model to the index of the item in this display-model
     virtual QModelIndex mapFromSource(const QModelIndex &sourceIndex) const;
 
     enum gm { ScopeType = 0x1, Scope = 0x2, AccessType = 0x4, ItemType = 0x8 };
 
     enum { // An own property that will be used to mark the best-matches group internally
         BestMatchesProperty = 2 * KTextEditor::CodeCompletionModel::LastProperty
     };
 
     Q_DECLARE_FLAGS(GroupingMethods, gm)
 
     static const int ScopeTypeMask = 0x380000;
     static const int AccessTypeMask = 0x7;
     static const int ItemTypeMask = 0xfe0;
 
     void debugStats();
 
     /// Returns whether one of the filtered items exactly matches its completion string
     bool shouldMatchHideCompletionList() const;
 
     KTEXTEDITOR_EXPORT uint filteredItemCount() const;
 
 protected:
     int contextMatchQuality(const QModelIndex &index) const override;
 
 Q_SIGNALS:
     void expandIndex(const QModelIndex &index);
     // Emitted whenever something has changed about the group of argument-hints
     void argumentHintsChanged();
 
 private Q_SLOTS:
     void slotRowsInserted(const QModelIndex &parent, int start, int end);
     void slotRowsRemoved(const QModelIndex &parent, int start, int end);
     void slotModelReset();
 
     // Updates the best-matches group
     void updateBestMatches();
     // Makes sure that the ungrouped group contains each item only once
     // Must only be called right after the group was created
     void makeGroupItemsUnique(bool onlyFiltered = false);
 
 private:
     typedef QPair<KTextEditor::CodeCompletionModel *, QModelIndex> ModelRow;
     virtual int contextMatchQuality(const ModelRow &sourceRow) const;
 
     QTreeView *treeView() const override;
 
     friend class KateArgumentHintModel;
     static ModelRow modelRowPair(const QModelIndex &index);
 
     // Represents a source row; provides sorting method
     class Item
     {
     public:
         Item(bool doInitialMatch, KateCompletionModel *model, const HierarchicalModelHandler &handler, ModelRow sourceRow);
 
         // Returns true if the item is not filtered and matches the current completion string
         bool isVisible() const;
 
         enum MatchType { NoMatch = 0, PerfectMatch, StartsWithMatch, AbbreviationMatch, ContainsMatch };
         MatchType match(KateCompletionModel *model);
 
         const ModelRow &sourceRow() const;
 
         // Sorting operator
         bool lessThan(KateCompletionModel *model, const Item &rhs) const;
 
         bool haveExactMatch() const
         {
             return m_haveExactMatch;
         }
 
         QString name() const
         {
             return m_nameColumn;
         }
 
     private:
         ModelRow m_sourceRow;
 
         QString m_nameColumn;
 
         int inheritanceDepth;
 
         // True when currently matching completion string
         MatchType matchCompletion;
         bool m_haveExactMatch;
         bool m_unimportant;
     };
 
 public:
     // Grouping and sorting of rows
     class Group
     {
     public:
         explicit Group(const QString &title, int attribute, KateCompletionModel *model);
 
         void addItem(const Item &i, bool notifyModel = false);
         /// Removes the item specified by \a row.  Returns true if a change was made to rows.
         bool removeItem(const ModelRow &row);
         void resort();
         void clear();
         // Returns whether this group should be ordered before other
         bool orderBefore(Group *other) const;
         // Returns a number that can be used for ordering
         int orderNumber() const;
 
         /// Returns the row in the this group's filtered list of the given model-row in a source-model
         ///-1 if the item is not in the filtered list
         ///@todo Implement an efficient way of doing this map, that does _not_ iterate over all items!
         int rowOf(const ModelRow &item)
         {
             for (int a = 0; a < (int)filtered.size(); ++a) {
                 if (filtered[a].sourceRow() == item) {
                     return a;
                 }
             }
             return -1;
         }
 
         KateCompletionModel *model;
         int attribute;
         QString title, scope;
         std::vector<Item> filtered;
         std::vector<Item> prefilter;
         bool isEmpty;
         //-1 if none was set
         int customSortingKey;
     };
 
     typedef std::set<Group *> GroupSet;
 
     bool hasGroups() const
     {
         // qCDebug(LOG_KTE) << "m_groupHash.size()"<<m_groupHash.size();
         // qCDebug(LOG_KTE) << "m_rowTable.count()"<<m_rowTable.count();
         return m_hasGroups;
     }
 
 private:
     QString commonPrefixInternal(const QString &forcePrefix) const;
     /// @note performs model reset
     void createGroups();
     /// Creates all sub-items of index i, or the item corresponding to index i. Returns the affected groups.
     /// i must be an index in the source model
     GroupSet createItems(const HierarchicalModelHandler &, const QModelIndex &i, bool notifyModel = false);
     /// Deletes all sub-items of index i, or the item corresponding to index i. Returns the affected groups.
     /// i must be an index in the source model
     GroupSet deleteItems(const QModelIndex &i);
     Group *createItem(const HierarchicalModelHandler &, const QModelIndex &i, bool notifyModel = false);
     /// @note Make sure you're in a {begin,end}ResetModel block when calling this!
     void clearGroups();
     void hideOrShowGroup(Group *g, bool notifyModel = false);
     /// When forceGrouping is enabled, all given attributes will be used for grouping, regardless of the completion settings.
     Group *fetchGroup(int attribute, bool forceGrouping = false);
     // If this returns nonzero on an index, the index is the header of the returned group
     Group *groupForIndex(const QModelIndex &index) const;
     inline Group *groupOfParent(const QModelIndex &child) const
     {
         return static_cast<Group *>(child.internalPointer());
     }
     QModelIndex indexForRow(Group *g, int row) const;
     QModelIndex indexForGroup(Group *g) const;
 
     enum changeTypes { Broaden, Narrow, Change };
 
     // Returns whether the model needs to be reset
     void changeCompletions(Group *g);
 
     bool hasCompletionModel() const;
 
     /// Removes attributes not used in grouping from the input \a attribute
     int groupingAttributes(int attribute) const;
     static int countBits(int value);
 
     void resort();
 
     KTEXTEDITOR_EXPORT static bool matchesAbbreviation(const QString &word, const QString &typed, int &score);
     // exported for completion_test
 
     bool m_hasGroups = false;
 
     // ### Runtime state
     // General
     QList<KTextEditor::CodeCompletionModel *> m_completionModels;
     QMap<KTextEditor::CodeCompletionModel *, QString> m_currentMatch;
 
     // Column merging
     const std::array<std::vector<int>, 3> m_columnMerges = {{
         {0},
         {1, 2, 3, 4},
         {5},
     }};
 
     QTimer *m_updateBestMatchesTimer;
 
     Group *m_ungrouped;
     Group *m_argumentHints; // The argument-hints will be passed on to another model, to be shown in another widget
     Group *m_bestMatches; // A temporary group used for holding the best matches of all visible items
 
     // Storing the sorted order
     std::vector<Group *> m_rowTable;
     std::vector<Group *> m_emptyGroups;
     // Quick access to each specific group (if it exists)
     QMultiHash<int, Group *> m_groupHash;
     // Maps custom group-names to their specific groups
     QHash<QString, Group *> m_customGroupHash;
 
     friend class CompletionTest;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KateCompletionModel::GroupingMethods)
 
 #endif