feedlist.cpp

/*
    This file is part of Akregator.
 
    Copyright (C) 2004 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.
*/
#include "feedlist.h"
 
#include <tqdatetime.h>
#include <tqdom.h>
#include <tqmap.h>
#include <tqvaluelist.h>
 
#include <kdebug.h>
#include <tdelocale.h>
 
#include "article.h"
#include "feed.h"
#include "folder.h"
#include "treenode.h"
#include "treenodevisitor.h"
 
namespace Akregator {
 
class FeedList::FeedListPrivate
{
    public:
 
        TQMap<TQString, TQValueList<Feed*> > urlMap;
        AddNodeVisitor* addNodeVisitor;
        RemoveNodeVisitor* removeNodeVisitor;
};
 
class FeedList::AddNodeVisitor : public TreeNodeVisitor
{
    public:
        AddNodeVisitor(FeedList* list) : m_list(list) {}
        virtual ~AddNodeVisitor() {}
 
 
        virtual bool visitFeed(Feed* node)
        {
            m_list->idMap()->insert(node->id(), node);
            m_list->flatList()->append(node);
            return true;
        }
 
    private:
        FeedList* m_list;
};
 
class FeedList::RemoveNodeVisitor : public TreeNodeVisitor
{
    public:
        RemoveNodeVisitor(FeedList* list) : m_list(list) {}
        virtual ~RemoveNodeVisitor() {}
 
        virtual bool visitFeed(Feed* node)
        {
            m_list->d->urlMap[node->xmlUrl()].remove(node);
            return true;
        }
 
    private:
        FeedList* m_list;
};
 
FeedList::FeedList(TQObject *parent, const char *name)
    : NodeList(parent, name), d(new FeedListPrivate)
{
    d->addNodeVisitor = new AddNodeVisitor(this);
    d->removeNodeVisitor = new RemoveNodeVisitor(this);
 
    Folder* rootNode = new Folder(i18n("All Feeds"));
    rootNode->setId(1);
    setRootNode(rootNode);
    addNode(rootNode, true);
}
 
void FeedList::addNode(TreeNode* node, bool preserveID)
{
    NodeList::addNode(node, preserveID);
    d->addNodeVisitor->visit(node);
}
 
void FeedList::removeNode(TreeNode* node)
{
   NodeList::removeNode(node);
   d->removeNodeVisitor->visit(node);
}
 
void FeedList::parseChildNodes(TQDomNode &node, Folder* parent)
{
    TQDomElement e = node.toElement(); // try to convert the node to an element.
 
    if( !e.isNull() )
    {
        TQString title = e.hasAttribute("text") ? e.attribute("text") : e.attribute("title");
 
        if (e.hasAttribute("xmlUrl") || e.hasAttribute("xmlurl") || e.hasAttribute("xmlURL") )
        {
            Feed* feed = Feed::fromOPML(e);
            if (feed)
            {
                if (!d->urlMap[feed->xmlUrl()].contains(feed))
                    d->urlMap[feed->xmlUrl()].append(feed);
                parent->appendChild(feed);
            }
        }
        else
        {
            Folder* fg = Folder::fromOPML(e);
            parent->appendChild(fg);
 
            if (e.hasChildNodes())
            {
                TQDomNode child = e.firstChild();
                while(!child.isNull())
                {
                    parseChildNodes(child, fg);
                    child = child.nextSibling();
                }
            }
        }
    }
}
 
bool FeedList::readFromXML(const TQDomDocument& doc)
{
    TQDomElement root = doc.documentElement();
 
    kdDebug() << "loading OPML feed " << root.tagName().lower() << endl;
 
    kdDebug() << "measuring startup time: START" << endl;
    TQTime spent;
    spent.start();
 
    if (root.tagName().lower() != "opml")
    {
        return false;
    }
    TQDomNode bodyNode = root.firstChild();
 
    while (!bodyNode.isNull() && bodyNode.toElement().tagName().lower() != "body")
        bodyNode = bodyNode.nextSibling();
 
 
    if (bodyNode.isNull())
    {
        kdDebug() << "Failed to acquire body node, markup broken?" << endl;
        return false;
    }
 
    TQDomElement body = bodyNode.toElement();
 
    TQDomNode i = body.firstChild();
 
    while( !i.isNull() )
    {
        parseChildNodes(i, rootNode());
        i = i.nextSibling();
    }
 
    for (TreeNode* i = rootNode()->firstChild(); i && i != rootNode(); i = i->next() )
        if (i->id() == 0)
    {
            uint id = generateID();
            i->setId(id);
            idMap()->insert(id, i);
    }
 
    kdDebug() << "measuring startup time: STOP, " << spent.elapsed() << "ms" << endl;
    kdDebug() << "Number of articles loaded: " << rootNode()->totalCount() << endl;
    return true;
}
 
FeedList::~FeedList()
{
    emit signalDestroyed(this);
    setRootNode(0);
    delete d->addNodeVisitor;
    delete d->removeNodeVisitor;
    delete d;
    d = 0;
}
 
Feed* FeedList::findByURL(const TQString& feedURL) const
{
    if (d->urlMap[feedURL].isEmpty())
        return 0;
    else
        return *(d->urlMap[feedURL].begin());
}
 
Article FeedList::findArticle(const TQString& feedURL, const TQString& guid) const
{
    Feed* feed = findByURL(feedURL);
 
    return feed ? feed->findArticle(guid) : Article();
}
 
void FeedList::append(FeedList* list, Folder* parent, TreeNode* after)
{
    if ( list == this )
        return;
 
    if ( !flatList()->contains(parent) )
        parent = rootNode();
 
    TQValueList<TreeNode*> children = list->rootNode()->children();
 
    TQValueList<TreeNode*>::ConstIterator end(  children.end() );
    for (TQValueList<TreeNode*>::ConstIterator it = children.begin(); it != end; ++it)
    {
        list->rootNode()->removeChild(*it);
        parent->insertChild(*it, after);
        after = *it;
    }
}
 
TQDomDocument FeedList::toXML() const
{
    TQDomDocument doc;
    doc.appendChild( doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
 
    TQDomElement root = doc.createElement( "opml" );
    root.setAttribute( "version", "1.0" );
    doc.appendChild( root );
 
    TQDomElement head = doc.createElement( "head" );
    root.appendChild( head );
 
    TQDomElement ti = doc.createElement( "text" );
    head.appendChild( ti );
 
    TQDomText t = doc.createTextNode( title() );
    ti.appendChild( t );
 
    TQDomElement body = doc.createElement( "body" );
    root.appendChild( body );
 
    TQValueList<TreeNode*> children = rootNode()->children();
 
    TQValueList<TreeNode*>::ConstIterator end(  children.end() );
 
    for (TQValueList<TreeNode*>::ConstIterator it = children.begin(); it != end; ++it)
        body.appendChild( (*it)->toOPML(body, doc) );
 
    return doc;
}
 
} // namespace Akregator
#include "feedlist.moc"