• Skip to content
  • Skip to link menu
KDE 4.1 API Reference
  • KDE API Reference
  • kdelibs
  • Sitemap
  • Contact Us
 

KIO

forwardingslavebase.cpp

Go to the documentation of this file.
00001 /* This file is part of the KDE project
00002    Copyright (c) 2004 Kevin Ottens <ervin@ipsquad.net>
00003 
00004    This library is free software; you can redistribute it and/or
00005    modify it under the terms of the GNU Library General Public
00006    License as published by the Free Software Foundation; either
00007    version 2 of the License, or (at your option) any later version.
00008 
00009    This library is distributed in the hope that it will be useful,
00010    but WITHOUT ANY WARRANTY; without even the implied warranty of
00011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012    Library General Public License for more details.
00013 
00014    You should have received a copy of the GNU Library General Public License
00015    along with this library; see the file COPYING.LIB.  If not, write to
00016    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017    Boston, MA 02110-1301, USA.
00018 */
00019 
00020 #include "forwardingslavebase.h"
00021 
00022 #include "deletejob.h"
00023 #include "job.h"
00024 
00025 #include <kdebug.h>
00026 #include <kmimetype.h>
00027 #include <kprotocolinfo.h>
00028 
00029 #include <QtGui/QApplication>
00030 #include <QtCore/QEventLoop>
00031 
00032 namespace KIO
00033 {
00034 
00035 class ForwardingSlaveBasePrivate
00036 {
00037 public:
00038     ForwardingSlaveBasePrivate(QObject * eventLoopParent) :
00039         eventLoop(eventLoopParent)
00040     {}
00041     ForwardingSlaveBase *q;
00042 
00043     KUrl m_processedURL;
00044     KUrl m_requestedURL;
00045     QEventLoop eventLoop;
00046 
00047     bool internalRewriteUrl(const KUrl &url, KUrl &newURL);
00048 
00049     void connectJob(Job *job);
00050     void connectSimpleJob(SimpleJob *job);
00051     void connectListJob(ListJob *job);
00052     void connectTransferJob(TransferJob *job);
00053 
00054     void _k_slotResult(KJob *job);
00055     void _k_slotWarning(KJob *job, const QString &msg);
00056     void _k_slotInfoMessage(KJob *job, const QString &msg);
00057     void _k_slotTotalSize(KJob *job, qulonglong size);
00058     void _k_slotProcessedSize(KJob *job, qulonglong size);
00059     void _k_slotSpeed(KJob *job, unsigned long bytesPerSecond);
00060 
00061     // KIO::SimpleJob subclasses
00062     void _k_slotRedirection(KIO::Job *job, const KUrl &url);
00063 
00064     // KIO::ListJob
00065     void _k_slotEntries(KIO::Job *job, const KIO::UDSEntryList &entries);
00066 
00067     // KIO::TransferJob
00068     void _k_slotData(KIO::Job *job, const QByteArray &data);
00069     void _k_slotDataReq(KIO::Job *job, QByteArray &data);
00070     void _k_slotMimetype (KIO::Job *job, const QString &type);
00071     void _k_slotCanResume (KIO::Job *job, KIO::filesize_t offset);
00072 };
00073 
00074 ForwardingSlaveBase::ForwardingSlaveBase(const QByteArray &protocol,
00075                                          const QByteArray &poolSocket,
00076                                          const QByteArray &appSocket)
00077     : QObject(), SlaveBase(protocol, poolSocket, appSocket),
00078       d( new ForwardingSlaveBasePrivate(this) )
00079 {
00080     d->q = this;
00081 }
00082 
00083 ForwardingSlaveBase::~ForwardingSlaveBase()
00084 {
00085     delete d;
00086 }
00087 
00088 bool ForwardingSlaveBasePrivate::internalRewriteUrl(const KUrl &url, KUrl &newURL)
00089 {
00090     bool result = true;
00091 
00092     if ( url.protocol() == q->mProtocol )
00093     {
00094         result = q->rewriteUrl(url, newURL);
00095     }
00096     else
00097     {
00098         newURL = url;
00099     }
00100 
00101     m_processedURL = newURL;
00102     m_requestedURL = url;
00103     return result;
00104 }
00105 
00106 void ForwardingSlaveBase::prepareUDSEntry(KIO::UDSEntry &entry,
00107                                           bool listing) const
00108 {
00109     //kDebug() << "listing==" << listing;
00110 
00111     const QString name = entry.stringValue( KIO::UDSEntry::UDS_NAME );
00112     QString mimetype = entry.stringValue( KIO::UDSEntry::UDS_MIME_TYPE );
00113     KUrl url;
00114     const QString urlStr = entry.stringValue( KIO::UDSEntry::UDS_URL );
00115     const bool url_found = !urlStr.isEmpty();
00116     if ( url_found )
00117     {
00118         url = urlStr;
00119         KUrl new_url = d->m_requestedURL;
00120         if (listing)
00121             new_url.addPath(url.fileName());
00122         // ## Didn't find a way to use an iterator instead of re-doing a key lookup
00123         entry.insert( KIO::UDSEntry::UDS_URL, new_url.url() );
00124         kDebug() << "URL =" << url;
00125         kDebug() << "New URL =" << urlStr;
00126     }
00127 
00128     if (mimetype.isEmpty())
00129     {
00130         KUrl new_url = d->m_processedURL;
00131         if (url_found && listing)
00132         {
00133             new_url.addPath( url.fileName() );
00134         }
00135         else if (listing)
00136         {
00137             new_url.addPath( name );
00138         }
00139 
00140         mimetype = KMimeType::findByUrl(new_url)->name();
00141 
00142         entry.insert( KIO::UDSEntry::UDS_MIME_TYPE, mimetype );
00143 
00144         kDebug() << "New Mimetype = " << mimetype;
00145     }
00146 
00147     if ( d->m_processedURL.isLocalFile() )
00148     {
00149         KUrl new_url = d->m_processedURL;
00150         if (listing)
00151         {
00152             new_url.addPath( name );
00153         }
00154 
00155         entry.insert( KIO::UDSEntry::UDS_LOCAL_PATH, new_url.path() );
00156     }
00157 }
00158 
00159 KUrl ForwardingSlaveBase::processedUrl() const
00160 {
00161     return d->m_processedURL;
00162 }
00163 
00164 KUrl ForwardingSlaveBase::requestedUrl() const
00165 {
00166     return d->m_requestedURL;
00167 }
00168 
00169 void ForwardingSlaveBase::get(const KUrl &url)
00170 {
00171     kDebug() << url;
00172 
00173     KUrl new_url;
00174     if ( d->internalRewriteUrl(url, new_url) )
00175     {
00176         KIO::TransferJob *job = KIO::get(new_url, NoReload, HideProgressInfo);
00177         d->connectTransferJob(job);
00178 
00179         d->eventLoop.exec();
00180     }
00181 }
00182 
00183 void ForwardingSlaveBase::put(const KUrl &url, int permissions,
00184                               JobFlags flags)
00185 {
00186     kDebug() << url;
00187 
00188     KUrl new_url;
00189     if ( d->internalRewriteUrl(url, new_url) )
00190     {
00191         KIO::TransferJob *job = KIO::put(new_url, permissions,
00192                                          flags | HideProgressInfo);
00193         d->connectTransferJob(job);
00194 
00195         d->eventLoop.exec();
00196     }
00197 }
00198 
00199 void ForwardingSlaveBase::stat(const KUrl &url)
00200 {
00201     kDebug() << url;
00202 
00203     KUrl new_url;
00204     if ( d->internalRewriteUrl(url, new_url) )
00205     {
00206         KIO::SimpleJob *job = KIO::stat(new_url, KIO::HideProgressInfo);
00207         d->connectSimpleJob(job);
00208 
00209         d->eventLoop.exec();
00210     }
00211 }
00212 
00213 void ForwardingSlaveBase::mimetype(const KUrl &url)
00214 {
00215     kDebug() << url;
00216 
00217     KUrl new_url;
00218     if ( d->internalRewriteUrl(url, new_url) )
00219     {
00220         KIO::TransferJob *job = KIO::mimetype(new_url, KIO::HideProgressInfo);
00221         d->connectTransferJob(job);
00222 
00223         d->eventLoop.exec();
00224     }
00225 }
00226 
00227 void ForwardingSlaveBase::listDir(const KUrl &url)
00228 {
00229     kDebug() << url;
00230 
00231     KUrl new_url;
00232     if ( d->internalRewriteUrl(url, new_url) )
00233     {
00234         KIO::ListJob *job = KIO::listDir(new_url, KIO::HideProgressInfo);
00235         d->connectListJob(job);
00236 
00237         d->eventLoop.exec();
00238     }
00239 }
00240 
00241 void ForwardingSlaveBase::mkdir(const KUrl &url, int permissions)
00242 {
00243     kDebug() << url;
00244 
00245     KUrl new_url;
00246     if ( d->internalRewriteUrl(url, new_url) )
00247     {
00248         KIO::SimpleJob *job = KIO::mkdir(new_url, permissions);
00249         d->connectSimpleJob(job);
00250 
00251         d->eventLoop.exec();
00252     }
00253 }
00254 
00255 void ForwardingSlaveBase::rename(const KUrl &src, const KUrl &dest,
00256                                  JobFlags flags)
00257 {
00258     kDebug() << src << "," << dest;
00259 
00260     KUrl new_src, new_dest;
00261     if ( d->internalRewriteUrl(src, new_src) && d->internalRewriteUrl(dest, new_dest) )
00262     {
00263         KIO::Job *job = KIO::rename(new_src, new_dest, flags);
00264         d->connectJob(job);
00265 
00266         d->eventLoop.exec();
00267     }
00268 }
00269 
00270 void ForwardingSlaveBase::symlink(const QString &target, const KUrl &dest,
00271                                   JobFlags flags)
00272 {
00273     kDebug() << target << ", " << dest;
00274 
00275     KUrl new_dest;
00276     if ( d->internalRewriteUrl(dest, new_dest) )
00277     {
00278         KIO::SimpleJob *job = KIO::symlink(target, new_dest, flags & HideProgressInfo);
00279         d->connectSimpleJob(job);
00280 
00281         d->eventLoop.exec();
00282     }
00283 }
00284 
00285 void ForwardingSlaveBase::chmod(const KUrl &url, int permissions)
00286 {
00287     kDebug() << url;
00288 
00289     KUrl new_url;
00290     if ( d->internalRewriteUrl(url, new_url) )
00291     {
00292         KIO::SimpleJob *job = KIO::chmod(new_url, permissions);
00293         d->connectSimpleJob(job);
00294 
00295         d->eventLoop.exec();
00296     }
00297 }
00298 
00299 void ForwardingSlaveBase::setModificationTime(const KUrl& url, const QDateTime& mtime)
00300 {
00301     kDebug() << url;
00302 
00303     KUrl new_url;
00304     if ( d->internalRewriteUrl(url, new_url) )
00305     {
00306         KIO::SimpleJob *job = KIO::setModificationTime(new_url, mtime);
00307         d->connectSimpleJob(job);
00308 
00309         d->eventLoop.exec();
00310     }
00311 }
00312 
00313 void ForwardingSlaveBase::copy(const KUrl &src, const KUrl &dest,
00314                                int permissions, JobFlags flags)
00315 {
00316     kDebug() << src << "," << dest;
00317 
00318     KUrl new_src, new_dest;
00319     if ( d->internalRewriteUrl(src, new_src) && d->internalRewriteUrl(dest, new_dest) )
00320     {
00321       // Are you sure you want to display here a ProgressInfo ???
00322         KIO::Job *job = KIO::file_copy(new_src, new_dest, permissions,
00323                                        (flags & (~Overwrite) & (~HideProgressInfo)) );
00324         d->connectJob(job);
00325 
00326         d->eventLoop.exec();
00327     }
00328 }
00329 
00330 void ForwardingSlaveBase::del(const KUrl &url, bool isfile)
00331 {
00332     kDebug() << url;
00333 
00334     KUrl new_url;
00335     if ( d->internalRewriteUrl(url, new_url) )
00336     {
00337         if (isfile)
00338         {
00339             KIO::DeleteJob *job = KIO::del(new_url, HideProgressInfo);
00340             d->connectJob(job);
00341         }
00342         else
00343         {
00344             KIO::SimpleJob *job = KIO::rmdir(new_url);
00345             d->connectSimpleJob(job);
00346         }
00347 
00348         d->eventLoop.exec();
00349     }
00350 }
00351 
00352 
00354 
00355 void ForwardingSlaveBasePrivate::connectJob(KIO::Job *job)
00356 {
00357     // We will forward the warning message, no need to let the job
00358     // display it itself
00359     job->setUiDelegate( 0 );
00360 
00361     // Forward metadata (e.g. modification time for put())
00362     job->setMetaData( q->allMetaData() );
00363 #if 0 // debug code
00364     kDebug() << "transferring metadata:";
00365     const MetaData md = allMetaData();
00366     for ( MetaData::const_iterator it = md.begin(); it != md.end(); ++it )
00367         kDebug() << it.key() << " = " << it.data();
00368 #endif
00369 
00370     q->connect( job, SIGNAL( result(KJob *) ),
00371                 SLOT( _k_slotResult(KJob *) ) );
00372     q->connect( job, SIGNAL( warning(KJob *, const QString &, const QString &) ),
00373                 SLOT( _k_slotWarning(KJob *, const QString &) ) );
00374     q->connect( job, SIGNAL( infoMessage(KJob *, const QString &, const QString &) ),
00375                 SLOT( _k_slotInfoMessage(KJob *, const QString &) ) );
00376     q->connect( job, SIGNAL( totalSize(KJob *, qulonglong) ),
00377                 SLOT( _k_slotTotalSize(KJob *, qulonglong) ) );
00378     q->connect( job, SIGNAL( processedSize(KJob *, qulonglong) ),
00379                 SLOT( _k_slotProcessedSize(KJob *, qulonglong) ) );
00380     q->connect( job, SIGNAL( speed(KJob *, unsigned long) ),
00381                 SLOT( _k_slotSpeed(KJob *, unsigned long) ) );
00382 }
00383 
00384 void ForwardingSlaveBasePrivate::connectSimpleJob(KIO::SimpleJob *job)
00385 {
00386     connectJob(job);
00387     q->connect( job, SIGNAL( redirection(KIO::Job *, const KUrl &) ),
00388                 SLOT( _k_slotRedirection(KIO::Job *, const KUrl &) ) );
00389 }
00390 
00391 void ForwardingSlaveBasePrivate::connectListJob(KIO::ListJob *job)
00392 {
00393     connectSimpleJob(job);
00394     q->connect( job, SIGNAL( entries(KIO::Job *, const KIO::UDSEntryList &) ),
00395                 SLOT( _k_slotEntries(KIO::Job *, const KIO::UDSEntryList &) ) );
00396 }
00397 
00398 void ForwardingSlaveBasePrivate::connectTransferJob(KIO::TransferJob *job)
00399 {
00400     connectSimpleJob(job);
00401     q->connect( job, SIGNAL( data(KIO::Job *, const QByteArray &) ),
00402                 SLOT( _k_slotData(KIO::Job *, const QByteArray &) ) );
00403     q->connect( job, SIGNAL( dataReq(KIO::Job *, QByteArray &) ),
00404                 SLOT( _k_slotDataReq(KIO::Job *, QByteArray &) ) );
00405     q->connect( job, SIGNAL( mimetype(KIO::Job *, const QString &) ),
00406                 SLOT( _k_slotMimetype(KIO::Job *, const QString &) ) );
00407     q->connect( job, SIGNAL( canResume(KIO::Job *, KIO::filesize_t) ),
00408                 SLOT( _k_slotCanResume(KIO::Job *, KIO::filesize_t) ) );
00409 }
00410 
00412 
00413 void ForwardingSlaveBasePrivate::_k_slotResult(KJob *job)
00414 {
00415     if ( job->error() != 0)
00416     {
00417         q->error( job->error(), job->errorText() );
00418     }
00419     else
00420     {
00421         KIO::StatJob *stat_job = qobject_cast<KIO::StatJob *>(job);
00422         if ( stat_job!=0L )
00423         {
00424             KIO::UDSEntry entry = stat_job->statResult();
00425         q->prepareUDSEntry(entry);
00426             q->statEntry( entry );
00427         }
00428         q->finished();
00429     }
00430 
00431     eventLoop.exit();
00432 }
00433 
00434 void ForwardingSlaveBasePrivate::_k_slotWarning(KJob* /*job*/, const QString &msg)
00435 {
00436     q->warning(msg);
00437 }
00438 
00439 void ForwardingSlaveBasePrivate::_k_slotInfoMessage(KJob* /*job*/, const QString &msg)
00440 {
00441     q->infoMessage(msg);
00442 }
00443 
00444 void ForwardingSlaveBasePrivate::_k_slotTotalSize(KJob* /*job*/, qulonglong size)
00445 {
00446     q->totalSize(size);
00447 }
00448 
00449 void ForwardingSlaveBasePrivate::_k_slotProcessedSize(KJob* /*job*/, qulonglong size)
00450 {
00451     q->processedSize(size);
00452 }
00453 
00454 void ForwardingSlaveBasePrivate::_k_slotSpeed(KJob* /*job*/, unsigned long bytesPerSecond)
00455 {
00456     q->speed(bytesPerSecond);
00457 }
00458 
00459 void ForwardingSlaveBasePrivate::_k_slotRedirection(KIO::Job *job, const KUrl &url)
00460 {
00461     q->redirection(url);
00462 
00463     // We've been redirected stop everything.
00464     job->kill( KJob::Quietly );
00465     q->finished();
00466 
00467     eventLoop.exit();
00468 }
00469 
00470 void ForwardingSlaveBasePrivate::_k_slotEntries(KIO::Job* /*job*/,
00471                                       const KIO::UDSEntryList &entries)
00472 {
00473     KIO::UDSEntryList final_entries = entries;
00474 
00475     KIO::UDSEntryList::iterator it = final_entries.begin();
00476     const KIO::UDSEntryList::iterator end = final_entries.end();
00477 
00478     for(; it!=end; ++it)
00479     {
00480         q->prepareUDSEntry(*it, true);
00481     }
00482 
00483     q->listEntries( final_entries );
00484 }
00485 
00486 void ForwardingSlaveBasePrivate::_k_slotData(KIO::Job* /*job*/, const QByteArray &_data)
00487 {
00488     q->data(_data);
00489 }
00490 
00491 void ForwardingSlaveBasePrivate::_k_slotDataReq(KIO::Job* /*job*/, QByteArray &data)
00492 {
00493     q->dataReq();
00494     q->readData(data);
00495 }
00496 
00497 void ForwardingSlaveBasePrivate::_k_slotMimetype (KIO::Job* /*job*/, const QString &type)
00498 {
00499     q->mimeType(type);
00500 }
00501 
00502 void ForwardingSlaveBasePrivate::_k_slotCanResume (KIO::Job* /*job*/, KIO::filesize_t offset)
00503 {
00504     q->canResume(offset);
00505 }
00506 
00507 }
00508 
00509 #include "forwardingslavebase.moc"
00510 

KIO

Skip menu "KIO"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

kdelibs

Skip menu "kdelibs"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • Kate
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • KIO
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • Kross
  • KUtils
  • Nepomuk
  • Solid
  • Sonnet
  • ThreadWeaver
Generated for kdelibs by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal