diff --git a/plugins/cvs/cvsproxy.cpp b/plugins/cvs/cvsproxy.cpp
index a2cb216518..d26c19630a 100644
--- a/plugins/cvs/cvsproxy.cpp
+++ b/plugins/cvs/cvsproxy.cpp
@@ -1,485 +1,485 @@
 /***************************************************************************
  *   Copyright 2007 Robert Gruber <rgruber@users.sourceforge.net>          *
  *                                                                         *
  *   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 "cvsproxy.h"
 
 #include <QFileInfo>
 #include <QDir>
 #include <QDateTime>
 #include <KLocale>
 #include <KUrl>
 #include <KMessageBox>
 #include <kshell.h>
 #include <KDebug>
 
 #include "cvsjob.h"
 #include "cvsannotatejob.h"
 #include "cvslogjob.h"
 #include "cvsstatusjob.h"
 #include "cvsdiffjob.h"
 
 #include <interfaces/iplugin.h>
 
 CvsProxy::CvsProxy(KDevelop::IPlugin* parent)
 : QObject(parent), vcsplugin(parent)
 {
 }
 
 CvsProxy::~CvsProxy()
 {
 }
 
-bool CvsProxy::isValidDirectory(const KUrl & dirPath) const
+bool CvsProxy::isValidDirectory(KUrl dirPath) const
 {
     QFileInfo fsObject( dirPath.toLocalFile() );
     if( !fsObject.isDir() )
         dirPath.setFileName( QString() );
 
     dirPath.addPath( "CVS" );
     fsObject.setFile( dirPath.toLocalFile() );
     return fsObject.exists();
 }
 
-bool CvsProxy::isVersionControlled(const KUrl& filePath) const
+bool CvsProxy::isVersionControlled(KUrl filePath) const
 {
     QFileInfo fsObject( filePath.toLocalFile() );
     if( !fsObject.isDir() )
         filePath.setFileName( QString() );
 
     filePath.addPath( "CVS" );
     QFileInfo cvsObject( filePath.toLocalFile() );
     if( !cvsObject.exists() )
         return false;
 
     if( fsObject.isDir() )
         return true;
 
     filePath.addPath( "Entries" );
     QFile cvsEntries( filePath.toLocalFile() );
     cvsEntries.open( QIODevice::ReadOnly );
     QString cvsEntriesData = cvsEntries.readAll();
     cvsEntries.close();
     return ( cvsEntriesData.indexOf( fsObject.fileName() ) != -1 );
 }
 
 
 bool CvsProxy::prepareJob(CvsJob* job, const QString& repository, enum RequestedOperation op)
 {
     // Only do this check if it's a normal operation like diff, log ...
     // For other operations like "cvs import" isValidDirectory() would fail as the
     // directory is not yet under CVS control
     if (op == CvsProxy::NormalOperation &&
         !isValidDirectory(repository)) {
         kDebug(9500) << repository << " is not a valid CVS repository";
         return false;
     }
 
     // clear commands and args from a possible previous run
     job->clear();
 
     // setup the working directory for the new job
     job->setDirectory(repository);
 
     return true;
 }
 
 bool CvsProxy::addFileList(CvsJob* job, const QString& repository, const KUrl::List& urls)
 {
     QStringList args;
 
     foreach(const KUrl &url, urls) {
         ///@todo this is ok for now, but what if some of the urls are not
         ///      to the given repository
         QString file = KUrl::relativeUrl(QString(repository + QDir::separator()), url);
 
         args << KShell::quoteArg( file );
     }
 
     *job << args;
 
     return true;
 }
 
 QString CvsProxy::convertVcsRevisionToString(const KDevelop::VcsRevision & rev)
 {
     QString str;
 
     switch (rev.revisionType())
     {
         case KDevelop::VcsRevision::Special:
             break;
 
         case KDevelop::VcsRevision::FileNumber:
             if (rev.revisionValue().isValid())
                 str = "-r"+rev.revisionValue().toString();
             break;
 
         case KDevelop::VcsRevision::Date:
             if (rev.revisionValue().isValid())
                 str = "-D"+rev.revisionValue().toString();
             break;
 
         case KDevelop::VcsRevision::GlobalNumber: // !! NOT SUPPORTED BY CVS !!
         default:
             break;
     }
 
     return str;
 }
 
 QString CvsProxy::convertRevisionToPrevious(const KDevelop::VcsRevision& rev)
 {
     QString str;
 
     // this only works if the revision is a real revisionnumber and not a date or special
     switch (rev.revisionType())
     {
         case KDevelop::VcsRevision::FileNumber:
             if (rev.revisionValue().isValid()) {
                 QString orig = rev.revisionValue().toString();
 
                 // First we need to find the base (aka branch-part) of the revision number which will not change
                 QString base(orig);
                 base.truncate(orig.lastIndexOf("."));
 
                 // next we need to cut off the last part of the revision number
                 // this number is a count of revisions with a branch
                 // so if we want to diff to the previous we just need to lower it by one
                 int number = orig.mid(orig.lastIndexOf(".")+1).toInt();
                 if (number > 1) // of course this is only possible if our revision is not the first on the branch
                     number--;
 
                 str = QString("-r") + base + '.' + QString::number(number);
                 kDebug(9500) << "Converted revision "<<orig<<" to previous revision "<<str;
             }
             break;
 
         default:
             break;
     }
 
     return str;
 }
 
 CvsJob* CvsProxy::log(const KUrl& url, const KDevelop::VcsRevision& rev)
 {
     QFileInfo info(url.toLocalFile());
     if (!info.isFile())
         return 0;
 
     CvsLogJob* job = new CvsLogJob(vcsplugin);
     if ( prepareJob(job, info.absolutePath()) ) {
         *job << "cvs";
         *job << "log";
 
         QString convRev = convertVcsRevisionToString(rev);
         if (!convRev.isEmpty()) {
             convRev.replace("-D", "-d");
             *job << convRev;
         }
 
         *job << KShell::quoteArg(info.fileName());
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob* CvsProxy::diff(const KUrl& url, 
             const KDevelop::VcsRevision& revA, 
             const KDevelop::VcsRevision& revB,
             const QString& diffOptions)
 {
     QFileInfo info(url.toLocalFile());
 
     CvsDiffJob* job = new CvsDiffJob(vcsplugin);
     if ( prepareJob(job, info.absolutePath()) ) {
         *job << "cvs";
         *job << "diff";
 
         if (!diffOptions.isEmpty())
             *job << diffOptions;
 
         QString rA;
         if (revA.revisionType() == KDevelop::VcsRevision::Special) {
             // We only support diffing to previous for now
             // Other special types might be added later
             KDevelop::VcsRevision::RevisionSpecialType specialtype =
                     revA.revisionValue().value<KDevelop::VcsRevision::RevisionSpecialType>();
             if (specialtype == KDevelop::VcsRevision::Previous) {
                 rA = convertRevisionToPrevious(revB);
             }
         } else {
             rA = convertVcsRevisionToString(revA);
         }
         if (!rA.isEmpty())
             *job << rA;
 
         QString rB = convertVcsRevisionToString(revB);
         if (!rB.isEmpty())
             *job << rB;
 
         // in case the KUrl is a directory there is no filename
         if (!info.fileName().isEmpty())
             *job << KShell::quoteArg(info.fileName());
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob * CvsProxy::annotate(const KUrl & url, const KDevelop::VcsRevision& rev)
 {
     QFileInfo info(url.toLocalFile());
 
     CvsAnnotateJob* job = new CvsAnnotateJob(vcsplugin);
     if ( prepareJob(job, info.absolutePath()) ) {
         *job << "cvs";
         *job << "annotate";
 
         QString revision = convertVcsRevisionToString(rev);
         if (!revision.isEmpty())
             *job << revision;
 
         *job << KShell::quoteArg(info.fileName());
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob* CvsProxy::edit(const QString& repo, const KUrl::List& files)
 {
     CvsJob* job = new CvsJob(vcsplugin);
     if ( prepareJob(job, repo) ) {
         *job << "cvs";
         *job << "edit";
 
         addFileList(job, repo, files);
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 
 CvsJob* CvsProxy::unedit(const QString& repo, const KUrl::List& files)
 {
     CvsJob* job = new CvsJob(vcsplugin);
     if ( prepareJob(job, repo) ) {
         *job << "cvs";
         *job << "unedit";
 
         addFileList(job, repo, files);
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob* CvsProxy::editors(const QString& repo, const KUrl::List& files)
 {
     CvsJob* job = new CvsJob(vcsplugin);
     if ( prepareJob(job, repo) ) {
         *job << "cvs";
         *job << "editors";
 
         addFileList(job, repo, files);
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob* CvsProxy::commit(const QString& repo, const KUrl::List& files, const QString& message)
 {
     CvsJob* job = new CvsJob(vcsplugin);
     if ( prepareJob(job, repo) ) {
         *job << "cvs";
         *job << "commit";
 
         *job << "-m";
         *job << KShell::quoteArg( message );
 
         addFileList(job, repo, files);
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob* CvsProxy::add(const QString & repo, const KUrl::List & files, 
                       bool recursiv, bool binary)
 {
     Q_UNUSED(recursiv);
     // FIXME recursiv is not implemented yet
     CvsJob* job = new CvsJob(vcsplugin);
     if ( prepareJob(job, repo) ) {
         *job << "cvs";
         *job << "add";
 
         if (binary) {
             *job << "-kb";
         }
 
         addFileList(job, repo, files);
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob * CvsProxy::remove(const QString & repo, const KUrl::List & files)
 {
     CvsJob* job = new CvsJob(vcsplugin);
     if ( prepareJob(job, repo) ) {
         *job << "cvs";
         *job << "remove";
 
         *job << "-f"; //existing files will be deleted
 
         addFileList(job, repo, files);
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob * CvsProxy::update(const QString & repo, const KUrl::List & files, 
                           const KDevelop::VcsRevision & rev, 
                           const QString & updateOptions, 
                           bool recursive, bool pruneDirs, bool createDirs)
 {
     CvsJob* job = new CvsJob(vcsplugin);
     if ( prepareJob(job, repo) ) {
         *job << "cvs";
         *job << "update";
 
         if (recursive)
             *job << "-R";
         else 
             *job << "-L";
         if (pruneDirs)
             *job << "-P";
         if (createDirs)
             *job << "-d";
         if (!updateOptions.isEmpty())
             *job << updateOptions;
 
         QString revision = convertVcsRevisionToString(rev);
         if (!revision.isEmpty())
             *job << revision;
 
         addFileList(job, repo, files);
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob * CvsProxy::import(const KUrl & directory,
                           const QString & server, const QString & repositoryName,
                           const QString & vendortag, const QString & releasetag,
                           const QString& message)
 {
     CvsJob* job = new CvsJob(vcsplugin);
     if ( prepareJob(job, directory.toLocalFile(), CvsProxy::Import) ) {
         *job << "cvs";
         *job << "-q"; // don't print directory changes
         *job << "-d";
         *job << server;
         *job << "import";
 
         *job << "-m";
         *job << KShell::quoteArg( message );
 
         *job << repositoryName;
         *job << vendortag;
         *job << releasetag;
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob * CvsProxy::checkout(const KUrl & targetDir,
                             const QString & server, const QString & module,
                             const QString & checkoutOptions,
                             const QString & revision,
                             bool recursive,
                             bool pruneDirs)
 {
     CvsJob* job = new CvsJob(vcsplugin);
     ///@todo when doing a checkout we don't have the targetdir yet,
     ///      for now it'll work to just run the command from the root
     if ( prepareJob(job, "/", CvsProxy::CheckOut) ) {
         *job << "cvs";
         *job << "-q"; // don't print directory changes
         *job << "-d" << server;
         *job << "checkout";
 
         if (!checkoutOptions.isEmpty())
             *job << checkoutOptions;
 
         if (!revision.isEmpty()) {
             *job << "-r" << revision;
         }
 
         if (pruneDirs)
             *job << "-P";
 
         if (!recursive)
             *job << "-l";
 
         *job << "-d" << targetDir.toLocalFile(KUrl::RemoveTrailingSlash);
 
         *job << module;
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 CvsJob * CvsProxy::status(const QString & repo, const KUrl::List & files, bool recursive, bool taginfo)
 {
     CvsStatusJob* job = new CvsStatusJob(vcsplugin);
     job->setCommunicationMode( KProcess::MergedChannels );
     if ( prepareJob(job, repo) ) {
         *job << "cvs";
         *job << "status";
 
         if (recursive)
             *job << "-R";
         else
             *job << "-l";
         if (taginfo)
             *job << "-v";
 
         addFileList(job, repo, files);
 
         return job;
     }
     if (job) delete job;
     return NULL;
 }
 
 #include "cvsproxy.moc"
diff --git a/plugins/cvs/cvsproxy.h b/plugins/cvs/cvsproxy.h
index 9a660c5f24..59c338f387 100644
--- a/plugins/cvs/cvsproxy.h
+++ b/plugins/cvs/cvsproxy.h
@@ -1,107 +1,107 @@
 /***************************************************************************
  *   Copyright 2007 Robert Gruber <rgruber@users.sourceforge.net>          *
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef CVSPROXY_H
 #define CVSPROXY_H
 
 
 #include <KUrl>
 #include <KJob>
 #include <vcs/vcsrevision.h>
 
 class CvsJob;
 
 namespace KDevelop
 {
 class IPlugin;
 }
 
 /**
  * This proxy acts as a single point of entry for most of the common cvs commands.
  * It is very easy to use, as the caller does not have to deal which the CvsJob class directly.
  * All the command line generation and job handling is done internally. The caller gets a CvsJob
  * object returned from the proxy and can then call it's start() method.
  *
  * Here is and example of how to user the proxy:
  * @code
  * CvsJob* job = proxy->editors( repo, urls );
  * if ( job ) {
  *     connect(job, SIGNAL( result(KJob*) ),
  *             this, SIGNAL( jobFinished(KJob*) ));
  *     job->start();
  * }
  * @endcode
  *
  * @note All actions that take a KUrl::List also need an url to the repository which
  *       must be a common base directory to all files from the KUrl::List.
  *       Actions that just take a single KUrl don't need a repository, the cvs command will be
  *       called directly in the directory of the given file
  *
  * @author Robert Gruber <rgruber@users.sourceforge.net>
  */
 class CvsProxy : public QObject
 {
     Q_OBJECT
 public:
     CvsProxy(KDevelop::IPlugin* parent = 0);
     ~CvsProxy();
 
-    bool isValidDirectory(const KUrl &dirPath) const;
-    bool isVersionControlled(const KUrl& filePath) const;
+    bool isValidDirectory(KUrl dirPath) const;
+    bool isVersionControlled(KUrl filePath) const;
 
     CvsJob* import(const KUrl& directory,
                 const QString & server, const QString& repositoryName,
                 const QString& vendortag, const QString& releasetag,
                 const QString& message);
     CvsJob* log(const KUrl& file, const KDevelop::VcsRevision& rev);
     CvsJob* diff(const KUrl& url, 
                  const KDevelop::VcsRevision& revA, 
                  const KDevelop::VcsRevision& revB,
                  const QString& diffOptions="");
     CvsJob* annotate(const KUrl& url, const KDevelop::VcsRevision& rev);
     CvsJob* edit(const QString& repo, const KUrl::List& files);
     CvsJob* unedit(const QString& repo, const KUrl::List& files);
     CvsJob* editors(const QString& repo, const KUrl::List& files);
     CvsJob* commit(const QString& repo, const KUrl::List& files,
                 const QString& message);
     CvsJob* add(const QString& repo, const KUrl::List& files,
                 bool recursiv = true, bool binary = false);
     CvsJob* remove(const QString& repo, const KUrl::List& files);
     CvsJob* update(const QString& repo, const KUrl::List& files,
                 const KDevelop::VcsRevision& rev, 
                 const QString& updateOptions,
                 bool resursive = true, bool pruneDirs = true, bool createDirs = true);
 
     CvsJob* checkout(const KUrl& targetDir,
                 const QString & server, const QString& module,
                 const QString& checkoutOptions="",
                 const QString& revision="",
                 bool recursive = true,
                 bool pruneDirs = true);
 
     CvsJob* status(const QString & repo, const KUrl::List & files,
                 bool recursive=false, bool taginfo=false);
 
 private:
     bool addFileList(CvsJob* job, const QString& repository, const KUrl::List& urls);
     QString convertVcsRevisionToString(const KDevelop::VcsRevision& rev);
     QString convertRevisionToPrevious(const KDevelop::VcsRevision& rev);
 
     enum RequestedOperation {
         NormalOperation,
         Import,
         CheckOut
     };
     bool prepareJob(CvsJob* job, const QString& repository,
                     enum RequestedOperation op = CvsProxy::NormalOperation);
     KDevelop::IPlugin* vcsplugin;
 };
 
 #endif