libkonq Library API Documentation

konq_historymgr.cc

00001 /* This file is part of the KDE project 00002 Copyright (C) 2000,2001 Carsten Pfeiffer <pfeiffer@kde.org> 00003 00004 This program is free software; you can redistribute it and/or 00005 modify it under the terms of the GNU 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 program 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 General Public License for more details. 00013 00014 You should have received a copy of the GNU General Public License 00015 along with this program; see the file COPYING. If not, write to 00016 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 00017 Boston, MA 02111-1307, USA. 00018 */ 00019 00020 #include "konq_historymgr.h" 00021 00022 #include <dcopclient.h> 00023 00024 #include <kapplication.h> 00025 #include <kdebug.h> 00026 #include <ksavefile.h> 00027 #include <ksimpleconfig.h> 00028 #include <kstandarddirs.h> 00029 00030 #include <zlib.h> 00031 00032 #include "konqbookmarkmanager.h" 00033 00034 const Q_UINT32 KonqHistoryManager::s_historyVersion = 3; 00035 00036 KonqHistoryManager::KonqHistoryManager( QObject *parent, const char *name ) 00037 : KParts::HistoryProvider( parent, name ), 00038 KonqHistoryComm( "KonqHistoryManager" ) 00039 { 00040 m_updateTimer = new QTimer( this ); 00041 00042 // defaults 00043 KConfig *config = KGlobal::config(); 00044 KConfigGroupSaver cs( config, "HistorySettings" ); 00045 m_maxCount = config->readNumEntry( "Maximum of History entries", 500 ); 00046 m_maxCount = QMAX( 1, m_maxCount ); 00047 m_maxAgeDays = config->readNumEntry( "Maximum age of History entries", 90); 00048 00049 m_history.setAutoDelete( true ); 00050 m_filename = locateLocal( "data", 00051 QString::fromLatin1("konqueror/konq_history" )); 00052 00053 if ( !kapp->dcopClient()->isAttached() ) 00054 kapp->dcopClient()->attach(); 00055 00056 00057 // take care of the completion object 00058 m_pCompletion = new KCompletion; 00059 m_pCompletion->setOrder( KCompletion::Weighted ); 00060 00061 // and load the history 00062 loadHistory(); 00063 00064 connect( m_updateTimer, SIGNAL( timeout() ), SLOT( slotEmitUpdated() )); 00065 } 00066 00067 00068 KonqHistoryManager::~KonqHistoryManager() 00069 { 00070 delete m_pCompletion; 00071 clearPending(); 00072 } 00073 00074 bool KonqHistoryManager::isSenderOfBroadcast() 00075 { 00076 DCOPClient *dc = callingDcopClient(); 00077 return !dc || (dc->senderId() == dc->appId()); 00078 } 00079 00080 // loads the entire history 00081 bool KonqHistoryManager::loadHistory() 00082 { 00083 clearPending(); 00084 m_history.clear(); 00085 m_pCompletion->clear(); 00086 00087 QFile file( m_filename ); 00088 if ( !file.open( IO_ReadOnly ) ) { 00089 if ( file.exists() ) 00090 kdWarning() << "Can't open " << file.name() << endl; 00091 00092 // try to load the old completion history 00093 bool ret = loadFallback(); 00094 emit loadingFinished(); 00095 return ret; 00096 } 00097 00098 QDataStream fileStream( &file ); 00099 QByteArray data; // only used for version == 2 00100 // we construct the stream object now but fill in the data later. 00101 // thanks to QBA's explicit sharing this works :) 00102 QDataStream crcStream( data, IO_ReadOnly ); 00103 00104 if ( !fileStream.atEnd() ) { 00105 Q_UINT32 version; 00106 fileStream >> version; 00107 00108 QDataStream *stream = &fileStream; 00109 00110 bool crcChecked = false; 00111 bool crcOk = false; 00112 00113 if ( version == 2 || version == 3) { 00114 Q_UINT32 crc; 00115 crcChecked = true; 00116 fileStream >> crc >> data; 00117 crcOk = crc32( 0, reinterpret_cast<unsigned char *>( data.data() ), data.size() ) == crc; 00118 stream = &crcStream; // pick up the right stream 00119 } 00120 00121 if ( version == 3 ) 00122 { 00123 //Use KURL marshalling for V3 format. 00124 KonqHistoryEntry::marshalURLAsStrings = false; 00125 } 00126 00127 if ( version != 0 && version < 3 ) //Versions 1,2 (but not 0) are also valid 00128 { 00129 //Turn on backwards compatibility mode.. 00130 KonqHistoryEntry::marshalURLAsStrings = true; 00131 // it doesn't make sense to save to save maxAge and maxCount in the 00132 // binary file, this would make backups impossible (they would clear 00133 // themselves on startup, because all entries expire). 00134 // [But V1 and V2 formats did it, so we do a dummy read] 00135 Q_UINT32 dummy; 00136 *stream >> dummy; 00137 *stream >> dummy; 00138 00139 //OK. 00140 version = 3; 00141 } 00142 00143 if ( s_historyVersion != version || ( crcChecked && !crcOk ) ) { 00144 kdWarning() << "The history version doesn't match, aborting loading" << endl; 00145 file.close(); 00146 emit loadingFinished(); 00147 return false; 00148 } 00149 00150 00151 while ( !stream->atEnd() ) { 00152 KonqHistoryEntry *entry = new KonqHistoryEntry; 00153 Q_CHECK_PTR( entry ); 00154 *stream >> *entry; 00155 // kdDebug(1203) << "## loaded entry: " << entry->url << ", Title: " << entry->title << endl; 00156 m_history.append( entry ); 00157 QString urlString2 = entry->url.prettyURL(); 00158 00159 addToCompletion( urlString2, entry->typedURL, entry->numberOfTimesVisited ); 00160 00161 // and fill our baseclass. 00162 QString urlString = entry->url.url(); 00163 KParts::HistoryProvider::insert( urlString ); 00164 // DF: also insert the "pretty" version if different 00165 // This helps getting 'visited' links on websites which don't use fully-escaped urls. 00166 00167 if ( urlString != urlString2 ) 00168 KParts::HistoryProvider::insert( urlString2 ); 00169 } 00170 00171 kdDebug(1203) << "## loaded: " << m_history.count() << " entries." << endl; 00172 00173 m_history.sort(); 00174 adjustSize(); 00175 } 00176 00177 00178 //This is important - we need to switch to a consistent marshalling format for 00179 //communicating between different konqueror instances. Since during an upgrade 00180 //some "old" copies may still running, we use the old format for the DCOP transfers. 00181 //This doesn't make that much difference performance-wise for single entries anyway. 00182 KonqHistoryEntry::marshalURLAsStrings = true; 00183 00184 00185 // Theoretically, we should emit update() here, but as we only ever 00186 // load items on startup up to now, this doesn't make much sense. Same 00187 // thing for the above loadFallback(). 00188 // emit KParts::HistoryProvider::update( some list ); 00189 00190 00191 00192 file.close(); 00193 emit loadingFinished(); 00194 00195 return true; 00196 } 00197 00198 00199 // saves the entire history 00200 bool KonqHistoryManager::saveHistory() 00201 { 00202 KSaveFile file( m_filename ); 00203 if ( file.status() != 0 ) { 00204 kdWarning() << "Can't open " << file.name() << endl; 00205 return false; 00206 } 00207 00208 QDataStream *fileStream = file.dataStream(); 00209 *fileStream << s_historyVersion; 00210 00211 QByteArray data; 00212 QDataStream stream( data, IO_WriteOnly ); 00213 00214 //We use KURL for marshalling URLs in entries in the V3 00215 //file format 00216 KonqHistoryEntry::marshalURLAsStrings = false; 00217 QPtrListIterator<KonqHistoryEntry> it( m_history ); 00218 KonqHistoryEntry *entry; 00219 while ( (entry = it.current()) ) { 00220 stream << *entry; 00221 ++it; 00222 } 00223 00224 //For DCOP, transfer strings instead - wire compat. 00225 KonqHistoryEntry::marshalURLAsStrings = true; 00226 00227 Q_UINT32 crc = crc32( 0, reinterpret_cast<unsigned char *>( data.data() ), data.size() ); 00228 *fileStream << crc << data; 00229 00230 file.close(); 00231 00232 return true; 00233 } 00234 00235 00236 void KonqHistoryManager::adjustSize() 00237 { 00238 KonqHistoryEntry *entry = m_history.getFirst(); 00239 00240 while ( m_history.count() > m_maxCount || isExpired( entry ) ) { 00241 removeFromCompletion( entry->url.prettyURL(), entry->typedURL ); 00242 00243 QString urlString = entry->url.url(); 00244 KParts::HistoryProvider::remove( urlString ); 00245 00246 addToUpdateList( urlString ); 00247 00248 emit entryRemoved( m_history.getFirst() ); 00249 m_history.removeFirst(); // deletes the entry 00250 00251 entry = m_history.getFirst(); 00252 } 00253 } 00254 00255 00256 void KonqHistoryManager::addPending( const KURL& url, const QString& typedURL, 00257 const QString& title ) 00258 { 00259 addToHistory( true, url, typedURL, title ); 00260 } 00261 00262 void KonqHistoryManager::confirmPending( const KURL& url, 00263 const QString& typedURL, 00264 const QString& title ) 00265 { 00266 addToHistory( false, url, typedURL, title ); 00267 } 00268 00269 00270 void KonqHistoryManager::addToHistory( bool pending, const KURL& _url, 00271 const QString& typedURL, 00272 const QString& title ) 00273 { 00274 kdDebug(1203) << "## addToHistory: " << _url.prettyURL() << " Typed URL: " << typedURL << ", Title: " << title << endl; 00275 00276 if ( filterOut( _url ) ) // we only want remote URLs 00277 return; 00278 00279 // http URLs without a path will get redirected immediately to url + '/' 00280 if ( _url.path().isEmpty() && _url.protocol().startsWith("http") ) 00281 return; 00282 00283 KURL url( _url ); 00284 url.setPass( QString::null ); // No password in the history, especially not in the completion! 00285 url.setHost( url.host().lower() ); // All host parts lower case 00286 KonqHistoryEntry entry; 00287 QString u = url.prettyURL(); 00288 entry.url = url; 00289 if ( u != typedURL ) 00290 entry.typedURL = typedURL; 00291 00292 // we only keep the title if we are confirming an entry. Otherwise, 00293 // we might get bogus titles from the previous url (actually it's just 00294 // konqueror's window caption). 00295 if ( !pending && u != title ) 00296 entry.title = title; 00297 entry.firstVisited = QDateTime::currentDateTime(); 00298 entry.lastVisited = entry.firstVisited; 00299 00300 if ( !pending ) { // remove from pending if available. 00301 QMapIterator<QString,KonqHistoryEntry*> it = m_pending.find( u ); 00302 00303 if ( it != m_pending.end() ) { 00304 delete it.data(); 00305 m_pending.remove( it ); 00306 00307 // we make a pending entry official, so we just have to update 00308 // and not increment the counter. No need to care about 00309 // firstVisited, as this is not taken into account on update. 00310 entry.numberOfTimesVisited = 0; 00311 } 00312 } 00313 00314 else { 00315 // We add a copy of the current history entry of the url to the 00316 // pending list, so that we can restore it if the user canceled. 00317 // If there is no entry for the url yet, we just store the url. 00318 KonqHistoryEntry *oldEntry = findEntry( url ); 00319 m_pending.insert( u, oldEntry ? 00320 new KonqHistoryEntry( *oldEntry ) : 0L ); 00321 } 00322 00323 // notify all konqueror instances about the entry 00324 emitAddToHistory( entry ); 00325 } 00326 00327 // interface of KParts::HistoryManager 00328 // Usually, we only record the history for non-local URLs (i.e. filterOut() 00329 // returns false). But when using the HistoryProvider interface, we record 00330 // exactly those filtered-out urls. 00331 // Moreover, we don't get any pending/confirming entries, just one insert() 00332 void KonqHistoryManager::insert( const QString& url ) 00333 { 00334 KURL u = url; 00335 if ( !filterOut( url ) || u.protocol() == "about" ) { // remote URL 00336 return; 00337 } 00338 // Local URL -> add to history 00339 KonqHistoryEntry entry; 00340 entry.url = u; 00341 entry.firstVisited = QDateTime::currentDateTime(); 00342 entry.lastVisited = entry.firstVisited; 00343 emitAddToHistory( entry ); 00344 } 00345 00346 void KonqHistoryManager::emitAddToHistory( const KonqHistoryEntry& entry ) 00347 { 00348 QByteArray data; 00349 QDataStream stream( data, IO_WriteOnly ); 00350 stream << entry << objId(); 00351 kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager", 00352 "notifyHistoryEntry(KonqHistoryEntry, QCString)", 00353 data ); 00354 } 00355 00356 00357 void KonqHistoryManager::removePending( const KURL& url ) 00358 { 00359 // kdDebug(1203) << "## Removing pending... " << url.prettyURL() << endl; 00360 00361 if ( url.isLocalFile() ) 00362 return; 00363 00364 QMapIterator<QString,KonqHistoryEntry*> it = m_pending.find( url.prettyURL() ); 00365 if ( it != m_pending.end() ) { 00366 KonqHistoryEntry *oldEntry = it.data(); // the old entry, may be 0L 00367 emitRemoveFromHistory( url ); // remove the current pending entry 00368 00369 if ( oldEntry ) // we had an entry before, now use that instead 00370 emitAddToHistory( *oldEntry ); 00371 00372 delete oldEntry; 00373 m_pending.remove( it ); 00374 } 00375 } 00376 00377 // clears the pending list and makes sure the entries get deleted. 00378 void KonqHistoryManager::clearPending() 00379 { 00380 QMapIterator<QString,KonqHistoryEntry*> it = m_pending.begin(); 00381 while ( it != m_pending.end() ) { 00382 delete it.data(); 00383 ++it; 00384 } 00385 m_pending.clear(); 00386 } 00387 00388 void KonqHistoryManager::emitRemoveFromHistory( const KURL& url ) 00389 { 00390 QByteArray data; 00391 QDataStream stream( data, IO_WriteOnly ); 00392 stream << url << objId(); 00393 kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager", 00394 "notifyRemove(KURL, QCString)", data ); 00395 } 00396 00397 void KonqHistoryManager::emitRemoveFromHistory( const KURL::List& urls ) 00398 { 00399 QByteArray data; 00400 QDataStream stream( data, IO_WriteOnly ); 00401 stream << urls << objId(); 00402 kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager", 00403 "notifyRemove(KURL::List, QCString)", data ); 00404 } 00405 00406 void KonqHistoryManager::emitClear() 00407 { 00408 QByteArray data; 00409 QDataStream stream( data, IO_WriteOnly ); 00410 stream << objId(); 00411 kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager", 00412 "notifyClear(QCString)", data ); 00413 } 00414 00415 void KonqHistoryManager::emitSetMaxCount( Q_UINT32 count ) 00416 { 00417 QByteArray data; 00418 QDataStream stream( data, IO_WriteOnly ); 00419 stream << count << objId(); 00420 kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager", 00421 "notifyMaxCount(Q_UINT32, QCString)", data ); 00422 } 00423 00424 void KonqHistoryManager::emitSetMaxAge( Q_UINT32 days ) 00425 { 00426 QByteArray data; 00427 QDataStream stream( data, IO_WriteOnly ); 00428 stream << days << objId(); 00429 kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager", 00430 "notifyMaxAge(Q_UINT32, QCString)", data ); 00431 } 00432 00434 // DCOP called methods 00435 00436 void KonqHistoryManager::notifyHistoryEntry( KonqHistoryEntry e, 00437 QCString ) 00438 { 00439 //kdDebug(1203) << "Got new entry from Broadcast: " << e.url.prettyURL() << endl; 00440 00441 KonqHistoryEntry *entry = findEntry( e.url ); 00442 QString urlString = e.url.url(); 00443 00444 if ( !entry ) { // create a new history entry 00445 entry = new KonqHistoryEntry; 00446 entry->url = e.url; 00447 entry->firstVisited = e.firstVisited; 00448 entry->numberOfTimesVisited = 0; // will get set to 1 below 00449 m_history.append( entry ); 00450 KParts::HistoryProvider::insert( urlString ); 00451 } 00452 00453 if ( !e.typedURL.isEmpty() ) 00454 entry->typedURL = e.typedURL; 00455 if ( !e.title.isEmpty() ) 00456 entry->title = e.title; 00457 entry->numberOfTimesVisited += e.numberOfTimesVisited; 00458 entry->lastVisited = e.lastVisited; 00459 00460 addToCompletion( entry->url.prettyURL(), entry->typedURL ); 00461 00462 // bool pending = (e.numberOfTimesVisited != 0); 00463 00464 adjustSize(); 00465 00466 // note, no need to do the updateBookmarkMetadata for every 00467 // history object, only need to for the broadcast sender as 00468 // the history object itself keeps the data consistant. 00469 bool updated = KonqBookmarkManager::self()->updateAccessMetadata( urlString ); 00470 00471 if ( isSenderOfBroadcast() ) { 00472 // we are the sender of the broadcast, so we save 00473 saveHistory(); 00474 // note, bk save does not notify, and we don't want to! 00475 if (updated) 00476 KonqBookmarkManager::self()->save(); 00477 } 00478 00479 addToUpdateList( urlString ); 00480 emit entryAdded( entry ); 00481 } 00482 00483 void KonqHistoryManager::notifyMaxCount( Q_UINT32 count, QCString ) 00484 { 00485 m_maxCount = count; 00486 clearPending(); 00487 adjustSize(); 00488 00489 KConfig *config = KGlobal::config(); 00490 KConfigGroupSaver cs( config, "HistorySettings" ); 00491 config->writeEntry( "Maximum of History entries", m_maxCount ); 00492 00493 if ( isSenderOfBroadcast() ) { 00494 saveHistory(); 00495 config->sync(); 00496 } 00497 } 00498 00499 void KonqHistoryManager::notifyMaxAge( Q_UINT32 days, QCString ) 00500 { 00501 m_maxAgeDays = days; 00502 clearPending(); 00503 adjustSize(); 00504 00505 KConfig *config = KGlobal::config(); 00506 KConfigGroupSaver cs( config, "HistorySettings" ); 00507 config->writeEntry( "Maximum age of History entries", m_maxAgeDays ); 00508 00509 if ( isSenderOfBroadcast() ) { 00510 saveHistory(); 00511 config->sync(); 00512 } 00513 } 00514 00515 void KonqHistoryManager::notifyClear( QCString ) 00516 { 00517 clearPending(); 00518 m_history.clear(); 00519 m_pCompletion->clear(); 00520 00521 if ( isSenderOfBroadcast() ) 00522 saveHistory(); 00523 00524 KParts::HistoryProvider::clear(); // also emits the cleared() signal 00525 } 00526 00527 void KonqHistoryManager::notifyRemove( KURL url, QCString ) 00528 { 00529 kdDebug(1203) << "#### Broadcast: remove entry:: " << url.prettyURL() << endl; 00530 00531 00532 KonqHistoryEntry *entry = m_history.findEntry( url ); 00533 00534 if ( entry ) { // entry is now the current item 00535 removeFromCompletion( entry->url.prettyURL(), entry->typedURL ); 00536 00537 QString urlString = entry->url.url(); 00538 KParts::HistoryProvider::remove( urlString ); 00539 00540 addToUpdateList( urlString ); 00541 00542 m_history.take(); // does not delete 00543 emit entryRemoved( entry ); 00544 delete entry; 00545 00546 if ( isSenderOfBroadcast() ) 00547 saveHistory(); 00548 } 00549 } 00550 00551 void KonqHistoryManager::notifyRemove( KURL::List urls, QCString ) 00552 { 00553 kdDebug(1203) << "#### Broadcast: removing list!" << endl; 00554 00555 bool doSave = false; 00556 KURL::List::Iterator it = urls.begin(); 00557 while ( it != urls.end() ) { 00558 KonqHistoryEntry *entry = m_history.findEntry( *it ); 00559 00560 if ( entry ) { // entry is now the current item 00561 removeFromCompletion( entry->url.prettyURL(), entry->typedURL ); 00562 00563 QString urlString = entry->url.url(); 00564 KParts::HistoryProvider::remove( urlString ); 00565 00566 addToUpdateList( urlString ); 00567 00568 m_history.take(); // does not delete 00569 emit entryRemoved( entry ); 00570 delete entry; 00571 doSave = true; 00572 } 00573 00574 ++it; 00575 } 00576 00577 if (doSave && isSenderOfBroadcast()) 00578 saveHistory(); 00579 } 00580 00581 00582 // compatibility fallback, try to load the old completion history 00583 bool KonqHistoryManager::loadFallback() 00584 { 00585 QString file = locateLocal( "config", QString::fromLatin1("konq_history")); 00586 if ( file.isEmpty() ) 00587 return false; 00588 00589 KonqHistoryEntry *entry; 00590 KSimpleConfig config( file ); 00591 config.setGroup("History"); 00592 QStringList items = config.readListEntry( "CompletionItems" ); 00593 QStringList::Iterator it = items.begin(); 00594 00595 while ( it != items.end() ) { 00596 entry = createFallbackEntry( *it ); 00597 if ( entry ) { 00598 m_history.append( entry ); 00599 addToCompletion( entry->url.prettyURL(), QString::null, entry->numberOfTimesVisited ); 00600 00601 KParts::HistoryProvider::insert( entry->url.url() ); 00602 } 00603 ++it; 00604 } 00605 00606 m_history.sort(); 00607 adjustSize(); 00608 saveHistory(); 00609 00610 return true; 00611 } 00612 00613 // tries to create a small KonqHistoryEntry out of a string, where the string 00614 // looks like "http://www.bla.com/bla.html:23" 00615 // the attached :23 is the weighting from KCompletion 00616 KonqHistoryEntry * KonqHistoryManager::createFallbackEntry(const QString& item) const 00617 { 00618 // code taken from KCompletion::addItem(), adjusted to use weight = 1 00619 uint len = item.length(); 00620 uint weight = 1; 00621 00622 // find out the weighting of this item (appended to the string as ":num") 00623 int index = item.findRev(':'); 00624 if ( index > 0 ) { 00625 bool ok; 00626 weight = item.mid( index + 1 ).toUInt( &ok ); 00627 if ( !ok ) 00628 weight = 1; 00629 00630 len = index; // only insert until the ':' 00631 } 00632 00633 00634 KonqHistoryEntry *entry = 0L; 00635 KURL u( item.left( len )); 00636 if ( u.isValid() ) { 00637 entry = new KonqHistoryEntry; 00638 // that's the only entries we know about... 00639 entry->url = u; 00640 entry->numberOfTimesVisited = weight; 00641 // to make it not expire immediately... 00642 entry->lastVisited = QDateTime::currentDateTime(); 00643 } 00644 00645 return entry; 00646 } 00647 00648 KonqHistoryEntry * KonqHistoryManager::findEntry( const KURL& url ) 00649 { 00650 // small optimization (dict lookup) for items _not_ in our history 00651 if ( !KParts::HistoryProvider::contains( url.url() ) ) 00652 return 0L; 00653 00654 return m_history.findEntry( url ); 00655 } 00656 00657 bool KonqHistoryManager::filterOut( const KURL& url ) 00658 { 00659 return ( url.isLocalFile() || url.host().isEmpty() ); 00660 } 00661 00662 void KonqHistoryManager::slotEmitUpdated() 00663 { 00664 emit KParts::HistoryProvider::updated( m_updateURLs ); 00665 m_updateURLs.clear(); 00666 } 00667 00668 QStringList KonqHistoryManager::allURLs() const 00669 { 00670 QStringList list; 00671 KonqHistoryIterator it ( m_history ); 00672 for ( ; it.current(); ++it ) 00673 list.append( it.current()->url.url() ); 00674 00675 return list; 00676 } 00677 00678 void KonqHistoryManager::addToCompletion( const QString& url, const QString& typedURL, 00679 int numberOfTimesVisited ) 00680 { 00681 m_pCompletion->addItem( url, numberOfTimesVisited ); 00682 // typed urls have a higher priority 00683 m_pCompletion->addItem( typedURL, numberOfTimesVisited +10 ); 00684 } 00685 00686 void KonqHistoryManager::removeFromCompletion( const QString& url, const QString& typedURL ) 00687 { 00688 m_pCompletion->removeItem( url ); 00689 m_pCompletion->removeItem( typedURL ); 00690 } 00691 00693 00694 00695 KonqHistoryEntry * KonqHistoryList::findEntry( const KURL& url ) 00696 { 00697 // we search backwards, probably faster to find an entry 00698 KonqHistoryEntry *entry = last(); 00699 while ( entry ) { 00700 if ( entry->url == url ) 00701 return entry; 00702 00703 entry = prev(); 00704 } 00705 00706 return 0L; 00707 } 00708 00709 // sort by lastVisited date (oldest go first) 00710 int KonqHistoryList::compareItems( QPtrCollection::Item item1, 00711 QPtrCollection::Item item2 ) 00712 { 00713 KonqHistoryEntry *entry1 = static_cast<KonqHistoryEntry *>( item1 ); 00714 KonqHistoryEntry *entry2 = static_cast<KonqHistoryEntry *>( item2 ); 00715 00716 if ( entry1->lastVisited > entry2->lastVisited ) 00717 return 1; 00718 else if ( entry1->lastVisited < entry2->lastVisited ) 00719 return -1; 00720 else 00721 return 0; 00722 } 00723 00724 using namespace KParts; // for IRIX 00725 00726 #include "konq_historymgr.moc"
KDE Logo
This file is part of the documentation for libkonq Library Version 3.2.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Sep 16 15:59:26 2004 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003