feed.h

/*
    This file is part of Akregator.
 
    Copyright (C) 2004 Stanislav Karchebny <Stanislav.Karchebny@kdemail.net>
                  2005 Frank Osterfeld <frank.osterfeld at kdemail.net>
 
    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 TQt, and distribute the resulting executable,
    without including the source code for TQt in the source distribution.
*/
 
#ifndef AKREGATORFEED_H
#define AKREGATORFEED_H
 
#include "treenode.h"
#include "librss/librss.h"
 
class TQDomElement;
class TQPixmap;
class TQString;
class TQStringList;
class KURL;
 
 
namespace KPIM {
    class ProgressItem;
}
 
// needed for slot fetchCompleted()
using RSS::Document;
using RSS::Loader;
using RSS::Status;
 
namespace Akregator
{
    class Article;
    class FetchQueue;
    class Folder;
    class TreeNodeVisitor;
 
    namespace Backend
    {
        class FeedStorage;
    }
    class Feed : public TreeNode
    {
        friend class Article;
        
        TQ_OBJECT
  
        public:
            enum ArchiveMode { globalDefault, keepAllArticles, disableArchiving, limitArticleNumber, limitArticleAge };
 
            // class methods
            static ArchiveMode stringToArchiveMode(const TQString& str);
 
            static TQString archiveModeToString(ArchiveMode mode);
 
            static Feed* fromOPML(TQDomElement e);
 
            Feed();
 
            virtual ~Feed();
 
            virtual bool accept(TreeNodeVisitor* visitor);
 
            virtual TQDomElement toOPML( TQDomElement parent, TQDomDocument document ) const;
 
            bool useCustomFetchInterval() const;
 
            void setCustomFetchIntervalEnabled(bool enabled);
 
            // FIXME is it -1 or 0 to disable interval fetching?
            int fetchInterval() const;
 
            void setFetchInterval(int interval);
 
            ArchiveMode archiveMode() const;
 
            void setArchiveMode(ArchiveMode archiveMode);
 
            int maxArticleAge() const;
 
            void setMaxArticleAge(int maxArticleAge);
            
 
            int maxArticleNumber() const;
 
            void setMaxArticleNumber(int maxArticleNumber);
 
            bool markImmediatelyAsRead() const;
 
            void setMarkImmediatelyAsRead(bool enabled);
 
            void setUseNotification(bool enabled);
 
            bool useNotification() const;
 
            void setLoadLinkedWebsite(bool enabled);
 
            bool loadLinkedWebsite() const;
            
            const TQPixmap& favicon() const;
 
            void setFavicon(const TQPixmap& p);
 
            const TQPixmap& image() const;
 
            const TQString& xmlUrl() const;
            void setXmlUrl(const TQString& s);
 
            const TQString& htmlUrl() const;
            void setHtmlUrl(const TQString& s);
 
            const TQString& description() const;
 
            void setDescription(const TQString& s);
 
            virtual TQValueList<Article> articles(const TQString& tag=TQString());
 
            virtual Article findArticle(const TQString& guid) const;
            
            virtual TQStringList tags() const;
            
            bool fetchErrorOccurred();
 
            virtual int unread() const;
 
            virtual int totalCount() const;
 
            bool isArticlesLoaded() const;
 
            virtual bool isGroup() const { return false; }
 
            virtual TreeNode* next();
 
            void loadFavicon();
            
            void loadImage();
            
        public slots:
            void fetch(bool followDiscovery=false);
 
            void slotAbortFetch();
 
            virtual void slotDeleteExpiredArticles();
 
            virtual void slotMarkAllArticlesAsRead();
 
            virtual void slotAddToFetchQueue(FetchQueue* queue, bool intervalFetchOnly=false);
 
        signals:
            void fetchStarted(Feed*);
            void fetched(Feed *);
            void fetchError(Feed *);
            void fetchDiscovery(Feed *);
            void fetchAborted(Feed *);
           
        protected:
            void loadArticles();
 
            void recalcUnreadCount();
 
            virtual void doArticleNotification();
 
            void setUnread(int unread);
 
            
        private slots:
 
            void fetchCompleted(Loader *loader, Document doc, Status status);
            void slotImageFetched(const TQPixmap& image);
 
        private:
            
            void setArticleDeleted(Article& a);
 
            void setArticleChanged(Article& a, int oldStatus=-1);
            
            void enforceLimitArticleNumber();
 
            void appendArticles(const RSS::Document &d);
            void appendArticle(const Article& a);
 
            bool isExpired(const Article& a) const;
 
            bool usesExpiryByAge() const;
 
            void tryFetch();
 
            class FeedPrivate;
            FeedPrivate* d;
    };
}
 
#endif