mirror of
https://github.com/RetroShare/RetroShare.git
synced 2024-12-26 07:59:35 -05:00
608 lines
21 KiB
C++
608 lines
21 KiB
C++
/*******************************************************************************
|
|
* plugins/FeedReader/gui/AddFeedDialog.cpp *
|
|
* *
|
|
* Copyright (C) 2012 by Thunder *
|
|
* *
|
|
* This program is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU Affero General Public License as *
|
|
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Affero General Public License *
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
|
|
* *
|
|
*******************************************************************************/
|
|
|
|
#include <QMessageBox>
|
|
#include <QDateTime>
|
|
#include <QPushButton>
|
|
|
|
#include "AddFeedDialog.h"
|
|
#include "ui_AddFeedDialog.h"
|
|
#include "PreviewFeedDialog.h"
|
|
#include "FeedReaderStringDefs.h"
|
|
#include "gui/settings/rsharesettings.h"
|
|
#include "gui/common/UIStateHelper.h"
|
|
|
|
#include <retroshare/rsgxsforums.h>
|
|
#include <retroshare/rsposted.h>
|
|
#include <iostream>
|
|
|
|
#define TOKEN_TYPE_FORUM_GROUPS 1
|
|
#define TOKEN_TYPE_POSTED_GROUPS 2
|
|
|
|
AddFeedDialog::AddFeedDialog(RsFeedReader *feedReader, FeedReaderNotify *notify, QWidget *parent)
|
|
: QDialog(parent, Qt::Window), mFeedReader(feedReader), mNotify(notify), ui(new Ui::AddFeedDialog)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
/* Setup UI helper */
|
|
mStateHelper = new UIStateHelper(this);
|
|
|
|
mFeedId = 0;
|
|
mParentId = 0;
|
|
|
|
mStateHelper->addWidget(TOKEN_TYPE_FORUM_GROUPS, ui->forumComboBox, UISTATE_LOADING_DISABLED);
|
|
mStateHelper->addWidget(TOKEN_TYPE_FORUM_GROUPS, ui->buttonBox->button(QDialogButtonBox::Ok), UISTATE_LOADING_DISABLED);
|
|
mStateHelper->addWidget(TOKEN_TYPE_POSTED_GROUPS, ui->postedComboBox, UISTATE_LOADING_DISABLED);
|
|
mStateHelper->addWidget(TOKEN_TYPE_POSTED_GROUPS, ui->buttonBox->button(QDialogButtonBox::Ok), UISTATE_LOADING_DISABLED);
|
|
|
|
/* Setup TokenQueue */
|
|
mForumTokenQueue = new TokenQueue(rsGxsForums->getTokenService(), this);
|
|
mPostedTokenQueue = new TokenQueue(rsPosted->getTokenService(), this);
|
|
|
|
/* Connect signals */
|
|
connect(ui->buttonBox->button(QDialogButtonBox::Ok), SIGNAL(clicked()), this, SLOT(createFeed()));
|
|
connect(ui->buttonBox->button(QDialogButtonBox::Cancel), SIGNAL(clicked()), this, SLOT(reject()));
|
|
|
|
connect(ui->useAuthenticationCheckBox, SIGNAL(toggled(bool)), this, SLOT(authenticationToggled()));
|
|
connect(ui->useStandardStorageTimeCheckBox, SIGNAL(toggled(bool)), this, SLOT(useStandardStorageTimeToggled()));
|
|
connect(ui->useStandardUpdateInterval, SIGNAL(toggled(bool)), this, SLOT(useStandardUpdateIntervalToggled()));
|
|
connect(ui->useStandardProxyCheckBox, SIGNAL(toggled(bool)), this, SLOT(useStandardProxyToggled()));
|
|
connect(ui->typeForumCheckBox, SIGNAL(toggled(bool)), this, SLOT(typeForumToggled()));
|
|
connect(ui->typePostedCheckBox, SIGNAL(toggled(bool)), this, SLOT(typePostedToggled()));
|
|
connect(ui->typeLocalCheckBox, SIGNAL(toggled(bool)), this, SLOT(typeLocalToggled()));
|
|
connect(ui->postedFirstImageCheckBox, SIGNAL(toggled(bool)), this, SLOT(postedFirstImageToggled()));
|
|
connect(ui->previewButton, SIGNAL(clicked()), this, SLOT(preview()));
|
|
|
|
/* currently only for local feeds */
|
|
connect(ui->saveCompletePageCheckBox, SIGNAL(toggled(bool)), this, SLOT(denyForumAndPostedToggled()));
|
|
|
|
connect(ui->urlLineEdit, SIGNAL(textChanged(QString)), this, SLOT(validate()));
|
|
connect(ui->nameLineEdit, SIGNAL(textChanged(QString)), this, SLOT(validate()));
|
|
connect(ui->useInfoFromFeedCheckBox, SIGNAL(toggled(bool)), this, SLOT(validate()));
|
|
connect(ui->typeLocalCheckBox, SIGNAL(toggled(bool)), this, SLOT(validate()));
|
|
connect(ui->typeForumCheckBox, SIGNAL(toggled(bool)), this, SLOT(validate()));
|
|
connect(ui->forumComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(validate()));
|
|
connect(ui->typePostedCheckBox, SIGNAL(toggled(bool)), this, SLOT(validate()));
|
|
connect(ui->postedComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(validate()));
|
|
|
|
connect(ui->clearCachePushButton, SIGNAL(clicked()), this, SLOT(clearMessageCache()));
|
|
|
|
ui->headerFrame->setHeaderText(tr("Feed Details"));
|
|
ui->headerFrame->setHeaderImage(QPixmap(":/images/FeedReader.png"));
|
|
|
|
ui->activatedCheckBox->setChecked(true);
|
|
mStateHelper->setWidgetEnabled(ui->forumComboBox, false);
|
|
mStateHelper->setWidgetEnabled(ui->postedComboBox, false);
|
|
ui->useInfoFromFeedCheckBox->setChecked(true);
|
|
ui->updateForumInfoCheckBox->setEnabled(false);
|
|
ui->updateForumInfoCheckBox->setChecked(true);
|
|
ui->updatePostedInfoCheckBox->setEnabled(false);
|
|
ui->updatePostedInfoCheckBox->setChecked(true);
|
|
ui->postedFirstImageCheckBox->setEnabled(false);
|
|
ui->postedFirstImageCheckBox->setChecked(false);
|
|
ui->postedOnlyImageCheckBox->setEnabled(false);
|
|
ui->postedOnlyImageCheckBox->setChecked(false);
|
|
ui->postedShinkImageCheckBox->setEnabled(false);
|
|
ui->postedShinkImageCheckBox->setChecked(true);
|
|
ui->useAuthenticationCheckBox->setChecked(false);
|
|
ui->useStandardStorageTimeCheckBox->setChecked(true);
|
|
ui->useStandardUpdateInterval->setChecked(true);
|
|
ui->useStandardProxyCheckBox->setChecked(true);
|
|
ui->embedImagesCheckBox->setChecked(true);
|
|
ui->saveCompletePageCheckBox->setEnabled(false);
|
|
|
|
/* not yet supported */
|
|
ui->authenticationGroupBox->setEnabled(false);
|
|
|
|
mTransformationType = RS_FEED_TRANSFORMATION_TYPE_NONE;
|
|
ui->transformationTypeLabel->setText(FeedReaderStringDefs::transforationTypeString(mTransformationType));
|
|
|
|
ui->clearCachePushButton->show();
|
|
|
|
/* fill own forums */
|
|
requestForumGroups();
|
|
|
|
/* fill own posted */
|
|
requestPostedGroups();
|
|
|
|
validate();
|
|
|
|
ui->urlLineEdit->setFocus();
|
|
|
|
/* load settings */
|
|
processSettings(true);
|
|
}
|
|
|
|
AddFeedDialog::~AddFeedDialog()
|
|
{
|
|
/* save settings */
|
|
processSettings(false);
|
|
|
|
delete(ui);
|
|
delete(mForumTokenQueue);
|
|
delete(mPostedTokenQueue);
|
|
}
|
|
|
|
void AddFeedDialog::processSettings(bool load)
|
|
{
|
|
Settings->beginGroup(QString("AddFeedDialog"));
|
|
|
|
if (load) {
|
|
// load settings
|
|
QByteArray geometry = Settings->value("Geometry").toByteArray();
|
|
if (!geometry.isEmpty()) {
|
|
restoreGeometry(geometry);
|
|
}
|
|
} else {
|
|
// save settings
|
|
Settings->setValue("Geometry", saveGeometry());
|
|
}
|
|
|
|
Settings->endGroup();
|
|
}
|
|
|
|
void AddFeedDialog::authenticationToggled()
|
|
{
|
|
bool checked = ui->useAuthenticationCheckBox->isChecked();
|
|
ui->userLineEdit->setEnabled(checked);
|
|
ui->passwordLineEdit->setEnabled(checked);
|
|
}
|
|
|
|
void AddFeedDialog::useStandardStorageTimeToggled()
|
|
{
|
|
bool checked = ui->useStandardStorageTimeCheckBox->isChecked();
|
|
ui->storageTimeSpinBox->setEnabled(!checked);
|
|
}
|
|
|
|
void AddFeedDialog::useStandardUpdateIntervalToggled()
|
|
{
|
|
bool checked = ui->useStandardUpdateInterval->isChecked();
|
|
ui->updateIntervalSpinBox->setEnabled(!checked);
|
|
}
|
|
|
|
void AddFeedDialog::useStandardProxyToggled()
|
|
{
|
|
bool checked = ui->useStandardProxyCheckBox->isChecked();
|
|
ui->proxyAddressLineEdit->setEnabled(!checked);
|
|
ui->proxyPortSpinBox->setEnabled(!checked);
|
|
}
|
|
|
|
void AddFeedDialog::typeForumToggled()
|
|
{
|
|
bool checked = ui->typeForumCheckBox->isChecked();
|
|
mStateHelper->setWidgetEnabled(ui->forumComboBox, checked);
|
|
ui->updateForumInfoCheckBox->setEnabled(checked);
|
|
|
|
if (checked) {
|
|
ui->typeLocalCheckBox->setChecked(false);
|
|
}
|
|
}
|
|
|
|
void AddFeedDialog::postedFirstImageToggled()
|
|
{
|
|
bool checked = ui->postedFirstImageCheckBox->isChecked();
|
|
ui->postedOnlyImageCheckBox->setEnabled(checked);
|
|
|
|
if (!checked) {
|
|
ui->postedOnlyImageCheckBox->setChecked(false);
|
|
}
|
|
}
|
|
|
|
void AddFeedDialog::typePostedToggled()
|
|
{
|
|
bool checked = ui->typePostedCheckBox->isChecked();
|
|
mStateHelper->setWidgetEnabled(ui->postedComboBox, checked);
|
|
ui->updatePostedInfoCheckBox->setEnabled(checked);
|
|
ui->postedFirstImageCheckBox->setEnabled(checked);
|
|
ui->postedShinkImageCheckBox->setEnabled(checked);
|
|
|
|
if (checked) {
|
|
ui->typeLocalCheckBox->setChecked(false);
|
|
}else {
|
|
ui->postedFirstImageCheckBox->setChecked(false);
|
|
}
|
|
}
|
|
|
|
void AddFeedDialog::typeLocalToggled()
|
|
{
|
|
bool checked = ui->typeLocalCheckBox->isChecked();
|
|
if (checked) {
|
|
mStateHelper->setWidgetEnabled(ui->forumComboBox, false);
|
|
mStateHelper->setWidgetEnabled(ui->postedComboBox, false);
|
|
ui->typeForumCheckBox->setChecked(false);
|
|
ui->typePostedCheckBox->setChecked(false);
|
|
ui->saveCompletePageCheckBox->setEnabled(true);
|
|
} else {
|
|
ui->saveCompletePageCheckBox->setEnabled(false);
|
|
ui->saveCompletePageCheckBox->setChecked(false);
|
|
}
|
|
}
|
|
|
|
void AddFeedDialog::denyForumAndPostedToggled()
|
|
{
|
|
if (ui->saveCompletePageCheckBox->isChecked()) {
|
|
ui->typeForumCheckBox->setEnabled(false);
|
|
ui->typeForumCheckBox->setChecked(false);
|
|
ui->typePostedCheckBox->setEnabled(false);
|
|
ui->typePostedCheckBox->setChecked(false);
|
|
ui->typeLocalCheckBox->setChecked(true);
|
|
} else {
|
|
ui->typeForumCheckBox->setEnabled(true);
|
|
ui->typePostedCheckBox->setEnabled(true);
|
|
}
|
|
}
|
|
|
|
void AddFeedDialog::validate()
|
|
{
|
|
bool ok = true;
|
|
|
|
if (ui->urlLineEdit->text().isEmpty()) {
|
|
ok = false;
|
|
}
|
|
if (ui->nameLineEdit->text().isEmpty() && !ui->useInfoFromFeedCheckBox->isChecked()) {
|
|
ok = false;
|
|
}
|
|
|
|
ui->previewButton->setEnabled(ok);
|
|
|
|
if (!ui->typeLocalCheckBox->isChecked() && !ui->typeForumCheckBox->isChecked() && !ui->typePostedCheckBox->isChecked()) {
|
|
ok = false;
|
|
}
|
|
|
|
if (ui->typeForumCheckBox->isChecked() && ui->forumComboBox->itemData(ui->forumComboBox->currentIndex()).toString().isEmpty()) {
|
|
ok = false;
|
|
}
|
|
|
|
if (ui->typePostedCheckBox->isChecked() && ui->postedComboBox->itemData(ui->postedComboBox->currentIndex()).toString().isEmpty()) {
|
|
ok = false;
|
|
}
|
|
|
|
mStateHelper->setWidgetEnabled(ui->buttonBox->button(QDialogButtonBox::Ok), ok);
|
|
}
|
|
|
|
void AddFeedDialog::setParent(uint32_t parentId)
|
|
{
|
|
mParentId = parentId;
|
|
}
|
|
|
|
bool AddFeedDialog::fillFeed(uint32_t feedId)
|
|
{
|
|
mFeedId = feedId;
|
|
|
|
if (mFeedId) {
|
|
FeedInfo feedInfo;
|
|
if (!mFeedReader->getFeedInfo(mFeedId, feedInfo)) {
|
|
mFeedId = 0;
|
|
return false;
|
|
}
|
|
|
|
setWindowTitle(tr("Edit feed"));
|
|
|
|
mParentId = feedInfo.parentId;
|
|
|
|
ui->nameLineEdit->setText(QString::fromUtf8(feedInfo.name.c_str()));
|
|
ui->urlLineEdit->setText(QString::fromUtf8(feedInfo.url.c_str()));
|
|
ui->useInfoFromFeedCheckBox->setChecked(feedInfo.flag.infoFromFeed);
|
|
ui->updateForumInfoCheckBox->setChecked(feedInfo.flag.updateForumInfo);
|
|
ui->updatePostedInfoCheckBox->setChecked(feedInfo.flag.updatePostedInfo);
|
|
ui->postedFirstImageCheckBox->setChecked(feedInfo.flag.postedFirstImage);
|
|
ui->postedOnlyImageCheckBox->setChecked(feedInfo.flag.postedOnlyImage);
|
|
ui->postedShinkImageCheckBox->setChecked(feedInfo.flag.postedShrinkImage);
|
|
ui->activatedCheckBox->setChecked(!feedInfo.flag.deactivated);
|
|
ui->embedImagesCheckBox->setChecked(feedInfo.flag.embedImages);
|
|
ui->saveCompletePageCheckBox->setChecked(feedInfo.flag.saveCompletePage);
|
|
|
|
ui->descriptionPlainTextEdit->setPlainText(QString::fromUtf8(feedInfo.description.c_str()));
|
|
|
|
if (feedInfo.flag.forum || feedInfo.flag.posted) {
|
|
if (feedInfo.flag.forum) {
|
|
mStateHelper->setWidgetEnabled(ui->forumComboBox, true);
|
|
ui->typeForumCheckBox->setChecked(true);
|
|
|
|
setActiveForumId(feedInfo.forumId);
|
|
}
|
|
if (feedInfo.flag.posted) {
|
|
mStateHelper->setWidgetEnabled(ui->postedComboBox, true);
|
|
ui->typePostedCheckBox->setChecked(true);
|
|
|
|
setActivePostedId(feedInfo.postedId);
|
|
}
|
|
ui->saveCompletePageCheckBox->setEnabled(false);
|
|
} else {
|
|
ui->typeLocalCheckBox->setChecked(true);
|
|
mStateHelper->setWidgetEnabled(ui->forumComboBox, false);
|
|
}
|
|
|
|
ui->useAuthenticationCheckBox->setChecked(feedInfo.flag.authentication);
|
|
ui->userLineEdit->setText(QString::fromUtf8(feedInfo.user.c_str()));
|
|
ui->passwordLineEdit->setText(QString::fromUtf8(feedInfo.password.c_str()));
|
|
|
|
ui->useStandardProxyCheckBox->setChecked(feedInfo.flag.standardProxy);
|
|
ui->proxyAddressLineEdit->setText(QString::fromUtf8(feedInfo.proxyAddress.c_str()));
|
|
ui->proxyPortSpinBox->setValue(feedInfo.proxyPort);
|
|
|
|
ui->useStandardUpdateInterval->setChecked(feedInfo.flag.standardUpdateInterval);
|
|
ui->updateIntervalSpinBox->setValue(feedInfo.updateInterval / 60);
|
|
QDateTime dateTime;
|
|
dateTime.setTime_t(feedInfo.lastUpdate);
|
|
ui->lastUpdate->setText(dateTime.toString());
|
|
|
|
ui->useStandardStorageTimeCheckBox->setChecked(feedInfo.flag.standardStorageTime);
|
|
ui->storageTimeSpinBox->setValue(feedInfo.storageTime / (60 * 60 *24));
|
|
|
|
mTransformationType = feedInfo.transformationType;
|
|
mXPathsToUse = feedInfo.xpathsToUse;
|
|
mXPathsToRemove = feedInfo.xpathsToRemove;
|
|
mXslt = feedInfo.xslt;
|
|
|
|
ui->transformationTypeLabel->setText(FeedReaderStringDefs::transforationTypeString(mTransformationType));
|
|
|
|
ui->clearCachePushButton->show();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void AddFeedDialog::setActiveForumId(const std::string &forumId)
|
|
{
|
|
if (mStateHelper->isLoading(TOKEN_TYPE_FORUM_GROUPS)) {
|
|
mFillForumId = forumId;
|
|
return;
|
|
}
|
|
|
|
int index = ui->forumComboBox->findData(QString::fromStdString(forumId));
|
|
if (index >= 0) {
|
|
ui->forumComboBox->setCurrentIndex(index);
|
|
} else {
|
|
ui->forumComboBox->setCurrentIndex(0);
|
|
}
|
|
}
|
|
|
|
void AddFeedDialog::setActivePostedId(const std::string &postedId)
|
|
{
|
|
if (mStateHelper->isLoading(TOKEN_TYPE_POSTED_GROUPS)) {
|
|
mFillPostedId = postedId;
|
|
return;
|
|
}
|
|
|
|
int index = ui->postedComboBox->findData(QString::fromStdString(postedId));
|
|
if (index >= 0) {
|
|
ui->postedComboBox->setCurrentIndex(index);
|
|
} else {
|
|
ui->postedComboBox->setCurrentIndex(0);
|
|
}
|
|
}
|
|
|
|
void AddFeedDialog::getFeedInfo(FeedInfo &feedInfo)
|
|
{
|
|
feedInfo.parentId = mParentId;
|
|
|
|
feedInfo.name = ui->nameLineEdit->text().toUtf8().constData();
|
|
feedInfo.url = ui->urlLineEdit->text().toUtf8().constData();
|
|
feedInfo.flag.infoFromFeed = ui->useInfoFromFeedCheckBox->isChecked();
|
|
feedInfo.flag.updateForumInfo = ui->updateForumInfoCheckBox->isChecked() && ui->updateForumInfoCheckBox->isEnabled();
|
|
feedInfo.flag.updatePostedInfo = ui->updatePostedInfoCheckBox->isChecked() && ui->updatePostedInfoCheckBox->isEnabled();
|
|
feedInfo.flag.postedFirstImage = ui->postedFirstImageCheckBox->isChecked() && ui->postedFirstImageCheckBox->isEnabled();
|
|
feedInfo.flag.postedOnlyImage = ui->postedOnlyImageCheckBox->isChecked() && ui->postedOnlyImageCheckBox->isEnabled();
|
|
feedInfo.flag.postedShrinkImage = ui->postedShinkImageCheckBox->isChecked() && ui->postedShinkImageCheckBox->isEnabled();
|
|
feedInfo.flag.deactivated = !ui->activatedCheckBox->isChecked();
|
|
feedInfo.flag.embedImages = ui->embedImagesCheckBox->isChecked();
|
|
feedInfo.flag.saveCompletePage = ui->saveCompletePageCheckBox->isChecked();
|
|
|
|
feedInfo.description = ui->descriptionPlainTextEdit->toPlainText().toUtf8().constData();
|
|
|
|
feedInfo.flag.forum = ui->typeForumCheckBox->isChecked();
|
|
|
|
if (feedInfo.flag.forum) {
|
|
feedInfo.forumId = ui->forumComboBox->itemData(ui->forumComboBox->currentIndex()).toString().toStdString();
|
|
}
|
|
|
|
feedInfo.flag.posted = ui->typePostedCheckBox->isChecked();
|
|
|
|
if (feedInfo.flag.posted) {
|
|
feedInfo.postedId = ui->postedComboBox->itemData(ui->postedComboBox->currentIndex()).toString().toStdString();
|
|
}
|
|
|
|
feedInfo.flag.authentication = ui->useAuthenticationCheckBox->isChecked();
|
|
feedInfo.user = ui->userLineEdit->text().toUtf8().constData();
|
|
feedInfo.password = ui->passwordLineEdit->text().toUtf8().constData();
|
|
|
|
feedInfo.flag.standardProxy = ui->useStandardProxyCheckBox->isChecked();
|
|
feedInfo.proxyAddress = ui->proxyAddressLineEdit->text().toUtf8().constData();
|
|
feedInfo.proxyPort = ui->proxyPortSpinBox->value();
|
|
|
|
feedInfo.flag.standardUpdateInterval = ui->useStandardUpdateInterval->isChecked();
|
|
feedInfo.updateInterval = ui->updateIntervalSpinBox->value() * 60;
|
|
|
|
feedInfo.flag.standardStorageTime = ui->useStandardStorageTimeCheckBox->isChecked();
|
|
feedInfo.storageTime = ui->storageTimeSpinBox->value() * 60 *60 * 24;
|
|
|
|
feedInfo.transformationType = mTransformationType;
|
|
feedInfo.xpathsToUse = mXPathsToUse;
|
|
feedInfo.xpathsToRemove = mXPathsToRemove;
|
|
feedInfo.xslt = mXslt;
|
|
}
|
|
|
|
void AddFeedDialog::createFeed()
|
|
{
|
|
FeedInfo feedInfo;
|
|
if (mFeedId) {
|
|
if (!mFeedReader->getFeedInfo(mFeedId, feedInfo)) {
|
|
QMessageBox::critical(this, tr("Edit feed"), tr("Can't edit feed. Feed does not exist."));
|
|
return;
|
|
}
|
|
}
|
|
|
|
getFeedInfo(feedInfo);
|
|
|
|
if (mFeedId == 0) {
|
|
/* add new feed */
|
|
RsFeedResult result = mFeedReader->addFeed(feedInfo, mFeedId);
|
|
if (FeedReaderStringDefs::showError(this, result, tr("Create feed"), tr("Cannot create feed."))) {
|
|
return;
|
|
}
|
|
} else {
|
|
RsFeedResult result = mFeedReader->setFeed(mFeedId, feedInfo);
|
|
if (FeedReaderStringDefs::showError(this, result, tr("Edit feed"), tr("Cannot change feed."))) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
close();
|
|
}
|
|
|
|
void AddFeedDialog::preview()
|
|
{
|
|
FeedInfo feedInfo;
|
|
getFeedInfo(feedInfo);
|
|
|
|
PreviewFeedDialog dialog(mFeedReader, mNotify, feedInfo, this);
|
|
if (dialog.exec() == QDialog::Accepted) {
|
|
mTransformationType = dialog.getData(mXPathsToUse, mXPathsToRemove, mXslt);
|
|
ui->transformationTypeLabel->setText(FeedReaderStringDefs::transforationTypeString(mTransformationType));
|
|
}
|
|
}
|
|
|
|
void AddFeedDialog::clearMessageCache()
|
|
{
|
|
if (mFeedId == 0) {
|
|
return;
|
|
}
|
|
|
|
mFeedReader->clearMessageCache(mFeedId);
|
|
}
|
|
|
|
void AddFeedDialog::requestForumGroups()
|
|
{
|
|
mStateHelper->setLoading(TOKEN_TYPE_FORUM_GROUPS, true);
|
|
|
|
RsTokReqOptions opts;
|
|
opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA;
|
|
|
|
mForumTokenQueue->cancelActiveRequestTokens(TOKEN_TYPE_FORUM_GROUPS);
|
|
|
|
uint32_t token;
|
|
mForumTokenQueue->requestGroupInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts, TOKEN_TYPE_FORUM_GROUPS);
|
|
}
|
|
|
|
void AddFeedDialog::loadForumGroups(const uint32_t &token)
|
|
{
|
|
std::vector<RsGxsForumGroup> groups;
|
|
rsGxsForums->getGroupData(token, groups);
|
|
|
|
ui->forumComboBox->clear();
|
|
|
|
for (std::vector<RsGxsForumGroup>::iterator it = groups.begin(); it != groups.end(); ++it) {
|
|
const RsGxsForumGroup &group = *it;
|
|
|
|
/* show only own forums */
|
|
if (IS_GROUP_PUBLISHER(group.mMeta.mSubscribeFlags) && IS_GROUP_ADMIN(group.mMeta.mSubscribeFlags) && !group.mMeta.mAuthorId.isNull()) {
|
|
ui->forumComboBox->addItem(QString::fromUtf8(group.mMeta.mGroupName.c_str()), QString::fromStdString(group.mMeta.mGroupId.toStdString()));
|
|
}
|
|
}
|
|
|
|
/* insert empty item */
|
|
ui->forumComboBox->insertItem(0, "", "");
|
|
ui->forumComboBox->setCurrentIndex(0);
|
|
|
|
mStateHelper->setLoading(TOKEN_TYPE_FORUM_GROUPS, false);
|
|
|
|
if (!mFillForumId.empty()) {
|
|
setActiveForumId(mFillForumId);
|
|
mFillForumId.clear();
|
|
}
|
|
}
|
|
|
|
void AddFeedDialog::requestPostedGroups()
|
|
{
|
|
mStateHelper->setLoading(TOKEN_TYPE_POSTED_GROUPS, true);
|
|
|
|
RsTokReqOptions opts;
|
|
opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA;
|
|
|
|
mPostedTokenQueue->cancelActiveRequestTokens(TOKEN_TYPE_POSTED_GROUPS);
|
|
|
|
uint32_t token;
|
|
mPostedTokenQueue->requestGroupInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts, TOKEN_TYPE_POSTED_GROUPS);
|
|
}
|
|
|
|
void AddFeedDialog::loadPostedGroups(const uint32_t &token)
|
|
{
|
|
std::vector<RsPostedGroup> groups;
|
|
rsPosted->getGroupData(token, groups);
|
|
|
|
ui->postedComboBox->clear();
|
|
|
|
for (std::vector<RsPostedGroup>::iterator it = groups.begin(); it != groups.end(); ++it) {
|
|
const RsPostedGroup &group = *it;
|
|
|
|
/* show only own posted */
|
|
if (IS_GROUP_PUBLISHER(group.mMeta.mSubscribeFlags) && IS_GROUP_ADMIN(group.mMeta.mSubscribeFlags) && !group.mMeta.mAuthorId.isNull()) {
|
|
ui->postedComboBox->addItem(QString::fromUtf8(group.mMeta.mGroupName.c_str()), QString::fromStdString(group.mMeta.mGroupId.toStdString()));
|
|
}
|
|
}
|
|
|
|
/* insert empty item */
|
|
ui->postedComboBox->insertItem(0, "", "");
|
|
ui->postedComboBox->setCurrentIndex(0);
|
|
|
|
mStateHelper->setLoading(TOKEN_TYPE_POSTED_GROUPS, false);
|
|
|
|
if (!mFillPostedId.empty()) {
|
|
setActivePostedId(mFillPostedId);
|
|
mFillPostedId.clear();
|
|
}
|
|
}
|
|
|
|
void AddFeedDialog::loadRequest(const TokenQueue *queue, const TokenRequest &req)
|
|
{
|
|
if (queue == mForumTokenQueue)
|
|
{
|
|
/* now switch on req */
|
|
switch(req.mUserType)
|
|
{
|
|
case TOKEN_TYPE_FORUM_GROUPS:
|
|
loadForumGroups(req.mToken);
|
|
break;
|
|
|
|
default:
|
|
std::cerr << "AddFeedDialog::loadRequest() ERROR: INVALID TYPE";
|
|
std::cerr << std::endl;
|
|
|
|
}
|
|
}
|
|
|
|
if (queue == mPostedTokenQueue)
|
|
{
|
|
/* now switch on req */
|
|
switch(req.mUserType)
|
|
{
|
|
case TOKEN_TYPE_POSTED_GROUPS:
|
|
loadPostedGroups(req.mToken);
|
|
break;
|
|
|
|
default:
|
|
std::cerr << "AddFeedDialog::loadRequest() ERROR: INVALID TYPE";
|
|
std::cerr << std::endl;
|
|
|
|
}
|
|
}
|
|
}
|