vcspluginhelper.cpp Source File

kdevplatform/vcs

 /***************************************************************************
  *   Copyright 2008 Andreas Pakulat <[email protected]>                         *
  *   Copyright 2010 Aleix Pol Gonzalez <[email protected]>                  *
  *   Copyright 2017-2018 Friedrich W. H. Kossebau <[email protected]>       *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
  
 #include "vcspluginhelper.h"
  
 #include <QAction>
 #include <QApplication>
 #include <QClipboard>
 #include <QDialogButtonBox>
 #include <QFileInfo>
 #include <QMenu>
 #include <QTimer>
 #include <QVBoxLayout>
 #include <QVariant>
  
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KParts/MainWindow>
 #include <KTextEditor/AnnotationInterface>
 #include <KTextEditor/Document>
 #include <KTextEditor/ModificationInterface>
 #include <KTextEditor/View>
 #include <ktexteditor_version.h>
  
 #include <interfaces/context.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocument.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iplugin.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/isession.h>
 #include <interfaces/iuicontroller.h>
 #include <util/path.h>
 #include <util/scopeddialog.h>
 #include <vcs/interfaces/ibasicversioncontrol.h>
 #include <vcs/models/vcsannotationmodel.h>
 #if KTEXTEDITOR_VERSION >= QT_VERSION_CHECK(5,53,0)
 #include <vcs/widgets/vcsannotationitemdelegate.h>
 #endif
 #include <vcs/widgets/vcseventwidget.h>
 #include <vcs/widgets/vcscommitdialog.h>
 #include <vcs/vcsjob.h>
 #include <vcs/vcsrevision.h>
 #include <vcs/vcslocation.h>
 #include <vcs/vcsdiff.h>
  
 #include "interfaces/idistributedversioncontrol.h"
 #include "vcsevent.h"
 #include "debug.h"
 #include "widgets/vcsdiffpatchsources.h"
  
 namespace KDevelop
 {
  
 class VcsPluginHelperPrivate
 {
 public:
     IPlugin * plugin;
     IBasicVersionControl * vcs;
  
     QList<QUrl> ctxUrls;
     QAction* commitAction;
     QAction* addAction;
     QAction* updateAction;
     QAction* historyAction;
     QAction* annotationAction;
     QAction* diffToBaseAction;
     QAction* revertAction;
     QAction* diffForRevAction;
     QAction* diffForRevGlobalAction;
     QAction* pushAction;
     QAction* pullAction;
  
     void createActions(VcsPluginHelper* parent) {
         auto iconWithFallback = [] (const QString &icon, const QString &fallback) {
             return QIcon::fromTheme(icon, QIcon::fromTheme(fallback));
         };
         commitAction = new QAction(iconWithFallback(QStringLiteral("vcs-commit"), QStringLiteral("svn-commit")), i18nc("@action:inmenu", "Commit..."), parent);
         updateAction = new QAction(iconWithFallback(QStringLiteral("vcs-pull"), QStringLiteral("svn-update")), i18nc("@action:inmenu", "Update"), parent);
         addAction = new QAction(QIcon::fromTheme(QStringLiteral("list-add")), i18nc("@action:inmenu", "Add"), parent);
         diffToBaseAction = new QAction(iconWithFallback(QStringLiteral("vcs-diff"), QStringLiteral("text-x-patch")), i18nc("@action:inmenu", "Show Differences..."), parent);
         revertAction = new QAction(QIcon::fromTheme(QStringLiteral("archive-remove")), i18nc("@action:inmenu", "Revert"), parent);
         historyAction = new QAction(QIcon::fromTheme(QStringLiteral("view-history")), i18nc("@action:inmenu revision history", "History..."), parent);
         annotationAction = new QAction(QIcon::fromTheme(QStringLiteral("user-properties")), i18nc("@action:inmenu", "Annotation..."), parent);
         diffForRevAction = new QAction(iconWithFallback(QStringLiteral("vcs-diff"), QStringLiteral("text-x-patch")), i18nc("@action:inmenu", "Show Diff..."), parent);
         diffForRevGlobalAction = new QAction(iconWithFallback(QStringLiteral("vcs-diff"), QStringLiteral("text-x-patch")), i18nc("@action:inmenu", "Show Diff (All Files)..."), parent);
         pushAction = new QAction(iconWithFallback(QStringLiteral("vcs-push"), QStringLiteral("arrow-up-double")), i18nc("@action:inmenu", "Push"), parent);
         pullAction = new QAction(iconWithFallback(QStringLiteral("vcs-pull"), QStringLiteral("arrow-down-double")), i18nc("@action:inmenu", "Pull"), parent);
  
         QObject::connect(commitAction, &QAction::triggered, parent, &VcsPluginHelper::commit);
         QObject::connect(addAction, &QAction::triggered, parent, &VcsPluginHelper::add);
         QObject::connect(updateAction, &QAction::triggered, parent, &VcsPluginHelper::update);
         QObject::connect(diffToBaseAction, &QAction::triggered, parent, &VcsPluginHelper::diffToBase);
         QObject::connect(revertAction, &QAction::triggered, parent, &VcsPluginHelper::revert);
         QObject::connect(historyAction, &QAction::triggered, parent, [=] { parent->history(); });
         QObject::connect(annotationAction, &QAction::triggered, parent, &VcsPluginHelper::annotation);
         QObject::connect(diffForRevAction, &QAction::triggered, parent, QOverload<>::of(&VcsPluginHelper::diffForRev));
         QObject::connect(diffForRevGlobalAction, &QAction::triggered, parent, &VcsPluginHelper::diffForRevGlobal);
         QObject::connect(pullAction, &QAction::triggered, parent, &VcsPluginHelper::pull);
         QObject::connect(pushAction, &QAction::triggered, parent, &VcsPluginHelper::push);
     }
  
     bool allLocalFiles(const QList<QUrl>& urls)
     {
         bool ret=true;
         for (const QUrl& url : urls) {
             QFileInfo info(url.toLocalFile());
             ret &= info.isFile();
         }
         return ret;
     }
  
     QMenu* createMenu(QWidget* parent)
     {
         bool allVersioned=true;
         for (const QUrl& url : qAsConst(ctxUrls)) {
             allVersioned=allVersioned && vcs->isVersionControlled(url);
  
             if(!allVersioned)
                 break;
         }
  
         auto* menu = new QMenu(vcs->name(), parent);
         menu->setIcon(QIcon::fromTheme(ICore::self()->pluginController()->pluginInfo(plugin).iconName()));
         menu->addAction(commitAction);
         if(plugin->extension<IDistributedVersionControl>()) {
             menu->addAction(pushAction);
             menu->addAction(pullAction);
         } else {
             menu->addAction(updateAction);
         }
         menu->addSeparator();
         menu->addAction(addAction);
         menu->addAction(revertAction);
         menu->addSeparator();
         menu->addAction(historyAction);
         menu->addAction(annotationAction);
         menu->addAction(diffToBaseAction);
  
         const bool singleVersionedFile = ctxUrls.count() == 1 && allVersioned;
         historyAction->setEnabled(singleVersionedFile);
         annotationAction->setEnabled(singleVersionedFile && allLocalFiles(ctxUrls));
         diffToBaseAction->setEnabled(singleVersionedFile);
         commitAction->setEnabled(singleVersionedFile);
  
         return menu;
     }
 };
  
  
 VcsPluginHelper::VcsPluginHelper(KDevelop::IPlugin* parent, KDevelop::IBasicVersionControl* vcs)
         : QObject(parent)
         , d_ptr(new VcsPluginHelperPrivate())
 {
     Q_D(VcsPluginHelper);
  
     Q_ASSERT(vcs);
     Q_ASSERT(parent);
     d->plugin = parent;
     d->vcs = vcs;
     d->createActions(this);
 }
  
 VcsPluginHelper::~VcsPluginHelper()
 {}
  
 void VcsPluginHelper::addContextDocument(const QUrl &url)
 {
     Q_D(VcsPluginHelper);
  
     d->ctxUrls.append(url);
 }
  
 void VcsPluginHelper::disposeEventually(KTextEditor::View *, bool dont)
 {
     if ( ! dont ) {
         deleteLater();
     }
 }
  
 void VcsPluginHelper::disposeEventually(KTextEditor::Document *)
 {
     deleteLater();
 }
  
 void VcsPluginHelper::setupFromContext(Context* context)
 {
     Q_D(VcsPluginHelper);
  
     d->ctxUrls = context->urls();
 }
  
 QList<QUrl> VcsPluginHelper::contextUrlList() const
 {
     Q_D(const VcsPluginHelper);
  
     return d->ctxUrls;
 }
  
 QMenu* VcsPluginHelper::commonActions(QWidget* parent)
 {
     Q_D(VcsPluginHelper);
  
     /* TODO: the following logic to determine which actions need to be enabled
      * or disabled does not work properly. What needs to be implemented is that
      * project items that are vc-controlled enable all except add, project
      * items that are not vc-controlled enable add action. For urls that cannot
      * be made into a project item, or if the project has no associated VC
      * plugin we need to check whether a VC controls the parent dir, if we have
      * one we assume the urls can be added but are not currently controlled. If
      * the url is already version controlled then just enable all except add
      */
     return d->createMenu(parent);
 }
  
 #define EXECUTE_VCS_METHOD( method ) \
     d->plugin->core()->runController()->registerJob( d->vcs-> method ( d->ctxUrls ) )
  
 #define SINGLEURL_SETUP_VARS \
     KDevelop::IBasicVersionControl* iface = d->vcs;\
     const QUrl &url = d->ctxUrls.front();
  
  
 void VcsPluginHelper::revert()
 {
     Q_D(VcsPluginHelper);
  
     VcsJob* job=d->vcs->revert(d->ctxUrls);
     connect(job, &VcsJob::finished, this, &VcsPluginHelper::revertDone);
  
     for (const QUrl& url : qAsConst(d->ctxUrls)) {
         IDocument* doc=ICore::self()->documentController()->documentForUrl(url);
  
         if(doc && doc->textDocument()) {
             auto* modif = qobject_cast<KTextEditor::ModificationInterface*>(doc->textDocument());
             if (modif) {
                 modif->setModifiedOnDiskWarning(false);
             }
             doc->textDocument()->setModified(false);
         }
     }
     job->setProperty("urls", QVariant::fromValue(d->ctxUrls));
  
     d->plugin->core()->runController()->registerJob(job);
 }
  
 void VcsPluginHelper::revertDone(KJob* job)
 {
     auto* modificationTimer = new QTimer;
     modificationTimer->setInterval(100);
     connect(modificationTimer, &QTimer::timeout, this, &VcsPluginHelper::delayedModificationWarningOn);
     connect(modificationTimer, &QTimer::timeout, modificationTimer, &QTimer::deleteLater);
  
  
     modificationTimer->setProperty("urls", job->property("urls"));
     modificationTimer->start();
 }
  
 void VcsPluginHelper::delayedModificationWarningOn()
 {
     QObject* timer = sender();
     const QList<QUrl> urls = timer->property("urls").value<QList<QUrl>>();
  
     for (const QUrl& url : urls) {
         IDocument* doc=ICore::self()->documentController()->documentForUrl(url);
  
         if(doc) {
             doc->reload();
  
             auto* modif = qobject_cast<KTextEditor::ModificationInterface*>(doc->textDocument());
             modif->setModifiedOnDiskWarning(true);
         }
     }
 }
  
  
 void VcsPluginHelper::diffJobFinished(KJob* job)
 {
     auto* vcsjob = qobject_cast<KDevelop::VcsJob*>(job);
     Q_ASSERT(vcsjob);
  
     if (vcsjob->status() == KDevelop::VcsJob::JobSucceeded) {
         KDevelop::VcsDiff d = vcsjob->fetchResults().value<KDevelop::VcsDiff>();
         if(d.isEmpty())
             KMessageBox::information(ICore::self()->uiController()->activeMainWindow(),
                                      i18n("There are no differences."),
                                      i18nc("@title:window", "VCS Support"));
         else {
             auto* patch=new VCSDiffPatchSource(d);
             showVcsDiff(patch);
         }
     } else {
         KMessageBox::error(ICore::self()->uiController()->activeMainWindow(), vcsjob->errorString(), i18nc("@title:window", "Unable to Get Differences"));
     }
 }
  
 void VcsPluginHelper::diffToBase()
 {
     Q_D(VcsPluginHelper);
  
     SINGLEURL_SETUP_VARS
     ICore::self()->documentController()->saveAllDocuments();
  
     auto* patch =new VCSDiffPatchSource(new VCSStandardDiffUpdater(iface, url));
     showVcsDiff(patch);
 }
  
 void VcsPluginHelper::diffForRev()
 {
     Q_D(VcsPluginHelper);
  
     if (d->ctxUrls.isEmpty()) {
         return;
     }
     diffForRev(d->ctxUrls.first());
 }
  
 void VcsPluginHelper::diffForRevGlobal()
 {
     Q_D(VcsPluginHelper);
  
     if (d->ctxUrls.isEmpty()) {
         return;
     }
     QUrl url = d->ctxUrls.first();
     IProject* project = ICore::self()->projectController()->findProjectForUrl( url );
     if( project ) {
         url = project->path().toUrl();
     }
  
     diffForRev(url);
 }
  
 void VcsPluginHelper::diffForRev(const QUrl& url)
 {
     Q_D(VcsPluginHelper);
  
     auto* action = qobject_cast<QAction*>( sender() );
     Q_ASSERT(action);
     Q_ASSERT(action->data().canConvert<VcsRevision>());
     VcsRevision rev = action->data().value<VcsRevision>();
  
     ICore::self()->documentController()->saveAllDocuments();
     VcsRevision prev = KDevelop::VcsRevision::createSpecialRevision(KDevelop::VcsRevision::Previous);
     KDevelop::VcsJob* job = d->vcs->diff(url, prev, rev );
  
     connect(job, &VcsJob::finished, this, &VcsPluginHelper::diffJobFinished);
     d->plugin->core()->runController()->registerJob(job);
 }
  
 void VcsPluginHelper::history(const VcsRevision& rev)
 {
     Q_D(VcsPluginHelper);
  
     SINGLEURL_SETUP_VARS
     auto* dlg = new QDialog(ICore::self()->uiController()->activeMainWindow());
     dlg->setAttribute(Qt::WA_DeleteOnClose);
     dlg->setWindowTitle(i18nc("@title:window %1: path or URL, %2: name of a version control system",
                           "%2 History (%1)", url.toDisplayString(QUrl::PreferLocalFile), iface->name()));
  
     auto *mainLayout = new QVBoxLayout(dlg);
  
     auto* logWidget = new KDevelop::VcsEventWidget(url, rev, iface, dlg);
     mainLayout->addWidget(logWidget);
  
     auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     dlg->connect(buttonBox, &QDialogButtonBox::accepted, dlg, &QDialog::accept);
     dlg->connect(buttonBox, &QDialogButtonBox::rejected, dlg, &QDialog::reject);
     mainLayout->addWidget(buttonBox);
  
     dlg->show();
 }
  
 void VcsPluginHelper::annotation()
 {
     Q_D(VcsPluginHelper);
  
     SINGLEURL_SETUP_VARS
     KDevelop::IDocument* doc = ICore::self()->documentController()->documentForUrl(url);
  
     if (!doc)
         doc = ICore::self()->documentController()->openDocument(url);
  
     KTextEditor::View* view = doc ? doc->activeTextView() : nullptr;
     KTextEditor::AnnotationInterface* annotateiface = qobject_cast<KTextEditor::AnnotationInterface*>(doc->textDocument());
     auto viewiface = qobject_cast<KTextEditor::AnnotationViewInterface*>(view);
     if (viewiface && viewiface->isAnnotationBorderVisible()) {
         viewiface->setAnnotationBorderVisible(false);
         return;
     }
  
     if (doc && doc->textDocument() && iface) {
         KDevelop::VcsJob* job = iface->annotate(url);
         if( !job )
         {
             qCWarning(VCS) << "Couldn't create annotate job for:" << url << "with iface:" << iface << dynamic_cast<KDevelop::IPlugin*>( iface );
             return;
         }
  
         QColor foreground(Qt::black);
         QColor background(Qt::white);
         if (view) {
             KTextEditor::Attribute::Ptr style = view->defaultStyleAttribute(KTextEditor::dsNormal);
             foreground = style->foreground().color();
             if (style->hasProperty(QTextFormat::BackgroundBrush)) {
                 background = style->background().color();
             }
         }
  
         if (annotateiface && viewiface) {
             // TODO: only create model if there is none yet (e.g. from another view)
             auto* model = new KDevelop::VcsAnnotationModel(job, url, doc->textDocument(),
                                                                                    foreground, background);
             annotateiface->setAnnotationModel(model);
  
 #if KTEXTEDITOR_VERSION >= QT_VERSION_CHECK(5,53,0)
             auto viewifaceV2 = qobject_cast<KTextEditor::AnnotationViewInterfaceV2*>(view);
             if (viewifaceV2) {
                 // TODO: only create delegate if there is none yet
                 auto delegate = new VcsAnnotationItemDelegate(view, model, view);
                 viewifaceV2->setAnnotationItemDelegate(delegate);
                 viewifaceV2->setAnnotationUniformItemSizes(true);
             }
 #endif
             viewiface->setAnnotationBorderVisible(true);
             // can't use new signal slot syntax here, AnnotationInterface is not a QObject
             connect(view, SIGNAL(annotationContextMenuAboutToShow(KTextEditor::View*,QMenu*,int)),
                     this, SLOT(annotationContextMenuAboutToShow(KTextEditor::View*,QMenu*,int)));
             connect(view, SIGNAL(annotationBorderVisibilityChanged(View*,bool)),
                     this, SLOT(handleAnnotationBorderVisibilityChanged(View*,bool)));
         } else {
             KMessageBox::error(nullptr, i18n("Cannot display annotations, missing interface KTextEditor::AnnotationInterface for the editor."));
             delete job;
         }
     } else {
         KMessageBox::error(nullptr, i18n("Cannot execute annotate action because the "
                                    "document was not found, or was not a text document:\n%1", url.toDisplayString(QUrl::PreferLocalFile)));
     }
 }
  
 void VcsPluginHelper::annotationContextMenuAboutToShow( KTextEditor::View* view, QMenu* menu, int line )
 {
     Q_D(VcsPluginHelper);
  
 #if KTEXTEDITOR_VERSION >= QT_VERSION_CHECK(5,53,0)
     auto viewifaceV2 = qobject_cast<KTextEditor::AnnotationViewInterfaceV2*>(view);
     if (viewifaceV2) {
         viewifaceV2->annotationItemDelegate()->hideTooltip(view);
     }
 #endif
  
     KTextEditor::AnnotationInterface* annotateiface =
         qobject_cast<KTextEditor::AnnotationInterface*>(view->document());
  
     auto* model = qobject_cast<VcsAnnotationModel*>( annotateiface->annotationModel() );
     Q_ASSERT(model);
  
     VcsRevision rev = model->revisionForLine(line);
     // check if the user clicked on a row without revision information
     if (rev.revisionType() == VcsRevision::Invalid) {
         // in this case, do not action depending on revision information
         return;
     }
  
     d->diffForRevAction->setData(QVariant::fromValue(rev));
     d->diffForRevGlobalAction->setData(QVariant::fromValue(rev));
     menu->addSeparator();
     menu->addAction(d->diffForRevAction);
     menu->addAction(d->diffForRevGlobalAction);
  
     QAction* copyAction = menu->addAction(QIcon::fromTheme(QStringLiteral("edit-copy")), i18nc("@action:inmenu", "Copy Revision Id"));
     connect(copyAction, &QAction::triggered, this, [rev]() {
         QApplication::clipboard()->setText(rev.revisionValue().toString());
     });
  
     QAction* historyAction = menu->addAction(QIcon::fromTheme(QStringLiteral("view-history")), i18nc("@action:inmenu revision history", "History..."));
     connect(historyAction, &QAction::triggered, this, [this, rev]() {
         history(rev);
     });
 }
  
 void VcsPluginHelper::handleAnnotationBorderVisibilityChanged(View* view, bool visible)
 {
     if (visible) {
         return;
     }
  
     disconnect(view, SIGNAL(annotationContextMenuAboutToShow(KTextEditor::View*,QMenu*,int)),
                this, SLOT(annotationContextMenuAboutToShow(KTextEditor::View*,QMenu*,int)));
  
     disconnect(view, SIGNAL(annotationBorderVisibilityChanged(View*,bool)),
                this, SLOT(handleAnnotationBorderVisibilityChanged(View*,bool)));
  
     // TODO: remove the model if last user of it
 }
  
 void VcsPluginHelper::update()
 {
     Q_D(VcsPluginHelper);
  
     EXECUTE_VCS_METHOD(update);
 }
  
 void VcsPluginHelper::add()
 {
     Q_D(VcsPluginHelper);
  
     EXECUTE_VCS_METHOD(add);
 }
  
 void VcsPluginHelper::commit()
 {
     Q_D(VcsPluginHelper);
  
     Q_ASSERT(!d->ctxUrls.isEmpty());
     ICore::self()->documentController()->saveAllDocuments();
  
     QUrl url = d->ctxUrls.first();
  
     // We start the commit UI no matter whether there is real differences, as it can also be used to commit untracked files
     auto* patchSource = new VCSCommitDiffPatchSource(new VCSStandardDiffUpdater(d->vcs, url));
  
     bool ret = showVcsDiff(patchSource);
  
     if(!ret) {
         ScopedDialog<VcsCommitDialog> commitDialog(patchSource);
         commitDialog->setCommitCandidates(patchSource->infos());
         commitDialog->exec();
     }
 }
  
 void VcsPluginHelper::push()
 {
     Q_D(VcsPluginHelper);
  
     for (const QUrl& url : qAsConst(d->ctxUrls)) {
         VcsJob* job = d->plugin->extension<IDistributedVersionControl>()->push(url, VcsLocation());
         ICore::self()->runController()->registerJob(job);
     }
 }
  
 void VcsPluginHelper::pull()
 {
     Q_D(VcsPluginHelper);
  
     for (const QUrl& url : qAsConst(d->ctxUrls)) {
         VcsJob* job = d->plugin->extension<IDistributedVersionControl>()->pull(VcsLocation(), url);
         ICore::self()->runController()->registerJob(job);
     }
 }
  
 }
  
  

KDevelop::VcsAnnotationModel

Definition: vcsannotationmodel.h:40

QColor

KDevelop::VcsRevision::revisionValue

QVariant revisionValue() const

Return the value of this revision.

Definition: vcsrevision.cpp:100

QVBoxLayout

QApplication::clipboard

QClipboard * clipboard()

KDevelop::VcsPluginHelper::diffToBase

void diffToBase()

Definition: vcspluginhelper.cpp:319

QTimer

QObject::disconnect

bool disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method)

QDialog::reject

virtual void reject()

QVariant::fromValue

QVariant fromValue(const T &value)

QUrl

KDevelop::VcsPluginHelper::addContextDocument

void addContextDocument(const QUrl &url)

Definition: vcspluginhelper.cpp:189

QList::count

int count(const T &value) const

KDevelop::VcsPluginHelper::history

void history(const VcsRevision &rev=VcsRevision::createSpecialRevision(VcsRevision::Base))

Definition: vcspluginhelper.cpp:373

QVariant::value

T value() const

QWidget

QIcon::fromTheme

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

VCSDiffPatchSource

Definition: vcsdiffpatchsources.h:66

vcscommitdialog.h

QMenu::addSeparator

QAction * addSeparator()

KDevelop::VcsDiff

A class representing a unified diff, possibly with conflict markers.

Definition: vcsdiff.h:95

KDevelop::VcsRevision::Invalid

The type is not set, this is an invalid revision.

Definition: vcsrevision.h:82

QObject::sender

QObject * sender() const

KDevelop::IBasicVersionControl

This is the basic interface that all Version Control or Source Code Management plugins need to implem...

Definition: ibasicversioncontrol.h:52

QMenu

showVcsDiff

bool showVcsDiff(IPatchSource *vcsDiff)

Sends the diff to the patch-review plugin.

Definition: vcsdiffpatchsources.cpp:291

ibasicversioncontrol.h

IPlugin

KDevelop::VcsRevision

Encapsulates a vcs revision number, date or range of revisions.

Definition: vcsrevision.h:66

KDevelop::VcsPluginHelper::push

void push()

Definition: vcspluginhelper.cpp:554

vcsannotationitemdelegate.h

QList< QUrl >

vcsdiff.h

QObject::connect

bool connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)

QFileInfo::isFile

bool isFile() const

KDevelop::VcsPluginHelper::annotationContextMenuAboutToShow

void annotationContextMenuAboutToShow(KTextEditor::View *view, QMenu *menu, int line)

Definition: vcspluginhelper.cpp:463

KDevelop::VcsEventWidget

Definition: vcseventwidget.h:35

