You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdebase/libkonq/konq_historymgr.h

386 lines
12 KiB

/* This file is part of the KDE project
Copyright (C) 2000,2001 Carsten Pfeiffer <pfeiffer@kde.org>
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.
*/
#ifndef KONQ_HISTORY_H
#define KONQ_HISTORY_H
#include <tqdatastream.h>
#include <tqfile.h>
#include <tqptrlist.h>
#include <tqobject.h>
#include <tqmap.h>
#include <tqtimer.h>
#include <dcopobject.h>
#include <kcompletion.h>
#include <kurl.h>
#include <kparts/historyprovider.h>
#include "konq_historycomm.h"
#include <libkonq_export.h>
class KCompletion;
typedef TQPtrList<KonqHistoryEntry> KonqBaseHistoryList;
typedef TQPtrListIterator<KonqHistoryEntry> KonqHistoryIterator;
class LIBKONQ_EXPORT KonqHistoryList : public KonqBaseHistoryList
{
public:
/**
* Finds an entry by URL. The found item will also be current().
* If no matching entry is found, 0L is returned and current() will be
* the first item in the list.
*/
KonqHistoryEntry * findEntry( const KURL& url );
protected:
/**
* Ensures that the items are sorted by the lastVisited date
*/
virtual int compareItems( TQPtrCollection::Item, TQPtrCollection::Item );
};
///////////////////////////////////////////////////////////////////
/**
* This class maintains and manages a history of all URLs visited by one
* Konqueror instance. Additionally it synchronizes the history with other
* Konqueror instances via DCOP to keep one global and persistant history.
*
* It keeps the history in sync with one KCompletion object
*/
class LIBKONQ_EXPORT KonqHistoryManager : public KParts::HistoryProvider,
public KonqHistoryComm
{
Q_OBJECT
public:
static KonqHistoryManager *kself() {
return static_cast<KonqHistoryManager*>( KParts::HistoryProvider::self() );
}
KonqHistoryManager( TQObject *parent, const char *name );
~KonqHistoryManager();
/**
* Sets a new maximum size of history and truncates the current history
* if necessary. Notifies all other Konqueror instances via DCOP
* to do the same.
*
* The history is saved after receiving the DCOP call.
*/
void emitSetMaxCount( TQ_UINT32 count );
/**
* Sets a new maximum age of history entries and removes all entries that
* are older than @p days. Notifies all other Konqueror instances via DCOP
* to do the same.
*
* An age of 0 means no expiry based on the age.
*
* The history is saved after receiving the DCOP call.
*/
void emitSetMaxAge( TQ_UINT32 days );
/**
* Removes the history entry for @p url, if existant. Tells all other
* Konqueror instances via DCOP to do the same.
*
* The history is saved after receiving the DCOP call.
*/
void emitRemoveFromHistory( const KURL& url );
/**
* Removes the history entries for the given list of @p urls. Tells all
* other Konqueror instances via DCOP to do the same.
*
* The history is saved after receiving the DCOP call.
*/
void emitRemoveFromHistory( const KURL::List& urls );
/**
* @returns the current maximum number of history entries.
*/
TQ_UINT32 maxCount() const { return m_maxCount; }
/**
* @returns the current maximum age (in days) of history entries.
*/
TQ_UINT32 maxAge() const { return m_maxAgeDays; }
/**
* Adds a pending entry to the history. Pending means, that the entry is
* not verified yet, i.e. it is not sure @p url does exist at all. You
* probably don't know the title of the url in that case either.
* Call @ref confirmPending() as soon you know the entry is good and should
* be updated.
*
* If an entry with @p url already exists,
* it will be updated (lastVisited date will become the current time
* and the number of visits will be incremented).
*
* @param url The url of the history entry
* @param typedURL the string that the user typed, which resulted in url
* Doesn't have to be a valid url, e.g. "slashdot.org".
* @param title The title of the URL. If you don't know it (yet), you may
specify it in @ref confirmPending().
*/
void addPending( const KURL& url, const TQString& typedURL = TQString::null,
const TQString& title = TQString::null );
/**
* Confirms and updates the entry for @p url.
*/
void confirmPending( const KURL& url,
const TQString& typedURL = TQString::null,
const TQString& title = TQString::null );
/**
* Removes a pending url from the history, e.g. when the url does not
* exist, or the user aborted loading.
*/
void removePending( const KURL& url );
/**
* @returns the KCompletion object.
*/
KCompletion * completionObject() const { return m_pCompletion; }
/**
* @returns the list of all history entries, sorted by date
* (oldest entries first)
*/
const KonqHistoryList& entries() const { return m_history; }
// HistoryProvider interfae, let konq handle this
/**
* Reimplemented in such a way that all URLs that would be filtered
* out normally (see @ref filterOut()) will still be added to the history.
* By default, file:/ urls will be filtered out, but if they come thru
* the HistoryProvider interface, they are added to the history.
*/
virtual void insert( const TQString& );
virtual void remove( const TQString& ) {}
virtual void clear() {}
public slots:
/**
* Loads the history and fills the completion object.
*/
bool loadHistory();
/**
* Saves the entire history.
*/
bool saveHistory();
/**
* Clears the history and tells all other Konqueror instances via DCOP
* to do the same.
* The history is saved afterwards, if necessary.
*/
void emitClear();
signals:
/**
* Emitted after the entire history was loaded from disk.
*/
void loadingFinished();
/**
* Emitted after a new entry was added
*/
void entryAdded( const KonqHistoryEntry *entry );
/**
* Emitted after an entry was removed from the history
* Note, that this entry will be deleted immediately after you got
* that signal.
*/
void entryRemoved( const KonqHistoryEntry *entry );
protected:
/**
* Resizes the history list to contain less or equal than m_maxCount
* entries. The first (oldest) entries are removed.
*/
void adjustSize();
/**
* @returns true if @p entry is older than the given maximum age,
* otherwise false.
*/
inline bool isExpired( KonqHistoryEntry *entry ) {
return (entry && m_maxAgeDays > 0 && entry->lastVisited <
TQDate::tqcurrentDate().addDays( -m_maxAgeDays ));
}
/**
* Notifes all running instances about a new HistoryEntry via DCOP
*/
void emitAddToHistory( const KonqHistoryEntry& entry );
/**
* Every konqueror instance broadcasts new history entries to the other
* konqueror instances. Those add the entry to their list, but don't
* save the list, because the sender saves the list.
*
* @param e the new history entry
* @param saveId is the DCOPObject::objId() of the sender so that
* only the sender saves the new history.
*/
virtual void notifyHistoryEntry( KonqHistoryEntry e, TQCString saveId );
/**
* Called when the configuration of the maximum count changed.
* Called via DCOP by some config-module
*/
virtual void notifyMaxCount( TQ_UINT32 count, TQCString saveId );
/**
* Called when the configuration of the maximum age of history-entries
* changed. Called via DCOP by some config-module
*/
virtual void notifyMaxAge( TQ_UINT32 days, TQCString saveId );
/**
* Clears the history completely. Called via DCOP by some config-module
*/
virtual void notifyClear( TQCString saveId );
/**
* Notifes about a url that has to be removed from the history.
* The instance where saveId == objId() has to save the history.
*/
virtual void notifyRemove( KURL url, TQCString saveId );
/**
* Notifes about a list of urls that has to be removed from the history.
* The instance where saveId == objId() has to save the history.
*/
virtual void notifyRemove( KURL::List urls, TQCString saveId );
/**
* @returns a list of all urls in the history.
*/
virtual TQStringList allURLs() const;
/**
* Does the work for @ref addPending() and @ref confirmPending().
*
* Adds an entry to the history. If an entry with @p url already exists,
* it will be updated (lastVisited date will become the current time
* and the number of visits will be incremented).
* @p pending means, the entry has not been "verified", it's been added
* right after typing the url.
* If @p pending is false, @p url will be removed from the pending urls
* (if available) and NOT be added again in that case.
*/
void addToHistory( bool pending, const KURL& url,
const TQString& typedURL = TQString::null,
const TQString& title = TQString::null );
/**
* @returns true if the given @p url should be filtered out and not be
* added to the history. By default, all local urls (url.isLocalFile())
* will return true, as well as urls with an empty host.
*/
virtual bool filterOut( const KURL& url );
void addToUpdateList( const TQString& url ) {
m_updateURLs.append( url );
m_updateTimer->start( 500, true );
}
/**
* The list of urls that is going to be emitted in slotEmitUpdated. Add
* urls to it whenever you modify the list of history entries and start
* m_updateTimer.
*/
TQStringList m_updateURLs;
private slots:
/**
* Called by the updateTimer to emit the KParts::HistoryProvider::updated()
* signal so that khtml can tqrepaint the updated links.
*/
void slotEmitUpdated();
private:
/**
* Returns whether the DCOP call we are handling was a call from us self
*/
bool isSenderOfBroadcast();
void clearPending();
/**
* a little optimization for KonqHistoryList::findEntry(),
* checking the dict of KParts::HistoryProvider before traversing the list.
* Can't be used everywhere, because it always returns 0L for "pending"
* entries, as those are not added to the dict, currently.
*/
KonqHistoryEntry * findEntry( const KURL& url );
/**
* Stuff to create a proper history out of KDE 2.0's konq_history for
* completion.
*/
bool loadFallback();
KonqHistoryEntry * createFallbackEntry( const TQString& ) const;
void addToCompletion( const TQString& url, const TQString& typedURL, int numberOfTimesVisited = 1 );
void removeFromCompletion( const TQString& url, const TQString& typedURL );
TQString m_filename;
KonqHistoryList m_history;
/**
* List of pending entries, which were added to the history, but not yet
* confirmed (i.e. not yet added with pending = false).
* Note: when removing an entry, you have to delete the KonqHistoryEntry
* of the item you remove.
*/
TQMap<TQString,KonqHistoryEntry*> m_pending;
TQ_UINT32 m_maxCount; // maximum of history entries
TQ_UINT32 m_maxAgeDays; // maximum age of a history entry
KCompletion *m_pCompletion; // the completion object we sync with
/**
* A timer that will emit the KParts::HistoryProvider::updated() signal
* thru the slotEmitUpdated slot.
*/
TQTimer *m_updateTimer;
static const TQ_UINT32 s_historyVersion;
};
#endif // KONQ_HISTORY_H