d4708/qBittorrent
1
0
Fork 0
mirror of https://github.com/d47081/qBittorrent.git synced 2025-02-02 18:04:32 +00:00
Code Issues Projects Releases Wiki Activity

RSS: Use SharedPtr everywhere

Browse Source
This commit is contained in:
Christophe Dumez 2012-02-19 18:53:10 +02:00
parent a13bb06ec3
commit 50a3e4e776
18 changed files with 313 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
src/rss/automatedrssdownloader.cpp
View File

@ -45,10 +45,10 @@
#include "rssfeed.h" #include "rssfeed.h"
#include "iconprovider.h" #include "iconprovider.h"
AutomatedRssDownloader::AutomatedRssDownloader(QWidget *parent) : AutomatedRssDownloader::AutomatedRssDownloader(const QWeakPointer<RssManager>& manager, QWidget *parent) :
QDialog(parent), QDialog(parent),
ui(new Ui::AutomatedRssDownloader), ui(new Ui::AutomatedRssDownloader),
m_editedRule(0) m_manager(manager), m_editedRule(0)
{ {
ui->setupUi(this); ui->setupUi(this);
// Icons // Icons
@ -129,7 +129,7 @@ void AutomatedRssDownloader::loadRulesList()
foreach (const QString &rule_name, m_ruleList->ruleNames()) { foreach (const QString &rule_name, m_ruleList->ruleNames()) {
QListWidgetItem *item = new QListWidgetItem(rule_name, ui->listRules); QListWidgetItem *item = new QListWidgetItem(rule_name, ui->listRules);
item->setFlags(item->flags()|Qt::ItemIsUserCheckable); item->setFlags(item->flags()|Qt::ItemIsUserCheckable);
if(m_ruleList->getRule(rule_name).isEnabled()) if(m_ruleList->getRule(rule_name)->isEnabled())
item->setCheckState(Qt::Checked); item->setCheckState(Qt::Checked);
else else
item->setCheckState(Qt::Unchecked); item->setCheckState(Qt::Unchecked);
@ -164,17 +164,17 @@ void AutomatedRssDownloader::updateFeedList()
const QString feed_url = item->data(Qt::UserRole).toString(); const QString feed_url = item->data(Qt::UserRole).toString();
bool all_enabled = false; bool all_enabled = false;
foreach(const QListWidgetItem *ruleItem, ui->listRules->selectedItems()) { foreach(const QListWidgetItem *ruleItem, ui->listRules->selectedItems()) {
RssDownloadRule rule = m_ruleList->getRule(ruleItem->text()); RssDownloadRulePtr rule = m_ruleList->getRule(ruleItem->text());
if(!rule.isValid()) continue; if(!rule) continue;
qDebug() << "Rule" << rule.name() << "affects" << rule.rssFeeds().size() << "feeds."; qDebug() << "Rule" << rule->name() << "affects" << rule->rssFeeds().size() << "feeds.";
foreach(QString test, rule.rssFeeds()) { foreach(QString test, rule->rssFeeds()) {
qDebug() << "Feed is " << test; qDebug() << "Feed is " << test;
} }
if(rule.rssFeeds().contains(feed_url)) { if(rule->rssFeeds().contains(feed_url)) {
qDebug() << "Rule " << rule.name() << " affects feed " << feed_url; qDebug() << "Rule " << rule->name() << " affects feed " << feed_url;
all_enabled = true; all_enabled = true;
} else { } else {
qDebug() << "Rule " << rule.name() << " does NOT affect feed " << feed_url; qDebug() << "Rule " << rule->name() << " does NOT affect feed " << feed_url;
all_enabled = false; all_enabled = false;
break; break;
} }
@ -203,18 +203,18 @@ void AutomatedRssDownloader::updateRuleDefinitionBox()
const QList<QListWidgetItem*> selection = ui->listRules->selectedItems(); const QList<QListWidgetItem*> selection = ui->listRules->selectedItems();
if(selection.count() == 1) { if(selection.count() == 1) {
m_editedRule = selection.first(); m_editedRule = selection.first();
RssDownloadRule rule = getCurrentRule(); RssDownloadRulePtr rule = getCurrentRule();
if(rule.isValid()) { if (rule) {
ui->lineContains->setText(rule.mustContain()); ui->lineContains->setText(rule->mustContain());
ui->lineNotContains->setText(rule.mustNotContain()); ui->lineNotContains->setText(rule->mustNotContain());
ui->saveDiffDir_check->setChecked(!rule.savePath().isEmpty()); ui->saveDiffDir_check->setChecked(!rule->savePath().isEmpty());
ui->lineSavePath->setText(rule.savePath()); ui->lineSavePath->setText(rule->savePath());
ui->checkRegex->setChecked(rule.useRegex()); ui->checkRegex->setChecked(rule->useRegex());
if(rule.label().isEmpty()) { if (rule->label().isEmpty()) {
ui->comboLabel->setCurrentIndex(-1); ui->comboLabel->setCurrentIndex(-1);
ui->comboLabel->clearEditText(); ui->comboLabel->clearEditText();
} else { } else {
ui->comboLabel->setCurrentIndex(ui->comboLabel->findText(rule.label())); ui->comboLabel->setCurrentIndex(ui->comboLabel->findText(rule->label()));
} }
updateMustLineValidity(); updateMustLineValidity();
updateMustNotLineValidity(); updateMustNotLineValidity();
@ -247,12 +247,12 @@ void AutomatedRssDownloader::clearRuleDefinitionBox()
updateMustNotLineValidity(); updateMustNotLineValidity();
} }
RssDownloadRule AutomatedRssDownloader::getCurrentRule() const RssDownloadRulePtr AutomatedRssDownloader::getCurrentRule() const
{ {
QListWidgetItem * current_item = ui->listRules->currentItem(); QListWidgetItem * current_item = ui->listRules->currentItem();
if(current_item) if(current_item)
return m_ruleList->getRule(current_item->text()); return m_ruleList->getRule(current_item->text());
return RssDownloadRule(); return RssDownloadRulePtr();
} }
void AutomatedRssDownloader::initLabelCombobox() void AutomatedRssDownloader::initLabelCombobox()
@ -273,26 +273,26 @@ void AutomatedRssDownloader::saveEditedRule()
qDebug() << "Probably removed the item, no need to save it"; qDebug() << "Probably removed the item, no need to save it";
return; return;
} }
RssDownloadRule rule = m_ruleList->getRule(m_editedRule->text()); RssDownloadRulePtr rule = m_ruleList->getRule(m_editedRule->text());
if(!rule.isValid()) { if (!rule) {
rule.setName(m_editedRule->text()); rule->setName(m_editedRule->text());
} }
if(m_editedRule->checkState() == Qt::Unchecked) if (m_editedRule->checkState() == Qt::Unchecked)
rule.setEnabled(false); rule->setEnabled(false);
else else
rule.setEnabled(true); rule->setEnabled(true);
rule.setUseRegex(ui->checkRegex->isChecked()); rule->setUseRegex(ui->checkRegex->isChecked());
rule.setMustContain(ui->lineContains->text()); rule->setMustContain(ui->lineContains->text());
rule.setMustNotContain(ui->lineNotContains->text()); rule->setMustNotContain(ui->lineNotContains->text());
if(ui->saveDiffDir_check->isChecked()) if(ui->saveDiffDir_check->isChecked())
rule.setSavePath(ui->lineSavePath->text()); rule->setSavePath(ui->lineSavePath->text());
else else
rule.setSavePath(""); rule->setSavePath("");
rule.setLabel(ui->comboLabel->currentText()); rule->setLabel(ui->comboLabel->currentText());
// Save new label // Save new label
if(!rule.label().isEmpty()) if(!rule->label().isEmpty())
Preferences().addTorrentLabel(rule.label()); Preferences().addTorrentLabel(rule->label());
//rule.setRssFeeds(getSelectedFeeds()); //rule->setRssFeeds(getSelectedFeeds());
// Save it // Save it
m_ruleList->saveRule(rule); m_ruleList->saveRule(rule);
} }
@ -301,15 +301,15 @@ void AutomatedRssDownloader::saveEditedRule()
void AutomatedRssDownloader::on_addRuleBtn_clicked() void AutomatedRssDownloader::on_addRuleBtn_clicked()
{ {
// Ask for a rule name // Ask for a rule name
const QString rule = QInputDialog::getText(this, tr("New rule name"), tr("Please type the name of the new download rule.")); const QString rule_name = QInputDialog::getText(this, tr("New rule name"), tr("Please type the name of the new download rule->"));
if(rule.isEmpty()) return; if(rule_name.isEmpty()) return;
// Check if this rule name already exists // Check if this rule name already exists
if(m_ruleList->getRule(rule).isValid()) { if(m_ruleList->getRule(rule_name)) {
QMessageBox::warning(this, tr("Rule name conflict"), tr("A rule with this name already exists, please choose another name.")); QMessageBox::warning(this, tr("Rule name conflict"), tr("A rule with this name already exists, please choose another name."));
return; return;
} }
// Add the new rule to the list // Add the new rule to the list
QListWidgetItem * item = new QListWidgetItem(rule, ui->listRules); QListWidgetItem * item = new QListWidgetItem(rule_name, ui->listRules);
item->setFlags(item->flags()|Qt::ItemIsUserCheckable); item->setFlags(item->flags()|Qt::ItemIsUserCheckable);
item->setCheckState(Qt::Checked); // Enable as a default item->setCheckState(Qt::Checked); // Enable as a default
ui->listRules->clearSelection(); ui->listRules->clearSelection();
@ -382,7 +382,7 @@ void AutomatedRssDownloader::displayRulesListMenu(const QPoint &pos)
{ {
Q_UNUSED(pos); Q_UNUSED(pos);
QMenu menu; QMenu menu;
QAction *addAct = menu.addAction(IconProvider::instance()->getIcon("list-add"), tr("Add new rule...")); QAction *addAct = menu.addAction(IconProvider::instance()->getIcon("list-add"), tr("Add new rule->.."));
QAction *delAct = 0; QAction *delAct = 0;
QAction *renameAct = 0; QAction *renameAct = 0;
const QList<QListWidgetItem*> selection = ui->listRules->selectedItems(); const QList<QListWidgetItem*> selection = ui->listRules->selectedItems();
@ -390,7 +390,7 @@ void AutomatedRssDownloader::displayRulesListMenu(const QPoint &pos)
if(selection.count() == 1) { if(selection.count() == 1) {
delAct = menu.addAction(IconProvider::instance()->getIcon("list-remove"), tr("Delete rule")); delAct = menu.addAction(IconProvider::instance()->getIcon("list-remove"), tr("Delete rule"));
menu.addSeparator(); menu.addSeparator();
renameAct = menu.addAction(IconProvider::instance()->getIcon("edit-rename"), tr("Rename rule...")); renameAct = menu.addAction(IconProvider::instance()->getIcon("edit-rename"), tr("Rename rule->.."));
} else { } else {
delAct = menu.addAction(IconProvider::instance()->getIcon("list-remove"), tr("Delete selected rules")); delAct = menu.addAction(IconProvider::instance()->getIcon("list-remove"), tr("Delete selected rules"));
} }
@ -438,9 +438,9 @@ void AutomatedRssDownloader::handleFeedCheckStateChange(QListWidgetItem *feed_it
} }
const QString feed_url = feed_item->data(Qt::UserRole).toString(); const QString feed_url = feed_item->data(Qt::UserRole).toString();
foreach (QListWidgetItem* rule_item, ui->listRules->selectedItems()) { foreach (QListWidgetItem* rule_item, ui->listRules->selectedItems()) {
RssDownloadRule rule = m_ruleList->getRule(rule_item->text()); RssDownloadRulePtr rule = m_ruleList->getRule(rule_item->text());
Q_ASSERT(rule.isValid()); Q_ASSERT(rule);
QStringList affected_feeds = rule.rssFeeds(); QStringList affected_feeds = rule->rssFeeds();
if(feed_item->checkState() == Qt::Checked) { if(feed_item->checkState() == Qt::Checked) {
if(!affected_feeds.contains(feed_url)) if(!affected_feeds.contains(feed_url))
affected_feeds << feed_url; affected_feeds << feed_url;
@ -449,8 +449,8 @@ void AutomatedRssDownloader::handleFeedCheckStateChange(QListWidgetItem *feed_it
affected_feeds.removeOne(feed_url); affected_feeds.removeOne(feed_url);
} }
// Save the updated rule // Save the updated rule
if(affected_feeds.size() != rule.rssFeeds().size()) { if(affected_feeds.size() != rule->rssFeeds().size()) {
rule.setRssFeeds(affected_feeds); rule->setRssFeeds(affected_feeds);
m_ruleList->saveRule(rule); m_ruleList->saveRule(rule);
} }
} }
@ -464,26 +464,29 @@ void AutomatedRssDownloader::updateMatchingArticles()
if(ui->ruleDefBox->isEnabled()) { if(ui->ruleDefBox->isEnabled()) {
saveEditedRule(); saveEditedRule();
} }
const QHash<QString, RssFeed*> all_feeds = RssManager::instance()->getAllFeedsAsHash(); RssManagerPtr manager = m_manager.toStrongRef();
if (!manager)
return;
const QHash<QString, RssFeedPtr> all_feeds = manager->getAllFeedsAsHash();
foreach(const QListWidgetItem *rule_item, ui->listRules->selectedItems()) { foreach(const QListWidgetItem *rule_item, ui->listRules->selectedItems()) {
RssDownloadRule rule = m_ruleList->getRule(rule_item->text()); RssDownloadRulePtr rule = m_ruleList->getRule(rule_item->text());
if(!rule.isValid()) continue; if(!rule) continue;
foreach(const QString &feed_url, rule.rssFeeds()) { foreach(const QString &feed_url, rule->rssFeeds()) {
qDebug() << Q_FUNC_INFO << feed_url; qDebug() << Q_FUNC_INFO << feed_url;
Q_ASSERT(all_feeds.contains(feed_url)); Q_ASSERT(all_feeds.contains(feed_url));
if(!all_feeds.contains(feed_url)) continue; if(!all_feeds.contains(feed_url)) continue;
const RssFeed *feed = all_feeds.value(feed_url); RssFeedPtr feed = all_feeds.value(feed_url);
Q_ASSERT(feed); Q_ASSERT(feed);
if(!feed) continue; if(!feed) continue;
const QStringList matching_articles = rule.findMatchingArticles(feed); const QStringList matching_articles = rule->findMatchingArticles(feed);
if(!matching_articles.isEmpty()) if(!matching_articles.isEmpty())
addFeedArticlesToTree(feed, matching_articles); addFeedArticlesToTree(feed, matching_articles);
} }
} }
} }
void AutomatedRssDownloader::addFeedArticlesToTree(const RssFeed *feed, const QStringList &articles) void AutomatedRssDownloader::addFeedArticlesToTree(const RssFeedPtr& feed, const QStringList &articles)
{ {
// Check if this feed is already in the tree // Check if this feed is already in the tree
QTreeWidgetItem *treeFeedItem = 0; QTreeWidgetItem *treeFeedItem = 0;

9
src/rss/automatedrssdownloader.h
View File

@ -32,6 +32,7 @@
#define AUTOMATEDRSSDOWNLOADER_H #define AUTOMATEDRSSDOWNLOADER_H
#include <QDialog> #include <QDialog>
#include <QWeakPointer>
#include "rssdownloadrule.h" #include "rssdownloadrule.h"
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
@ -41,6 +42,7 @@ class AutomatedRssDownloader;
QT_END_NAMESPACE QT_END_NAMESPACE
class RssDownloadRuleList; class RssDownloadRuleList;
class RssManager;
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class QListWidgetItem; class QListWidgetItem;
@ -51,7 +53,7 @@ class AutomatedRssDownloader : public QDialog
Q_OBJECT Q_OBJECT
public: public:
explicit AutomatedRssDownloader(QWidget *parent = 0); explicit AutomatedRssDownloader(const QWeakPointer<RssManager>& manager, QWidget *parent = 0);
~AutomatedRssDownloader(); ~AutomatedRssDownloader();
bool isRssDownloaderEnabled() const; bool isRssDownloaderEnabled() const;
@ -80,12 +82,13 @@ private slots:
void updateMustNotLineValidity(); void updateMustNotLineValidity();
private: private:
RssDownloadRule getCurrentRule() const; RssDownloadRulePtr getCurrentRule() const;
void initLabelCombobox(); void initLabelCombobox();
void addFeedArticlesToTree(const RssFeed *feed, const QStringList& articles); void addFeedArticlesToTree(const RssFeedPtr& feed, const QStringList& articles);
private: private:
Ui::AutomatedRssDownloader *ui; Ui::AutomatedRssDownloader *ui;
QWeakPointer<RssManager> m_manager;
QListWidgetItem* m_editedRule; QListWidgetItem* m_editedRule;
RssDownloadRuleList *m_ruleList; RssDownloadRuleList *m_ruleList;
}; };

54
src/rss/feedlistwidget.cpp
View File

@ -33,7 +33,7 @@
#include "rssfeed.h" #include "rssfeed.h"
#include "iconprovider.h" #include "iconprovider.h"
FeedListWidget::FeedListWidget(QWidget *parent, RssManager *rssmanager): QTreeWidget(parent), m_rssManager(rssmanager) { FeedListWidget::FeedListWidget(QWidget *parent, const RssManagerPtr& rssmanager): QTreeWidget(parent), m_rssManager(rssmanager) {
setContextMenuPolicy(Qt::CustomContextMenu); setContextMenuPolicy(Qt::CustomContextMenu);
setDragDropMode(QAbstractItemView::InternalMove); setDragDropMode(QAbstractItemView::InternalMove);
setSelectionMode(QAbstractItemView::ExtendedSelection); setSelectionMode(QAbstractItemView::ExtendedSelection);
@ -51,20 +51,20 @@ FeedListWidget::~FeedListWidget() {
delete m_unreadStickyItem; delete m_unreadStickyItem;
} }
void FeedListWidget::itemAdded(QTreeWidgetItem *item, IRssFile* file) { void FeedListWidget::itemAdded(QTreeWidgetItem *item, const RssFilePtr& file) {
m_rssMapping[item] = file; m_rssMapping[item] = file;
if(file->type() == IRssFile::FEED) { if (RssFeedPtr feed = qSharedPointerDynamicCast<RssFeed>(file)) {
m_feedsItems[file->id()] = item; m_feedsItems[feed->id()] = item;
} }
} }
void FeedListWidget::itemAboutToBeRemoved(QTreeWidgetItem *item) { void FeedListWidget::itemAboutToBeRemoved(QTreeWidgetItem *item) {
IRssFile* file = m_rssMapping.take(item); RssFilePtr file = m_rssMapping.take(item);
if(file->type() == IRssFile::FEED) { if (RssFeedPtr feed = qSharedPointerDynamicCast<RssFeed>(file)) {
m_feedsItems.remove(file->id()); m_feedsItems.remove(feed->id());
} else { } if (RssFolderPtr folder = qSharedPointerDynamicCast<RssFolder>(file)) {
QList<RssFeed*> feeds = ((RssFolder*)file)->getAllFeeds(); RssFeedList feeds = folder->getAllFeeds();
foreach(RssFeed* feed, feeds) { foreach(const RssFeedPtr& feed, feeds) {
m_feedsItems.remove(feed->id()); m_feedsItems.remove(feed->id());
} }
} }
@ -105,7 +105,7 @@ QList<QTreeWidgetItem*> FeedListWidget::getAllOpenFolders(QTreeWidgetItem *paren
item = parent->child(i); item = parent->child(i);
else else
item = topLevelItem(i); item = topLevelItem(i);
if(getItemType(item) == IRssFile::FOLDER && item->isExpanded()) { if(isFolder(item) && item->isExpanded()) {
QList<QTreeWidgetItem*> open_subfolders = getAllOpenFolders(item); QList<QTreeWidgetItem*> open_subfolders = getAllOpenFolders(item);
if(!open_subfolders.empty()) { if(!open_subfolders.empty()) {
open_folders << open_subfolders; open_folders << open_subfolders;
@ -122,7 +122,7 @@ QList<QTreeWidgetItem*> FeedListWidget::getAllFeedItems(QTreeWidgetItem* folder)
const int nbChildren = folder->childCount(); const int nbChildren = folder->childCount();
for(int i=0; i<nbChildren; ++i) { for(int i=0; i<nbChildren; ++i) {
QTreeWidgetItem *item = folder->child(i); QTreeWidgetItem *item = folder->child(i);
if(getItemType(item) == IRssFile::FEED) { if(isFeed(item)) {
feeds << item; feeds << item;
} else { } else {
feeds << getAllFeedItems(item); feeds << getAllFeedItems(item);
@ -131,12 +131,18 @@ QList<QTreeWidgetItem*> FeedListWidget::getAllFeedItems(QTreeWidgetItem* folder)
return feeds; return feeds;
} }
IRssFile* FeedListWidget::getRSSItem(QTreeWidgetItem *item) const { RssFilePtr FeedListWidget::getRSSItem(QTreeWidgetItem *item) const {
return m_rssMapping.value(item, 0); return m_rssMapping.value(item, RssFilePtr());
} }
IRssFile::FileType FeedListWidget::getItemType(QTreeWidgetItem *item) const { bool FeedListWidget::isFeed(QTreeWidgetItem *item) const
return m_rssMapping.value(item)->type(); {
return (qSharedPointerDynamicCast<RssFeed>(m_rssMapping.value(item)) != NULL);
}
bool FeedListWidget::isFolder(QTreeWidgetItem *item) const
{
return (qSharedPointerDynamicCast<RssFolder>(m_rssMapping.value(item)) != NULL);
} }
QString FeedListWidget::getItemID(QTreeWidgetItem *item) const { QString FeedListWidget::getItemID(QTreeWidgetItem *item) const {
@ -147,8 +153,8 @@ QTreeWidgetItem* FeedListWidget::getTreeItemFromUrl(const QString &url) const{
return m_feedsItems.value(url, 0); return m_feedsItems.value(url, 0);
} }
RssFeed* FeedListWidget::getRSSItemFromUrl(const QString &url) const { RssFeedPtr FeedListWidget::getRSSItemFromUrl(const QString &url) const {
return dynamic_cast<RssFeed*>(getRSSItem(getTreeItemFromUrl(url))); return qSharedPointerDynamicCast<RssFeed>(getRSSItem(getTreeItemFromUrl(url)));
} }
QTreeWidgetItem* FeedListWidget::currentItem() const { QTreeWidgetItem* FeedListWidget::currentItem() const {
@ -162,7 +168,7 @@ QTreeWidgetItem* FeedListWidget::currentFeed() const {
void FeedListWidget::updateCurrentFeed(QTreeWidgetItem* new_item) { void FeedListWidget::updateCurrentFeed(QTreeWidgetItem* new_item) {
if(!new_item) return; if(!new_item) return;
if(!m_rssMapping.contains(new_item)) return; if(!m_rssMapping.contains(new_item)) return;
if((getItemType(new_item) == IRssFile::FEED) || new_item == m_unreadStickyItem) if(isFeed(new_item) || new_item == m_unreadStickyItem)
m_currentFeed = new_item; m_currentFeed = new_item;
} }
@ -171,7 +177,7 @@ void FeedListWidget::dragMoveEvent(QDragMoveEvent * event) {
if(item == m_unreadStickyItem) { if(item == m_unreadStickyItem) {
event->ignore(); event->ignore();
} else { } else {
if(item && getItemType(item) != IRssFile::FOLDER) if(item && isFolder(item))
event->ignore(); event->ignore();
else { else {
if(selectedItems().contains(m_unreadStickyItem)) { if(selectedItems().contains(m_unreadStickyItem)) {
@ -187,9 +193,9 @@ void FeedListWidget::dropEvent(QDropEvent *event) {
qDebug("dropEvent"); qDebug("dropEvent");
QList<QTreeWidgetItem*> folders_altered; QList<QTreeWidgetItem*> folders_altered;
QTreeWidgetItem *dest_folder_item = itemAt(event->pos()); QTreeWidgetItem *dest_folder_item = itemAt(event->pos());
RssFolder *dest_folder; RssFolderPtr dest_folder;
if(dest_folder_item) { if(dest_folder_item) {
dest_folder = (RssFolder*)getRSSItem(dest_folder_item); dest_folder = qSharedPointerCast<RssFolder>(getRSSItem(dest_folder_item));
folders_altered << dest_folder_item; folders_altered << dest_folder_item;
} else { } else {
dest_folder = m_rssManager; dest_folder = m_rssManager;
@ -197,7 +203,7 @@ void FeedListWidget::dropEvent(QDropEvent *event) {
QList<QTreeWidgetItem *> src_items = selectedItems(); QList<QTreeWidgetItem *> src_items = selectedItems();
// Check if there is not going to overwrite another file // Check if there is not going to overwrite another file
foreach(QTreeWidgetItem *src_item, src_items) { foreach(QTreeWidgetItem *src_item, src_items) {
IRssFile *file = getRSSItem(src_item); RssFilePtr file = getRSSItem(src_item);
if(dest_folder->hasChild(file->id())) { if(dest_folder->hasChild(file->id())) {
emit overwriteAttempt(file->id()); emit overwriteAttempt(file->id());
return; return;
@ -209,7 +215,7 @@ void FeedListWidget::dropEvent(QDropEvent *event) {
if(parent_folder && !folders_altered.contains(parent_folder)) if(parent_folder && !folders_altered.contains(parent_folder))
folders_altered << parent_folder; folders_altered << parent_folder;
// Actually move the file // Actually move the file
IRssFile *file = getRSSItem(src_item); RssFilePtr file = getRSSItem(src_item);
m_rssManager->moveFile(file, dest_folder); m_rssManager->moveFile(file, dest_folder);
} }
QTreeWidget::dropEvent(event); QTreeWidget::dropEvent(event);

20
src/rss/feedlistwidget.h
View File

@ -40,15 +40,14 @@
#include <QUrl> #include <QUrl>
#include "rssfile.h" #include "rssfile.h"
#include "rssfeed.h"
class RssManager; #include "rssmanager.h"
class RssFeed;
class FeedListWidget: public QTreeWidget { class FeedListWidget: public QTreeWidget {
Q_OBJECT Q_OBJECT
public: public:
FeedListWidget(QWidget *parent, RssManager *m_rssManager); FeedListWidget(QWidget *parent, const RssManagerPtr& rssManager);
~FeedListWidget(); ~FeedListWidget();
bool hasFeed(const QString &url) const; bool hasFeed(const QString &url) const;
@ -57,16 +56,17 @@ public:
QStringList getItemPath(QTreeWidgetItem* item) const; QStringList getItemPath(QTreeWidgetItem* item) const;
QList<QTreeWidgetItem*> getAllOpenFolders(QTreeWidgetItem *parent=0) const; QList<QTreeWidgetItem*> getAllOpenFolders(QTreeWidgetItem *parent=0) const;
QList<QTreeWidgetItem*> getAllFeedItems(QTreeWidgetItem* folder); QList<QTreeWidgetItem*> getAllFeedItems(QTreeWidgetItem* folder);
IRssFile* getRSSItem(QTreeWidgetItem *item) const; RssFilePtr getRSSItem(QTreeWidgetItem *item) const;
IRssFile::FileType getItemType(QTreeWidgetItem *item) const; bool isFeed(QTreeWidgetItem *item) const;
bool isFolder(QTreeWidgetItem *item) const;
QString getItemID(QTreeWidgetItem *item) const; QString getItemID(QTreeWidgetItem *item) const;
QTreeWidgetItem* getTreeItemFromUrl(const QString &url) const; QTreeWidgetItem* getTreeItemFromUrl(const QString &url) const;
RssFeed* getRSSItemFromUrl(const QString &url) const; RssFeedPtr getRSSItemFromUrl(const QString &url) const;
QTreeWidgetItem* currentItem() const; QTreeWidgetItem* currentItem() const;
QTreeWidgetItem* currentFeed() const; QTreeWidgetItem* currentFeed() const;
public slots: public slots:
void itemAdded(QTreeWidgetItem *item, IRssFile* file); void itemAdded(QTreeWidgetItem *item, const RssFilePtr& file);
void itemAboutToBeRemoved(QTreeWidgetItem *item); void itemAboutToBeRemoved(QTreeWidgetItem *item);
signals: signals:
@ -81,8 +81,8 @@ protected:
void dropEvent(QDropEvent *event); void dropEvent(QDropEvent *event);
private: private:
RssManager *m_rssManager; RssManagerPtr m_rssManager;
QHash<QTreeWidgetItem*, IRssFile*> m_rssMapping; QHash<QTreeWidgetItem*, RssFilePtr> m_rssMapping;
QHash<QString, QTreeWidgetItem*> m_feedsItems; QHash<QString, QTreeWidgetItem*> m_feedsItems;
QTreeWidgetItem* m_currentFeed; QTreeWidgetItem* m_currentFeed;
QTreeWidgetItem *m_unreadStickyItem; QTreeWidgetItem *m_unreadStickyItem;

67
src/rss/rss_imp.cpp
View File

@ -78,7 +78,7 @@ void RSSImp::displayRSSListMenu(const QPoint& pos){
myRSSListMenu.addAction(actionRename); myRSSListMenu.addAction(actionRename);
myRSSListMenu.addAction(actionDelete); myRSSListMenu.addAction(actionDelete);
myRSSListMenu.addSeparator(); myRSSListMenu.addSeparator();
if(m_feedList->getItemType(selectedItems.first()) == IRssFile::FOLDER) { if(m_feedList->isFolder(selectedItems.first())) {
myRSSListMenu.addAction(actionNew_folder); myRSSListMenu.addAction(actionNew_folder);
} else { } else {
myRSSListMenu.addAction(actionManage_cookies); myRSSListMenu.addAction(actionManage_cookies);
@ -86,7 +86,7 @@ void RSSImp::displayRSSListMenu(const QPoint& pos){
} }
} }
myRSSListMenu.addAction(actionNew_subscription); myRSSListMenu.addAction(actionNew_subscription);
if(m_feedList->getItemType(selectedItems.first()) == IRssFile::FEED) { if(m_feedList->isFeed(selectedItems.first())) {
myRSSListMenu.addSeparator(); myRSSListMenu.addSeparator();
myRSSListMenu.addAction(actionCopy_feed_URL); myRSSListMenu.addAction(actionCopy_feed_URL);
} }
@ -137,18 +137,18 @@ void RSSImp::on_actionManage_cookies_triggered() {
void RSSImp::askNewFolder() { void RSSImp::askNewFolder() {
QTreeWidgetItem *parent_item = 0; QTreeWidgetItem *parent_item = 0;
RssFolder *rss_parent; RssFolderPtr rss_parent;
if(m_feedList->selectedItems().size() > 0) { if(m_feedList->selectedItems().size() > 0) {
parent_item = m_feedList->selectedItems().at(0); parent_item = m_feedList->selectedItems().at(0);
rss_parent = dynamic_cast<RssFolder*>(m_feedList->getRSSItem(parent_item)); rss_parent = qSharedPointerDynamicCast<RssFolder>(m_feedList->getRSSItem(parent_item));
Q_ASSERT(rss_parent->type() == IRssFile::FOLDER); Q_ASSERT(rss_parent);
} else { } else {
rss_parent = m_rssManager; rss_parent = m_rssManager;
} }
bool ok; bool ok;
QString new_name = QInputDialog::getText(this, tr("Please choose a folder name"), tr("Folder name:"), QLineEdit::Normal, tr("New folder"), &ok); QString new_name = QInputDialog::getText(this, tr("Please choose a folder name"), tr("Folder name:"), QLineEdit::Normal, tr("New folder"), &ok);
if(ok) { if(ok) {
RssFolder* new_folder = rss_parent->addFolder(new_name); RssFolderPtr new_folder = rss_parent->addFolder(new_name);
QTreeWidgetItem* folder_item; QTreeWidgetItem* folder_item;
if(parent_item) if(parent_item)
folder_item = new QTreeWidgetItem(parent_item); folder_item = new QTreeWidgetItem(parent_item);
@ -183,13 +183,13 @@ void RSSImp::on_newFeedButton_clicked() {
if(parent_item == m_feedList->stickyUnreadItem()) { if(parent_item == m_feedList->stickyUnreadItem()) {
parent_item = 0; parent_item = 0;
} else { } else {
if(m_feedList->getItemType(parent_item) != IRssFile::FOLDER) if(m_feedList->isFolder(parent_item))
parent_item = parent_item->parent(); parent_item = parent_item->parent();
} }
} }
RssFolder *rss_parent; RssFolderPtr rss_parent;
if(parent_item) { if(parent_item) {
rss_parent = (RssFolder*)m_feedList->getRSSItem(parent_item); rss_parent = qSharedPointerCast<RssFolder>(m_feedList->getRSSItem(parent_item));
} else { } else {
rss_parent = m_rssManager; rss_parent = m_rssManager;
} }
@ -210,7 +210,7 @@ void RSSImp::on_newFeedButton_clicked() {
QMessageBox::Ok); QMessageBox::Ok);
return; return;
} }
RssFeed *stream = rss_parent->addStream(newUrl); RssFeedPtr stream = rss_parent->addStream(m_rssManager.data(), newUrl);
// Create TreeWidget item // Create TreeWidget item
QTreeWidgetItem* item; QTreeWidgetItem* item;
if(parent_item) if(parent_item)
@ -248,7 +248,7 @@ void RSSImp::deleteSelectedItems() {
m_currentArticle = 0; m_currentArticle = 0;
listArticles->clear(); listArticles->clear();
} }
IRssFile *rss_item = m_feedList->getRSSItem(item); RssFilePtr rss_item = m_feedList->getRSSItem(item);
QTreeWidgetItem * parent = item->parent(); QTreeWidgetItem * parent = item->parent();
// Notify TreeWidget // Notify TreeWidget
m_feedList->itemAboutToBeRemoved(item); m_feedList->itemAboutToBeRemoved(item);
@ -350,7 +350,7 @@ void RSSImp::renameFiles() {
QList<QTreeWidgetItem*> selectedItems = m_feedList->selectedItems(); QList<QTreeWidgetItem*> selectedItems = m_feedList->selectedItems();
Q_ASSERT(selectedItems.size() == 1); Q_ASSERT(selectedItems.size() == 1);
QTreeWidgetItem *item = selectedItems.at(0); QTreeWidgetItem *item = selectedItems.at(0);
IRssFile *rss_item = m_feedList->getRSSItem(item); RssFilePtr rss_item = m_feedList->getRSSItem(item);
bool ok; bool ok;
QString newName; QString newName;
do { do {
@ -375,7 +375,7 @@ void RSSImp::renameFiles() {
void RSSImp::refreshSelectedItems() { void RSSImp::refreshSelectedItems() {
QList<QTreeWidgetItem*> selectedItems = m_feedList->selectedItems(); QList<QTreeWidgetItem*> selectedItems = m_feedList->selectedItems();
foreach(QTreeWidgetItem* item, selectedItems){ foreach(QTreeWidgetItem* item, selectedItems){
IRssFile* file = m_feedList->getRSSItem(item); RssFilePtr file = m_feedList->getRSSItem(item);
// Update icons // Update icons
if(item == m_feedList->stickyUnreadItem()) { if(item == m_feedList->stickyUnreadItem()) {
foreach(QTreeWidgetItem *feed, m_feedList->getAllFeedItems()) { foreach(QTreeWidgetItem *feed, m_feedList->getAllFeedItems()) {
@ -384,9 +384,9 @@ void RSSImp::refreshSelectedItems() {
file->refresh(); file->refresh();
break; break;
} else { } else {
if(file->type() == IRssFile::FEED) { if (qSharedPointerDynamicCast<RssFeed>(file)) {
item->setData(0,Qt::DecorationRole, QVariant(QIcon(":/Icons/loading.png"))); item->setData(0,Qt::DecorationRole, QVariant(QIcon(":/Icons/loading.png")));
} else { } else if (qSharedPointerDynamicCast<RssFolder>(file)) {
// Update feeds in the folder // Update feeds in the folder
foreach(QTreeWidgetItem *feed, m_feedList->getAllFeedItems(item)) { foreach(QTreeWidgetItem *feed, m_feedList->getAllFeedItems(item)) {
feed->setData(0,Qt::DecorationRole, QVariant(QIcon(":/Icons/loading.png"))); feed->setData(0,Qt::DecorationRole, QVariant(QIcon(":/Icons/loading.png")));
@ -403,7 +403,7 @@ void RSSImp::copySelectedFeedsURL() {
QList<QTreeWidgetItem*> selectedItems = m_feedList->selectedItems(); QList<QTreeWidgetItem*> selectedItems = m_feedList->selectedItems();
QTreeWidgetItem* item; QTreeWidgetItem* item;
foreach(item, selectedItems){ foreach(item, selectedItems){
if(m_feedList->getItemType(item) == IRssFile::FEED) if(m_feedList->isFeed(item))
URLs << m_feedList->getItemID(item); URLs << m_feedList->getItemID(item);
} }
qApp->clipboard()->setText(URLs.join("\n")); qApp->clipboard()->setText(URLs.join("\n"));
@ -413,7 +413,7 @@ void RSSImp::on_markReadButton_clicked() {
QList<QTreeWidgetItem*> selectedItems = m_feedList->selectedItems(); QList<QTreeWidgetItem*> selectedItems = m_feedList->selectedItems();
QTreeWidgetItem* item; QTreeWidgetItem* item;
foreach(item, selectedItems){ foreach(item, selectedItems){
IRssFile *rss_item = m_feedList->getRSSItem(item); RssFilePtr rss_item = m_feedList->getRSSItem(item);
rss_item->markAsRead(); rss_item->markAsRead();
updateItemInfos(item); updateItemInfos(item);
} }
@ -421,14 +421,14 @@ void RSSImp::on_markReadButton_clicked() {
refreshArticleList(m_feedList->currentItem()); refreshArticleList(m_feedList->currentItem());
} }
void RSSImp::fillFeedsList(QTreeWidgetItem *parent, RssFolder *rss_parent) { void RSSImp::fillFeedsList(QTreeWidgetItem *parent, const RssFolderPtr& rss_parent) {
QList<IRssFile*> children; QList<RssFilePtr> children;
if(parent) { if(parent) {
children = rss_parent->getContent(); children = rss_parent->getContent();
} else { } else {
children = m_rssManager->getContent(); children = m_rssManager->getContent();
} }
foreach(IRssFile* rss_child, children){ foreach (const RssFilePtr& rss_child, children){
QTreeWidgetItem* item; QTreeWidgetItem* item;
if(!parent) if(!parent)
item = new QTreeWidgetItem(m_feedList); item = new QTreeWidgetItem(m_feedList);
@ -438,12 +438,12 @@ void RSSImp::fillFeedsList(QTreeWidgetItem *parent, RssFolder *rss_parent) {
// Notify TreeWidget of item addition // Notify TreeWidget of item addition
m_feedList->itemAdded(item, rss_child); m_feedList->itemAdded(item, rss_child);
// Set Icon // Set Icon
if(rss_child->type() == IRssFile::FEED) { if(qSharedPointerDynamicCast<RssFeed>(rss_child)) {
item->setData(0,Qt::DecorationRole, QVariant(QIcon(QString::fromUtf8(":/Icons/loading.png")))); item->setData(0,Qt::DecorationRole, QVariant(QIcon(QString::fromUtf8(":/Icons/loading.png"))));
} else { } else if (RssFolderPtr folder = qSharedPointerDynamicCast<RssFolder>(rss_child)) {
item->setData(0,Qt::DecorationRole, QVariant(IconProvider::instance()->getIcon("inode-directory"))); item->setData(0,Qt::DecorationRole, QVariant(IconProvider::instance()->getIcon("inode-directory")));
// Recurvive call to load sub folders/files // Recurvive call to load sub folders/files
fillFeedsList(item, (RssFolder*)rss_child); fillFeedsList(item, folder);
} }
} }
} }
@ -455,11 +455,11 @@ void RSSImp::refreshArticleList(QTreeWidgetItem* item) {
return; return;
} }
IRssFile *rss_item = m_feedList->getRSSItem(item); RssFilePtr rss_item = m_feedList->getRSSItem(item);
if(!rss_item) return; if(!rss_item) return;
qDebug("Getting the list of news"); qDebug("Getting the list of news");
QList<RssArticlePtr> news; RssArticleList news;
if(rss_item == m_rssManager) if(rss_item == m_rssManager)
news = rss_item->unreadArticleList(); news = rss_item->unreadArticleList();
else if(rss_item) else if(rss_item)
@ -507,7 +507,7 @@ void RSSImp::refreshTextBrowser() {
} }
m_currentArticle = item; m_currentArticle = item;
} }
RssFeed *stream = m_feedList->getRSSItemFromUrl(item->data(Article::FeedUrlRole).toString()); RssFeedPtr stream = m_feedList->getRSSItemFromUrl(item->data(Article::FeedUrlRole).toString());
RssArticlePtr article = stream->getItem(item->data(Article::IdRole).toString()); RssArticlePtr article = stream->getItem(item->data(Article::IdRole).toString());
QString html; QString html;
html += "<div style='border: 2px solid red; margin-left: 5px; margin-right: 5px; margin-bottom: 5px;'>"; html += "<div style='border: 2px solid red; margin-left: 5px; margin-right: 5px; margin-bottom: 5px;'>";
@ -556,7 +556,7 @@ void RSSImp::updateItemsInfos(const QList<QTreeWidgetItem *> &items) {
} }
void RSSImp::updateItemInfos(QTreeWidgetItem *item) { void RSSImp::updateItemInfos(QTreeWidgetItem *item) {
IRssFile *rss_item = m_feedList->getRSSItem(item); RssFilePtr rss_item = m_feedList->getRSSItem(item);
if (!rss_item) if (!rss_item)
return; return;
@ -579,7 +579,7 @@ void RSSImp::updateFeedIcon(const QString &url, const QString &icon_path){
void RSSImp::updateFeedInfos(const QString &url, const QString &display_name, uint nbUnread){ void RSSImp::updateFeedInfos(const QString &url, const QString &display_name, uint nbUnread){
qDebug() << Q_FUNC_INFO << display_name; qDebug() << Q_FUNC_INFO << display_name;
QTreeWidgetItem *item = m_feedList->getTreeItemFromUrl(url); QTreeWidgetItem *item = m_feedList->getTreeItemFromUrl(url);
RssFeed *stream = (RssFeed*)m_feedList->getRSSItem(item); RssFeedPtr stream = qSharedPointerCast<RssFeed>(m_feedList->getRSSItem(item));
item->setText(0, display_name + QString::fromUtf8(" (") + QString::number(nbUnread, 10)+ QString(")")); item->setText(0, display_name + QString::fromUtf8(" (") + QString::number(nbUnread, 10)+ QString(")"));
if(!stream->isLoading()) if(!stream->isLoading())
item->setData(0,Qt::DecorationRole, QVariant(QIcon(stream->icon()))); item->setData(0,Qt::DecorationRole, QVariant(QIcon(stream->icon())));
@ -603,7 +603,7 @@ void RSSImp::updateRefreshInterval(uint val) {
m_rssManager->updateRefreshInterval(val); m_rssManager->updateRefreshInterval(val);
} }
RSSImp::RSSImp(QWidget *parent) : QWidget(parent) { RSSImp::RSSImp(QWidget *parent) : QWidget(parent), m_rssManager(new RssManager) {
setupUi(this); setupUi(this);
// Icons // Icons
actionCopy_feed_URL->setIcon(IconProvider::instance()->getIcon("edit-copy")); actionCopy_feed_URL->setIcon(IconProvider::instance()->getIcon("edit-copy"));
@ -623,8 +623,6 @@ RSSImp::RSSImp(QWidget *parent) : QWidget(parent) {
rssDownloaderBtn->setIcon(IconProvider::instance()->getIcon("download")); rssDownloaderBtn->setIcon(IconProvider::instance()->getIcon("download"));
settingsButton->setIcon(IconProvider::instance()->getIcon("preferences-system")); settingsButton->setIcon(IconProvider::instance()->getIcon("preferences-system"));
m_rssManager = RssManager::instance();
m_feedList = new FeedListWidget(splitter_h, m_rssManager); m_feedList = new FeedListWidget(splitter_h, m_rssManager);
splitter_h->insertWidget(0, m_feedList); splitter_h->insertWidget(0, m_feedList);
listArticles->setSelectionBehavior(QAbstractItemView::SelectItems); listArticles->setSelectionBehavior(QAbstractItemView::SelectItems);
@ -635,8 +633,8 @@ RSSImp::RSSImp(QWidget *parent) : QWidget(parent) {
refreshArticleList(m_feedList->currentItem()); refreshArticleList(m_feedList->currentItem());
loadFoldersOpenState(); loadFoldersOpenState();
connect(m_rssManager, SIGNAL(feedInfosChanged(QString, QString, unsigned int)), this, SLOT(updateFeedInfos(QString, QString, unsigned int))); connect(m_rssManager.data(), SIGNAL(feedInfosChanged(QString, QString, unsigned int)), this, SLOT(updateFeedInfos(QString, QString, unsigned int)));
connect(m_rssManager, SIGNAL(feedIconChanged(QString, QString)), this, SLOT(updateFeedIcon(QString, QString))); connect(m_rssManager.data(), SIGNAL(feedIconChanged(QString, QString)), this, SLOT(updateFeedIcon(QString, QString)));
connect(m_feedList, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(displayRSSListMenu(const QPoint&))); connect(m_feedList, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(displayRSSListMenu(const QPoint&)));
connect(listArticles, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(displayItemsListMenu(const QPoint&))); connect(listArticles, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(displayItemsListMenu(const QPoint&)));
@ -676,7 +674,6 @@ RSSImp::~RSSImp(){
qDebug("Deleting RSSImp..."); qDebug("Deleting RSSImp...");
saveFoldersOpenState(); saveFoldersOpenState();
delete m_feedList; delete m_feedList;
RssManager::drop();
qDebug("RSSImp deleted"); qDebug("RSSImp deleted");
} }
@ -689,7 +686,7 @@ void RSSImp::on_settingsButton_clicked() {
void RSSImp::on_rssDownloaderBtn_clicked() void RSSImp::on_rssDownloaderBtn_clicked()
{ {
AutomatedRssDownloader dlg(this); AutomatedRssDownloader dlg(m_rssManager, this);
dlg.exec(); dlg.exec();
if(dlg.isRssDownloaderEnabled()) if(dlg.isRssDownloaderEnabled())
on_updateAllButton_clicked(); on_updateAllButton_clicked();

8
src/rss/rss_imp.h
View File

@ -35,10 +35,10 @@
#include <QPointer> #include <QPointer>
#include "ui_rss.h" #include "ui_rss.h"
#include "rssfolder.h"
#include "rssmanager.h"
class FeedListWidget; class FeedListWidget;
class RssFolder;
class RssManager;
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class QTreeWidgetItem; class QTreeWidgetItem;
@ -72,7 +72,7 @@ private slots:
void updateItemInfos(QTreeWidgetItem *item); void updateItemInfos(QTreeWidgetItem *item);
void openNewsUrl(); void openNewsUrl();
void downloadTorrent(); void downloadTorrent();
void fillFeedsList(QTreeWidgetItem *parent=0, RssFolder *rss_parent=0); void fillFeedsList(QTreeWidgetItem *parent=0, const RssFolderPtr& rss_parent = RssFolderPtr());
void saveSlidersPosition(); void saveSlidersPosition();
void restoreSlidersPosition(); void restoreSlidersPosition();
void askNewFolder(); void askNewFolder();
@ -84,7 +84,7 @@ private slots:
void on_rssDownloaderBtn_clicked(); void on_rssDownloaderBtn_clicked();
private: private:
RssManager *m_rssManager; RssManagerPtr m_rssManager;
FeedListWidget *m_feedList; FeedListWidget *m_feedList;
QListWidgetItem* m_currentArticle; QListWidgetItem* m_currentArticle;

38
src/rss/rssdownloadrule.cpp
View File

@ -76,35 +76,35 @@ void RssDownloadRule::setMustNotContain(const QString &tokens)
m_mustNotContain = tokens.split(QRegExp("[\\s|]")); m_mustNotContain = tokens.split(QRegExp("[\\s|]"));
} }
RssDownloadRule RssDownloadRule::fromOldFormat(const QVariantHash &rule_hash, const QString &feed_url, const QString &rule_name) RssDownloadRulePtr RssDownloadRule::fromOldFormat(const QVariantHash &rule_hash, const QString &feed_url, const QString &rule_name)
{ {
qDebug() << Q_FUNC_INFO << feed_url << rule_name; qDebug() << Q_FUNC_INFO << feed_url << rule_name;
RssDownloadRule rule; RssDownloadRulePtr rule(new RssDownloadRule);
rule.setName(rule_name); rule->setName(rule_name);
rule.setMustContain(rule_hash.value("matches", "").toString()); rule->setMustContain(rule_hash.value("matches", "").toString());
rule.setMustNotContain(rule_hash.value("not", "").toString()); rule->setMustNotContain(rule_hash.value("not", "").toString());
if(!feed_url.isEmpty()) if(!feed_url.isEmpty())
rule.setRssFeeds(QStringList() << feed_url); rule->setRssFeeds(QStringList() << feed_url);
rule.setSavePath(rule_hash.value("save_path", "").toString()); rule->setSavePath(rule_hash.value("save_path", "").toString());
// Is enabled? // Is enabled?
QIniSettings qBTRSS("qBittorrent", "qBittorrent-rss"); QIniSettings qBTRSS("qBittorrent", "qBittorrent-rss");
const QHash<QString, QVariant> feeds_w_downloader = qBTRSS.value("downloader_on").toHash(); const QHash<QString, QVariant> feeds_w_downloader = qBTRSS.value("downloader_on").toHash();
rule.setEnabled(feeds_w_downloader.value(feed_url, true).toBool()); rule->setEnabled(feeds_w_downloader.value(feed_url, true).toBool());
// label was unsupported < 2.5.0 // label was unsupported < 2.5.0
return rule; return rule;
} }
RssDownloadRule RssDownloadRule::fromNewFormat(const QVariantHash &rule_hash) RssDownloadRulePtr RssDownloadRule::fromNewFormat(const QVariantHash &rule_hash)
{ {
RssDownloadRule rule; RssDownloadRulePtr rule(new RssDownloadRule);
rule.setName(rule_hash.value("name").toString()); rule->setName(rule_hash.value("name").toString());
rule.setMustContain(rule_hash.value("must_contain").toString()); rule->setMustContain(rule_hash.value("must_contain").toString());
rule.setMustNotContain(rule_hash.value("must_not_contain").toString()); rule->setMustNotContain(rule_hash.value("must_not_contain").toString());
rule.setRssFeeds(rule_hash.value("affected_feeds").toStringList()); rule->setRssFeeds(rule_hash.value("affected_feeds").toStringList());
rule.setEnabled(rule_hash.value("enabled", false).toBool()); rule->setEnabled(rule_hash.value("enabled", false).toBool());
rule.setSavePath(rule_hash.value("save_path").toString()); rule->setSavePath(rule_hash.value("save_path").toString());
rule.setLabel(rule_hash.value("label_assigned").toString()); rule->setLabel(rule_hash.value("label_assigned").toString());
rule.setUseRegex(rule_hash.value("use_regex", false).toBool()); rule->setUseRegex(rule_hash.value("use_regex", false).toBool());
return rule; return rule;
} }
@ -134,7 +134,7 @@ void RssDownloadRule::setSavePath(const QString &save_path)
m_savePath = QString(); m_savePath = QString();
} }
QStringList RssDownloadRule::findMatchingArticles(const RssFeed *feed) const QStringList RssDownloadRule::findMatchingArticles(const RssFeedPtr& feed) const
{ {
QStringList ret; QStringList ret;
const RssArticleHash& feed_articles = feed->articleHash(); const RssArticleHash& feed_articles = feed->articleHash();

12
src/rss/rssdownloadrule.h
View File

@ -33,16 +33,21 @@
#include <QStringList> #include <QStringList>
#include <QVariantHash> #include <QVariantHash>
#include <QSharedPointer>
class RssFeed; class RssFeed;
typedef QSharedPointer<RssFeed> RssFeedPtr;
class RssDownloadRule;
typedef QSharedPointer<RssDownloadRule> RssDownloadRulePtr;
class RssDownloadRule class RssDownloadRule
{ {
public: public:
explicit RssDownloadRule(); explicit RssDownloadRule();
static RssDownloadRule fromOldFormat(const QVariantHash& rule_hash, const QString &feed_url, const QString &rule_name); // Before v2.5.0 static RssDownloadRulePtr fromOldFormat(const QVariantHash& rule_hash, const QString &feed_url, const QString &rule_name); // Before v2.5.0
static RssDownloadRule fromNewFormat(const QVariantHash &rule_hash); static RssDownloadRulePtr fromNewFormat(const QVariantHash &rule_hash);
QVariantHash toVariantHash() const; QVariantHash toVariantHash() const;
bool matches(const QString &article_title) const; bool matches(const QString &article_title) const;
void setMustContain(const QString &tokens); void setMustContain(const QString &tokens);
@ -57,12 +62,11 @@ public:
inline void setLabel(const QString &_label) { m_label = _label; } inline void setLabel(const QString &_label) { m_label = _label; }
inline bool isEnabled() const { return m_enabled; } inline bool isEnabled() const { return m_enabled; }
inline void setEnabled(bool enable) { m_enabled = enable; } inline void setEnabled(bool enable) { m_enabled = enable; }
inline bool isValid() const { return !m_name.isEmpty(); }
inline QString mustContain() const { return m_mustContain.join(" "); } inline QString mustContain() const { return m_mustContain.join(" "); }
inline QString mustNotContain() const { return m_mustNotContain.join(" "); } inline QString mustNotContain() const { return m_mustNotContain.join(" "); }
inline bool useRegex() const { return m_useRegex; } inline bool useRegex() const { return m_useRegex; }
inline void setUseRegex(bool enabled) { m_useRegex = enabled; } inline void setUseRegex(bool enabled) { m_useRegex = enabled; }
QStringList findMatchingArticles(const RssFeed* feed) const; QStringList findMatchingArticles(const RssFeedPtr& feed) const;
// Operators // Operators
bool operator==(const RssDownloadRule &other); bool operator==(const RssDownloadRule &other);

60
src/rss/rssdownloadrulelist.cpp
View File

@ -51,19 +51,21 @@ RssDownloadRuleList* RssDownloadRuleList::instance()
void RssDownloadRuleList::drop() void RssDownloadRuleList::drop()
{ {
if(m_instance) if (m_instance) {
delete m_instance; delete m_instance;
m_instance = 0;
}
} }
RssDownloadRule RssDownloadRuleList::findMatchingRule(const QString &feed_url, const QString &article_title) const RssDownloadRulePtr RssDownloadRuleList::findMatchingRule(const QString &feed_url, const QString &article_title) const
{ {
Q_ASSERT(RssSettings().isRssDownloadingEnabled()); Q_ASSERT(RssSettings().isRssDownloadingEnabled());
const QStringList rule_names = m_feedRules.value(feed_url); QStringList rule_names = m_feedRules.value(feed_url);
foreach(const QString &rule_name, rule_names) { foreach(const QString &rule_name, rule_names) {
const RssDownloadRule &rule = m_rules[rule_name]; RssDownloadRulePtr rule = m_rules[rule_name];
if(rule.isEnabled() && rule.matches(article_title)) return rule; if(rule->isEnabled() && rule->matches(article_title)) return rule;
} }
return RssDownloadRule(); return RssDownloadRulePtr();
} }
void RssDownloadRuleList::saveRulesToStorage() void RssDownloadRuleList::saveRulesToStorage()
@ -97,11 +99,11 @@ void RssDownloadRuleList::importFeedsInOldFormat(const QHash<QString, QVariant>
void RssDownloadRuleList::importFeedRulesInOldFormat(const QString &feed_url, const QHash<QString, QVariant> &rules) void RssDownloadRuleList::importFeedRulesInOldFormat(const QString &feed_url, const QHash<QString, QVariant> &rules)
{ {
foreach(const QString &rule_name, rules.keys()) { foreach(const QString &rule_name, rules.keys()) {
RssDownloadRule rule = RssDownloadRule::fromOldFormat(rules.value(rule_name).toHash(), feed_url, rule_name); RssDownloadRulePtr rule = RssDownloadRule::fromOldFormat(rules.value(rule_name).toHash(), feed_url, rule_name);
if(!rule.isValid()) continue; if(!rule) continue;
// Check for rule name clash // Check for rule name clash
while(m_rules.contains(rule.name())) { while(m_rules.contains(rule->name())) {
rule.setName(rule.name()+"_"); rule->setName(rule->name()+"_");
} }
// Add the rule to the list // Add the rule to the list
saveRule(rule); saveRule(rule);
@ -111,8 +113,8 @@ void RssDownloadRuleList::importFeedRulesInOldFormat(const QString &feed_url, co
QVariantHash RssDownloadRuleList::toVariantHash() const QVariantHash RssDownloadRuleList::toVariantHash() const
{ {
QVariantHash ret; QVariantHash ret;
foreach(const RssDownloadRule &rule, m_rules.values()) { foreach(const RssDownloadRulePtr &rule, m_rules.values()) {
ret.insert(rule.name(), rule.toVariantHash()); ret.insert(rule->name(), rule->toVariantHash());
} }
return ret; return ret;
} }
@ -120,25 +122,25 @@ QVariantHash RssDownloadRuleList::toVariantHash() const
void RssDownloadRuleList::loadRulesFromVariantHash(const QVariantHash &h) void RssDownloadRuleList::loadRulesFromVariantHash(const QVariantHash &h)
{ {
foreach(const QVariant& v, h.values()) { foreach(const QVariant& v, h.values()) {
RssDownloadRule rule = RssDownloadRule::fromNewFormat(v.toHash()); RssDownloadRulePtr rule = RssDownloadRule::fromNewFormat(v.toHash());
if(!rule.name().isEmpty()) { if(rule && !rule->name().isEmpty()) {
saveRule(rule); saveRule(rule);
} }
} }
} }
void RssDownloadRuleList::saveRule(const RssDownloadRule &rule) void RssDownloadRuleList::saveRule(const RssDownloadRulePtr &rule)
{ {
qDebug() << Q_FUNC_INFO << rule.name(); qDebug() << Q_FUNC_INFO << rule->name();
Q_ASSERT(rule.isValid()); Q_ASSERT(rule);
if(m_rules.contains(rule.name())) { if(m_rules.contains(rule->name())) {
qDebug("This is an update, removing old rule first"); qDebug("This is an update, removing old rule first");
removeRule(rule.name()); removeRule(rule->name());
} }
m_rules.insert(rule.name(), rule); m_rules.insert(rule->name(), rule);
// Update feedRules hashtable // Update feedRules hashtable
foreach(const QString &feed_url, rule.rssFeeds()) { foreach(const QString &feed_url, rule->rssFeeds()) {
m_feedRules[feed_url].append(rule.name()); m_feedRules[feed_url].append(rule->name());
} }
// Save rules // Save rules
saveRulesToStorage(); saveRulesToStorage();
@ -149,10 +151,10 @@ void RssDownloadRuleList::removeRule(const QString &name)
{ {
qDebug() << Q_FUNC_INFO << name; qDebug() << Q_FUNC_INFO << name;
if(!m_rules.contains(name)) return; if(!m_rules.contains(name)) return;
const RssDownloadRule rule = m_rules.take(name); RssDownloadRulePtr rule = m_rules.take(name);
// Update feedRules hashtable // Update feedRules hashtable
foreach(const QString &feed_url, rule.rssFeeds()) { foreach(const QString &feed_url, rule->rssFeeds()) {
m_feedRules[feed_url].removeOne(rule.name()); m_feedRules[feed_url].removeOne(rule->name());
} }
// Save rules // Save rules
saveRulesToStorage(); saveRulesToStorage();
@ -161,18 +163,18 @@ void RssDownloadRuleList::removeRule(const QString &name)
void RssDownloadRuleList::renameRule(const QString &old_name, const QString &new_name) void RssDownloadRuleList::renameRule(const QString &old_name, const QString &new_name)
{ {
if(!m_rules.contains(old_name)) return; if(!m_rules.contains(old_name)) return;
RssDownloadRule rule = m_rules.take(old_name); RssDownloadRulePtr rule = m_rules.take(old_name);
rule.setName(new_name); rule->setName(new_name);
m_rules.insert(new_name, rule); m_rules.insert(new_name, rule);
// Update feedRules hashtable // Update feedRules hashtable
foreach(const QString &feed_url, rule.rssFeeds()) { foreach(const QString &feed_url, rule->rssFeeds()) {
m_feedRules[feed_url].replace(m_feedRules[feed_url].indexOf(old_name), new_name); m_feedRules[feed_url].replace(m_feedRules[feed_url].indexOf(old_name), new_name);
} }
// Save rules // Save rules
saveRulesToStorage(); saveRulesToStorage();
} }
const RssDownloadRule RssDownloadRuleList::getRule(const QString &name) const RssDownloadRulePtr RssDownloadRuleList::getRule(const QString &name) const
{ {
return m_rules.value(name); return m_rules.value(name);
} }

8
src/rss/rssdownloadrulelist.h
View File

@ -49,12 +49,12 @@ private:
public: public:
static RssDownloadRuleList* instance(); static RssDownloadRuleList* instance();
static void drop(); static void drop();
RssDownloadRule findMatchingRule(const QString &feed_url, const QString &article_title) const; RssDownloadRulePtr findMatchingRule(const QString &feed_url, const QString &article_title) const;
// Operators // Operators
void saveRule(const RssDownloadRule &rule); void saveRule(const RssDownloadRulePtr &rule);
void removeRule(const QString &name); void removeRule(const QString &name);
void renameRule(const QString &old_name, const QString &new_name); void renameRule(const QString &old_name, const QString &new_name);
const RssDownloadRule getRule(const QString &name) const; RssDownloadRulePtr getRule(const QString &name) const;
inline QStringList ruleNames() const { return m_rules.keys(); } inline QStringList ruleNames() const { return m_rules.keys(); }
inline bool isEmpty() const { return m_rules.isEmpty(); } inline bool isEmpty() const { return m_rules.isEmpty(); }
bool serialize(const QString& path); bool serialize(const QString& path);
@ -69,7 +69,7 @@ private:
void saveRulesToStorage(); void saveRulesToStorage();
private: private:
QHash<QString, RssDownloadRule> m_rules; QHash<QString, RssDownloadRulePtr> m_rules;
QHash<QString, QStringList> m_feedRules; QHash<QString, QStringList> m_feedRules;
}; };

39
src/rss/rssfeed.cpp
View File

@ -39,16 +39,17 @@
#include "rssdownloadrulelist.h" #include "rssdownloadrulelist.h"
#include "downloadthread.h" #include "downloadthread.h"
RssFeed::RssFeed(RssFolder* parent, const QString &url): m_parent(parent), m_icon(":/Icons/oxygen/application-rss+xml.png"), RssFeed::RssFeed(RssManager* manager, RssFolder* parent, const QString &url):
m_manager(manager), m_parent(parent), m_icon(":/Icons/oxygen/application-rss+xml.png"),
m_refreshed(false), m_downloadFailure(false), m_loading(false) { m_refreshed(false), m_downloadFailure(false), m_loading(false) {
qDebug() << Q_FUNC_INFO << url; qDebug() << Q_FUNC_INFO << url;
m_url = QUrl::fromEncoded(url.toUtf8()).toString(); m_url = QUrl::fromEncoded(url.toUtf8()).toString();
// Listen for new RSS downloads // Listen for new RSS downloads
connect(RssManager::instance()->rssDownloader(), SIGNAL(downloadFinished(QString,QString)), SLOT(handleFinishedDownload(QString,QString))); connect(manager->rssDownloader(), SIGNAL(downloadFinished(QString,QString)), SLOT(handleFinishedDownload(QString,QString)));
connect(RssManager::instance()->rssDownloader(), SIGNAL(downloadFailure(QString,QString)), SLOT(handleDownloadFailure(QString,QString))); connect(manager->rssDownloader(), SIGNAL(downloadFailure(QString,QString)), SLOT(handleDownloadFailure(QString,QString)));
// Download the RSS Feed icon // Download the RSS Feed icon
m_iconUrl = iconUrl(); m_iconUrl = iconUrl();
RssManager::instance()->rssDownloader()->downloadUrl(m_iconUrl); manager->rssDownloader()->downloadUrl(m_iconUrl);
// Load old RSS articles // Load old RSS articles
loadItemsFromDisk(); loadItemsFromDisk();
@ -90,10 +91,6 @@ void RssFeed::loadItemsFromDisk() {
} }
} }
IRssFile::FileType RssFeed::type() const {
return IRssFile::FEED;
}
void RssFeed::refresh() { void RssFeed::refresh() {
if(m_loading) { if(m_loading) {
qWarning() << Q_FUNC_INFO << "Feed" << this->displayName() << "is already being refreshed, ignoring request"; qWarning() << Q_FUNC_INFO << "Feed" << this->displayName() << "is already being refreshed, ignoring request";
@ -101,7 +98,7 @@ void RssFeed::refresh() {
} }
m_loading = true; m_loading = true;
// Download the RSS again // Download the RSS again
RssManager::instance()->rssDownloader()->downloadUrl(m_url); m_manager->rssDownloader()->downloadUrl(m_url);
} }
void RssFeed::removeAllSettings() { void RssFeed::removeAllSettings() {
@ -189,7 +186,7 @@ void RssFeed::markAsRead() {
for (RssArticleHash::ConstIterator it=m_articles.begin(); it != m_articles.end(); it++) { for (RssArticleHash::ConstIterator it=m_articles.begin(); it != m_articles.end(); it++) {
it.value()->markAsRead(); it.value()->markAsRead();
} }
RssManager::instance()->forwardFeedInfosChanged(m_url, displayName(), 0); m_manager->forwardFeedInfosChanged(m_url, displayName(), 0);
} }
uint RssFeed::unreadCount() const{ uint RssFeed::unreadCount() const{
@ -201,12 +198,12 @@ uint RssFeed::unreadCount() const{
return nbUnread; return nbUnread;
} }
const QList<RssArticlePtr> RssFeed::articleList() const{ const RssArticleList RssFeed::articleList() const{
return m_articles.values(); return m_articles.values();
} }
const QList<RssArticlePtr> RssFeed::unreadArticleList() const { const RssArticleList RssFeed::unreadArticleList() const {
QList<RssArticlePtr> unread_news; RssArticleList unread_news;
for (RssArticleHash::ConstIterator it = m_articles.begin(); it != m_articles.end(); it++) { for (RssArticleHash::ConstIterator it = m_articles.begin(); it != m_articles.end(); it++) {
if(!it.value()->isRead()) if(!it.value()->isRead())
unread_news << it.value(); unread_news << it.value();
@ -270,7 +267,7 @@ bool RssFeed::parseRSS(QIODevice* device) {
QString icon_path = xml.attributes().value("url").toString(); QString icon_path = xml.attributes().value("url").toString();
if(!icon_path.isEmpty()) { if(!icon_path.isEmpty()) {
m_iconUrl = icon_path; m_iconUrl = icon_path;
RssManager::instance()->rssDownloader()->downloadUrl(m_iconUrl); m_manager->rssDownloader()->downloadUrl(m_iconUrl);
} }
} }
else if(xml.name() == "item") { else if(xml.name() == "item") {
@ -305,13 +302,13 @@ void RssFeed::downloadMatchingArticleTorrents() {
else else
torrent_url = item->link(); torrent_url = item->link();
// Check if the item should be automatically downloaded // Check if the item should be automatically downloaded
const RssDownloadRule matching_rule = RssDownloadRuleList::instance()->findMatchingRule(m_url, item->title()); RssDownloadRulePtr matching_rule = RssDownloadRuleList::instance()->findMatchingRule(m_url, item->title());
if(matching_rule.isValid()) { if(matching_rule) {
// Item was downloaded, consider it as Read // Item was downloaded, consider it as Read
item->markAsRead(); item->markAsRead();
// Download the torrent // Download the torrent
QBtSession::instance()->addConsoleMessage(tr("Automatically downloading %1 torrent from %2 RSS feed...").arg(item->title()).arg(displayName())); QBtSession::instance()->addConsoleMessage(tr("Automatically downloading %1 torrent from %2 RSS feed...").arg(item->title()).arg(displayName()));
QBtSession::instance()->downloadUrlAndSkipDialog(torrent_url, matching_rule.savePath(), matching_rule.label()); QBtSession::instance()->downloadUrlAndSkipDialog(torrent_url, matching_rule->savePath(), matching_rule->label());
} }
} }
} }
@ -320,7 +317,7 @@ void RssFeed::resizeList() {
const uint max_articles = RssSettings().getRSSMaxArticlesPerFeed(); const uint max_articles = RssSettings().getRSSMaxArticlesPerFeed();
const uint nb_articles = m_articles.size(); const uint nb_articles = m_articles.size();
if(nb_articles > max_articles) { if(nb_articles > max_articles) {
QList<RssArticlePtr> listItems = m_articles.values(); RssArticleList listItems = m_articles.values();
RssManager::sortNewsList(listItems); RssManager::sortNewsList(listItems);
const int excess = nb_articles - max_articles; const int excess = nb_articles - max_articles;
for(uint i=nb_articles-excess; i<nb_articles; ++i){ for(uint i=nb_articles-excess; i<nb_articles; ++i){
@ -358,14 +355,14 @@ void RssFeed::handleFinishedDownload(const QString& url, const QString &file_pat
// Parse the download RSS // Parse the download RSS
if(parseXmlFile(file_path)) { if(parseXmlFile(file_path)) {
m_refreshed = true; m_refreshed = true;
RssManager::instance()->forwardFeedInfosChanged(m_url, displayName(), unreadCount()); // XXX: Ugly m_manager->forwardFeedInfosChanged(m_url, displayName(), unreadCount()); // XXX: Ugly
qDebug() << Q_FUNC_INFO << "Feed parsed successfuly"; qDebug() << Q_FUNC_INFO << "Feed parsed successfuly";
} }
} }
else if(url == m_iconUrl) { else if(url == m_iconUrl) {
m_icon = file_path; m_icon = file_path;
qDebug() << Q_FUNC_INFO << "icon path:" << m_icon; qDebug() << Q_FUNC_INFO << "icon path:" << m_icon;
RssManager::instance()->forwardFeedIconChanged(m_url, m_icon); // XXX: Ugly m_manager->forwardFeedIconChanged(m_url, m_icon); // XXX: Ugly
} }
} }
@ -373,7 +370,7 @@ void RssFeed::handleDownloadFailure(const QString &url, const QString& error) {
if(url != m_url) return; if(url != m_url) return;
m_downloadFailure = true; m_downloadFailure = true;
m_loading = false; m_loading = false;
RssManager::instance()->forwardFeedInfosChanged(m_url, displayName(), unreadCount()); // XXX: Ugly m_manager->forwardFeedInfosChanged(m_url, displayName(), unreadCount()); // XXX: Ugly
qWarning() << "Failed to download RSS feed at" << url; qWarning() << "Failed to download RSS feed at" << url;
qWarning() << "Reason:" << error; qWarning() << "Reason:" << error;
} }

14
src/rss/rssfeed.h
View File

@ -32,22 +32,25 @@
#define RSSFEED_H #define RSSFEED_H
#include <QHash> #include <QHash>
#include <QSharedPointer>
#include "rssfile.h" #include "rssfile.h"
class RssFeed;
class RssManager; class RssManager;
typedef QHash<QString, RssArticlePtr> RssArticleHash; typedef QHash<QString, RssArticlePtr> RssArticleHash;
typedef QSharedPointer<RssFeed> RssFeedPtr;
typedef QList<RssFeedPtr> RssFeedList;
class RssFeed: public QObject, public IRssFile { class RssFeed: public QObject, public RssFile {
Q_OBJECT Q_OBJECT
public: public:
RssFeed(RssFolder* m_parent, const QString &url); RssFeed(RssManager* manager, RssFolder* m_parent, const QString &url);
virtual ~RssFeed(); virtual ~RssFeed();
inline RssFolder* parent() const { return m_parent; } inline RssFolder* parent() const { return m_parent; }
void setParent(RssFolder* parent) { m_parent = parent; } void setParent(RssFolder* parent) { m_parent = parent; }
FileType type() const;
void refresh(); void refresh();
QString id() const { return m_url; } QString id() const { return m_url; }
void removeAllSettings(); void removeAllSettings();
@ -65,9 +68,9 @@ public:
uint count() const; uint count() const;
void markAsRead(); void markAsRead();
uint unreadCount() const; uint unreadCount() const;
const QList<RssArticlePtr> articleList() const; const RssArticleList articleList() const;
const RssArticleHash& articleHash() const { return m_articles; } const RssArticleHash& articleHash() const { return m_articles; }
const QList<RssArticlePtr> unreadArticleList() const; const RssArticleList unreadArticleList() const;
private slots: private slots:
void handleFinishedDownload(const QString& url, const QString &file_path); void handleFinishedDownload(const QString& url, const QString &file_path);
@ -83,6 +86,7 @@ private:
void loadItemsFromDisk(); void loadItemsFromDisk();
private: private:
RssManager* m_manager;
RssArticleHash m_articles; RssArticleHash m_articles;
RssFolder *m_parent; RssFolder *m_parent;
QString m_title; QString m_title;

2
src/rss/rssfile.cpp
View File

@ -31,7 +31,7 @@
#include "rssfile.h" #include "rssfile.h"
#include "rssfolder.h" #include "rssfolder.h"
QStringList IRssFile::pathHierarchy() const { QStringList RssFile::pathHierarchy() const {
QStringList path; QStringList path;
if(parent()) if(parent())
path << parent()->pathHierarchy(); path << parent()->pathHierarchy();

22
src/rss/rssfile.h
View File

@ -33,19 +33,25 @@
#include <QList> #include <QList>
#include <QStringList> #include <QStringList>
#include "rssarticle.h" #include <QSharedPointer>
class RssFolder; class RssFolder;
class RssFile;
class RssArticle;
class IRssFile { typedef QSharedPointer<RssFile> RssFilePtr;
typedef QSharedPointer<RssArticle> RssArticlePtr;
typedef QList<RssArticlePtr> RssArticleList;
typedef QList<RssFilePtr> RssFileList;
/**
* Parent interface for RssFolder and RssFeed.
*/
class RssFile {
public: public:
enum FileType {FEED, FOLDER}; virtual ~RssFile() {}
virtual ~IRssFile() {}
virtual uint unreadCount() const = 0; virtual uint unreadCount() const = 0;
virtual FileType type() const = 0;
virtual QString displayName() const = 0; virtual QString displayName() const = 0;
virtual QString id() const = 0; virtual QString id() const = 0;
virtual void rename(const QString &new_name) = 0; virtual void rename(const QString &new_name) = 0;
@ -54,8 +60,8 @@ public:
virtual void setParent(RssFolder* parent) = 0; virtual void setParent(RssFolder* parent) = 0;
virtual void refresh() = 0; virtual void refresh() = 0;
virtual void removeAllSettings() = 0; virtual void removeAllSettings() = 0;
virtual const QList<RssArticlePtr> articleList() const = 0; virtual const RssArticleList articleList() const = 0;
virtual const QList<RssArticlePtr> unreadArticleList() const = 0; virtual const RssArticleList unreadArticleList() const = 0;
QStringList pathHierarchy() const; QStringList pathHierarchy() const;
}; };

86
src/rss/rssfolder.cpp
View File

@ -40,8 +40,6 @@ RssFolder::RssFolder(RssFolder *parent, const QString &name): m_parent(parent),
} }
RssFolder::~RssFolder() { RssFolder::~RssFolder() {
qDebug("Deleting a RSS folder, removing elements");
qDeleteAll(m_children.values());
} }
unsigned int RssFolder::unreadCount() const { unsigned int RssFolder::unreadCount() const {
@ -52,31 +50,26 @@ unsigned int RssFolder::unreadCount() const {
return nb_unread; return nb_unread;
} }
IRssFile::FileType RssFolder::type() const {
return IRssFile::FOLDER;
}
void RssFolder::removeChild(const QString &childId) { void RssFolder::removeChild(const QString &childId) {
if (m_children.contains(childId)) { if (m_children.contains(childId)) {
IRssFile* child = m_children.take(childId); RssFilePtr child = m_children.take(childId);
child->removeAllSettings(); child->removeAllSettings();
delete child;
} }
} }
RssFolder* RssFolder::addFolder(const QString &name) { RssFolderPtr RssFolder::addFolder(const QString &name) {
RssFolder *subfolder; RssFolderPtr subfolder;
if (!m_children.contains(name)) { if (!m_children.contains(name)) {
subfolder = new RssFolder(this, name); subfolder = RssFolderPtr(new RssFolder(this, name));
m_children[name] = subfolder; m_children[name] = subfolder;
} else { } else {
subfolder = dynamic_cast<RssFolder*>(m_children.value(name)); subfolder = qSharedPointerDynamicCast<RssFolder>(m_children.value(name));
} }
return subfolder; return subfolder;
} }
RssFeed* RssFolder::addStream(const QString &url) { RssFeedPtr RssFolder::addStream(RssManager* manager, const QString &url) {
RssFeed* stream = new RssFeed(this, url); RssFeedPtr stream(new RssFeed(manager, this, url));
Q_ASSERT(!m_children.contains(stream->url())); Q_ASSERT(!m_children.contains(stream->url()));
m_children[stream->url()] = stream; m_children[stream->url()] = stream;
stream->refresh(); stream->refresh();
@ -90,33 +83,33 @@ void RssFolder::refresh() {
} }
} }
const QList<RssArticlePtr> RssFolder::articleList() const { const RssArticleList RssFolder::articleList() const {
QList<RssArticlePtr> news; RssArticleList news;
for (RssFileHash::ConstIterator it = m_children.begin(); it != m_children.end(); it++) { for (RssFileHash::ConstIterator it = m_children.begin(); it != m_children.end(); it++) {
news << it.value()->articleList(); news << it.value()->articleList();
} }
return news; return news;
} }
const QList<RssArticlePtr> RssFolder::unreadArticleList() const { const RssArticleList RssFolder::unreadArticleList() const {
QList<RssArticlePtr> unread_news; RssArticleList unread_news;
for (RssFileHash::ConstIterator it = m_children.begin(); it != m_children.end(); it++) { for (RssFileHash::ConstIterator it = m_children.begin(); it != m_children.end(); it++) {
unread_news << it.value()->unreadArticleList(); unread_news << it.value()->unreadArticleList();
} }
return unread_news; return unread_news;
} }
QList<IRssFile*> RssFolder::getContent() const { RssFileList RssFolder::getContent() const {
return m_children.values(); return m_children.values();
} }
unsigned int RssFolder::getNbFeeds() const { unsigned int RssFolder::getNbFeeds() const {
uint nbFeeds = 0; uint nbFeeds = 0;
for (RssFileHash::ConstIterator it = m_children.begin(); it != m_children.end(); it++) { for (RssFileHash::ConstIterator it = m_children.begin(); it != m_children.end(); it++) {
if (it.value()->type() == IRssFile::FOLDER) if (RssFolderPtr folder = qSharedPointerDynamicCast<RssFolder>(it.value()))
nbFeeds += ((RssFolder*)*it)->getNbFeeds(); nbFeeds += folder->getNbFeeds();
else else
nbFeeds += 1; ++nbFeeds; // Feed
} }
return nbFeeds; return nbFeeds;
} }
@ -142,51 +135,46 @@ void RssFolder::markAsRead() {
} }
} }
QList<RssFeed*> RssFolder::getAllFeeds() const { RssFeedList RssFolder::getAllFeeds() const {
QList<RssFeed*> streams; RssFeedList streams;
for (RssFileHash::ConstIterator it = m_children.begin(); it != m_children.end(); it++) { for (RssFileHash::ConstIterator it = m_children.begin(); it != m_children.end(); it++) {
if (it.value()->type() == IRssFile::FEED) { if (RssFeedPtr feed = qSharedPointerDynamicCast<RssFeed>(it.value())) {
streams << static_cast<RssFeed*>(it.value()); streams << feed;
} else { } else if (RssFolderPtr folder = qSharedPointerDynamicCast<RssFolder>(it.value())) {
streams << static_cast<RssFolder*>(it.value())->getAllFeeds(); streams << folder->getAllFeeds();
} }
} }
return streams; return streams;
} }
QHash<QString, RssFeed*> RssFolder::getAllFeedsAsHash() const { QHash<QString, RssFeedPtr> RssFolder::getAllFeedsAsHash() const {
QHash<QString, RssFeed*> ret; QHash<QString, RssFeedPtr> ret;
for (RssFileHash::ConstIterator it = m_children.begin(); it != m_children.end(); it++) { for (RssFileHash::ConstIterator it = m_children.begin(); it != m_children.end(); it++) {
if (it.value()->type() == IRssFile::FEED) { if (RssFeedPtr feed = qSharedPointerDynamicCast<RssFeed>(it.value())) {
RssFeed* feed = dynamic_cast<RssFeed*>(it.value());
Q_ASSERT(feed);
qDebug() << Q_FUNC_INFO << feed->url(); qDebug() << Q_FUNC_INFO << feed->url();
ret[feed->url()] = feed; ret[feed->url()] = feed;
} else { } else if (RssFolderPtr folder = qSharedPointerDynamicCast<RssFolder>(it.value())) {
ret.unite(static_cast<RssFolder*>(it.value())->getAllFeedsAsHash()); ret.unite(folder->getAllFeedsAsHash());
} }
} }
return ret; return ret;
} }
void RssFolder::addFile(IRssFile * item) { void RssFolder::addFile(const RssFilePtr& item) {
if (item->type() == IRssFile::FEED) { if (RssFeedPtr feed = qSharedPointerDynamicCast<RssFeed>(item)) {
RssFeed* feedItem = dynamic_cast<RssFeed*>(item); Q_ASSERT(!m_children.contains(feed->url()));
Q_ASSERT(!m_children.contains(feedItem->url())); m_children[feed->url()] = item;
m_children[feedItem->url()] = item; qDebug("Added feed %s to folder ./%s", qPrintable(feed->url()), qPrintable(m_name));
qDebug("Added feed %s to folder ./%s", qPrintable(feedItem->url()), qPrintable(m_name)); } else if (RssFolderPtr folder = qSharedPointerDynamicCast<RssFolder>(item)) {
} else { Q_ASSERT(!m_children.contains(folder->displayName()));
RssFolder* folderItem = dynamic_cast<RssFolder*>(item); m_children[folder->displayName()] = item;
Q_ASSERT(!m_children.contains(folderItem->displayName())); qDebug("Added folder %s to folder ./%s", qPrintable(folder->displayName()), qPrintable(m_name));
m_children[folderItem->displayName()] = item;
qDebug("Added folder %s to folder ./%s", qPrintable(folderItem->displayName()), qPrintable(m_name));
} }
// Update parent // Update parent
item->setParent(this); item->setParent(this);
} }
void RssFolder::removeAllItems() { void RssFolder::removeAllItems() {
qDeleteAll(m_children.values());
m_children.clear(); m_children.clear();
} }
@ -207,11 +195,11 @@ bool RssFolder::hasChild(const QString &childId) {
void RssFolder::renameChildFolder(const QString &old_name, const QString &new_name) void RssFolder::renameChildFolder(const QString &old_name, const QString &new_name)
{ {
Q_ASSERT(m_children.contains(old_name)); Q_ASSERT(m_children.contains(old_name));
IRssFile *folder = m_children.take(old_name); RssFilePtr folder = m_children.take(old_name);
m_children[new_name] = folder; m_children[new_name] = folder;
} }
IRssFile * RssFolder::takeChild(const QString &childId) RssFilePtr RssFolder::takeChild(const QString &childId)
{ {
return m_children.take(childId); return m_children.take(childId);
} }

31
src/rss/rssfolder.h
View File

@ -32,15 +32,19 @@
#define RSSFOLDER_H #define RSSFOLDER_H
#include <QHash> #include <QHash>
#include <QSharedPointer>
#include "rssfile.h" #include "rssfile.h"
class RssArticle; class RssFolder;
class RssFeed; class RssFeed;
class RssManager;
typedef QHash<QString, IRssFile*> RssFileHash; typedef QHash<QString, RssFilePtr> RssFileHash;
typedef QSharedPointer<RssFeed> RssFeedPtr;
typedef QSharedPointer<RssFolder> RssFolderPtr;
typedef QList<RssFeedPtr> RssFeedList;
class RssFolder: public QObject, public IRssFile { class RssFolder: public QObject, public RssFile {
Q_OBJECT Q_OBJECT
public: public:
@ -49,26 +53,25 @@ public:
inline RssFolder* parent() const { return m_parent; } inline RssFolder* parent() const { return m_parent; }
void setParent(RssFolder* parent) { m_parent = parent; } void setParent(RssFolder* parent) { m_parent = parent; }
unsigned int unreadCount() const; unsigned int unreadCount() const;
FileType type() const; RssFeedPtr addStream(RssManager* manager, const QString &url);
RssFeed* addStream(const QString &url); RssFolderPtr addFolder(const QString &name);
RssFolder* addFolder(const QString &name);
unsigned int getNbFeeds() const; unsigned int getNbFeeds() const;
QList<IRssFile*> getContent() const; RssFileList getContent() const;
QList<RssFeed*> getAllFeeds() const; RssFeedList getAllFeeds() const;
QHash<QString, RssFeed*> getAllFeedsAsHash() const; QHash<QString, RssFeedPtr> getAllFeedsAsHash() const;
QString displayName() const; QString displayName() const;
QString id() const; QString id() const;
bool hasChild(const QString &childId); bool hasChild(const QString &childId);
const QList<RssArticlePtr> articleList() const; const RssArticleList articleList() const;
const QList<RssArticlePtr> unreadArticleList() const; const RssArticleList unreadArticleList() const;
void removeAllSettings(); void removeAllSettings();
void removeAllItems(); void removeAllItems();
void renameChildFolder(const QString &old_name, const QString &new_name); void renameChildFolder(const QString &old_name, const QString &new_name);
IRssFile *takeChild(const QString &childId); RssFilePtr takeChild(const QString &childId);
public slots: public slots:
void refresh(); void refresh();
void addFile(IRssFile * item); void addFile(const RssFilePtr& item);
void removeChild(const QString &childId); void removeChild(const QString &childId);
void rename(const QString &new_name); void rename(const QString &new_name);
void markAsRead(); void markAsRead();

31
src/rss/rssmanager.cpp
View File

@ -37,8 +37,6 @@
#include "rssdownloadrulelist.h" #include "rssdownloadrulelist.h"
#include "downloadthread.h" #include "downloadthread.h"
RssManager* RssManager::m_instance = 0;
RssManager::RssManager(): m_rssDownloader(new DownloadThread(this)) { RssManager::RssManager(): m_rssDownloader(new DownloadThread(this)) {
connect(&m_refreshTimer, SIGNAL(timeout()), this, SLOT(refresh())); connect(&m_refreshTimer, SIGNAL(timeout()), this, SLOT(refresh()));
m_refreshInterval = RssSettings().getRSSRefreshInterval(); m_refreshInterval = RssSettings().getRSSRefreshInterval();
@ -78,14 +76,14 @@ void RssManager::loadStreamList() {
const QString feed_url = path.takeLast(); const QString feed_url = path.takeLast();
qDebug() << "Feed URL:" << feed_url; qDebug() << "Feed URL:" << feed_url;
// Create feed path (if it does not exists) // Create feed path (if it does not exists)
RssFolder * feed_parent = this; RssFolder* feed_parent = this;
foreach(const QString &folder_name, path) { foreach(const QString &folder_name, path) {
qDebug() << "Adding parent folder:" << folder_name; qDebug() << "Adding parent folder:" << folder_name;
feed_parent = feed_parent->addFolder(folder_name); feed_parent = feed_parent->addFolder(folder_name).data();
} }
// Create feed // Create feed
qDebug() << "Adding feed to parent folder"; qDebug() << "Adding feed to parent folder";
RssFeed *stream = feed_parent->addStream(feed_url); RssFeedPtr stream = feed_parent->addStream(this, feed_url);
const QString alias = aliases.at(i); const QString alias = aliases.at(i);
if(!alias.isEmpty()) { if(!alias.isEmpty()) {
stream->rename(alias); stream->rename(alias);
@ -103,7 +101,7 @@ void RssManager::forwardFeedIconChanged(const QString &url, const QString &icon_
emit feedIconChanged(url, icon_path); emit feedIconChanged(url, icon_path);
} }
void RssManager::moveFile(IRssFile* file, RssFolder* dest_folder) { void RssManager::moveFile(const RssFilePtr& file, const RssFolderPtr& dest_folder) {
RssFolder* src_folder = file->parent(); RssFolder* src_folder = file->parent();
if(dest_folder != src_folder) { if(dest_folder != src_folder) {
// Remove reference in old folder // Remove reference in old folder
@ -118,8 +116,8 @@ void RssManager::moveFile(IRssFile* file, RssFolder* dest_folder) {
void RssManager::saveStreamList() const { void RssManager::saveStreamList() const {
QStringList streamsUrl; QStringList streamsUrl;
QStringList aliases; QStringList aliases;
const QList<RssFeed*> streams = getAllFeeds(); QList<RssFeedPtr> streams = getAllFeeds();
foreach(const RssFeed *stream, streams) { foreach(const RssFeedPtr& stream, streams) {
QString stream_path = stream->pathHierarchy().join("\\"); QString stream_path = stream->pathHierarchy().join("\\");
if(stream_path.isNull()) { if(stream_path.isNull()) {
stream_path = ""; stream_path = "";
@ -138,21 +136,6 @@ static bool laterItemDate(const RssArticlePtr& a, const RssArticlePtr& b)
return (a->date() > b->date()); return (a->date() > b->date());
} }
void RssManager::sortNewsList(QList<RssArticlePtr>& news_list) { void RssManager::sortNewsList(RssArticleList& news_list) {
qSort(news_list.begin(), news_list.end(), laterItemDate); qSort(news_list.begin(), news_list.end(), laterItemDate);
} }
RssManager * RssManager::instance()
{
if(!m_instance)
m_instance = new RssManager;
return m_instance;
}
void RssManager::drop()
{
if(m_instance) {
delete m_instance;
m_instance = 0;
}
}

17
src/rss/rssmanager.h
View File

@ -32,31 +32,32 @@
#define RSSMANAGER_H #define RSSMANAGER_H
#include <QTimer> #include <QTimer>
#include <QSharedPointer>
#include "rssfolder.h" #include "rssfolder.h"
class DownloadThread; class DownloadThread;
class RssManager;
typedef QSharedPointer<RssManager> RssManagerPtr;
class RssManager: public RssFolder { class RssManager: public RssFolder {
Q_OBJECT Q_OBJECT
private:
explicit RssManager();
static RssManager* m_instance;
public: public:
static RssManager* instance(); RssManager();
static void drop();
virtual ~RssManager(); virtual ~RssManager();
inline DownloadThread* rssDownloader() const { return m_rssDownloader; } inline DownloadThread* rssDownloader() const { return m_rssDownloader; }
static void insertSortElem(QList<RssArticlePtr> &list, const RssArticlePtr &item); static void insertSortElem(RssArticleList &list, const RssArticlePtr &item);
static void sortNewsList(QList<RssArticlePtr>& news_list); static void sortNewsList(RssArticleList& news_list);
public slots: public slots:
void loadStreamList(); void loadStreamList();
void saveStreamList() const; void saveStreamList() const;
void forwardFeedInfosChanged(const QString &url, const QString &aliasOrUrl, uint nbUnread); void forwardFeedInfosChanged(const QString &url, const QString &aliasOrUrl, uint nbUnread);
void forwardFeedIconChanged(const QString &url, const QString &icon_path); void forwardFeedIconChanged(const QString &url, const QString &icon_path);
void moveFile(IRssFile* file, RssFolder* dest_folder); void moveFile(const RssFilePtr& file, const RssFolderPtr& dest_folder);
void updateRefreshInterval(uint val); void updateRefreshInterval(uint val);
signals: signals: