Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebase@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 733 insertions, 0 deletions

diff --git a/libkonq/konq_historymgr.cc b/libkonq/konq_historymgr.cc
new file mode 100644
index 000000000..72c6be3de
--- /dev/null
+++ b/libkonq/konq_historymgr.cc
@@ -0,0 +1,733 @@
+/* This file is part of the KDE project
+   Copyright (C) 2000,2001 Carsten Pfeiffer <[email protected]>
+
+   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.
+
+   This program 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
+    General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+#include "konq_historymgr.h"
+
+#include <dcopclient.h>
+
+#include <kapplication.h>
+#include <kdebug.h>
+#include <ksavefile.h>
+#include <ksimpleconfig.h>
+#include <kstandarddirs.h>
+
+#include <zlib.h>
+
+#include "konqbookmarkmanager.h"
+
+const Q_UINT32 KonqHistoryManager::s_historyVersion = 3;
+
+KonqHistoryManager::KonqHistoryManager( QObject *parent, const char *name )
+    : KParts::HistoryProvider( parent, name ),
+              KonqHistoryComm( "KonqHistoryManager" )
+{
+    m_updateTimer = new QTimer( this );
+
+    // defaults
+    KConfig *config = KGlobal::config();
+    KConfigGroupSaver cs( config, "HistorySettings" );
+    m_maxCount = config->readNumEntry( "Maximum of History entries", 500 );
+    m_maxCount = QMAX( 1, m_maxCount );
+    m_maxAgeDays = config->readNumEntry( "Maximum age of History entries", 90);
+
+    m_history.setAutoDelete( true );
+    m_filename = locateLocal( "data",
+			      QString::fromLatin1("konqueror/konq_history" ));
+
+    if ( !kapp->dcopClient()->isAttached() )
+	kapp->dcopClient()->attach();
+
+
+    // take care of the completion object
+    m_pCompletion = new KCompletion;
+    m_pCompletion->setOrder( KCompletion::Weighted );
+
+    // and load the history
+    loadHistory();
+
+    connect( m_updateTimer, SIGNAL( timeout() ), SLOT( slotEmitUpdated() ));
+}
+
+
+KonqHistoryManager::~KonqHistoryManager()
+{
+    delete m_pCompletion;
+    clearPending();
+}
+
+bool KonqHistoryManager::isSenderOfBroadcast()
+{
+    DCOPClient *dc = callingDcopClient();
+    return !dc || (dc->senderId() == dc->appId());
+}
+
+// loads the entire history
+bool KonqHistoryManager::loadHistory()
+{
+    clearPending();
+    m_history.clear();
+    m_pCompletion->clear();
+
+    QFile file( m_filename );
+    if ( !file.open( IO_ReadOnly ) ) {
+	if ( file.exists() )
+	    kdWarning() << "Can't open " << file.name() << endl;
+
+	// try to load the old completion history
+	bool ret = loadFallback();
+	emit loadingFinished();
+	return ret;
+    }
+
+    QDataStream fileStream( &file );
+    QByteArray data; // only used for version == 2
+    // we construct the stream object now but fill in the data later.
+    // thanks to QBA's explicit sharing this works :)
+    QDataStream crcStream( data, IO_ReadOnly );
+
+    if ( !fileStream.atEnd() ) {
+	Q_UINT32 version;
+        fileStream >> version;
+
+        QDataStream *stream = &fileStream;
+
+        bool crcChecked = false;
+        bool crcOk = false;
+
+        if ( version == 2 || version == 3) {
+            Q_UINT32 crc;
+            crcChecked = true;
+            fileStream >> crc >> data;
+            crcOk = crc32( 0, reinterpret_cast<unsigned char *>( data.data() ), data.size() ) == crc;
+            stream = &crcStream; // pick up the right stream
+        }
+
+	if ( version == 3 )
+	{
+	    //Use KURL marshalling for V3 format.
+	    KonqHistoryEntry::marshalURLAsStrings = false;
+	}
+
+	if ( version != 0 && version < 3 ) //Versions 1,2 (but not 0) are also valid
+	{
+	    //Turn on backwards compatibility mode..
+	    KonqHistoryEntry::marshalURLAsStrings = true;
+	    // it doesn't make sense to save to save maxAge and maxCount  in the
+	    // binary file, this would make backups impossible (they would clear
+	    // themselves on startup, because all entries expire).
+	    // [But V1 and V2 formats did it, so we do a dummy read]
+	    Q_UINT32 dummy;
+	    *stream >> dummy;
+	    *stream >> dummy;
+
+	    //OK.
+	    version = 3;
+	}
+
+        if ( s_historyVersion != version || ( crcChecked && !crcOk ) ) {
+	    kdWarning() << "The history version doesn't match, aborting loading" << endl;
+	    file.close();
+	    emit loadingFinished();
+	    return false;
+	}
+
+
+        while ( !stream->atEnd() ) {
+	    KonqHistoryEntry *entry = new KonqHistoryEntry;
+	    Q_CHECK_PTR( entry );
+            *stream >> *entry;
+	    // kdDebug(1203) << "## loaded entry: " << entry->url << ",  Title: " << entry->title << endl;
+	    m_history.append( entry );
+	    QString urlString2 = entry->url.prettyURL();    
+
+	    addToCompletion( urlString2, entry->typedURL, entry->numberOfTimesVisited );
+
+	    // and fill our baseclass.
+            QString urlString = entry->url.url();
+	    KParts::HistoryProvider::insert( urlString );
+            // DF: also insert the "pretty" version if different
+            // This helps getting 'visited' links on websites which don't use fully-escaped urls.
+        
+            if ( urlString != urlString2 )
+                KParts::HistoryProvider::insert( urlString2 );
+	}
+
+	kdDebug(1203) << "## loaded: " << m_history.count() << " entries." << endl;
+
+	m_history.sort();
+	adjustSize();
+    }
+    
+    
+    //This is important - we need to switch to a consistent marshalling format for
+    //communicating between different konqueror instances. Since during an upgrade
+    //some "old" copies may still running, we use the old format for the DCOP transfers.
+    //This doesn't make that much difference performance-wise for single entries anyway.
+    KonqHistoryEntry::marshalURLAsStrings = true;
+
+
+    // Theoretically, we should emit update() here, but as we only ever
+    // load items on startup up to now, this doesn't make much sense. Same
+    // thing for the above loadFallback().
+    // emit KParts::HistoryProvider::update( some list );
+
+
+
+    file.close();
+    emit loadingFinished();
+
+    return true;
+}
+
+
+// saves the entire history
+bool KonqHistoryManager::saveHistory()
+{
+    KSaveFile file( m_filename );
+    if ( file.status() != 0 ) {
+	kdWarning() << "Can't open " << file.name() << endl;
+	return false;
+    }
+
+    QDataStream *fileStream = file.dataStream();
+    *fileStream << s_historyVersion;
+
+    QByteArray data;
+    QDataStream stream( data, IO_WriteOnly );
+
+    //We use KURL for marshalling URLs in entries in the V3
+    //file format
+    KonqHistoryEntry::marshalURLAsStrings = false;
+    QPtrListIterator<KonqHistoryEntry> it( m_history );
+    KonqHistoryEntry *entry;
+    while ( (entry = it.current()) ) {
+        stream << *entry;
+	++it;
+    }
+
+    //For DCOP, transfer strings instead - wire compat.
+    KonqHistoryEntry::marshalURLAsStrings = true;
+
+    Q_UINT32 crc = crc32( 0, reinterpret_cast<unsigned char *>( data.data() ), data.size() );
+    *fileStream << crc << data;
+
+    file.close();
+
+    return true;
+}
+
+
+void KonqHistoryManager::adjustSize()
+{
+    KonqHistoryEntry *entry = m_history.getFirst();
+
+    while ( m_history.count() > m_maxCount || isExpired( entry ) ) {
+	removeFromCompletion( entry->url.prettyURL(), entry->typedURL );
+
+        QString urlString = entry->url.url();
+	KParts::HistoryProvider::remove( urlString );
+
+        addToUpdateList( urlString );
+
+	emit entryRemoved( m_history.getFirst() );
+	m_history.removeFirst(); // deletes the entry
+
+	entry = m_history.getFirst();
+    }
+}
+
+
+void KonqHistoryManager::addPending( const KURL& url, const QString& typedURL,
+				     const QString& title )
+{
+    addToHistory( true, url, typedURL, title );
+}
+
+void KonqHistoryManager::confirmPending( const KURL& url,
+					 const QString& typedURL,
+					 const QString& title )
+{
+    addToHistory( false, url, typedURL, title );
+}
+
+
+void KonqHistoryManager::addToHistory( bool pending, const KURL& _url,
+				       const QString& typedURL,
+				       const QString& title )
+{
+    kdDebug(1203) << "## addToHistory: " << _url.prettyURL() << " Typed URL: " << typedURL << ", Title: " << title << endl;
+
+    if ( filterOut( _url ) ) // we only want remote URLs
+	return;
+
+    // http URLs without a path will get redirected immediately to url + '/'
+    if ( _url.path().isEmpty() && _url.protocol().startsWith("http") )
+	return;
+
+    KURL url( _url );
+    bool hasPass = url.hasPass();
+    url.setPass( QString::null ); // No password in the history, especially not in the completion!
+    url.setHost( url.host().lower() ); // All host parts lower case
+    KonqHistoryEntry entry;
+    QString u = url.prettyURL();
+    entry.url = url;
+    if ( (u != typedURL) && !hasPass )
+	entry.typedURL = typedURL;
+
+    // we only keep the title if we are confirming an entry. Otherwise,
+    // we might get bogus titles from the previous url (actually it's just
+    // konqueror's window caption).
+    if ( !pending && u != title )
+	entry.title = title;
+    entry.firstVisited = QDateTime::currentDateTime();
+    entry.lastVisited = entry.firstVisited;
+
+    // always remove from pending if available, otherwise the else branch leaks
+    // if the map already contains an entry for this key.
+    QMapIterator<QString,KonqHistoryEntry*> it = m_pending.find( u );
+    if ( it != m_pending.end() ) {
+        delete it.data();
+        m_pending.remove( it );
+    }
+
+    if ( !pending ) {
+	if ( it != m_pending.end() ) {
+	    // we make a pending entry official, so we just have to update
+	    // and not increment the counter. No need to care about
+	    // firstVisited, as this is not taken into account on update.
+	    entry.numberOfTimesVisited = 0;
+	}
+    }
+
+    else {
+	// We add a copy of the current history entry of the url to the
+	// pending list, so that we can restore it if the user canceled.
+	// If there is no entry for the url yet, we just store the url.
+	KonqHistoryEntry *oldEntry = findEntry( url );
+	m_pending.insert( u, oldEntry ?
+                          new KonqHistoryEntry( *oldEntry ) : 0L );
+    }
+
+    // notify all konqueror instances about the entry
+    emitAddToHistory( entry );
+}
+
+// interface of KParts::HistoryManager
+// Usually, we only record the history for non-local URLs (i.e. filterOut()
+// returns false). But when using the HistoryProvider interface, we record
+// exactly those filtered-out urls.
+// Moreover, we  don't get any pending/confirming entries, just one insert()
+void KonqHistoryManager::insert( const QString& url )
+{
+    KURL u ( url );
+    if ( !filterOut( u ) || u.protocol() == "about" ) { // remote URL
+	return;
+    }
+    // Local URL -> add to history
+    KonqHistoryEntry entry;
+    entry.url = u;
+    entry.firstVisited = QDateTime::currentDateTime();
+    entry.lastVisited = entry.firstVisited;
+    emitAddToHistory( entry );
+}
+
+void KonqHistoryManager::emitAddToHistory( const KonqHistoryEntry& entry )
+{
+    QByteArray data;
+    QDataStream stream( data, IO_WriteOnly );
+    stream << entry << objId();
+    // Protection against very long urls (like data:)
+    if ( data.size() > 4096 )
+        return;
+    kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager",
+			      "notifyHistoryEntry(KonqHistoryEntry, QCString)",
+			      data );
+}
+
+
+void KonqHistoryManager::removePending( const KURL& url )
+{
+    // kdDebug(1203) << "## Removing pending... " << url.prettyURL() << endl;
+
+    if ( url.isLocalFile() )
+	return;
+
+    QMapIterator<QString,KonqHistoryEntry*> it = m_pending.find( url.prettyURL() );
+    if ( it != m_pending.end() ) {
+	KonqHistoryEntry *oldEntry = it.data(); // the old entry, may be 0L
+	emitRemoveFromHistory( url ); // remove the current pending entry
+
+	if ( oldEntry ) // we had an entry before, now use that instead
+	    emitAddToHistory( *oldEntry );
+
+	delete oldEntry;
+	m_pending.remove( it );
+    }
+}
+
+// clears the pending list and makes sure the entries get deleted.
+void KonqHistoryManager::clearPending()
+{
+    QMapIterator<QString,KonqHistoryEntry*> it = m_pending.begin();
+    while ( it != m_pending.end() ) {
+	delete it.data();
+	++it;
+    }
+    m_pending.clear();
+}
+
+void KonqHistoryManager::emitRemoveFromHistory( const KURL& url )
+{
+    QByteArray data;
+    QDataStream stream( data, IO_WriteOnly );
+    stream << url << objId();
+    kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager",
+			      "notifyRemove(KURL, QCString)", data );
+}
+
+void KonqHistoryManager::emitRemoveFromHistory( const KURL::List& urls )
+{
+    QByteArray data;
+    QDataStream stream( data, IO_WriteOnly );
+    stream << urls << objId();
+    kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager",
+			      "notifyRemove(KURL::List, QCString)", data );
+}
+
+void KonqHistoryManager::emitClear()
+{
+    QByteArray data;
+    QDataStream stream( data, IO_WriteOnly );
+    stream << objId();
+    kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager",
+			      "notifyClear(QCString)", data );
+}
+
+void KonqHistoryManager::emitSetMaxCount( Q_UINT32 count )
+{
+    QByteArray data;
+    QDataStream stream( data, IO_WriteOnly );
+    stream << count << objId();
+    kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager",
+			      "notifyMaxCount(Q_UINT32, QCString)", data );
+}
+
+void KonqHistoryManager::emitSetMaxAge( Q_UINT32 days )
+{
+    QByteArray data;
+    QDataStream stream( data, IO_WriteOnly );
+    stream << days << objId();
+    kapp->dcopClient()->send( "konqueror*", "KonqHistoryManager",
+			      "notifyMaxAge(Q_UINT32, QCString)", data );
+}
+
+///////////////////////////////////////////////////////////////////
+// DCOP called methods
+
+void KonqHistoryManager::notifyHistoryEntry( KonqHistoryEntry e,
+					     QCString  )
+{
+    //kdDebug(1203) << "Got new entry from Broadcast: " << e.url.prettyURL() << endl;
+
+    KonqHistoryEntry *entry = findEntry( e.url );
+    QString urlString = e.url.url();
+
+    if ( !entry ) { // create a new history entry
+	entry = new KonqHistoryEntry;
+	entry->url = e.url;
+	entry->firstVisited = e.firstVisited;
+	entry->numberOfTimesVisited = 0; // will get set to 1 below
+	m_history.append( entry );
+	KParts::HistoryProvider::insert( urlString );
+    }
+
+    if ( !e.typedURL.isEmpty() )
+	entry->typedURL = e.typedURL;
+    if ( !e.title.isEmpty() )
+	entry->title = e.title;
+    entry->numberOfTimesVisited += e.numberOfTimesVisited;
+    entry->lastVisited = e.lastVisited;
+
+    addToCompletion( entry->url.prettyURL(), entry->typedURL );
+
+    // bool pending = (e.numberOfTimesVisited != 0);
+
+    adjustSize();
+
+    // note, no need to do the updateBookmarkMetadata for every
+    // history object, only need to for the broadcast sender as
+    // the history object itself keeps the data consistant.
+    bool updated = KonqBookmarkManager::self()->updateAccessMetadata( urlString );
+
+    if ( isSenderOfBroadcast() ) {
+	// we are the sender of the broadcast, so we save
+	saveHistory();
+	// note, bk save does not notify, and we don't want to!
+	if (updated) 
+	    KonqBookmarkManager::self()->save();
+    }
+
+    addToUpdateList( urlString );
+    emit entryAdded( entry );
+}
+
+void KonqHistoryManager::notifyMaxCount( Q_UINT32 count, QCString )
+{
+    m_maxCount = count;
+    clearPending();
+    adjustSize();
+
+    KConfig *config = KGlobal::config();
+    KConfigGroupSaver cs( config, "HistorySettings" );
+    config->writeEntry( "Maximum of History entries", m_maxCount );
+
+    if ( isSenderOfBroadcast() ) { 
+	saveHistory();
+	config->sync();
+    }
+}
+
+void KonqHistoryManager::notifyMaxAge( Q_UINT32 days, QCString  )
+{
+    m_maxAgeDays = days;
+    clearPending();
+    adjustSize();
+
+    KConfig *config = KGlobal::config();
+    KConfigGroupSaver cs( config, "HistorySettings" );
+    config->writeEntry( "Maximum age of History entries", m_maxAgeDays );
+
+    if ( isSenderOfBroadcast() ) { 
+	saveHistory();
+	config->sync();
+    }
+}
+
+void KonqHistoryManager::notifyClear( QCString )
+{
+    clearPending();
+    m_history.clear();
+    m_pCompletion->clear();
+
+    if ( isSenderOfBroadcast() )
+	saveHistory();
+
+    KParts::HistoryProvider::clear(); // also emits the cleared() signal
+}
+
+void KonqHistoryManager::notifyRemove( KURL url, QCString )
+{
+    kdDebug(1203) << "#### Broadcast: remove entry:: " << url.prettyURL() << endl;
+    
+
+    KonqHistoryEntry *entry = m_history.findEntry( url );
+    
+    if ( entry ) { // entry is now the current item
+	removeFromCompletion( entry->url.prettyURL(), entry->typedURL );
+
+        QString urlString = entry->url.url();
+	KParts::HistoryProvider::remove( urlString );
+
+        addToUpdateList( urlString );
+
+	m_history.take(); // does not delete
+	emit entryRemoved( entry );
+	delete entry;
+
+	if ( isSenderOfBroadcast() )
+	    saveHistory();
+    }
+}
+
+void KonqHistoryManager::notifyRemove( KURL::List urls, QCString )
+{
+    kdDebug(1203) << "#### Broadcast: removing list!" << endl;
+
+    bool doSave = false;
+    KURL::List::Iterator it = urls.begin();
+    while ( it != urls.end() ) {
+	KonqHistoryEntry *entry = m_history.findEntry( *it );
+	
+	if ( entry ) { // entry is now the current item
+	    removeFromCompletion( entry->url.prettyURL(), entry->typedURL );
+
+            QString urlString = entry->url.url();
+	    KParts::HistoryProvider::remove( urlString );
+
+            addToUpdateList( urlString );
+
+	    m_history.take(); // does not delete
+	    emit entryRemoved( entry );
+	    delete entry;
+	    doSave = true;
+	}
+
+	++it;
+    }
+
+    if (doSave && isSenderOfBroadcast())
+        saveHistory();
+}
+
+
+// compatibility fallback, try to load the old completion history
+bool KonqHistoryManager::loadFallback()
+{
+    QString file = locateLocal( "config", QString::fromLatin1("konq_history"));
+    if ( file.isEmpty() )
+	return false;
+
+    KonqHistoryEntry *entry;
+    KSimpleConfig config( file );
+    config.setGroup("History");
+    QStringList items = config.readListEntry( "CompletionItems" );
+    QStringList::Iterator it = items.begin();
+
+    while ( it != items.end() ) {
+	entry = createFallbackEntry( *it );
+	if ( entry ) {
+	    m_history.append( entry );
+	    addToCompletion( entry->url.prettyURL(), QString::null, entry->numberOfTimesVisited );
+
+	    KParts::HistoryProvider::insert( entry->url.url() );
+   	}
+	++it;
+    }
+
+    m_history.sort();
+    adjustSize();
+    saveHistory();
+
+    return true;
+}
+
+// tries to create a small KonqHistoryEntry out of a string, where the string
+// looks like "http://www.bla.com/bla.html:23"
+// the attached :23 is the weighting from KCompletion
+KonqHistoryEntry * KonqHistoryManager::createFallbackEntry(const QString& item) const
+{
+    // code taken from KCompletion::addItem(), adjusted to use weight = 1
+    uint len = item.length();
+    uint weight = 1;
+
+    // find out the weighting of this item (appended to the string as ":num")
+    int index = item.findRev(':');
+    if ( index > 0 ) {
+	bool ok;
+	weight = item.mid( index + 1 ).toUInt( &ok );
+	if ( !ok )
+	    weight = 1;
+
+	len = index; // only insert until the ':'
+    }
+
+
+    KonqHistoryEntry *entry = 0L;
+    KURL u( item.left( len ));
+    if ( u.isValid() ) {
+	entry = new KonqHistoryEntry;
+	// that's the only entries we know about...
+	entry->url = u;
+	entry->numberOfTimesVisited = weight;
+	// to make it not expire immediately...
+	entry->lastVisited = QDateTime::currentDateTime();
+    }
+
+    return entry;
+}
+
+KonqHistoryEntry * KonqHistoryManager::findEntry( const KURL& url )
+{
+    // small optimization (dict lookup) for items _not_ in our history
+    if ( !KParts::HistoryProvider::contains( url.url() ) )
+        return 0L;
+
+    return m_history.findEntry( url );
+}
+
+bool KonqHistoryManager::filterOut( const KURL& url )
+{
+    return ( url.isLocalFile() || url.host().isEmpty() );
+}
+
+void KonqHistoryManager::slotEmitUpdated()
+{
+    emit KParts::HistoryProvider::updated( m_updateURLs );
+    m_updateURLs.clear();
+}
+
+QStringList KonqHistoryManager::allURLs() const
+{
+    QStringList list;
+    KonqHistoryIterator it ( m_history );
+    for ( ; it.current(); ++it )
+        list.append( it.current()->url.url() );
+    
+    return list;
+}
+
+void KonqHistoryManager::addToCompletion( const QString& url, const QString& typedURL, 
+                                          int numberOfTimesVisited )
+{
+    m_pCompletion->addItem( url, numberOfTimesVisited );
+    // typed urls have a higher priority
+    m_pCompletion->addItem( typedURL, numberOfTimesVisited +10 );
+}
+
+void KonqHistoryManager::removeFromCompletion( const QString& url, const QString& typedURL )
+{
+    m_pCompletion->removeItem( url );
+    m_pCompletion->removeItem( typedURL );
+}
+
+//////////////////////////////////////////////////////////////////
+
+
+KonqHistoryEntry * KonqHistoryList::findEntry( const KURL& url )
+{
+    // we search backwards, probably faster to find an entry
+    KonqHistoryEntry *entry = last();
+    while ( entry ) {
+	if ( entry->url == url )
+	    return entry;
+
+	entry = prev();
+    }
+
+    return 0L;
+}
+
+// sort by lastVisited date (oldest go first)
+int KonqHistoryList::compareItems( QPtrCollection::Item item1,
+				   QPtrCollection::Item item2 )
+{
+    KonqHistoryEntry *entry1 = static_cast<KonqHistoryEntry *>( item1 );
+    KonqHistoryEntry *entry2 = static_cast<KonqHistoryEntry *>( item2 );
+
+    if ( entry1->lastVisited > entry2->lastVisited )
+	return 1;
+    else if ( entry1->lastVisited < entry2->lastVisited )
+	return -1;
+    else
+	return 0;
+}
+
+using namespace KParts; // for IRIX
+
+#include "konq_historymgr.moc"