File indexing completed on 2024-05-05 04:40:52

 /*
     SPDX-FileCopyrightText: 2007 David Nolden <david.nolden.kdevelop@art-master.de>
 
     SPDX-License-Identifier: LGPL-2.0-only
 */
 
 #include "projectitemquickopen.h"
 
 #include <QIcon>
 
 #include <KLocalizedString>
 
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/icore.h>
 
 #include <language/interfaces/iquickopen.h>
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/functiondefinition.h>
 
 using namespace KDevelop;
 
 DUChainItemData::DUChainItemData(const DUChainItem& file, bool openDefinition)
     : m_item(file)
     , m_openDefinition(openDefinition)
 {
 }
 
 QString DUChainItemData::text() const
 {
     DUChainReadLocker lock;
     Declaration* decl = m_item.m_item.data();
     if (!decl) {
         return i18n("Not available any more: %1", m_item.m_text);
     }
 
     if (auto* def = dynamic_cast<FunctionDefinition*>(decl)) {
         if (def->declaration()) {
             decl = def->declaration();
         }
     }
 
     QString text = decl->qualifiedIdentifier().toString();
 
     if (!decl->abstractType()) {
         //With simplified representation, still mark functions as such by adding parens
         if (dynamic_cast<AbstractFunctionDeclaration*>(decl)) {
             text += QLatin1String("(...)");
         }
     } else if (TypePtr<FunctionType> function = decl->type<FunctionType>()) {
         text += function->partToString(FunctionType::SignatureArguments);
     }
 
     return text;
 }
 
 QList<QVariant> DUChainItemData::highlighting() const
 {
     DUChainReadLocker lock;
 
     Declaration* decl = m_item.m_item.data();
     if (!decl) {
         return QList<QVariant>();
     }
 
     if (auto* def = dynamic_cast<FunctionDefinition*>(decl)) {
         if (def->declaration()) {
             decl = def->declaration();
         }
     }
 
     QTextCharFormat boldFormat;
     boldFormat.setFontWeight(QFont::Bold);
     QTextCharFormat normalFormat;
 
     int prefixLength = 0;
 
     QString signature;
     TypePtr<FunctionType> function = decl->type<FunctionType>();
     if (function) {
         signature = function->partToString(FunctionType::SignatureArguments);
     }
 
     //Only highlight the last part of the qualified identifier, so the scope doesn't distract too much
     QualifiedIdentifier id = decl->qualifiedIdentifier();
     QString fullId = id.toString();
     QString lastId;
     if (!id.isEmpty()) {
         lastId = id.last().toString();
     }
 
     prefixLength += fullId.length() - lastId.length();
 
     QList<QVariant> ret{
         0,
         prefixLength,
         QVariant(normalFormat),
         prefixLength,
         lastId.length(),
         QVariant(boldFormat),
     };
     if (!signature.isEmpty()) {
         ret << prefixLength + lastId.length();
         ret << signature.length();
         ret << QVariant(normalFormat);
     }
 
     return ret;
 }
 
 QString DUChainItemData::htmlDescription() const
 {
     if (m_item.m_noHtmlDestription) {
         return QString();
     }
 
     DUChainReadLocker lock;
     Declaration* decl = m_item.m_item.data();
     if (!decl) {
         return i18n("Not available any more");
     }
 
     TypePtr<FunctionType> function = decl->type<FunctionType>();
 
     QString text;
 
     if (function && function->returnType()) {
         text = i18nc("%1: function signature", "Return: %1",
                      function->partToString(FunctionType::SignatureReturn)) + QLatin1Char(' ');
     }
 
     text += i18nc("%1: file path", "File: %1", ICore::self()->projectController()->prettyFileName(decl->url().toUrl()));
 
     QString ret = QLatin1String("<small><small>") + text + QLatin1String("</small></small>");
 
     return ret;
 }
 
 bool DUChainItemData::execute(QString& /*filterText*/)
 {
     DUChainReadLocker lock;
     Declaration* decl = m_item.m_item.data();
     if (!decl) {
         return false;
     }
 
     if (m_openDefinition && FunctionDefinition::definition(decl)) {
         decl = FunctionDefinition::definition(decl);
     }
 
     QUrl url = decl->url().toUrl();
     KTextEditor::Cursor cursor = decl->rangeInCurrentRevision().start();
 
     DUContext* internal = decl->internalContext();
 
     if (internal && (internal->type() == DUContext::Other || internal->type() == DUContext::Class)) {
         //Move into the body
         if (internal->range().end.line > internal->range().start.line) {
             cursor = KTextEditor::Cursor(internal->range().start.line + 1, 0); //Move into the body
         }
     }
 
     lock.unlock();
     ICore::self()->documentController()->openDocument(url, cursor);
     return true;
 }
 
 bool DUChainItemData::isExpandable() const
 {
     return true;
 }
 
 QWidget* DUChainItemData::expandingWidget() const
 {
     DUChainReadLocker lock;
 
     auto* decl = dynamic_cast<KDevelop::Declaration*>(m_item.m_item.data());
     if (!decl || !decl->context()) {
         return nullptr;
     }
 
     return decl->context()->createNavigationWidget(decl, decl->topContext(),
                                                    AbstractNavigationWidget::EmbeddableWidget);
 }
 
 QIcon DUChainItemData::icon() const
 {
     return QIcon();
 }
 
 Path DUChainItemData::projectPath() const
 {
     return m_item.m_projectPath;
 }
 
 DUChainItemDataProvider::DUChainItemDataProvider(IQuickOpen* quickopen, bool openDefinitions)
     : m_quickopen(quickopen)
     , m_openDefinitions(openDefinitions)
 {
     reset();
 }
 
 void DUChainItemDataProvider::setFilterText(const QString& text)
 {
     Base::setFilter(text);
 }
 
 uint DUChainItemDataProvider::itemCount() const
 {
     return Base::filteredItems().count();
 }
 
 uint DUChainItemDataProvider::unfilteredItemCount() const
 {
     return Base::items().count();
 }
 
 QuickOpenDataPointer DUChainItemDataProvider::data(uint row) const
 {
     return KDevelop::QuickOpenDataPointer(createData(Base::filteredItems()[row]));
 }
 
 DUChainItemData* DUChainItemDataProvider::createData(const DUChainItem& item) const
 {
     return new DUChainItemData(item, m_openDefinitions);
 }
 
 QString DUChainItemDataProvider::itemText(const DUChainItem& data) const
 {
     return data.m_text;
 }
 
 void DUChainItemDataProvider::reset()
 {
 }
 
 #include "moc_duchainitemquickopen.cpp"