plugins/subversion/kdevsvnplugin.cpp

   1 /***************************************************************************
   2  *   Copyright 2007 Dukju Ahn <dukjuahn@gmail.com>                         *
   3  *   Copyright 2008 Andreas Pakulat <apaku@gmx.de>                         *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  ***************************************************************************/
  11
  12 #include "kdevsvnplugin.h"
  13
  14 #include <QtDesigner/QExtensionFactory>
  15 #include <QAction>
  16 #include <QVariant>
  17 #include <QTextStream>
  18 #include <QMenu>
  19
  20 #include <kparts/part.h>
  21 #include <kparts/partmanager.h>
  22 #include <kparts/mainwindow.h>
  23 #include <kaboutdata.h>
  24 #include <ktexteditor/document.h>
  25 #include <ktexteditor/markinterface.h>
  26 #include <kpluginfactory.h>
  27 #include <kpluginloader.h>
  28 #include <klocale.h>
  29 #include <kurlrequester.h>
  30 #include <kaction.h>
  31 #include <kurlrequesterdialog.h>
  32 #include <kfile.h>
  33 #include <ktemporaryfile.h>
  34 #include <kmessagebox.h>
  35
  36 #include <interfaces/iuicontroller.h>
  37 #include <interfaces/idocumentcontroller.h>
  38 #include <interfaces/idocument.h>
  39 #include <interfaces/iplugincontroller.h>
  40 #include <interfaces/icore.h>
  41 #include <interfaces/iruncontroller.h>
  42 #include <outputview/ioutputview.h>
  43 #include <project/projectmodel.h>
  44 #include <interfaces/context.h>
  45 #include <interfaces/contextmenuextension.h>
  46 #include <vcs/vcsrevision.h>
  47 #include <vcs/vcsevent.h>
  48 #include <vcs/vcsrevision.h>
  49 #include <vcs/vcsmapping.h>
  50 #include <vcs/vcsstatusinfo.h>
  51 #include <vcs/vcsannotation.h>
  52 #include <vcs/widgets/vcsannotationwidget.h>
  53 #include <vcs/widgets/vcseventwidget.h>
  54 #include <vcs/widgets/vcsdiffwidget.h>
  55 #include <vcs/widgets/vcscommitdialog.h>
  56
  57 #include "kdevsvncpp/apr.hpp"
  58
  59 #include "svncommitjob.h"
  60 #include "svnstatusjob.h"
  61 #include "svnaddjob.h"
  62 #include "svnrevertjob.h"
  63 #include "svnremovejob.h"
  64 #include "svnupdatejob.h"
  65 #include "svninfojob.h"
  66 #include "svndiffjob.h"
  67 #include "svncopyjob.h"
  68 #include "svnmovejob.h"
  69 #include "svnlogjob.h"
  70 #include "svnblamejob.h"
  71 #include "svnimportjob.h"
  72 #include "svncheckoutjob.h"
  73
  74 #include "svnoutputdelegate.h"
  75 #include "svnoutputmodel.h"
  76 #include "svnimportmetadatawidget.h"
  77 #include "svncheckoutmetadatawidget.h"
  78
  79 K_PLUGIN_FACTORY(KDevSvnFactory, registerPlugin<KDevSvnPlugin>(); )
  80 K_EXPORT_PLUGIN(KDevSvnFactory(KAboutData("kdevsubversion","kdevsubversion", ki18n("Subversion"), "0.1", ki18n("Support for Subversion version control systems"), KAboutData::License_GPL)))
  81
  82 KDevSvnPlugin::KDevSvnPlugin( QObject *parent, const QVariantList & )
  83     : KDevelop::IPlugin(KDevSvnFactory::componentData(), parent)
  84     , m_outputmodel(0), m_outputdelegate(0), m_factory(0)
  85 {
  86     KDEV_USE_EXTENSION_INTERFACE( KDevelop::IBasicVersionControl)
  87     KDEV_USE_EXTENSION_INTERFACE( KDevelop::ICentralizedVersionControl )
  88
  89     qRegisterMetaType<KDevelop::VcsStatusInfo>();
  90     qRegisterMetaType<SvnInfoHolder>();
  91     qRegisterMetaType<KDevelop::VcsEvent>();
  92     qRegisterMetaType<KDevelop::VcsRevision>();
  93     qRegisterMetaType<KDevelop::VcsRevision::RevisionSpecialType>();
  94     qRegisterMetaType<KDevelop::VcsAnnotation>();
  95     qRegisterMetaType<KDevelop::VcsAnnotationLine>();
  96     m_outputmodel = new SvnOutputModel( this, this );
  97
  98     IPlugin* plugin = core()->pluginController()->pluginForExtension( "org.kdevelop.IOutputView" );
  99     Q_ASSERT( plugin );
 100     if( plugin )
 101     {
 102         m_outputdelegate = new SvnOutputDelegate( this );
 103         KDevelop::IOutputView* iface = plugin->extension<KDevelop::IOutputView>();
 104         int tvid = iface->registerToolView( "Subversion", KDevelop::IOutputView::OneView, KIcon("vcs_commit") );
 105         int id = iface->registerOutputInToolView( tvid, "Output", KDevelop::IOutputView::AllowUserClose | KDevelop::IOutputView::AutoScroll );
 106         iface->setModel( id, m_outputmodel );
 107         iface->setDelegate( id, m_outputdelegate );
 108     }
 109 }
 110
 111 KDevSvnPlugin::~KDevSvnPlugin()
 112 {
 113 }
 114
 115 bool KDevSvnPlugin::isVersionControlled( const KUrl& localLocation )
 116 {
 117     SvnInfoJob* job = new SvnInfoJob( this );
 118
 119     job->setLocation( localLocation );
 120     if( job->exec() )
 121     {
 122         QVariant result = job->fetchResults();
 123         if( result.isValid() )
 124         {
 125             SvnInfoHolder h = qVariantValue<SvnInfoHolder>( result );
 126             return !h.name.isEmpty();
 127         }
 128     }else
 129     {
 130         kDebug(9510) << "Couldn't execute job";
 131     }
 132     return false;
 133 }
 134
 135 KDevelop::VcsJob* KDevSvnPlugin::repositoryLocation( const KUrl& localLocation )
 136 {
 137     SvnInfoJob* job = new SvnInfoJob( this );
 138
 139     job->setLocation( localLocation );
 140     job->setProvideInformation( SvnInfoJob::RepoUrlOnly );
 141     return job;
 142 }
 143
 144 KDevelop::VcsJob* KDevSvnPlugin::status( const KUrl::List& localLocations,
 145                                     KDevelop::IBasicVersionControl::RecursionMode mode )
 146 {
 147     SvnStatusJob* job = new SvnStatusJob( this );
 148     job->setLocations( localLocations );
 149     job->setRecursive( ( mode == KDevelop::IBasicVersionControl::Recursive ) );
 150     return job;
 151 }
 152
 153 KDevelop::VcsJob* KDevSvnPlugin::add( const KUrl::List& localLocations,
 154                                       KDevelop::IBasicVersionControl::RecursionMode recursion )
 155 {
 156     SvnAddJob* job = new SvnAddJob( this );
 157     job->setLocations( localLocations );
 158     job->setRecursive( ( recursion == KDevelop::IBasicVersionControl::Recursive ) );
 159     return job;
 160 }
 161
 162 KDevelop::VcsJob* KDevSvnPlugin::remove( const KUrl::List& localLocations )
 163 {
 164     SvnRemoveJob* job = new SvnRemoveJob( this );
 165     job->setLocations( localLocations );
 166     return job;
 167 }
 168
 169 KDevelop::VcsJob* KDevSvnPlugin::edit( const KUrl& /*localLocation*/ )
 170 {
 171     return 0;
 172 }
 173
 174 KDevelop::VcsJob* KDevSvnPlugin::unedit( const KUrl& /*localLocation*/ )
 175 {
 176     return 0;
 177 }
 178
 179 KDevelop::VcsJob* KDevSvnPlugin::localRevision( const KUrl& localLocation, KDevelop::VcsRevision::RevisionType type )
 180 {
 181     SvnInfoJob* job = new SvnInfoJob( this );
 182
 183     job->setLocation( localLocation );
 184     job->setProvideInformation( SvnInfoJob::RevisionOnly );
 185     job->setProvideRevisionType( type );
 186     return job;
 187 }
 188
 189 KDevelop::VcsJob* KDevSvnPlugin::copy( const KUrl& localLocationSrc, const KUrl& localLocationDstn )
 190 {
 191     SvnCopyJob* job = new SvnCopyJob( this );
 192     job->setSourceLocation( localLocationSrc );
 193     job->setDestinationLocation( localLocationDstn );
 194     return job;
 195 }
 196
 197 KDevelop::VcsJob* KDevSvnPlugin::move( const KUrl& localLocationSrc, const KUrl& localLocationDst )
 198 {
 199     SvnMoveJob* job = new SvnMoveJob( this );
 200     job->setSourceLocation( localLocationSrc );
 201     job->setDestinationLocation( localLocationDst );
 202     return job;
 203 }
 204
 205 KDevelop::VcsJob* KDevSvnPlugin::revert( const KUrl::List& localLocations,
 206                                                KDevelop::IBasicVersionControl::RecursionMode recursion )
 207 {
 208     SvnRevertJob* job = new SvnRevertJob( this );
 209     job->setLocations( localLocations );
 210     job->setRecursive( ( recursion == KDevelop::IBasicVersionControl::Recursive ) );
 211     return job;
 212 }
 213
 214 KDevelop::VcsJob* KDevSvnPlugin::update( const KUrl::List& localLocations,
 215                                     const KDevelop::VcsRevision& rev,
 216                                     KDevelop::IBasicVersionControl::RecursionMode recursion )
 217 {
 218     SvnUpdateJob* job = new SvnUpdateJob( this );
 219     job->setLocations( localLocations );
 220     job->setRevision( rev );
 221     job->setRecursive( ( recursion == KDevelop::IBasicVersionControl::Recursive ) );
 222     return job;
 223 }
 224
 225 KDevelop::VcsJob* KDevSvnPlugin::commit( const QString& message, const KUrl::List& localLocations,
 226                     KDevelop::IBasicVersionControl::RecursionMode recursion )
 227 {
 228     SvnCommitJob* job = new SvnCommitJob( this );
 229     kDebug(9510) << "Commiting locations:" << localLocations << endl;
 230     job->setUrls( localLocations );
 231     job->setCommitMessage( message ) ;
 232     job->setRecursive( ( recursion == KDevelop::IBasicVersionControl::Recursive ) );
 233     return job;
 234 }
 235
 236 KDevelop::VcsJob* KDevSvnPlugin::diff( const KDevelop::VcsLocation& src,
 237                 const KDevelop::VcsLocation& dst,
 238                 const KDevelop::VcsRevision& srcRevision,
 239                 const KDevelop::VcsRevision& dstRevision,
 240                 KDevelop::VcsDiff::Type diffType,
 241                 KDevelop::IBasicVersionControl::RecursionMode recurse )
 242 {
 243     SvnDiffJob* job = new SvnDiffJob( this );
 244     job->setSource( src );
 245     job->setDestination( dst );
 246     job->setSrcRevision( srcRevision );
 247     job->setDstRevision( dstRevision );
 248     job->setDiffType( diffType );
 249     job->setRecursive( ( recurse == KDevelop::IBasicVersionControl::Recursive ) );
 250     return job;
 251 }
 252
 253 KDevelop::VcsJob* KDevSvnPlugin::log( const KUrl& localLocation, const KDevelop::VcsRevision& rev, unsigned long limit )
 254 {
 255     SvnLogJob* job = new SvnLogJob( this );
 256     job->setLocation( localLocation );
 257     job->setStartRevision( rev );
 258     job->setLimit( limit );
 259     return job;
 260 }
 261
 262 KDevelop::VcsJob* KDevSvnPlugin::log( const KUrl& localLocation,
 263             const KDevelop::VcsRevision& startRev,
 264             const KDevelop::VcsRevision& endRev )
 265 {
 266     SvnLogJob* job = new SvnLogJob( this );
 267     job->setLocation( localLocation );
 268     job->setStartRevision( startRev );
 269     job->setEndRevision( endRev );
 270     return job;
 271 }
 272
 273 KDevelop::VcsJob* KDevSvnPlugin::annotate( const KUrl& localLocation,
 274                 const KDevelop::VcsRevision& rev )
 275 {
 276     SvnBlameJob* job = new SvnBlameJob( this );
 277     job->setLocation( localLocation );
 278     job->setEndRevision( rev );
 279     return job;
 280 }
 281
 282 KDevelop::VcsJob* KDevSvnPlugin::merge( const KDevelop::VcsLocation& localOrRepoLocationSrc,
 283             const KDevelop::VcsLocation& localOrRepoLocationDst,
 284             const KDevelop::VcsRevision& srcRevision,
 285             const KDevelop::VcsRevision& dstRevision,
 286             const KUrl& localLocation )
 287 {
 288     // TODO implement merge
 289     Q_UNUSED( localOrRepoLocationSrc )
 290     Q_UNUSED( localOrRepoLocationDst )
 291     Q_UNUSED( srcRevision )
 292     Q_UNUSED( dstRevision )
 293     Q_UNUSED( localLocation )
 294     return 0;
 295 }
 296
 297 KDevelop::VcsJob* KDevSvnPlugin::resolve( const KUrl::List& /*localLocations*/,
 298                 KDevelop::IBasicVersionControl::RecursionMode /*recursion*/ )
 299 {
 300     return 0;
 301 }
 302
 303 KDevelop::VcsJob* KDevSvnPlugin::import( const KDevelop::VcsMapping& mapping, const QString& msg )
 304 {
 305     SvnImportJob* job = new SvnImportJob( this );
 306     job->setMapping( mapping );
 307     job->setMessage( msg );
 308     return job;
 309 }
 310
 311 KDevelop::VcsJob* KDevSvnPlugin::checkout( const KDevelop::VcsMapping& mapping )
 312 {
 313     SvnCheckoutJob* job = new SvnCheckoutJob( this );
 314     job->setMapping( mapping );
 315     return job;
 316 }
 317
 318
 319 const KUrl KDevSvnPlugin::urlFocusedDocument()
 320 {
 321     KParts::ReadOnlyPart *part =
 322             dynamic_cast<KParts::ReadOnlyPart*>( core()->partManager()->activePart() );
 323     if ( part ) {
 324         if (part->url().isLocalFile() ) {
 325             return part->url();
 326         }
 327     }
 328     return KUrl();
 329 }
 330
 331 KDevelop::ContextMenuExtension KDevSvnPlugin::contextMenuExtension( KDevelop::Context* context )
 332 {
 333     KUrl::List ctxUrlList;
 334     if( context->type() == KDevelop::Context::ProjectItemContext )
 335     {
 336         KDevelop::ProjectItemContext *itemCtx = dynamic_cast<KDevelop::ProjectItemContext*>(context);
 337         if( itemCtx )
 338         {
 339             QList<KDevelop::ProjectBaseItem *> baseItemList = itemCtx->items();
 340
 341             // now general case
 342             foreach( KDevelop::ProjectBaseItem* _item, baseItemList )
 343             {
 344                 if( _item->folder() ){
 345                     KDevelop::ProjectFolderItem *folderItem = dynamic_cast<KDevelop::ProjectFolderItem*>(_item);
 346                     ctxUrlList << folderItem->url();
 347                 }
 348                 else if( _item->file() ){
 349                     KDevelop::ProjectFileItem *fileItem = dynamic_cast<KDevelop::ProjectFileItem*>(_item);
 350                     ctxUrlList << fileItem->url();
 351                 }
 352             }
 353         }
 354     }else if( context->type() == KDevelop::Context::EditorContext )
 355     {
 356         KDevelop::EditorContext *itemCtx = dynamic_cast<KDevelop::EditorContext*>(context);
 357         ctxUrlList << itemCtx->url();
 358     }else if( context->type() == KDevelop::Context::FileContext )
 359     {
 360         KDevelop::FileContext *itemCtx = dynamic_cast<KDevelop::FileContext*>(context);
 361         ctxUrlList += itemCtx->urls();
 362     }
 363
 364
 365     KDevelop::ContextMenuExtension menuExt;
 366
 367     bool hasVersionControlledEntries = false;
 368     foreach( KUrl url, ctxUrlList )
 369     {
 370         if( isVersionControlled( url ) )
 371         {
 372             hasVersionControlledEntries = true;
 373             break;
 374         }
 375     }
 376     if( ctxUrlList.isEmpty() )
 377         return IPlugin::contextMenuExtension( context );
 378
 379
 380     m_ctxUrlList = ctxUrlList;
 381     QList<QAction*> actions;
 382     KAction *action;
 383     QMenu* menu = new QMenu("Subversion");
 384     kDebug() << "version controlled?" << hasVersionControlledEntries;
 385     if( hasVersionControlledEntries )
 386     {
 387 //         action = new KAction(i18n("Commit..."), this);
 388 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxCommit()) );
 389 //         menuExt.addAction( KDevelop::ContextMenuExtension::VcsGroup, action );
 390 //
 391 //         action = new KAction(i18n("Add to Repository"), this);
 392 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxAdd()) );
 393 //         menuExt.addAction( KDevelop::ContextMenuExtension::VcsGroup, action );
 394 //
 395 //         action = new KAction(i18n("Remove from Repository"), this);
 396 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxRemove()) );
 397 //         menuExt.addAction( KDevelop::ContextMenuExtension::VcsGroup, action );
 398 //
 399 //         action = new KAction(i18n("Update to Head"), this);
 400 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxUpdate()) );
 401 //         menuExt.addAction( KDevelop::ContextMenuExtension::VcsGroup, action );
 402 //
 403 //         action = new KAction(i18n("Revert"), this);
 404 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxRevert()) );
 405 //         menuExt.addAction( KDevelop::ContextMenuExtension::VcsGroup, action );
 406 //
 407 //         action = new KAction(i18n("Diff to Head"), this);
 408 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxDiffHead()) );
 409 //         menuExt.addAction( KDevelop::ContextMenuExtension::VcsGroup, action );
 410 //
 411 //         action = new KAction(i18n("Diff to Base"), this);
 412 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxDiffBase()) );
 413 //         menuExt.addAction( KDevelop::ContextMenuExtension::VcsGroup, action );
 414 //
 415         action = new KAction(i18n("Copy..."), this);
 416         connect( action, SIGNAL(triggered()), this, SLOT(ctxCopy()) );
 417         menu->addAction( action );
 418
 419         action = new KAction(i18n("Move..."), this);
 420         connect( action, SIGNAL(triggered()), this, SLOT(ctxMove()) );
 421         menu->addAction( action );
 422 //
 423 //         action = new KAction(i18n("History..."), this);
 424 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxHistory()) );
 425 //         menuExt.addAction( KDevelop::ContextMenuExtension::VcsGroup, action );
 426 //
 427 //         action = new KAction(i18n("Annotation..."), this);
 428 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxBlame()) );
 429 //         menuExt.addAction( KDevelop::ContextMenuExtension::VcsGroup, action );
 430     }
 431     else
 432     {
 433
 434         action = new KAction(i18n("Import..."), this);
 435         connect( action, SIGNAL(triggered()), this, SLOT(ctxImport()) );
 436         menu->addAction( action );
 437         action = new KAction(i18n("Checkout..."), this);
 438         connect( action, SIGNAL(triggered()), this, SLOT(ctxCheckout()) );
 439         menu->addAction( action );
 440
 441 //         action = new QAction(i18n("Blame/Annotate..."), this);
 442 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxBlame()) );
 443 //         actions << action;
 444 //
 445 //         action = new QAction(i18n("Cat..."), this);
 446 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxCat()) );
 447 //         actions << action;
 448 //
 449 //         action = new QAction(i18n("Diff to..."), this);
 450 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxDiff()) );
 451 //         actions << action;
 452 //
 453 //         action = new QAction(i18n("Information..."), this);
 454 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxInfo()) );
 455 //         actions << action;
 456 //
 457 //         action = new QAction(i18n("Status..."), this);
 458 //         connect( action, SIGNAL(triggered()), this, SLOT(ctxStatus()) );
 459 //         actions << action;
 460     }
 461     menuExt.addAction( KDevelop::ContextMenuExtension::ExtensionGroup, menu->menuAction() );
 462
 463     return menuExt;
 464 }
 465
 466 void KDevSvnPlugin::ctxHistory()
 467 {
 468     if( m_ctxUrlList.count() > 1 ){
 469         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 470         return;
 471     }
 472     KDevelop::VcsRevision start;
 473     start.setRevisionValue( qVariantFromValue<KDevelop::VcsRevision::RevisionSpecialType>( KDevelop::VcsRevision::Head ),
 474                             KDevelop::VcsRevision::Special );
 475     KDevelop::VcsJob *job = log( m_ctxUrlList.first(), start, 0 );
 476     KDialog* dlg = new KDialog();
 477     dlg->setButtons( KDialog::Close );
 478     dlg->setCaption( i18n( "Subversion Log (%1)", m_ctxUrlList.first().path() ) );
 479     KDevelop::VcsEventWidget* logWidget = new KDevelop::VcsEventWidget( m_ctxUrlList.first(), job, dlg );
 480     dlg->setMainWidget( logWidget );
 481     connect( dlg, SIGNAL( destroyed( QObject* ) ), job, SLOT( deleteLater() ) );
 482     dlg->show();
 483 }
 484 void KDevSvnPlugin::ctxBlame()
 485 {
 486     if( m_ctxUrlList.count() > 1 ){
 487         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 488         return;
 489     }
 490
 491     if( !m_ctxUrlList.first().isLocalFile() )
 492     {
 493         KMessageBox::error( 0, i18n("Annotate is only supported on local files") );
 494         return;
 495     }
 496
 497     KDevelop::IDocument* doc = core()->documentController()->documentForUrl( m_ctxUrlList.first() );
 498     if( !doc )
 499         doc = core()->documentController()->openDocument( m_ctxUrlList.first() );
 500
 501     if( doc && doc->textDocument() )
 502     {
 503         KDevelop::VcsRevision head;
 504         head.setRevisionValue( qVariantFromValue<KDevelop::VcsRevision::RevisionSpecialType>( KDevelop::VcsRevision::Head ),
 505                             KDevelop::VcsRevision::Special );
 506         KDevelop::VcsJob* job = annotate( m_ctxUrlList.first(), head );
 507         KTextEditor::MarkInterface* markiface = 0;
 508                 //qobject_cast<KTextEditor::MarkInterface*>(doc->textDocument());
 509         if( markiface )
 510         {
 511             //@TODO: Work with Kate devs towards a new interface for adding
 512             //       annotation information to the KTE's in KDE 4.1
 513         }else
 514         {
 515             KDialog* dlg = new KDialog();
 516             dlg->setButtons( KDialog::Close );
 517             dlg->setCaption( i18n("Annotation (%1)", m_ctxUrlList.first().prettyUrl() ) );
 518             KDevelop::VcsAnnotationWidget* w = new KDevelop::VcsAnnotationWidget( m_ctxUrlList.first(), job, dlg );
 519             dlg->setMainWidget( w );
 520             connect( dlg, SIGNAL( destroyed( QObject* ) ), job, SLOT( deleteLater() ) );
 521             dlg->show();
 522         }
 523     }else
 524     {
 525         KMessageBox::error( 0, i18n("Cannot execute annotate action because the "
 526                                     "document wasn't found or was not a text "
 527                                     "document:\n%1", m_ctxUrlList.first().prettyUrl() ) );
 528     }
 529
 530 }
 531 void KDevSvnPlugin::ctxCommit()
 532 {
 533     if( !m_ctxUrlList.isEmpty() )
 534     {
 535         KDevelop::VcsCommitDialog* dlg = new KDevelop::VcsCommitDialog( this, core()->uiController()->activeMainWindow() );
 536         dlg->setCommitCandidates( m_ctxUrlList );
 537         dlg->setRecursive( true );
 538         connect( dlg, SIGNAL( doCommit( KDevelop::VcsCommitDialog* ) ), this, SLOT( doCommit( KDevelop::VcsCommitDialog* ) ) );
 539         connect( dlg, SIGNAL( cancelCommit( KDevelop::VcsCommitDialog* ) ), this, SLOT( cancelCommit( KDevelop::VcsCommitDialog* ) ) );
 540         dlg->show();
 541     }
 542 }
 543
 544
 545 void KDevSvnPlugin::doCommit( KDevelop::VcsCommitDialog* dlg )
 546 {
 547     KDevelop::IBasicVersionControl::RecursionMode mode;
 548     if( dlg->recursive() )
 549     {
 550         mode = KDevelop::IBasicVersionControl::Recursive;
 551     }else
 552     {
 553         mode = KDevelop::IBasicVersionControl::NonRecursive;
 554     }
 555     KDevelop::ICore::self()->runController()->registerJob( commit( dlg->message(), dlg->checkedUrls(), mode ) );
 556     dlg->deleteLater();
 557 }
 558
 559 void KDevSvnPlugin::cancelCommit( KDevelop::VcsCommitDialog* dlg )
 560 {
 561     dlg->deleteLater();
 562 }
 563
 564 void KDevSvnPlugin::ctxUpdate()
 565 {
 566     KDevelop::VcsRevision rev;
 567     rev.setRevisionValue( qVariantFromValue<KDevelop::VcsRevision::RevisionSpecialType>( KDevelop::VcsRevision::Head ), KDevelop::VcsRevision::Special );
 568     KDevelop::ICore::self()->runController()->registerJob( update( m_ctxUrlList, rev ) );
 569 }
 570
 571 void KDevSvnPlugin::ctxAdd()
 572 {
 573     KDevelop::ICore::self()->runController()->registerJob( add( m_ctxUrlList ) );
 574 }
 575 void KDevSvnPlugin::ctxRemove()
 576 {
 577     KDevelop::ICore::self()->runController()->registerJob( remove( m_ctxUrlList ) );
 578 }
 579
 580 void KDevSvnPlugin::ctxRevert()
 581 {
 582     //@TODO: If one of the urls is a directory maybe ask whether all files in the dir should be reverted?
 583     KDevelop::ICore::self()->runController()->registerJob( revert( m_ctxUrlList ) );
 584 }
 585
 586 void KDevSvnPlugin::ctxDiff()
 587 {
 588     // TODO correct port
 589     if( m_ctxUrlList.count() > 1 ){
 590         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 591         return;
 592     }
 593 }
 594
 595 void KDevSvnPlugin::ctxDiffHead()
 596 {
 597     if( m_ctxUrlList.count() > 1 ){
 598         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 599         return;
 600     }
 601     KDevelop::VcsRevision srcRev,dstRev;
 602     srcRev.setRevisionValue( qVariantFromValue<KDevelop::VcsRevision::RevisionSpecialType>(KDevelop::VcsRevision::Head), KDevelop::VcsRevision::Special );
 603     dstRev.setRevisionValue( qVariantFromValue<KDevelop::VcsRevision::RevisionSpecialType>(KDevelop::VcsRevision::Working), KDevelop::VcsRevision::Special );
 604     KDevelop::VcsJob* job = diff( m_ctxUrlList.first(), m_ctxUrlList.first(), srcRev, dstRev );
 605
 606     //TODO: Fix this, the job should execute asynchronously via runcontroller
 607     job->exec();
 608     if( job->status() == KDevelop::VcsJob::JobSucceeded )
 609     {
 610         KDevelop::VcsDiff d = job->fetchResults().value<KDevelop::VcsDiff>();
 611         QString diff = d.diff();
 612         core()->documentController()->openDocumentFromText( diff );
 613     }else
 614     {
 615         kDebug(9510) << "Ooops couldn't diff";
 616     }
 617     delete job;
 618 }
 619 void KDevSvnPlugin::ctxDiffBase()
 620 {
 621     if( m_ctxUrlList.count() > 1 ){
 622         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 623         return;
 624     }
 625     KDevelop::VcsRevision srcRev,dstRev;
 626     srcRev.setRevisionValue( qVariantFromValue<KDevelop::VcsRevision::RevisionSpecialType>(KDevelop::VcsRevision::Base), KDevelop::VcsRevision::Special );
 627     dstRev.setRevisionValue( qVariantFromValue<KDevelop::VcsRevision::RevisionSpecialType>(KDevelop::VcsRevision::Working), KDevelop::VcsRevision::Special );
 628     KDevelop::VcsJob* job = diff( m_ctxUrlList.first(), m_ctxUrlList.first(), srcRev, dstRev );
 629
 630     //TODO: same as above ctxDiffHead
 631     job->exec();
 632     if( job->status() == KDevelop::VcsJob::JobSucceeded )
 633     {
 634         KDevelop::VcsDiff d = job->fetchResults().value<KDevelop::VcsDiff>();
 635         QString diff = d.diff();
 636         core()->documentController()->openDocumentFromText( diff );
 637     }else
 638     {
 639         kDebug(9510) << "Ooops couldn't diff";
 640     }
 641     delete job;
 642 }
 643 void KDevSvnPlugin::ctxInfo()
 644 {
 645     if( m_ctxUrlList.count() > 1 ){
 646         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 647         return;
 648     }
 649 }
 650 void KDevSvnPlugin::ctxStatus()
 651 {
 652     if( m_ctxUrlList.count() > 1 ){
 653         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 654         return;
 655     }
 656 }
 657
 658 void KDevSvnPlugin::ctxCopy()
 659 {
 660     if( m_ctxUrlList.count() > 1 ){
 661         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 662         return;
 663     }
 664     KUrl source = m_ctxUrlList.first();
 665     if( source.isLocalFile() )
 666     {
 667         QString dir = source.path();
 668         bool isFile = QFileInfo( source.path() ).isFile();
 669         if( isFile )
 670         {
 671             dir = source.directory();
 672         }
 673         KUrlRequesterDialog dlg( dir, i18n("Destination file/directory"), 0 );
 674         if( isFile )
 675         {
 676             dlg.urlRequester()->setMode( KFile::File | KFile::Directory | KFile::LocalOnly );
 677         }else
 678         {
 679             dlg.urlRequester()->setMode( KFile::Directory | KFile::LocalOnly );
 680         }
 681         if( dlg.exec() == QDialog::Accepted )
 682         {
 683             KDevelop::ICore::self()->runController()->registerJob( copy( source, dlg.selectedUrl() ) );
 684         }
 685     }else
 686     {
 687         KMessageBox::error( 0, i18n("Copying only works on local files") );
 688         return;
 689     }
 690
 691 }
 692
 693 void KDevSvnPlugin::ctxMove()
 694 {
 695     if( m_ctxUrlList.count() > 1 ){
 696         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 697         return;
 698     }
 699         KUrl source = m_ctxUrlList.first();
 700     if( source.isLocalFile() )
 701     {
 702         QString dir = source.path();
 703         bool isFile = QFileInfo( source.path() ).isFile();
 704         if( isFile )
 705         {
 706             dir = source.directory();
 707         }
 708         KUrlRequesterDialog dlg( dir, i18n("Destination file/directory"), 0 );
 709         if( isFile )
 710         {
 711             dlg.urlRequester()->setMode( KFile::File | KFile::Directory | KFile::LocalOnly );
 712         }else
 713         {
 714             dlg.urlRequester()->setMode( KFile::Directory | KFile::LocalOnly );
 715         }
 716         if( dlg.exec() == QDialog::Accepted )
 717         {
 718             KDevelop::ICore::self()->runController()->registerJob( move( source, dlg.selectedUrl() ) );
 719         }
 720     }else
 721     {
 722         KMessageBox::error( 0, i18n("Moving only works on local files/dirs") );
 723         return;
 724     }
 725 }
 726
 727 void KDevSvnPlugin::ctxCat()
 728 {
 729     if( m_ctxUrlList.count() > 1 ){
 730         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 731         return;
 732     }
 733 }
 734
 735
 736 SvnOutputModel* KDevSvnPlugin::outputModel() const
 737 {
 738     return m_outputmodel;
 739 }
 740
 741
 742 QString KDevSvnPlugin::name() const
 743 {
 744     return i18n("Subversion");
 745 }
 746
 747 KDevelop::VcsImportMetadataWidget* KDevSvnPlugin::createImportMetadataWidget( QWidget* parent )
 748 {
 749     return new SvnImportMetadataWidget( parent );
 750 }
 751
 752 void KDevSvnPlugin::ctxImport( )
 753 {
 754     if( m_ctxUrlList.count() > 1 ){
 755         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 756         return;
 757     }
 758     KDialog dlg;
 759     dlg.setCaption(i18n("Import into Subversion repository"));
 760     SvnImportMetadataWidget* widget = new SvnImportMetadataWidget(&dlg);
 761     widget->setSourceLocation( KDevelop::VcsLocation( m_ctxUrlList.first() ) );
 762     widget->setSourceLocationEditable( false );
 763     dlg.setMainWidget( widget );
 764     if( dlg.exec() == QDialog::Accepted )
 765     {
 766         KDevelop::ICore::self()->runController()->registerJob( import( widget->mapping(), widget->message() ) );
 767     }
 768 }
 769
 770 void KDevSvnPlugin::ctxCheckout( )
 771 {
 772     if( m_ctxUrlList.count() > 1 ){
 773         KMessageBox::error( 0, i18n("Please select only one item for this operation") );
 774         return;
 775     }
 776     KDialog dlg;
 777     dlg.setCaption(i18n("Checkout from Subversion repository"));
 778     SvnCheckoutMetadataWidget* widget = new SvnCheckoutMetadataWidget(&dlg);
 779     KUrl tmp = m_ctxUrlList.first();
 780     tmp.cd("..");
 781     widget->setDestinationLocation( tmp );
 782     dlg.setMainWidget( widget );
 783     if( dlg.exec() == QDialog::Accepted )
 784     {
 785         KDevelop::ICore::self()->runController()->registerJob( checkout( widget->mapping() ) );
 786     }
 787 }
 788
 789 #include "kdevsvnplugin.moc"
 790