akregator/src/progressmanager.cpp

   1 /*
   2     This file is part of Akregator.
   3
   4     Copyright (C) 2005 Frank Osterfeld <osterfeld@kde.org>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19
  20     As a special exception, permission is given to link this program
  21     with any edition of Qt, and distribute the resulting executable,
  22     without including the source code for Qt in the source distribution.
  23 */
  24
  25 #include "progressmanager.h"
  26 #include "feed.h"
  27 #include "treenode.h"
  28
  29 #include <QHash>
  30
  31 #include <KLocalizedString>
  32
  33 #include <Libkdepim/ProgressManager>
  34
  35 namespace Akregator
  36 {
  37
  38 class ProgressManager::ProgressManagerPrivate
  39 {
  40 public:
  41     ProgressManagerPrivate() : feedList() {}
  42     QSharedPointer<FeedList> feedList;
  43     QHash<Feed *, ProgressItemHandler *> handlers;
  44
  45 };
  46
  47 ProgressManager *ProgressManager::m_self = 0;
  48
  49 ProgressManager *ProgressManager::self()
  50 {
  51     static ProgressManager sself;
  52     if (!m_self) {
  53         m_self = &sself;
  54     }
  55     return m_self;
  56 }
  57
  58 ProgressManager::ProgressManager() : d(new ProgressManagerPrivate)
  59 {
  60 }
  61
  62 ProgressManager::~ProgressManager()
  63 {
  64     delete d;
  65     d = 0;
  66 }
  67
  68 void ProgressManager::setFeedList(const QSharedPointer<FeedList> &feedList)
  69 {
  70     if (feedList == d->feedList) {
  71         return;
  72     }
  73
  74     if (d->feedList) {
  75         qDeleteAll(d->handlers);
  76         d->handlers.clear();
  77         d->feedList->disconnect(this);
  78     }
  79
  80     d->feedList = feedList;
  81
  82     if (d->feedList) {
  83         QVector<Feed *> list = feedList->feeds();
  84
  85         foreach (TreeNode *i, list) {
  86             slotNodeAdded(i);
  87         }
  88         connect(feedList.data(), &FeedList::signalNodeAdded, this, &ProgressManager::slotNodeAdded);
  89         connect(feedList.data(), &FeedList::signalNodeRemoved, this, &ProgressManager::slotNodeRemoved);
  90     }
  91 }
  92
  93 void ProgressManager::slotNodeAdded(TreeNode *node)
  94 {
  95     Feed *const feed = qobject_cast<Feed *>(node);
  96     if (!feed) {
  97         return;
  98     }
  99
 100     if (d->handlers.contains(feed)) {
 101         return;
 102     }
 103
 104     d->handlers[feed] = new ProgressItemHandler(feed);
 105     connect(feed, &TreeNode::signalDestroyed, this, &ProgressManager::slotNodeDestroyed);
 106 }
 107
 108 void ProgressManager::slotNodeRemoved(TreeNode *node)
 109 {
 110     Feed *feed = qobject_cast<Feed *>(node);
 111     if (feed) {
 112         feed->disconnect(this);
 113         delete d->handlers[feed];
 114         d->handlers.remove(feed);
 115     }
 116 }
 117
 118 void ProgressManager::slotNodeDestroyed(TreeNode *node)
 119 {
 120     Feed *feed = qobject_cast<Feed *>(node);
 121     if (feed) {
 122         delete d->handlers[feed];
 123         d->handlers.remove(feed);
 124     }
 125 }
 126
 127 class ProgressItemHandler::ProgressItemHandlerPrivate
 128 {
 129 public:
 130
 131     Feed *feed;
 132     KPIM::ProgressItem *progressItem;
 133 };
 134
 135 ProgressItemHandler::ProgressItemHandler(Feed *feed) : d(new ProgressItemHandlerPrivate)
 136 {
 137     d->feed = feed;
 138     d->progressItem = 0;
 139
 140     connect(feed, &Feed::fetchStarted, this, &ProgressItemHandler::slotFetchStarted);
 141     connect(feed, &Feed::fetched, this, &ProgressItemHandler::slotFetchCompleted);
 142     connect(feed, &Feed::fetchError, this, &ProgressItemHandler::slotFetchError);
 143     connect(feed, &Feed::fetchAborted, this, &ProgressItemHandler::slotFetchAborted);
 144 }
 145
 146 ProgressItemHandler::~ProgressItemHandler()
 147 {
 148     if (d->progressItem) {
 149         d->progressItem->setComplete();
 150         d->progressItem = 0;
 151     }
 152
 153     delete d;
 154     d = 0;
 155 }
 156
 157 void ProgressItemHandler::slotFetchStarted()
 158 {
 159     if (d->progressItem) {
 160         d->progressItem->setComplete();
 161         d->progressItem = 0;
 162     }
 163
 164     d->progressItem = KPIM::ProgressManager::createProgressItem(KPIM::ProgressManager::getUniqueID(), d->feed->title(), QString(), true);
 165
 166     connect(d->progressItem, &KPIM::ProgressItem::progressItemCanceled, d->feed, &Feed::slotAbortFetch);
 167 }
 168
 169 void ProgressItemHandler::slotFetchCompleted()
 170 {
 171     if (d->progressItem) {
 172         d->progressItem->setStatus(i18n("Fetch completed"));
 173         d->progressItem->setComplete();
 174         d->progressItem = 0;
 175     }
 176 }
 177
 178 void ProgressItemHandler::slotFetchError()
 179 {
 180     if (d->progressItem) {
 181         d->progressItem->setStatus(i18n("Fetch error"));
 182         d->progressItem->setComplete();
 183         d->progressItem = 0;
 184     }
 185 }
 186
 187 void ProgressItemHandler::slotFetchAborted()
 188 {
 189     if (d->progressItem) {
 190         d->progressItem->setStatus(i18n("Fetch aborted"));
 191         d->progressItem->setComplete();
 192         d->progressItem = 0;
 193     }
 194 }
 195
 196 } // namespace Akregator
 197