KDevelop::VcsPluginHelper::add

void add()

Definition: vcspluginhelper.cpp:526

KDevelop::VcsPluginHelper::revertDone

void revertDone(KJob *job)

Definition: vcspluginhelper.cpp:269

KDevelop::VcsPluginHelper::diffForRevGlobal

void diffForRevGlobal()

Definition: vcspluginhelper.cpp:340

KDevelop::VcsPluginHelper::revert

void revert()

Definition: vcspluginhelper.cpp:246

QObject::deleteLater

void deleteLater()

KDevelop::IDistributedVersionControl

This interface has methods to support distributed version control systems like git or svk.

Definition: idistributedversioncontrol.h:37

VCSCommitDiffPatchSource

Definition: vcsdiffpatchsources.h:98

SINGLEURL_SETUP_VARS

#define SINGLEURL_SETUP_VARS

Definition: vcspluginhelper.cpp:241

idistributedversioncontrol.h

QObject

KDevelop::VcsRevision::revisionType

RevisionType revisionType() const

returns the type of the revision

Definition: vcsrevision.cpp:89

vcsdiffpatchsources.h

void timeout()

KDevelop::VcsPluginHelper::commonActions

QMenu * commonActions(QWidget *parent)

Creates and returns a menu with common actions.

Definition: vcspluginhelper.cpp:222

