kmail/annotationjobs.cpp

   1 /**
   2  * annotationjobs.cpp
   3  *
   4  * Copyright (c) 2004 David Faure <faure@kde.org>
   5  *
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; version 2 of the License
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  *  In addition, as a special exception, the copyright holders give
  21  *  permission to link the code of this program with any edition of
  22  *  the Qt library by Trolltech AS, Norway (or with modified versions
  23  *  of Qt that use the same license as Qt), and distribute linked
  24  *  combinations including the two.  You must obey the GNU General
  25  *  Public License in all respects for all of the code used other than
  26  *  Qt.  If you modify this file, you may extend this exception to
  27  *  your version of the file, but you are not obligated to do so.  If
  28  *  you do not wish to do so, delete this exception statement from
  29  *  your version.
  30  */
  31
  32
  33 #include "annotationjobs.h"
  34 #include <kio/scheduler.h>
  35 #include <kdebug.h>
  36
  37 using namespace KMail;
  38
  39 KIO::SimpleJob* AnnotationJobs::setAnnotation(
  40     KIO::Slave* slave, const KUrl& url, const QString& entry,
  41     const QMap<QString,QString>& attributes )
  42 {
  43   QByteArray packedArgs;
  44   QDataStream stream( &packedArgs, QIODevice::WriteOnly );
  45   stream << (int)'M' << (int)'S' << url << entry << attributes;
  46
  47   KIO::SimpleJob* job = KIO::special( url, packedArgs, KIO::HideProgressInfo );
  48   KIO::Scheduler::assignJobToSlave( slave, job );
  49   return job;
  50 }
  51
  52 AnnotationJobs::GetAnnotationJob* AnnotationJobs::getAnnotation(
  53     KIO::Slave* slave, const KUrl& url, const QString& entry,
  54     const QStringList& attributes )
  55 {
  56   QByteArray packedArgs;
  57   QDataStream stream( &packedArgs, QIODevice::WriteOnly );
  58   stream << (int)'M' << (int)'G' << url << entry << attributes;
  59
  60   GetAnnotationJob* job = new GetAnnotationJob( url, entry, packedArgs);
  61   KIO::Scheduler::assignJobToSlave( slave, job );
  62   return job;
  63 }
  64
  65 AnnotationJobs::GetAnnotationJob::GetAnnotationJob( const KUrl& url, const QString& entry,
  66                                                     const QByteArray &packedArgs)
  67   : KIO::SpecialJob( url, packedArgs),
  68     mEntry( entry )
  69 {
  70   connect( this, SIGNAL(infoMessage(KJob*,const QString&,const QString&)),
  71            SLOT(slotInfoMessage(KJob*,const QString&,const QString&)) );
  72 }
  73
  74 void AnnotationJobs::GetAnnotationJob::slotInfoMessage( KJob*, const QString& str,const QString& )
  75 {
  76   // Parse the result
  77   QStringList lst = str.split( "\r", QString::SkipEmptyParts );
  78   while ( lst.count() >= 2 ) // we take items 2 by 2
  79   {
  80     QString name = lst.front(); lst.pop_front();
  81     QString value = lst.front(); lst.pop_front();
  82     mAnnotations.append( AnnotationAttribute( mEntry, name, value ) );
  83   }
  84 }
  85
  86 AnnotationJobs::MultiGetAnnotationJob::MultiGetAnnotationJob(
  87   KIO::Slave* slave, const KUrl& url, const QStringList& entries )
  88   : KIO::Job(),
  89     mSlave( slave ),
  90     mUrl( url ), mEntryList( entries ), mEntryListIterator( mEntryList.begin() )
  91 {
  92   QTimer::singleShot(0, this, SLOT(slotStart()));
  93 }
  94
  95
  96 void AnnotationJobs::MultiGetAnnotationJob::slotStart()
  97 {
  98   if ( mEntryListIterator != mEntryList.end() ) {
  99     QStringList attributes;
 100     attributes << "value";
 101     KIO::Job* job = getAnnotation( mSlave, mUrl, *mEntryListIterator, attributes );
 102     addSubjob( job );
 103   } else { // done!
 104     emitResult();
 105   }
 106 }
 107
 108 void AnnotationJobs::MultiGetAnnotationJob::slotResult( KJob *job )
 109 {
 110   if ( job->error() ) {
 111     KIO::Job::slotResult( job ); // will set the error and emit result(this)
 112     return;
 113   }
 114   removeSubjob( job );
 115   const QString& entry = *mEntryListIterator;
 116   QString value;
 117   bool found = false;
 118   GetAnnotationJob* getJob = static_cast<GetAnnotationJob *>( job );
 119   const AnnotationList& lst = getJob->annotations();
 120   for ( int i = 0 ; i < lst.size() ; ++ i ) {
 121     kDebug(5006) <<"found annotation" << lst[i].name <<" =" << lst[i].value;
 122     if ( lst[i].name.startsWith( "value." ) ) { // value.priv or value.shared
 123       found = true;
 124       value = lst[i].value;
 125       break;
 126     }
 127   }
 128   emit annotationResult( entry, value, found );
 129   // Move on to next one
 130   ++mEntryListIterator;
 131   slotStart();
 132 }
 133
 134 AnnotationJobs::MultiGetAnnotationJob* AnnotationJobs::multiGetAnnotation( KIO::Slave* slave, const KUrl& url, const QStringList& entries )
 135 {
 136   return new MultiGetAnnotationJob( slave, url, entries );
 137 }
 138
 139 ////
 140
 141 AnnotationJobs::MultiSetAnnotationJob::MultiSetAnnotationJob(
 142   KIO::Slave* slave, const KUrl& url, const AnnotationList& annotations )
 143   : KIO::Job(),
 144     mSlave( slave ),
 145     mUrl( url ), mAnnotationList( annotations ), mAnnotationListIterator( mAnnotationList.begin() )
 146 {
 147   QTimer::singleShot(0, this, SLOT(slotStart()));
 148 }
 149
 150
 151 void AnnotationJobs::MultiSetAnnotationJob::slotStart()
 152 {
 153   if ( mAnnotationListIterator != mAnnotationList.end() ) {
 154     const AnnotationAttribute& attr = *mAnnotationListIterator;
 155     // setAnnotation can set multiple attributes for a given entry.
 156     // So in theory we could group entries coming from our list. Bah.
 157     QMap<QString, QString> attributes;
 158     attributes.insert( attr.name, attr.value );
 159     kDebug(5006) <<" setting annotation" << attr.entry << attr.name << attr.value;
 160     KIO::Job* job = setAnnotation( mSlave, mUrl, attr.entry, attributes );
 161     addSubjob( job );
 162   } else { // done!
 163     emitResult();
 164   }
 165 }
 166
 167 void AnnotationJobs::MultiSetAnnotationJob::slotResult( KJob *job )
 168 {
 169   if ( job->error() ) {
 170     KIO::Job::slotResult( job ); // will set the error and emit result(this)
 171     return;
 172   }
 173   removeSubjob( job );
 174   const AnnotationAttribute& attr = *mAnnotationListIterator;
 175   emit annotationChanged( attr.entry, attr.name, attr.value );
 176
 177   // Move on to next one
 178   ++mAnnotationListIterator;
 179   slotStart();
 180 }
 181
 182 AnnotationJobs::MultiSetAnnotationJob* AnnotationJobs::multiSetAnnotation(
 183   KIO::Slave* slave, const KUrl& url, const AnnotationList& annotations )
 184 {
 185   return new MultiSetAnnotationJob( slave, url, annotations );
 186 }
 187
 188
 189 AnnotationJobs::MultiUrlGetAnnotationJob::MultiUrlGetAnnotationJob( KIO::Slave* slave,
 190                                                                     const KUrl& baseUrl,
 191                                                                     const QStringList& paths,
 192                                                                     const QString& annotation )
 193   : KIO::Job(),
 194     mSlave( slave ),
 195     mUrl( baseUrl ),
 196     mPathList( paths ),
 197     mPathListIterator( mPathList.begin() ),
 198     mAnnotation( annotation )
 199 {
 200   QTimer::singleShot(0, this, SLOT(slotStart()));
 201 }
 202
 203
 204 void AnnotationJobs::MultiUrlGetAnnotationJob::slotStart()
 205 {
 206   if ( mPathListIterator != mPathList.end() ) {
 207     QStringList attributes;
 208     attributes << "value";
 209     KUrl url(mUrl);
 210     url.setPath( *mPathListIterator );
 211     KIO::Job* job = getAnnotation( mSlave, url, mAnnotation, attributes );
 212     addSubjob( job );
 213   } else { // done!
 214     emitResult();
 215   }
 216 }
 217
 218 void AnnotationJobs::MultiUrlGetAnnotationJob::slotResult( KJob *job )
 219 {
 220   if ( job->error() ) {
 221     KIO::Job::slotResult( job ); // will set the error and emit result(this)
 222     return;
 223   }
 224   removeSubjob( job );
 225   const QString& path = *mPathListIterator;
 226   GetAnnotationJob* getJob = static_cast<GetAnnotationJob *>( job );
 227   const AnnotationList& lst = getJob->annotations();
 228   for ( int i = 0 ; i < lst.size() ; ++ i ) {
 229     kDebug(5006) <<"MultiURL: found annotation" << lst[i].name <<" =" << lst[i].value <<" for path:" << path;
 230     if ( lst[i].name.startsWith( "value." ) ) { // value.priv or value.shared
 231       mAnnotations.insert( path, lst[i].value );
 232       break;
 233     }
 234   }
 235   // Move on to next one
 236   ++mPathListIterator;
 237   slotStart();
 238 }
 239
 240 QMap<QString, QString> AnnotationJobs::MultiUrlGetAnnotationJob::annotations() const
 241 {
 242   return mAnnotations;
 243 }
 244
 245 AnnotationJobs::MultiUrlGetAnnotationJob* AnnotationJobs::multiUrlGetAnnotation( KIO::Slave* slave,
 246                                                                                  const KUrl& baseUrl,
 247                                                                                  const QStringList& paths,
 248                                                                                  const QString& annotation )
 249 {
 250   return new MultiUrlGetAnnotationJob( slave, baseUrl, paths, annotation );
 251 }
 252
 253
 254 #include "annotationjobs.moc"