problemnavigationcontext.cpp Source File

kdevplatform/language/duchain

 /*
    Copyright 2009 David Nolden <[email protected]>
  
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
  
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
  
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
  
 #include "problemnavigationcontext.h"
  
 #include <debug.h>
  
 #include <QBuffer>
 #include <QStyle>
 #include <QApplication>
  
 #include <KLocalizedString>
  
 #include <language/duchain/declaration.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/problem.h>
  
 #include <language/duchain/duchain.h>
 #include <language/editor/documentrange.h>
  
 using namespace KDevelop;
  
 namespace {
 QString KEY_INVOKE_ACTION(int num) { return QStringLiteral("invoke_action_%1").arg(num); }
  
 QString htmlImg(const QIcon& icon, QStyle::PixelMetric metric)
 {
     const int size = qApp->style()->pixelMetric(metric, nullptr, nullptr);
     const QPixmap pixmap = icon.pixmap(size, size);
     QByteArray pngBytes;
     QBuffer buffer(&pngBytes);
     buffer.open(QIODevice::WriteOnly);
     pixmap.save(&buffer, "PNG", 100);
  
     const QString imgTag = QStringLiteral("<img width='%1' height='%1' src='data:image/png;base64, %2'/>")
            .arg(size)
            .arg(QString::fromLatin1(pngBytes.toBase64()));
     return imgTag;
 }
 }
  
 ProblemNavigationContext::ProblemNavigationContext(const QVector<IProblem::Ptr>& problems, const Flags flags)
     : m_problems(problems)
     , m_flags(flags)
     , m_widget(nullptr)
 {
     // Sort problems vector:
     // 1) By severity
     // 2) By sourceString, if severities are equals
     std::sort(m_problems.begin(), m_problems.end(), [](const IProblem::Ptr& a, const IProblem::Ptr& b) {
         if (a->severity() < b->severity())
             return true;
  
         if (a->severity() > b->severity())
             return false;
  
         if (a->sourceString() < b->sourceString())
             return true;
  
         return false;
     });
 }
  
 ProblemNavigationContext::~ProblemNavigationContext()
 {
     delete m_widget;
 }
  
 QWidget* ProblemNavigationContext::widget() const
 {
     return m_widget;
 }
  
 bool ProblemNavigationContext::isWidgetMaximized() const
 {
     return false;
 }
  
 QString ProblemNavigationContext::name() const
 {
     return i18n("Problem");
 }
  
 QString ProblemNavigationContext::escapedHtml(const QString& text) const
 {
     const QString htmlStart = QStringLiteral("<html>");
     const QString htmlEnd = QStringLiteral("</html>");
  
     QString result = text.trimmed();
  
     if (!result.startsWith(htmlStart))
         return result.toHtmlEscaped();
  
     result.remove(htmlStart);
     result.remove(htmlEnd);
  
     return result;
 }
  
 void ProblemNavigationContext::html(IProblem::Ptr problem)
 {
     modifyHtml() += QStringLiteral("<table><tr>");
  
     modifyHtml() += QStringLiteral("<td valign=\"middle\">%1</td>")
                     .arg(htmlImg(IProblem::iconForSeverity(problem->severity()), QStyle::PM_LargeIconSize));
  
     // BEGIN: right column
     modifyHtml() += QStringLiteral("<td>");
  
     modifyHtml() += i18n("Problem in <i>%1</i>", problem->sourceString());
     modifyHtml() += QStringLiteral("<br/>");
  
     if (m_flags & ShowLocation) {
         modifyHtml() += labelHighlight(i18n("Location: "));
         makeLink(QStringLiteral("%1 :%2")
                  .arg(problem->finalLocation().document.toUrl().fileName())
                  .arg(problem->finalLocation().start().line() + 1),
                  QString(),
                  NavigationAction(problem->finalLocation().document.toUrl(), problem->finalLocation().start())
         );
  
         modifyHtml() += QStringLiteral("<br/>");
     }
  
     QString description = escapedHtml(problem->description());
     QString explanation = escapedHtml(problem->explanation());
  
     modifyHtml() += description;
  
     // Add only non-empty explanation which differs from the problem description.
     // Skip this if we have more than one problem.
     if (m_problems.size() == 1 && !explanation.isEmpty() && explanation != description)
         modifyHtml() += QLatin1String("<p><i style=\"white-space:pre-wrap\">") + explanation +
                         QLatin1String("</i></p>");
  
     modifyHtml() += QStringLiteral("</td>");
     // END: right column
  
     modifyHtml() += QStringLiteral("</tr></table>");
  
     const auto diagnostics = problem->diagnostics();
     if (!diagnostics.isEmpty()) {
         DUChainReadLocker lock;
         for (auto diagnostic : diagnostics) {
             modifyHtml() += QStringLiteral("<p>");
             modifyHtml() += labelHighlight(QStringLiteral("%1: ").arg(diagnostic->severityString()));
             modifyHtml() += escapedHtml(diagnostic->description());
  
             const DocumentRange range = diagnostic->finalLocation();
             Declaration* declaration = DUChainUtils::itemUnderCursor(range.document.toUrl(), range.start()).declaration;
             if (declaration) {
                 modifyHtml() += i18n("<br>See: ");
                 makeLink(declaration->toString(), DeclarationPointer(declaration),
                          NavigationAction::NavigateDeclaration);
                 modifyHtml() += i18n(" in ");
                 const auto url = declaration->url().toUrl();
                 makeLink(QStringLiteral("%1 :%2")
                          .arg(url.fileName())
                          .arg(declaration->rangeInCurrentRevision().start().line() + 1),
                          url.toDisplayString(QUrl::PreferLocalFile), NavigationAction(url, declaration->rangeInCurrentRevision().start()));
             } else if (range.start().isValid()) {
                 modifyHtml() += i18n("<br>See: ");
                 const auto url = range.document.toUrl();
                 makeLink(QStringLiteral("%1 :%2")
                          .arg(url.fileName())
                          .arg(range.start().line() + 1),
                          url.toDisplayString(QUrl::PreferLocalFile), NavigationAction(url, range.start()));
             }
  
             modifyHtml() += QStringLiteral("</p>");
         }
     }
  
     auto assistant = problem->solutionAssistant();
     if (assistant && !assistant->actions().isEmpty()) {
         modifyHtml() +=
             QStringLiteral("<table width='100%' style='border: 1px solid black; background-color: %1;'>").arg(QStringLiteral(
                                                                                                                   "#b3d4ff"));
         modifyHtml() +=
             QStringLiteral("<tr><td valign='middle'>%1</td><td width='100%'>")
             .arg(htmlImg(QIcon::fromTheme(QStringLiteral("dialog-ok-apply")), QStyle::PM_LargeIconSize));
  
         const int startIndex = m_assistantsActions.size();
         int currentIndex = startIndex;
         const auto assistantActions = assistant->actions();
         for (auto& assistantAction : assistantActions) {
             m_assistantsActions.append(assistantAction);
  
             if (currentIndex != startIndex)
                 modifyHtml() += QStringLiteral("<br/>");
  
             makeLink(i18n("Solution (%1)", currentIndex + 1), KEY_INVOKE_ACTION(currentIndex),
                      NavigationAction(KEY_INVOKE_ACTION(currentIndex)));
             modifyHtml() += QLatin1String(": ") + assistantAction->description().toHtmlEscaped();
  
             ++currentIndex;
         }
  
         modifyHtml() += QStringLiteral("</td></tr>");
         modifyHtml() += QStringLiteral("</table>");
     }
 }
  
 QString ProblemNavigationContext::html(bool shorten)
 {
     AbstractNavigationContext::html(shorten);
  
     clear();
     m_assistantsActions.clear();
  
     int problemIndex = 0;
     for (auto& problem : qAsConst(m_problems)) {
         html(problem);
  
         if (++problemIndex != m_problems.size())
             modifyHtml() += QStringLiteral("<hr>");
     }
  
     return currentHtml();
 }
  
 NavigationContextPointer ProblemNavigationContext::executeKeyAction(const QString& key)
 {
     const QLatin1String invokeActionPrefix("invoke_action_");
     if (key.startsWith(invokeActionPrefix)) {
         const int index = key.midRef(invokeActionPrefix.size()).toInt();
         executeAction(index);
     }
  
     return {};
 }
  
 void ProblemNavigationContext::executeAction(int index)
 {
     if (index < 0 || index >= m_assistantsActions.size())
         return;
  
     auto action = m_assistantsActions.at(index);
     Q_ASSERT(action);
  
     if (action) {
         action->execute();
         if (topContext())
             DUChain::self()->updateContextForUrl(topContext()->url(), TopDUContext::ForceUpdate);
     } else {
         qCWarning(LANGUAGE()) << "No such action";
         return;
     }
 }

KDevelop::DUChainUtils::itemUnderCursor

KDEVPLATFORMLANGUAGE_EXPORT ItemUnderCursor itemUnderCursor(const QUrl &url, const KTextEditor::Cursor &cursor)

Returns 1.

Definition: duchainutils.cpp:332

duchainlock.h

KDevelop::ProblemNavigationContext::isWidgetMaximized

bool isWidgetMaximized() const override

Whether the widget returned by widget() should take the maximum possible spsace.

Definition: problemnavigationcontext.cpp:90

KDevelop::DUChainReadLocker

Customized read locker for the definition-use chain.

Definition: duchainlock.h:114

KDevelop::AbstractNavigationContext::currentHtml

QString currentHtml() const

Returns the html text being built in its current state.

Definition: abstractnavigationcontext.cpp:587

duchainutils.h

QVector::begin

iterator begin()

KDevelop::AbstractNavigationContext::labelHighlight

static const Colorizer labelHighlight

Definition: abstractnavigationcontext.h:164

problemnavigationcontext.h

QString::midRef

QStringRef midRef(int position, int n) const

KDevelop::DUChain::updateContextForUrl

void updateContextForUrl(const IndexedString &document, TopDUContext::Features minFeatures, QObject *notifyReady=nullptr, int priority=1) const

Makes sure the standard-context for the given url is up-to-date.

Definition: duchain.cpp:1839

QString::trimmed

QString trimmed() const

QVector::append

void append(const T &value)

QWidget

QIcon::fromTheme

QIcon fromTheme(const QString &name, const QIcon &fallback)

KDevelop::m_problems

KDEVPLATFORMLANGUAGE_EXPORT m_problems

Definition: topducontextdata.h:49

m_flags

DUContext::SearchFlags m_flags

Definition: ducontext.cpp:615

KDevelop::Declaration::toString

virtual QString toString() const

Determine this declaration as a string.

Definition: declaration.cpp:466

KDevelop::ProblemNavigationContext::widget

QWidget * widget() const override

Here the context can return a widget to be displayed.

Definition: problemnavigationcontext.cpp:85

KDevelop::Declaration

Represents a single declaration in a definition-use chain.

Definition: declaration.h:51

problem.h

QExplicitlySharedDataPointer< AbstractNavigationContext >

KDevelop::ProblemNavigationContext::html

QString html(bool shorten=false) override

Here the context can return html to be displayed.

Definition: problemnavigationcontext.cpp:220

KDevelop::ProblemNavigationContext::ProblemNavigationContext

ProblemNavigationContext(const QVector< IProblem::Ptr > &problems, const Flags flags={})

Definition: problemnavigationcontext.cpp:58

QPixmap

QBuffer

KDevelop::AbstractNavigationContext::makeLink

virtual void makeLink(const QString &name, const DeclarationPointer &declaration, NavigationAction::Type actionType)

Creates and registers a link to the given declaration, labeled by the given name.

Definition: abstractnavigationcontext.cpp:93

QVector::clear

void clear()

declaration.h

KDevelop::NavigationAction

Definition: navigationaction.h:31

KDevelop::DUChainBase::url

virtual IndexedString url() const

Definition: duchainbase.cpp:68

QString

QVector::at

const T & at(int i) const

QPixmap::save

bool save(const QString &fileName, const char *format, int quality) const

KDevelop::AbstractNavigationContext::clear

void clear()

Definition: abstractnavigationcontext.cpp:146

KDevelop::AbstractNavigationContext::modifyHtml

TextHandler modifyHtml()

Returns a convenience object that allows writing "modifyHtml() += "Hallo";".

Definition: abstractnavigationcontext.h:139

KDevelop::ProblemNavigationContext::executeKeyAction

NavigationContextPointer executeKeyAction(const QString &key) override

Override this to execute own key-actions using NavigationAction.

Definition: problemnavigationcontext.cpp:238

QIcon

QLatin1String

KDevelop::ProblemNavigationContext::ShowLocation

Definition: problemnavigationcontext.h:39

KDevelop::DUChainBase::rangeInCurrentRevision

KTextEditor::Range rangeInCurrentRevision() const

Returns the range assigned to this object, transformed into the current revision of the document.

Definition: duchainbase.cpp:157

QString::remove

QString & remove(int position, int n)

KDevelop::AbstractNavigationContext::html

virtual QString html(bool shorten=false)

Here the context can return html to be displayed.

Definition: abstractnavigationcontext.cpp:530

QString::startsWith

bool startsWith(const QString &s, Qt::CaseSensitivity cs) const

KDevelop::NavigationAction::NavigateDeclaration

Definition: navigationaction.h:35

KDevelop::AbstractNavigationContext::topContext

TopDUContextPointer topContext() const

Definition: abstractnavigationcontext.cpp:69

QVector::end

iterator end()

KDevelop::ProblemNavigationContext::~ProblemNavigationContext

~ProblemNavigationContext() override

Definition: problemnavigationcontext.cpp:80

QIcon::pixmap

QPixmap pixmap(const QSize &size, Mode mode, State state) const

QString::fromLatin1

QString fromLatin1(const char *str, int size)

duchain.h

QByteArray::toBase64

QByteArray toBase64() const

KDevelop

Definition: abstractfunctiondeclaration.cpp:27

QVector::size

int size() const

KDevelop::TopDUContext::ForceUpdate

Definition: topducontext.h:204

KDevelop::ProblemNavigationContext::executeAction

void executeAction(int index)

Definition: problemnavigationcontext.cpp:249

KDevelop::ProblemNavigationContext::name

QString name() const override

Definition: problemnavigationcontext.cpp:95

QVector< IProblem::Ptr >

QString::arg

QString arg(qlonglong a, int fieldWidth, int base, const QChar &fillChar) const

KDevelop::DeclarationPointer

DUChainPointer< Declaration > DeclarationPointer

Definition: duchainpointer.h:200

QByteArray

KDevelop::DUChain::self

static DUChain * self()

Returns the global static instance.

Definition: duchain.cpp:1230

KDE's Doxygen guidelines are available online.

kdevplatform/language/duchain

kdevplatform/language/duchain

kdevelop API Reference

Search