Skip to main content :: ::

KDE API Reference

:: Skip to Link Menu

/ API Reference / kio / kio

kdirlister.cpp /* This file is part of the KDE project Copyright (C) 1998, 1999 Torben Weis <weis@kde.org> 2000 Carsten Pfeiffer <pfeiffer@kde.org> 2001-2005 Michael Brade <brade@kde.org> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "kdirlister.h" #include <qregexp.h> #include <qptrlist.h> #include <qtimer.h> #include <kapplication.h> #include <kdebug.h> #include <klocale.h> #include <kio/job.h> #include <kmessagebox.h> #include <kglobal.h> #include <kglobalsettings.h> #include <kstaticdeleter.h> #include <kprotocolinfo.h> #include "kdirlister_p.h" #include <assert.h> KDirListerCache* KDirListerCache::s_pSelf = 0; static KStaticDeleter<KDirListerCache> sd_KDirListerCache; // Enable this to get printDebug() called often, to see the contents of the cache //#define DEBUG_CACHE // Make really sure it doesn't get activated in the final build #ifdef NDEBUG #undef DEBUG_CACHE #endif KDirListerCache::KDirListerCache( int maxCount ) : itemsCached( maxCount ) { kdDebug(7004) << "+KDirListerCache" << endl; itemsInUse.setAutoDelete( false ); itemsCached.setAutoDelete( true ); urlsCurrentlyListed.setAutoDelete( true ); urlsCurrentlyHeld.setAutoDelete( true ); pendingUpdates.setAutoDelete( true ); connect( kdirwatch, SIGNAL( dirty( const QString& ) ), this, SLOT( slotFileDirty( const QString& ) ) ); connect( kdirwatch, SIGNAL( created( const QString& ) ), this, SLOT( slotFileCreated( const QString& ) ) ); connect( kdirwatch, SIGNAL( deleted( const QString& ) ), this, SLOT( slotFileDeleted( const QString& ) ) ); } KDirListerCache::~KDirListerCache() { kdDebug(7004) << "-KDirListerCache" << endl; itemsInUse.setAutoDelete( true ); itemsInUse.clear(); itemsCached.clear(); urlsCurrentlyListed.clear(); urlsCurrentlyHeld.clear(); if ( KDirWatch::exists() ) kdirwatch->disconnect( this ); } // setting _reload to true will emit the old files and // call updateDirectory bool KDirListerCache::listDir( KDirLister *lister, const KURL& _u, bool _keep, bool _reload ) { // like this we don't have to worry about trailing slashes any further KURL _url = _u; _url.cleanPath(); // kill consecutive slashes _url.adjustPath(-1); QString urlStr = _url.url(); if ( !lister->validURL( _url ) ) return false; #ifdef DEBUG_CACHE printDebug(); #endif kdDebug(7004) << k_funcinfo << lister << " url=" << _url << " keep=" << _keep << " reload=" << _reload << endl; if ( !_keep ) { // stop any running jobs for lister stop( lister ); // clear our internal list for lister forgetDirs( lister ); lister->d->rootFileItem = 0; } else if ( lister->d->lstDirs.find( _url ) != lister->d->lstDirs.end() ) { // stop the job listing _url for this lister stop( lister, _url ); // clear _url for lister forgetDirs( lister, _url, true ); if ( lister->d->url == _url ) lister->d->rootFileItem = 0; } lister->d->lstDirs.append( _url ); if ( lister->d->url.isEmpty() || !_keep ) // set toplevel URL only if not set yet lister->d->url = _url; DirItem *itemU = itemsInUse[urlStr]; DirItem *itemC; if ( !urlsCurrentlyListed[urlStr] ) { // if there is an update running for _url already we get into // the following case - it will just be restarted by updateDirectory(). if ( itemU ) { kdDebug(7004) << "listDir: Entry already in use: " << _url << endl; bool oldState = lister->d->complete; lister->d->complete = false; emit lister->started( _url ); if ( !lister->d->rootFileItem && lister->d->url == _url ) lister->d->rootFileItem = itemU->rootItem; lister->addNewItems( *(itemU->lstItems) ); lister->emitItems(); // _url is already in use, so there is already an entry in urlsCurrentlyHeld assert( urlsCurrentlyHeld[urlStr] ); urlsCurrentlyHeld[urlStr]->append( lister ); lister->d->complete = oldState; emit lister->completed( _url ); if ( lister->d->complete ) emit lister->completed(); if ( _reload || !itemU->complete ) updateDirectory( _url ); } else if ( !_reload && (itemC = itemsCached.take( urlStr )) ) { kdDebug(7004) << "listDir: Entry in cache: " << _url << endl; itemC->decAutoUpdate(); itemsInUse.insert( urlStr, itemC ); itemU = itemC; bool oldState = lister->d->complete; lister->d->complete = false; emit lister->started( _url ); if ( !lister->d->rootFileItem && lister->d->url == _url ) lister->d->rootFileItem = itemC->rootItem; lister->addNewItems( *(itemC->lstItems) ); lister->emitItems(); Q_ASSERT( !urlsCurrentlyHeld[urlStr] ); QPtrList<KDirLister> *list = new QPtrList<KDirLister>; list->append( lister ); urlsCurrentlyHeld.insert( urlStr, list ); lister->d->complete = oldState; emit lister->completed( _url ); if ( lister->d->complete ) emit lister->completed(); if ( !itemC->complete ) updateDirectory( _url ); } else // dir not in cache or _reload is true { kdDebug(7004) << "listDir: Entry not in cache or reloaded: " << _url << endl; QPtrList<KDirLister> *list = new QPtrList<KDirLister>; list->append( lister ); urlsCurrentlyListed.insert( urlStr, list ); itemsCached.remove( urlStr ); itemU = new DirItem( _url ); itemsInUse.insert( urlStr, itemU ); // // we have a limit of MAX_JOBS_PER_LISTER concurrently running jobs // if ( lister->numJobs() >= MAX_JOBS_PER_LISTER ) // { // lstPendingUpdates.append( _url ); // } // else // { if ( lister->d->url == _url ) lister->d->rootFileItem = 0; KIO::ListJob* job = KIO::listDir( _url, false /* no default GUI */ ); jobs.insert( job, QValueList<KIO::UDSEntry>() ); lister->jobStarted( job ); lister->connectJob( job ); if ( lister->d->window ) job->setWindow( lister->d->window ); connect( job, SIGNAL( entries( KIO::Job *, const KIO::UDSEntryList & ) ), this, SLOT( slotEntries( KIO::Job *, const KIO::UDSEntryList & ) ) ); connect( job, SIGNAL( result( KIO::Job * ) ), this, SLOT( slotResult( KIO::Job * ) ) ); connect( job, SIGNAL( redirection( KIO::Job *, const KURL & ) ), this, SLOT( slotRedirection( KIO::Job *, const KURL & ) ) ); emit lister->started( _url ); // } } } else { kdDebug(7004) << "listDir: Entry currently being listed: " << _url << endl; emit lister->started( _url ); urlsCurrentlyListed[urlStr]->append( lister ); KIO::ListJob *job = jobForUrl( urlStr ); Q_ASSERT( job ); lister->jobStarted( job ); lister->connectJob( job ); Q_ASSERT( itemU ); if ( !lister->d->rootFileItem && lister->d->url == _url ) lister->d->rootFileItem = itemU->rootItem; lister->addNewItems( *(itemU->lstItems) ); lister->emitItems(); } // automatic updating of directories if ( lister->d->autoUpdate ) itemU->incAutoUpdate(); return true; } bool KDirListerCache::validURL( const KDirLister *lister, const KURL& url ) const { if ( !url.isValid() ) { if ( lister->d->autoErrorHandling ) { QString tmp = i18n("Malformed URL\n%1").arg( url.prettyURL() ); KMessageBox::error( lister->d->errorParent, tmp ); } return false; } if ( !KProtocolInfo::supportsListing( url ) ) { if ( lister->d->autoErrorHandling ) { // TODO: this message should be changed during next string unfreeze! QString tmp = i18n("Malformed URL\n%1").arg( url.prettyURL() ); KMessageBox::error( lister->d->errorParent, tmp ); } return false; } return true; } void KDirListerCache::stop( KDirLister *lister ) { #ifdef DEBUG_CACHE printDebug(); #endif kdDebug(7004) << k_funcinfo << "lister: " << lister << endl; bool stopped = false; QDictIterator< QPtrList<KDirLister> > it( urlsCurrentlyListed ); QPtrList<KDirLister> *listers; while ( (listers = it.current()) ) { if ( listers->findRef( lister ) > -1 ) { // lister is listing url QString url = it.currentKey(); //kdDebug(7004) << k_funcinfo << " found lister in list - for " << url << endl; bool ret = listers->removeRef( lister ); Q_ASSERT( ret ); KIO::ListJob *job = jobForUrl( url ); if ( job ) lister->jobDone( job ); // move lister to urlsCurrentlyHeld QPtrList<KDirLister> *holders = urlsCurrentlyHeld[url]; if ( !holders ) { holders = new QPtrList<KDirLister>; urlsCurrentlyHeld.insert( url, holders ); } holders->append( lister ); emit lister->canceled( KURL( url ) ); //kdDebug(7004) << k_funcinfo << "remaining list: " << listers->count() << " listers" << endl; if ( listers->isEmpty() ) { // kill the job since it isn't used any more if ( job ) killJob( job ); urlsCurrentlyListed.remove( url ); } stopped = true; } else ++it; } if ( stopped ) { emit lister->canceled(); lister->d->complete = true; } // this is wrong if there is still an update running! //Q_ASSERT( lister->d->complete ); } void KDirListerCache::stop( KDirLister *lister, const KURL& _u ) { QString urlStr( _u.url(-1) ); KURL _url( urlStr ); // TODO: consider to stop all the "child jobs" of _url as well kdDebug(7004) << k_funcinfo << lister << " url=" << _url << endl; QPtrList<KDirLister> *listers = urlsCurrentlyListed[urlStr]; if ( !listers || !listers->removeRef( lister ) ) return; // move lister to urlsCurrentlyHeld QPtrList<KDirLister> *holders = urlsCurrentlyHeld[urlStr]; if ( !holders ) { holders = new QPtrList<KDirLister>; urlsCurrentlyHeld.insert( urlStr, holders ); } holders->append( lister ); KIO::ListJob *job = jobForUrl( urlStr ); if ( job ) lister->jobDone( job ); emit lister->canceled( _url ); if ( listers->isEmpty() ) { // kill the job since it isn't used any more if ( job ) killJob( job ); urlsCurrentlyListed.remove( urlStr ); } if ( lister->numJobs() == 0 ) { lister->d->complete = true; // we killed the last job for lister emit lister->canceled(); } } void KDirListerCache::setAutoUpdate( KDirLister *lister, bool enable ) { // IMPORTANT: this method does not check for the current autoUpdate state! for ( KURL::List::Iterator it = lister->d->lstDirs.begin(); it != lister->d->lstDirs.end(); ++it ) { if ( enable ) itemsInUse[(*it).url()]->incAutoUpdate(); else itemsInUse[(*it).url()]->decAutoUpdate(); } } void KDirListerCache::forgetDirs( KDirLister *lister ) { kdDebug(7004) << k_funcinfo << lister << endl; emit lister->clear(); // forgetDirs() will modify lstDirs, make a copy first KURL::List lstDirsCopy = lister->d->lstDirs; for ( KURL::List::Iterator it = lstDirsCopy.begin(); it != lstDirsCopy.end(); ++it ) { forgetDirs( lister, *it, false ); } } void KDirListerCache::forgetDirs( KDirLister *lister, const KURL& _url, bool notify ) { kdDebug(7004) << k_funcinfo << lister << " _url: " << _url << endl; KURL url( _url ); url.adjustPath( -1 ); QString urlStr = url.url(); QPtrList<KDirLister> *holders = urlsCurrentlyHeld[urlStr]; Q_ASSERT( holders ); holders->removeRef( lister ); // remove the dir from lister->d->lstDirs so that it doesn't contain things // that itemsInUse doesn't. When emitting the canceled signals lstDirs must // not contain anything that itemsInUse does not contain. (otherwise it // might crash in findByName()). lister->d->lstDirs.remove( lister->d->lstDirs.find( url ) ); DirItem *item = itemsInUse[urlStr]; Q_ASSERT( item ); if ( holders->isEmpty() ) { urlsCurrentlyHeld.remove( urlStr ); // this deletes the (empty) holders list if ( !urlsCurrentlyListed[urlStr] ) { // item not in use anymore -> move into cache if complete itemsInUse.remove( urlStr ); // this job is a running update KIO::ListJob *job = jobForUrl( urlStr ); if ( job ) { lister->jobDone( job ); killJob( job ); kdDebug(7004) << k_funcinfo << "Killing update job for " << urlStr << endl; emit lister->canceled( url ); if ( lister->numJobs() == 0 ) { lister->d->complete = true; emit lister->canceled(); } } if ( notify ) emit lister->clear( url ); if ( item->complete ) { kdDebug(7004) << k_funcinfo << lister << " item moved into cache: " << url << endl; itemsCached.insert( urlStr, item ); // TODO: may return false!! // Should we forget the dir for good, or keep a watch on it? // Generally keep a watch, except when it would prevent // unmounting a removable device (#37780) const bool isLocal = item->url.isLocalFile(); const bool isManuallyMounted = isLocal && KIO::manually_mounted( item->url.path() ); bool containsManuallyMounted = false; if ( !isManuallyMounted && item->lstItems && isLocal ) { // Look for a manually-mounted directory inside // If there's one, we can't keep a watch either, FAM would prevent unmounting the CDROM // I hope this isn't too slow (manually_mounted caches the last device so most // of the time this is just a stat per subdir) KFileItemListIterator kit( *item->lstItems ); for ( ; kit.current() && !containsManuallyMounted; ++kit ) if ( (*kit)->isDir() && KIO::manually_mounted( (*kit)->url().path() ) ) containsManuallyMounted = true; } if ( isManuallyMounted || containsManuallyMounted ) { kdDebug(7004) << "Not adding a watch on " << item->url << " because it " << ( isManuallyMounted ? "is manually mounted" : "contains a manually mounted subdir" ) << endl; item->complete = false; // set to "dirty" } else item->incAutoUpdate(); // keep watch } else { delete item; item = 0; } } } if ( item && lister->d->autoUpdate ) item->decAutoUpdate(); } void KDirListerCache::updateDirectory( const KURL& _dir ) { kdDebug(7004) << k_funcinfo << _dir << endl; QString urlStr = _dir.url(-1); if ( !checkUpdate( urlStr ) ) return; // A job can be running to // - only list a new directory: the listers are in urlsCurrentlyListed // - only update a directory: the listers are in urlsCurrentlyHeld // - update a currently running listing: the listers are in urlsCurrentlyListed // and urlsCurrentlyHeld QPtrList<KDirLister> *listers = urlsCurrentlyListed[urlStr]; QPtrList<KDirLister> *holders = urlsCurrentlyHeld[urlStr]; // restart the job for _dir if it is running already bool killed = false; QWidget *window = 0; KIO::ListJob *job = jobForUrl( urlStr ); if ( job ) { window = job->window(); killJob( job ); killed = true; if ( listers ) for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) kdl->jobDone( job ); if ( holders ) for ( KDirLister *kdl = holders->first(); kdl; kdl = holders->next() ) kdl->jobDone( job ); } kdDebug(7004) << k_funcinfo << "Killed = " << killed << endl; // we don't need to emit canceled signals since we only replaced the job, // the listing is continuing. Q_ASSERT( !listers || (listers && killed) ); job = KIO::listDir( _dir, false /* no default GUI */ ); jobs.insert( job, QValueList<KIO::UDSEntry>() ); connect( job, SIGNAL(entries( KIO::Job *, const KIO::UDSEntryList & )), this, SLOT(slotUpdateEntries( KIO::Job *, const KIO::UDSEntryList & )) ); connect( job, SIGNAL(result( KIO::Job * )), this, SLOT(slotUpdateResult( KIO::Job * )) ); kdDebug(7004) << k_funcinfo << "update started in " << _dir << endl; if ( listers ) for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) kdl->jobStarted( job ); if ( holders ) { if ( !killed ) { bool first = true; for ( KDirLister *kdl = holders->first(); kdl; kdl = holders->next() ) { kdl->jobStarted( job ); if ( first && kdl->d->window ) { first = false; job->setWindow( kdl->d->window ); } emit kdl->started( _dir ); } } else { job->setWindow( window ); for ( KDirLister *kdl = holders->first(); kdl; kdl = holders->next() ) kdl->jobStarted( job ); } } } bool KDirListerCache::checkUpdate( const QString& _dir ) { if ( !itemsInUse[_dir] ) { DirItem *item = itemsCached[_dir]; if ( item && item->complete ) { item->complete = false; item->decAutoUpdate(); // Hmm, this debug output might include login/password from the _dir URL. //kdDebug(7004) << k_funcinfo << "directory " << _dir << " not in use, marked dirty." << endl; } //else //kdDebug(7004) << k_funcinfo << "aborted, directory " << _dir << " not in cache." << endl; return false; } else return true; } KFileItemList *KDirListerCache::itemsForDir( const KURL &_dir ) const { QString urlStr = _dir.url(-1); DirItem *item = itemsInUse[ urlStr ]; if ( !item ) item = itemsCached[ urlStr ]; return item ? item->lstItems : 0; } KFileItem *KDirListerCache::findByName( const KDirLister *lister, const QString& _name ) const { Q_ASSERT( lister ); for ( KURL::List::Iterator it = lister->d->lstDirs.begin(); it != lister->d->lstDirs.end(); ++it ) { KFileItemListIterator kit( *itemsInUse[(*it).url()]->lstItems ); for ( ; kit.current(); ++kit ) if ( (*kit)->name() == _name ) return (*kit); } return 0L; } KFileItem *KDirListerCache::findByURL( const KDirLister *lister, const KURL& _u ) const { KURL _url = _u; _url.adjustPath(-1); KURL parentDir( _url ); parentDir.setPath( parentDir.directory() ); // If lister is set, check that it contains this dir if ( lister && !lister->d->lstDirs.contains( parentDir ) ) return 0L; KFileItemList *itemList = itemsForDir( parentDir ); if ( itemList ) { KFileItemListIterator kit( *itemList ); for ( ; kit.current(); ++kit ) if ( (*kit)->url() == _url ) return (*kit); } return 0L; } void KDirListerCache::FilesAdded( const KURL &dir ) { kdDebug(7004) << k_funcinfo << dir << endl; updateDirectory( dir ); } void KDirListerCache::FilesRemoved( const KURL::List &fileList ) { kdDebug(7004) << k_funcinfo << endl; KURL::List::ConstIterator it = fileList.begin(); for ( ; it != fileList.end() ; ++it ) { // emit the deleteItem signal if this file was shown in any view KFileItem *fileitem = 0L; KURL parentDir( *it ); parentDir.setPath( parentDir.directory() ); KFileItemList *lstItems = itemsForDir( parentDir ); if ( lstItems ) { KFileItem *fit = lstItems->first(); for ( ; fit; fit = lstItems->next() ) if ( fit->url() == *it ) { fileitem = fit; lstItems->take(); // remove fileitem from list break; } } // Tell the views about it before deleting the KFileItems. They might need the subdirs' // file items (see the dirtree). if ( fileitem ) { QPtrList<KDirLister> *listers = urlsCurrentlyHeld[parentDir.url()]; if ( listers ) for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) kdl->emitDeleteItem( fileitem ); } // If we found a fileitem, we can test if it's a dir. If not, we'll go to deleteDir just in case. if ( !fileitem || fileitem->isDir() ) { // in case of a dir, check if we have any known children, there's much to do in that case // (stopping jobs, removing dirs from cache etc.) deleteDir( *it ); } // now remove the item itself delete fileitem; } } void KDirListerCache::FilesChanged( const KURL::List &fileList ) { KURL::List dirsToUpdate; kdDebug(7004) << k_funcinfo << "only half implemented" << endl; KURL::List::ConstIterator it = fileList.begin(); for ( ; it != fileList.end() ; ++it ) { if ( ( *it ).isLocalFile() ) { kdDebug(7004) << "KDirListerCache::FilesChanged " << *it << endl; KFileItem *fileitem = findByURL( 0, *it ); if ( fileitem ) { // we need to refresh the item, because e.g. the permissions can have changed. aboutToRefreshItem( fileitem ); fileitem->refresh(); emitRefreshItem( fileitem ); } else kdDebug(7004) << "item not found" << endl; } else { // For remote files, refresh() won't be able to figure out the new information. // Let's update the dir. KURL dir( *it ); dir.setPath( dir.directory( true ) ); if ( dirsToUpdate.find( dir ) == dirsToUpdate.end() ) dirsToUpdate.prepend( dir ); } } KURL::List::ConstIterator itdir = dirsToUpdate.begin(); for ( ; itdir != dirsToUpdate.end() ; ++itdir ) updateDirectory( *itdir ); // ## TODO problems with current jobs listing/updating that dir // ( see kde-2.2.2's kdirlister ) } void KDirListerCache::FileRenamed( const KURL &src, const KURL &dst ) { kdDebug(7004) << k_funcinfo << src.prettyURL() << " -> " << dst.prettyURL() << endl; #ifdef DEBUG_CACHE printDebug(); #endif // Somehow this should only be called if src is a dir. But how could we know if it is? // (Note that looking into itemsInUse isn't good enough. One could rename a subdir in a view.) renameDir( src, dst ); // Now update the KFileItem representing that file or dir (not exclusive with the above!) KURL oldurl( src ); oldurl.adjustPath( -1 ); KFileItem *fileitem = findByURL( 0, oldurl ); if ( fileitem ) { if ( !fileitem->isLocalFile() && !fileitem->localPath().isEmpty() ) // it uses UDS_LOCAL_PATH? ouch, needs an update then FilesChanged( src ); else { aboutToRefreshItem( fileitem ); fileitem->setURL( dst ); fileitem->refreshMimeType(); emitRefreshItem( fileitem ); } } #ifdef DEBUG_CACHE printDebug(); #endif } void KDirListerCache::aboutToRefreshItem( KFileItem *fileitem ) { // Look whether this item was shown in any view, i.e. held by any dirlister KURL parentDir( fileitem->url() ); parentDir.setPath( parentDir.directory() ); QString parentDirURL = parentDir.url(); QPtrList<KDirLister> *listers = urlsCurrentlyHeld[parentDirURL]; if ( listers ) for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) kdl->aboutToRefreshItem( fileitem ); // Also look in urlsCurrentlyListed, in case the user manages to rename during a listing listers = urlsCurrentlyListed[parentDirURL]; if ( listers ) for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) kdl->aboutToRefreshItem( fileitem ); } void KDirListerCache::emitRefreshItem( KFileItem *fileitem ) { // Look whether this item was shown in any view, i.e. held by any dirlister KURL parentDir( fileitem->url() ); parentDir.setPath( parentDir.directory() ); QString parentDirURL = parentDir.url(); QPtrList<KDirLister> *listers = urlsCurrentlyHeld[parentDirURL]; if ( listers ) for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) { kdl->addRefreshItem( fileitem ); kdl->emitItems(); } // Also look in urlsCurrentlyListed, in case the user manages to rename during a listing listers = urlsCurrentlyListed[parentDirURL]; if ( listers ) for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) { kdl->addRefreshItem( fileitem ); kdl->emitItems(); } } KDirListerCache* KDirListerCache::self() { if ( !s_pSelf ) s_pSelf = sd_KDirListerCache.setObject( s_pSelf, new KDirListerCache ); return s_pSelf; } bool KDirListerCache::exists() { return s_pSelf != 0; } // private slots // _file can also be a directory being currently held! void KDirListerCache::slotFileDirty( const QString& _file ) { kdDebug(7004) << k_funcinfo << _file << endl; if ( !pendingUpdates[_file] ) { KURL dir; dir.setPath( _file ); if ( checkUpdate( dir.url(-1) ) ) updateDirectory( dir ); // the parent directory of _file dir.setPath( dir.directory() ); if ( checkUpdate( dir.url() ) ) { // Nice hack to save memory: use the qt object name to store the filename QTimer *timer = new QTimer( this, _file.utf8() ); connect( timer, SIGNAL(timeout()), this, SLOT(slotFileDirtyDelayed()) ); pendingUpdates.insert( _file, timer ); timer->start( 500, true ); } } } // delayed updating of files, FAM is flooding us with events void KDirListerCache::slotFileDirtyDelayed() { QString file = QString::fromUtf8( sender()->name() ); kdDebug(7004) << k_funcinfo << file << endl; // TODO: do it better: don't always create/delete the QTimer but reuse it. // Delete the timer after the parent directory is removed from the cache. pendingUpdates.remove( file ); KURL u; u.setPath( file ); KFileItem *item = findByURL( 0, u ); // search all items if ( item ) { // we need to refresh the item, because e.g. the permissions can have changed. aboutToRefreshItem( item ); item->refresh(); emitRefreshItem( item ); } } void KDirListerCache::slotFileCreated( const QString& _file ) { kdDebug(7004) << k_funcinfo << _file << endl; // XXX: how to avoid a complete rescan here? KURL u; u.setPath( _file ); u.setPath( u.directory() ); FilesAdded( u ); } void KDirListerCache::slotFileDeleted( const QString& _file ) { kdDebug(7004) << k_funcinfo << _file << endl; KURL u; u.setPath( _file ); FilesRemoved( u ); } void KDirListerCache::slotEntries( KIO::Job *job, const KIO::UDSEntryList &entries ) { KURL url = joburl( static_cast<KIO::ListJob *>(job) ); url.adjustPath(-1); QString urlStr = url.url(); kdDebug(7004) << k_funcinfo << "new entries for " << url << endl; DirItem *dir = itemsInUse[urlStr]; Q_ASSERT( dir ); QPtrList<KDirLister> *listers = urlsCurrentlyListed[urlStr]; Q_ASSERT( listers ); Q_ASSERT( !listers->isEmpty() ); // check if anyone wants the mimetypes immediately bool delayedMimeTypes = true; for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) delayedMimeTypes = delayedMimeTypes && kdl->d->delayedMimeTypes; // avoid creating these QStrings again and again static const QString& dot = KGlobal::staticQString("."); static const QString& dotdot = KGlobal::staticQString(".."); KIO::UDSEntryListConstIterator it = entries.begin(); KIO::UDSEntryListConstIterator end = entries.end(); for ( ; it != end; ++it ) { QString name; // find out about the name KIO::UDSEntry::ConstIterator entit = (*it).begin(); for( ; entit != (*it).end(); ++entit ) if ( (*entit).m_uds == KIO::UDS_NAME ) { name = (*entit).m_str; break; } Q_ASSERT( !name.isEmpty() ); if ( name.isEmpty() ) continue; if ( name == dot ) { Q_ASSERT( !dir->rootItem ); dir->rootItem = new KFileItem( *it, url, delayedMimeTypes, true ); for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) if ( !kdl->d->rootFileItem && kdl->d->url == url ) kdl->d->rootFileItem = dir->rootItem; } else if ( name != dotdot ) { KFileItem* item = new KFileItem( *it, url, delayedMimeTypes, true ); Q_ASSERT( item ); //kdDebug(7004)<< "Adding item: " << item->url() << endl; dir->lstItems->append( item ); for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) kdl->addNewItem( item ); } } for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) kdl->emitItems(); } void KDirListerCache::slotResult( KIO::Job *j ) { Q_ASSERT( j ); KIO::ListJob *job = static_cast<KIO::ListJob *>( j ); jobs.remove( job ); KURL jobUrl = joburl( job ); jobUrl.adjustPath(-1); // need remove trailing slashes again, in case of redirections QString jobUrlStr = jobUrl.url(); kdDebug(7004) << k_funcinfo << "finished listing " << jobUrl << endl; #ifdef DEBUG_CACHE printDebug(); #endif QPtrList<KDirLister> *listers = urlsCurrentlyListed.take( jobUrlStr ); Q_ASSERT( listers ); // move the directory to the held directories, do it before emitting // the signals to make sure it exists in KDirListerCache in case someone // calls listDir during the signal emission Q_ASSERT( !urlsCurrentlyHeld[jobUrlStr] ); urlsCurrentlyHeld.insert( jobUrlStr, listers ); KDirLister *kdl; if ( job->error() ) { for ( kdl = listers->first(); kdl; kdl = listers->next() ) { kdl->jobDone( job ); kdl->handleError( job ); emit kdl->canceled( jobUrl ); if ( kdl->numJobs() == 0 ) { kdl->d->complete = true; emit kdl->canceled(); } } } else { DirItem *dir = itemsInUse[jobUrlStr]; Q_ASSERT( dir ); dir->complete = true; for ( kdl = listers->first(); kdl; kdl = listers->next() ) { kdl->jobDone( job ); emit kdl->completed( jobUrl ); if ( kdl->numJobs() == 0 ) { kdl->d->complete = true; emit kdl->completed(); } } } // TODO: hmm, if there was an error and job is a parent of one or more // of the pending urls we should cancel it/them as well processPendingUpdates(); #ifdef DEBUG_CACHE printDebug(); #endif } void KDirListerCache::slotRedirection( KIO::Job *j, const KURL& url ) { Q_ASSERT( j ); KIO::ListJob *job = static_cast<KIO::ListJob *>( j ); KURL oldUrl = job->url(); // here we really need the old url! KURL newUrl = url; // strip trailing slashes oldUrl.adjustPath(-1); newUrl.adjustPath(-1); if ( oldUrl == newUrl ) { kdDebug(7004) << k_funcinfo << "New redirection url same as old, giving up." << endl; return; } kdDebug(7004) << k_funcinfo << oldUrl.prettyURL() << " -> " << newUrl.prettyURL() << endl; #ifdef DEBUG_CACHE printDebug(); #endif // I don't think there can be dirItems that are childs of oldUrl. // Am I wrong here? And even if so, we don't need to delete them, right? // DF: redirection happens before listDir emits any item. Makes little sense otherwise. // oldUrl cannot be in itemsCached because only completed items are moved there DirItem *dir = itemsInUse.take( oldUrl.url() ); Q_ASSERT( dir ); QPtrList<KDirLister> *listers = urlsCurrentlyListed.take( oldUrl.url() ); Q_ASSERT( listers ); Q_ASSERT( !listers->isEmpty() ); for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) { // TODO: put in own method? if ( kdl->d->url.equals( oldUrl, true ) ) { kdl->d->rootFileItem = 0; kdl->d->url = newUrl; } *kdl->d->lstDirs.find( oldUrl ) = newUrl; if ( kdl->d->lstDirs.count() == 1 ) { emit kdl->clear(); emit kdl->redirection( newUrl ); emit kdl->redirection( oldUrl, newUrl ); } else { emit kdl->clear( oldUrl ); emit kdl->redirection( oldUrl, newUrl ); } } // when a lister was stopped before the job emits the redirection signal, the old url will // also be in urlsCurrentlyHeld QPtrList<KDirLister> *holders = urlsCurrentlyHeld.take( oldUrl.url() ); if ( holders ) { Q_ASSERT( !holders->isEmpty() ); for ( KDirLister *kdl = holders->first(); kdl; kdl = holders->next() ) { kdl->jobStarted( job ); // do it like when starting a new list-job that will redirect later emit kdl->started( oldUrl ); // TODO: maybe don't emit started if there's an update running for newUrl already? if ( kdl->d->url.equals( oldUrl, true ) ) { kdl->d->rootFileItem = 0; kdl->d->url = newUrl; } *kdl->d->lstDirs.find( oldUrl ) = newUrl; if ( kdl->d->lstDirs.count() == 1 ) { emit kdl->clear(); emit kdl->redirection( newUrl ); emit kdl->redirection( oldUrl, newUrl ); } else { emit kdl->clear( oldUrl ); emit kdl->redirection( oldUrl, newUrl ); } } } DirItem *newDir = itemsInUse[newUrl.url()]; if ( newDir ) { kdDebug(7004) << "slotRedirection: " << newUrl.url() << " already in use" << endl; // only in this case there can newUrl already be in urlsCurrentlyListed or urlsCurrentlyHeld delete dir; // get the job if one's running for newUrl already (can be a list-job or an update-job), but // do not return this 'job', which would happen because of the use of redirectionURL() KIO::ListJob *oldJob = jobForUrl( newUrl.url(), job ); // listers of newUrl with oldJob: forget about the oldJob and use the already running one // which will be converted to an updateJob QPtrList<KDirLister> *curListers = urlsCurrentlyListed[newUrl.url()]; if ( curListers ) { kdDebug(7004) << "slotRedirection: and it is currently listed" << endl; Q_ASSERT( oldJob ); // ?! for ( KDirLister *kdl = curListers->first(); kdl; kdl = curListers->next() ) // listers of newUrl { kdl->jobDone( oldJob ); kdl->jobStarted( job ); kdl->connectJob( job ); } // append listers of oldUrl with newJob to listers of newUrl with oldJob for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) curListers->append( kdl ); } else urlsCurrentlyListed.insert( newUrl.url(), listers ); if ( oldJob ) // kill the old job, be it a list-job or an update-job killJob( oldJob ); // holders of newUrl: use the already running job which will be converted to an updateJob QPtrList<KDirLister> *curHolders = urlsCurrentlyHeld[newUrl.url()]; if ( curHolders ) { kdDebug(7004) << "slotRedirection: and it is currently held." << endl; for ( KDirLister *kdl = curHolders->first(); kdl; kdl = curHolders->next() ) // holders of newUrl { kdl->jobStarted( job ); emit kdl->started( newUrl ); } // append holders of oldUrl to holders of newUrl if ( holders ) for ( KDirLister *kdl = holders->first(); kdl; kdl = holders->next() ) curHolders->append( kdl ); } else if ( holders ) urlsCurrentlyHeld.insert( newUrl.url(), holders ); // emit old items: listers, holders. NOT: newUrlListers/newUrlHolders, they already have them listed // TODO: make this a separate method? for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) { if ( !kdl->d->rootFileItem && kdl->d->url == newUrl ) kdl->d->rootFileItem = newDir->rootItem; kdl->addNewItems( *(newDir->lstItems) ); kdl->emitItems(); } if ( holders ) { for ( KDirLister *kdl = holders->first(); kdl; kdl = holders->next() ) { if ( !kdl->d->rootFileItem && kdl->d->url == newUrl ) kdl->d->rootFileItem = newDir->rootItem; kdl->addNewItems( *(newDir->lstItems) ); kdl->emitItems(); } } } else if ( (newDir = itemsCached.take( newUrl.url() )) ) { kdDebug(7004) << "slotRedirection: " << newUrl.url() << " is unused, but already in the cache." << endl; delete dir; itemsInUse.insert( newUrl.url(), newDir ); urlsCurrentlyListed.insert( newUrl.url(), listers ); if ( holders ) urlsCurrentlyHeld.insert( newUrl.url(), holders ); // emit old items: listers, holders for ( KDirLister *kdl = listers->first(); kdl; kdl = listers->next() ) { if ( !kdl->d->rootFileItem && kdl->d->url == newUrl ) kdl->d->rootFileItem = newDir->rootItem; kdl->addNewItems( *(newDir->lstItems) ); kdl->emitItems(); } if ( holders ) { for ( KDirLister *kdl = holders->first(); kdl; kdl = holders->next() ) { if ( !kdl->d->rootFileItem && kdl->d->url == newUrl ) kdl->d->rootFileItem = newDir->rootItem; kdl->addNewItems( *(newDir->lstItems) ); kdl->emitItems(); } } } else { kdDebug(7004) << "slotRedirection: " << newUrl.url() << " has not been listed yet." << endl; delete dir->rootItem; dir->rootItem = 0; dir->lstItems->clear(); dir->redirect( newUrl ); itemsInUse.insert( newUrl.url(), dir ); url