KDevelop::VcsPluginHelper::pull

void pull()

Definition: vcspluginhelper.cpp:564

QDialogButtonBox::accepted

void accepted()

QDialog::accept

virtual void accept()

VCSStandardDiffUpdater

Definition: vcsdiffpatchsources.h:53

KDevelop::VcsPluginHelper::~VcsPluginHelper

~VcsPluginHelper() override

Definition: vcspluginhelper.cpp:186

KDevelop::VcsPluginHelper

Definition: vcspluginhelper.h:44

QClipboard::setText

void setText(const QString &text, Mode mode)

KDevelop::VcsRevision::Previous

The version prior the other one (only valid in functions that take two revisions).

Definition: vcsrevision.h:90

KDevelop::VcsDiff::isEmpty

bool isEmpty() const

Definition: vcsdiff.cpp:583

KDevelop::VcsDiff::diff

QString diff() const

Definition: vcsdiff.cpp:588

KDevelop::VcsPluginHelper::disposeEventually

void disposeEventually(KTextEditor::Document *)

Definition: vcspluginhelper.cpp:203

vcslocation.h

QAction::triggered

void triggered(bool checked)

KDevelop::VcsPluginHelper::contextUrlList

QList< QUrl > contextUrlList() const

Definition: vcspluginhelper.cpp:215

QUrl::path

QString path() const

KDevelop::VcsJob

This class provides an extension of KJob to get various VCS-specific information about the job.

Definition: vcsjob.h:43

vcspluginhelper.h

QAction::setEnabled

void setEnabled(bool)

QDialogButtonBox::rejected

void rejected()

EXECUTE_VCS_METHOD

#define EXECUTE_VCS_METHOD(method)

Definition: vcspluginhelper.cpp:238

Definition: dvcsevent.h:33

KDevelop::VcsRevision::createSpecialRevision

static VcsRevision createSpecialRevision(KDevelop::VcsRevision::RevisionSpecialType type)

Helper function to create a vcs revision for one of the special types.

Definition: vcsrevision.cpp:49

KDevelop::VcsJob::JobSucceeded

The job succeeded.

Definition: vcsjob.h:88

KDevelop::VcsPluginHelper::commit

void commit()

Definition: vcspluginhelper.cpp:533

KDevelop::VcsPluginHelper::diffJobFinished

void diffJobFinished(KJob *job)

Definition: vcspluginhelper.cpp:299

QDialog

vcsannotationmodel.h

QMenu::addAction

void addAction(QAction *action)

QTimer::setInterval

void setInterval(int msec)

vcseventwidget.h

KDevelop::VcsPluginHelper::setupFromContext

void setupFromContext(KDevelop::Context *)

Definition: vcspluginhelper.cpp:208

KDevelop::VcsPluginHelper::VcsPluginHelper

VcsPluginHelper(IPlugin *parent, IBasicVersionControl *vcs)

Definition: vcspluginhelper.cpp:173

KDevelop::VcsPluginHelper::diffForRev

void diffForRev()

Definition: vcspluginhelper.cpp:330

QDialogButtonBox

QObject::parent

QObject * parent() const

vcsrevision.h

KDevelop::VcsLocation

Denotes a local or repository location for a Vcs system.

Definition: vcslocation.h:42

KDevelop::VcsPluginHelper::update

void update()

Definition: vcspluginhelper.cpp:519

KDevelop::VcsPluginHelper::annotation

void annotation()

Definition: vcspluginhelper.cpp:396

QVariant::toString

QString toString() const

QObject::property

QVariant property(const char *name) const

QMenu::setIcon

void setIcon(const QIcon &icon)

KDE's Doxygen guidelines are available online.

kdevplatform/vcs

kdevplatform/vcs

kdevelop API Reference

Search