feedlist.h

Go to the documentation of this file.

/*
    This file is part of Akregator.

    Copyright (C) 2004 Frank Osterfeld <osterfeld@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; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

    As a special exception, permission is given to link this program
    with any edition of Qt, and distribute the resulting executable,
    without including the source code for Qt in the source distribution.
*/

#ifndef AKREGATOR_FEEDLIST_H
#define AKREGATOR_FEEDLIST_H

#include "akregator_export.h"

#include "feedlistmanagementinterface.h"

#include <QObject>

#ifndef Q_MOC_RUN
#include <boost/shared_ptr.hpp>
#endif

class QDomDocument;
class QDomNode;
template <class T> class QList;
template <class K,class T> class QHash;
class QString;

class KJob;

namespace Akregator {

class Article;
class Feed;
class FeedList;
class FetchQueue;
class Folder;
class TreeNode;

namespace Backend {
    class Storage;
}


class AKREGATOR_EXPORT FeedListManagementImpl : public FeedListManagementInterface {
public:
    explicit FeedListManagementImpl( const boost::shared_ptr<FeedList>& list=boost::shared_ptr<FeedList>() );
    void setFeedList( const boost::shared_ptr<FeedList>& list );

    /* reimp */ QStringList categories() const;
    /* reimp */ QStringList feeds( const QString& catId ) const;
    /* reimp */ void addFeed( const QString& url, const QString& catId );
    /* reimp */ void removeFeed( const QString& url, const QString& catId );
    /* reimp */ QString addCategory( const QString& name, const QString& parentId ) const;
    /* reimp */ QString getCategoryName( const QString& catId ) const;

private:
    boost::shared_ptr<FeedList> m_feedList;
};

class AKREGATOR_EXPORT FeedList : public QObject
{
    Q_OBJECT
public:

    explicit FeedList(Akregator::Backend::Storage* storage);

    ~FeedList();

    const Folder* allFeedsFolder() const;
    Folder* allFeedsFolder();

    bool isEmpty() const;

    const TreeNode* findByID(int id) const;
    TreeNode* findByID(int id);

    QList<const TreeNode*> findByTitle(const QString &title) const;
    QList<TreeNode*> findByTitle(const QString &title);


    QString title() const;

    void setTitle(const QString& name);

    QVector<const Feed*> feeds() const;
    QVector<Feed*> feeds();

    QVector<int> feedIds() const;

    QVector<const Folder*> folders() const;
    QVector<Folder*> folders();

    void append(FeedList* list, Folder* parent=0, TreeNode* after=0);

    bool readFromOpml(const QDomDocument& doc);

    QDomDocument toOpml() const;

    const Feed* findByURL(const QString& feedURL) const;
    Feed* findByURL(const QString& feedURL);

    const Article findArticle(const QString& feedURL, const QString& guid) const;

    int unread() const;

    void addToFetchQueue( FetchQueue* queue, bool intervalOnly=false );
    KJob* createMarkAsReadJob();

signals:

    void signalDestroyed(Akregator::FeedList*);

    void signalNodeAdded(Akregator::TreeNode*);

    void signalNodeRemoved(Akregator::TreeNode*);

    void signalAboutToRemoveNode( Akregator::TreeNode* );

    void signalNodeChanged( Akregator::TreeNode* );

    void fetchStarted(Akregator::Feed*);

    void fetched(Akregator::Feed *);

    void fetchError(Akregator::Feed *);
    void fetchDiscovery(Akregator::Feed *);

    void fetchAborted(Akregator::Feed *);

    void unreadCountChanged( int unread );

private:

    void addNode(TreeNode* node, bool preserveID);
    void removeNode(TreeNode* node);

    int generateID() const;
    void setRootNode(Folder* folder);

    void parseChildNodes(QDomNode &node, Folder* parent);

private slots:

    void slotNodeDestroyed(Akregator::TreeNode* node);
    void slotNodeAdded(Akregator::TreeNode* node);
    void slotNodeRemoved(Akregator::Folder* parent, Akregator::TreeNode* node);
    void rootNodeChanged();

private:
    friend class AddNodeVisitor;
    class AddNodeVisitor;

    friend class RemoveNodeVisitor;
    class RemoveNodeVisitor;

    class Private;
    Private* const d;
};

} // namespace Akregator

#endif // AKREGATOR_FEEDLIST_H